· 9 min lezen

Waarom de meeste designsystemen stilletjes falen

De meeste designsystemen falen niet door een gebrek aan componenten, maar omdat teams er niet meer op vertrouwen. Niemand zegt het hardop: het ene team na het andere kopieert gewoon de knop.

Een designsysteem is de gedeelde set bouwstenen waarmee een bedrijf zijn producten maakt: de knoppen, menu's, kleuren en tekststijlen die elk team hoort te hergebruiken in plaats van ze zelf te tekenen. Veel designsystemen worden uiteindelijk nauwelijks gebruikt. Een team bouwt er maanden aan, lanceert het en ziet het daarna achteropraken doordat productteams het forken, wat betekent dat ze een onderdeel kopiëren en voor zichzelf aanpassen, telkens als het systeem het niet kan bijbenen. Ik heb dat meer dan eens zien gebeuren, ook bij systemen die ik zelf bouwde.

De oorzaak is bijna nooit technisch. De benoemde kleuren en maten zijn prima. De knoppen en menu's zijn prima. Wat stukgaat, is het gedeelde besef dat het systeem de extra moeite waard is om het te volgen.

Vertrouwen is de echte afhankelijkheid

Het vertrouwen daalt de eerste keer dat een team twee weken wacht op een component die het systeem niet heeft. Het daalt opnieuw als het team een toevoeging voorstelt en nooit iets terughoort. Bij de derde keer heeft het meestal een eigen privékopie van het systeem gebouwd, en gebruikt het het jouwe eigenlijk niet meer.

Dat is vanuit het systeemteam moeilijk te zien, omdat niemand het aankondigt. Geen enkel productteam verklaart dat het het systeem verlaat. Er is een deadline, en een component die bijna past, en een developer die hem naar een eigen deel van de code kopieert en twee dingen verandert. Die kopie is geen ontrouw. Het is de goedkoopste verstandige beslissing voor iemand met een datum die gehaald moet worden.

Elk van die kopieën is een redelijke beslissing om niet op het systeem te leunen. Een bruikbare maat voor de gezondheid van een systeem is hoe vaak die beslissing wordt genomen, en bijna niemand meet dat.

Wat er met de tijd met een kopie gebeurt

Een gekopieerde component begint precies gelijk aan het origineel, en daarom lijkt hij onschuldig. Dan krijgt het origineel een zichtbare omlijning voor toetsenbordgebruikers, een fix waardoor hij bruikbaar wordt met een schermlezer, een aanpassing in hoe hij omgaat met lange tekst op een smal scherm. De kopie krijgt daar niets van.

Zes maanden later zijn het echt verschillende componenten met dezelfde naam, en het verschil is op geen enkele screenshot te zien. Daar komen de kosten terecht: niet in de dubbeling, die goedkoop is, maar in het uit elkaar groeien van de twee, dat onopgemerkt blijft en met de tijd groter wordt.

Tegen de tijd dat iemand het merkt, is de oplossing geen snelle update meer. Die begint met uitzoeken hoe ver de twee uit elkaar zijn gegroeid.

Behandel het als een product, niet als een infrastructuurproject

Infrastructuur betekent hier iets dat één keer wordt gebouwd en daarna op de achtergrond wordt onderhouden. Wat in mijn ervaring beter werkt: een echte lijst van wat er hierna moet gebeuren, echte keuzes over wat eerst komt, en iemand wiens werk het is om de problemen op te merken waar productteams tegenaan lopen. Geen team dat onderdelen uitdeelt, maar een team dat andere teams sneller maakt.

Die verschuiving verandert het dagelijkse werk. Een infrastructuurteam vraagt wat er in de bibliotheek ontbreekt. Een productteam vraagt wie er op dit moment vastzit, en waardoor, en wat deze week de meeste mensen weer op gang zou helpen. Die twee vragen leiden tot heel verschillende roadmaps (het plan van wat er gebouwd wordt, en in welke volgorde), en alleen de tweede houdt bij of teams het systeem blijven gebruiken.

Het verandert ook naar wie je luistert. Infrastructuurteams nemen verzoeken aan van wie het hardst roept, en dat is in de praktijk vaak wie het hoogst in rang staat. Productteams gaan kijken. Het nuttigste uur dat ik ooit aan een designsysteem heb besteed, was naast een developer zitten die er een scherm mee bouwde, en niets zeggen terwijl die aan het werk was.

Je gebruikers zijn niet de designers

De mensen die het meest last hebben van een slecht designsysteem zijn engineers, en zij worden er meestal als laatste over geraadpleegd.

Een component, een van die herbruikbare onderdelen, kan perfect zijn in het designbestand en onhandig in code: vijftien instellingen, waarvan er drie elkaar opheffen, en geen manier om de ene variant te krijgen die dit scherm nodig heeft zonder er iets omheen te bouwen. De designers zijn tevreden, het gebruik van het systeem daalt, en niemand kan uitleggen waarom.

Als je systeem een designkant en een codekant heeft, is de codekant het product. De designkant is de documentatie.

Dekking is belangrijker dan kwaliteit

Met dekking bedoel ik hoeveel van wat teams nodig hebben het systeem echt heeft. Ik denk dat een middelmatige component die bestaat beter is dan een uitstekende die niet bestaat, al is niet iedereen het daarmee eens.

De reden is dat gedeeltelijke dekking op elk scherm een beslissing afdwingt. Zit dit ding in het systeem? Kijk ik eerst, of bouw ik het gewoon? Als het antwoord vaak genoeg "eerst kijken" is, wordt kijken een gewoonte. Als het systeem maar de helft dekt van wat teams nodig hebben, loont kijken de helft van de keren, en houden mensen op met kijken.

