· 9 min lezen

Waarom een designbestand geen overdracht is

De overdracht, waarbij een design van designer naar developer gaat, krijgt steeds betere tools. Wat verloren gaat, is de redenering, en een rijker bestand brengt die niet over.

De overdracht van een design is het moment waarop het van de designer naar de developers gaat die het bouwen. De tools ervoor blijven veranderen. Tekeningen met maten erop werden gedetailleerde specificaties, specificaties werden designbestanden waarin je overal op kon klikken om elke waarde af te lezen, en die werden code die rechtstreeks uit het design wordt gegenereerd. Elke stap was een verbetering, en geen ervan loste op wat die moest oplossen.

Het probleem was nooit het formaat. De bestanden zijn gestaag beter geworden en de frictie tussen designers en developers is gebleven, en dat doet vermoeden dat de frictie niet in het bestand zit.

Wat een designbestand weglaat

Een designbestand is een verzameling beslissingen waar de redenering uit is gehaald. Het laat zestien pixels ruimte zien, maar niet dat er voor zestien is gekozen omdat vierentwintig de layout brak op de kleinste telefoon. Het laat zien hoe een scherm eruitziet als er nog niets in staat, maar niet dat die versie belangrijker is dan de volle, omdat de meeste accounts hem nooit zullen vullen.

Als een engineer vanuit een bestand bouwt, moet die de bedoeling afleiden uit wat er op de pagina staat, en dat terwijl die ook te maken heeft met beperkingen waar de designer misschien niets van wist. De meeste meningsverschillen over hoe iets gebouwd is, zijn niet echt meningsverschillen. Het zijn twee mensen die redelijke gissingen doen op basis van onvolledige informatie over elkaars probleem.

Een gedetailleerder bestand lost dit niet op. Het voegt informatie toe over hoe het design eruitziet, wat een beetje helpt, en het doet niets aan de redenering, en daar zat de waarde.

De vragen die nooit gesteld worden

Het duidelijkste teken is de vraag die een engineer besluit niet te stellen. Iets in het design werkt niet helemaal met hoe de informatie binnenkomt, en het zou een gesprek kosten om dat uit te zoeken, en de designer zit in een andere tijdzone of op een ander project of is gewoon lastig te storen. Dus wordt er een redelijke gok gedaan.

Die gok gaat live. Meestal is dat prima. Af en toe is het juist wat de feature slechter maakt dan die had moeten zijn, en niemand komt daar ooit achter, omdat de gok nooit als beslissing op tafel is gekomen.

Vermenigvuldig dat met elk scherm in een release en je hebt de echte prijs van leunen op de overdracht, en dat is geen herstelwerk. Het is een lange lijst kleine keuzes waar niemand naar heeft gekeken.

Wat in plaats daarvan werkte

Dit is geen formeel proces. Het is een set gewoontes die steeds weer verminderde hoeveel een overdracht moest dragen.

Haal de engineer erbij voordat het design goed is

Niet bij de review, maar op het punt waarop er drie schetsen liggen en nog geen beslissing. De beperkingen die ertoe doen, komen in dat gesprek naar boven, en ze komen goedkoop naar boven. Een engineer die de alternatieven heeft gezien, begrijpt de keuze, en een engineer die de keuze begrijpt, kan die goed aanpassen als er iets onverwachts opduikt.

Ontwerp de toestanden die je niet ziet

Laden, leeg, een fout, tekst die te lang is, geen verbinding, half af. Dat zijn de situaties waarin wat er gebouwd wordt het meest afwijkt van wat er bedoeld was, omdat het bestand daar meestal over zwijgt en de engineer zelf iets moet verzinnen. Elke toestand die je specificeert, is een gok die je hebt voorkomen.

Schrijf het waarom op bij alles wat niet vanzelf spreekt

Geen document. Een zin naast het scherm in het designbestand. "Zestien, omdat vierentwintig de regel breekt op de kleinste telefoon." Het kost tien seconden en het blijft staan als jij het project verlaat, wat de redenering in je hoofd niet doet.

Schrijf op wat een gesprek niet kan vasthouden: de beperking die een voor de hand liggende aanpak fout maakte, het ding dat niet mag veranderen, ook als alles eromheen verandert. Sla over wat een herbruikbaar onderdeel al regelt en wat het scherm zichtbaar laat zien. De toets is of de notitie over zes maanden nog iemand zou helpen die er niet bij was. Redeneringen doorstaan die toets. Maten niet.

Bekijk het gebouwde samen, op een echt apparaat, en vroeg

Niet om fouten te vinden, al vind je die wel. Om het gedeelde begrip weer op te bouwen terwijl het nog goedkoop is om iets te veranderen. Een gesprek van tien minuten op vijftig procent is meer waard dan een uur commentaar op vijfennegentig.

Vragen kost aan de ene kant meer

Een designer die een engineer onderbreekt, kost die engineer een flink stuk focus, en dat weet iedereen. Een engineer die een designer onderbreekt, kost ongeveer hetzelfde en niemand telt het, omdat designwerk geacht wordt onderbreekbaar te zijn.

Het gevolg is dat de goedkoopste zet voor beide kanten gokken is in plaats van vragen, en de gokken blijven onzichtbaar tot ze live gaan. Teams die goed samenwerken, hebben vragen meestal op een specifieke manier goedkoop gemaakt: een kanaal waar een half uitgedachte vraag normaal is, een vast kwartier dat niemand hoeft in te plannen, de gewoonte om in een thread te antwoorden in plaats van in een meeting.