Dit is ook waarom de gewone onderdelen meer waard zijn dan ze lijken. Niemand schrijft een case study over een kalender om een datum te kiezen, een foutmelding direct bij het invoerveld of wat een tabel laat zien als er nog geen rijen in staan, maar juist die drie komen teams steeds weer tegen, en daar begint het kopiëren.

Strengheid heeft een prijs

Een deel van het dekkingsprobleem komt door hoe streng het systeem is in wat het toelaat. Een systeem dat vijftien zorgvuldig gecontroleerde componenten toelaat, wordt vaker gekopieerd dan een systeem dat er zestig ruwe toelaat, omdat die controle een prijs is die betaald wordt door de mensen die het hardst moeten kunnen opschieten.

Hoe streng je bent, moet afhangen van hoeveel er stukgaat als een onderdeel niet klopt. Een knop die op elk scherm staat, verdient een kritische blik. Een component die twee teams nodig hebben en die verder niemand aanraakt, heeft geen designreviewcommissie nodig.

Laat de tools het afdwingen

Dekking levert je de onderdelen. Wat ze in gebruik houdt, is dat het alternatief onhandig is, en dat is een taak voor de tools en niet voor de documentatie.

De sterkste handhaving is een automatische controle, en die werkt het best als hij simpel en streng is: een kleur, tekstgrootte of letterdikte die niet een van de benoemde is, wordt geweigerd, net als elke afstand of afronding van hoeken boven de kleinste stappen, met een melding die zegt welk soort benoemde waarde je in plaats daarvan moet gebruiken. Het is geen stijlvoorkeur. Het is het verschil tussen "gebruik alsjeblieft het systeem" in een document dat niemand leest en een wijziging die pas door de controles komt als je dat doet.

Het effect is groter dan het klinkt. Een designer die niet zomaar een grijs kan pakken dat toevallig mooi is, moet een van de echte kleuren gebruiken, dus wat die designer maakt, past bij de rest van het product en schakelt zonder extra werk over naar de donkere modus. De beperking doet een deel van het designwerk. Dat is het soort designsysteem dat gebruikt blijft worden: niet het systeem met de beste documentatie, maar het systeem waarin het goed doen de makkelijkste weg is en het anders doen een bewuste uitzondering vraagt, plus een zin die uitlegt waarom.

De melding is net zo belangrijk als de regel. Een controle die "onverwachte waarde" zegt, leert niemand iets. Een controle die zegt "gebruik een van de benoemde afstandsstappen in plaats van 12 pixels, en als er geen past, voeg er een toe met een notitie waarom" is documentatie die aankomt op het moment dat iemand die nodig heeft.

Adoptie is de maatstaf, en die moet zichtbaar zijn

De componenten zijn de output. Adoptie, dus hoeveel teams het systeem echt gebruiken, is de maat voor succes. Het systeem werkt pas als teams ervoor kiezen omdat het hun werk makkelijker maakt, niet omdat iemand hogerop dat zei.

Dat meetbaar maken is de moeite waard, en het is makkelijker dan het klinkt. Het aandeel van wat er op het scherm staat dat uit het systeem komt. Het aantal eenmalige stijlen per scherm. Hoe lang een verzoek wacht voordat het beantwoord wordt. Geen van deze is perfect, en ze zijn allemaal beter dan tellen hoeveel componenten je hebt opgeleverd, want dat meet jouw output en zegt niets over die van een ander.

Het getal dat voor mij de meeste gesprekken veranderde, was de tijd tot een antwoord op een verzoek. Niet de tijd tot de component er is: de tijd tot een reactie met een beslissing, ook als die "nee, en dit is waarom" luidt. Een snel nee houdt een team binnen het systeem. Een lange stilte stuurt het er meestal voorgoed uit.

Verplichtingen verhogen het gebruik, niet het vertrouwen

Grote organisaties komen vaak uit bij een verplichting van bovenaf: gebruik het systeem, geen uitzonderingen. Dat werkt, in de beperkte zin dat het gebruik stijgt.

Wat het niet doet, is de problemen weghalen waardoor mensen vertrokken. Teams gebruiken het systeem omdat het moet, en de frustratie is er nog steeds. Dat is lastiger op te lossen, want mensen die gefrustreerd zijn, houden op het je te vertellen. Ze volgen de regel, en ze werken er ook omheen op manieren die je pas later ontdekt.

Een verplichting is nuttig om een gewoonte in stand te houden als de meeste teams die al hebben. Om die gewoonte te laten ontstaan, doet ze weinig.

Wat ik anders zou doen

Begin kleiner dan comfortabel voelt, en ga diep op de onderdelen waar een team echt een scherm uit bouwt, in plaats van breed op een catalogus van onderdelen.

Zorg vanaf dag één voor een manier om componenten aan te vragen en bij te dragen, al is het een gedeeld kanaal en een belofte om binnen twee dagen te antwoorden. Dat die ingang er is, is belangrijker dan hoe gepolijst hij is, en de belofte nakomen is het allerbelangrijkst.

Publiceer de roadmap samen met een nee-lijst, de dingen waarvan je hebt besloten ze niet te bouwen, zodat een team in één oogopslag ziet of het moet wachten of zelf moet bouwen. Onzekerheid is wat tot kopieën leidt. Een duidelijk nee doet dat zelden.

En meet het resultaat dat je echt wilt. Niet het aantal gepubliceerde componenten. Niet het aantal benoemde kleuren. Het aantal keren dat iemand voor het systeem koos terwijl dat niet hoefde, en dat is het duidelijkste teken dat het de moeite waard was om te bouwen.