Dat is geen proces. Het zijn kleine afspraken die vragen makkelijker maken, en dat doet meer voor de kwaliteit van wat er gebouwd wordt dan welk specificatieformaat ook.

Hoe af een design moet zijn, hangt af van de mensen

Een terugkerende discussie is hoe af een design moet zijn voordat het wordt overgedragen. Designers noemen dat fidelity. In de praktijk hangt het af van de twee mensen die erbij betrokken zijn, en het behandelen als één vaste standaard is waarom de discussie steeds terugkomt.

Een engineer die al twee jaar met je werkt en het systeem kent, heeft genoeg aan een schets en een gesprek. Een ingehuurde developer die voor zes weken instapt in code die hij nog nooit heeft gezien, heeft iets nodig wat veel dichter bij af is, omdat hij geen achtergrond heeft om de gaten mee te vullen en geen werkrelatie die vragen makkelijk maakt.

Teams komen in de problemen door voor allebei één standaard te hanteren. Of het ervaren duo wordt afgeremd door formaliteiten die niets toevoegen, of de nieuwe persoon krijgt een schets en moet maar gokken, en die gokken zijn slechter omdat die persoon nieuw is. Geen van beide is een fidelityprobleem. In beide gevallen had het detailniveau moeten volgen hoeveel de twee mensen al delen.

Als de review verandert in fouten zoeken

Er is een versie hiervan die eruitziet als samenwerking en dat niet is: de designer bekijkt elke build en meldt elk verschil als een fout.

Dat is vermoeiend, het zet de twee kanten tegenover elkaar, en het steekt de moeite op de verkeerde plek. Het meeste wat in zo'n review naar boven komt, is een verschil van twee pixels dat niemand buiten het team ooit zal zien, en de tijd die daarin gaat zitten, is tijd die niet naar dat ene scherm gaat dat echt verwarrend uitpakte.

De versie die werkt, is concreet zijn over wat er bij een bepaalde feature echt toe doet, en dat vooraf zeggen. Soms zijn het de afstanden, omdat de feature een dichte tabel is. Soms doen de afstanden er niet toe en draait alles om wat het scherm zegt als er nog niets in staat. Een engineer die hoort welk aspect ertoe doet, zal dat beschermen; een engineer die een lijst van veertig opmerkingen krijgt, werkt ze op volgorde af en heeft geen tijd meer voordat de belangrijke aan de beurt zijn.

Het designsysteem verandert de vorm hiervan

Hier is een designsysteem, een bibliotheek van gedeelde, herbruikbare onderdelen, het nuttigst, en dat is niet de reden die er meestal voor wordt gegeven.

Het gangbare argument is consistentie. Het betere argument is dat een gedeeld systeem het grootste deel weghaalt van wat er überhaupt overgedragen moet worden. Als een knop een component is die beide mensen al begrijpen, hoeft niemand hem te specificeren, te inspecteren of te bespreken. Het gesprek gaat een niveau omhoog, naar wat het scherm probeert te doen, en dat is het gesprek dat de moeite waard is.

Daaruit volgt dat slechte dekking, een systeem waarin veel van de onderdelen ontbreken die teams nodig hebben, de overdracht slechter maakt, niet beter: elk scherm wordt een ongemarkeerde mix van gedeelde onderdelen die geen uitleg nodig hebben en eenmalige onderdelen die er juist veel nodig hebben, en die uit elkaar houden kost precies de vraag die de engineer probeerde te vermijden. Het is hetzelfde dekkingsprobleem waardoor veel designsystemen falen.

Remote teams hebben dit ook nodig

Het voor de hand liggende bezwaar is dat alles hierboven ervan uitgaat dat mensen dicht bij elkaar werken, en veel teams doen dat niet. Dat is terecht. Maar het antwoord op afstand is geen beter document, want dat is dezelfde aanname als eerst.

Het antwoord is de redenering blijvend en makkelijk vindbaar te maken, omdat een gesprek over tijdzones heen niet spontaan kan zijn. Een korte opgenomen rondleiding door een flow, drie minuten, waarin je het waarom vertelt in plaats van het wat, is meer waard dan welke hoeveelheid annotaties ook. Die kun je bekijken op het moment van bouwen, en dat is wanneer de vragen echt opkomen, in plaats van bij een review die plaatsvond voordat ze opkwamen.

Hetzelfde geldt voor beslissingen. Een thread waarin de afweging is uitgevochten, is zes maanden later nuttiger dan een nette samenvatting, omdat uit de samenvatting de alternatieven zijn weggehaald, en de alternatieven zijn wat iemand nodig heeft als de beperking verandert.

Waar je mee moet stoppen

Stop met het moment van overdracht te zien als het punt waarop de verantwoordelijkheid overgaat. Die kijk veroorzaakt de meeste problemen. Hij schept een voor en een na, zet een document op de grens en maakt dat document verantwoordelijk voor het overbrengen van alles wat in de hoofden van twee mensen zat.

De feature is niet ontworpen als het bestand af is. Die is ontworpen als die voor mensen staat en werkt, en alles tussen die twee punten is designwerk, of het nu in een designtool gebeurt of niet. Teams die zo werken, hebben tijdens het bouwen nog steeds wat frictie, maar die lossen ze op in gesprek, en daar hoort die thuis.