· 7 min lezen

Wat een team verliest als designers hun eigen code live zetten

Designers kunnen hun eigen werk nu zelf live zetten, en de snelheid is echt. Het verlies ook: een tweede lezer, de bezwaren van een engineer en code die van meer dan één persoon is.

Als een designer zijn eigen werk live zet, rechtstreeks in het product dat mensen gebruiken, verliest het team zijn engineer niet. Het verliest de dingen die de engineer deed zonder dat iemand erom vroeg: het design zo nauwkeurig lezen dat hij het kan bouwen, bezwaar maken als iets traag zou worden, de toestand opmerken die niemand tekende, en daarna eigenaar zijn van het resultaat. Die stonden nooit op een procesdiagram, dus niemand is van plan ze te vervangen, en ze verdwijnen de eerste keer dat een designer zijn eigen code goedkeurt en publiceert.

Dit is geen gedachte-experiment meer. Het AI in Design-rapport van Designer Fund en Foundation Capital (opent in een nieuw tabblad), gebaseerd op een enquête uit het eerste kwartaal van 2026, vond dat de helft van de ondervraagden door AI gegenereerde code in een live product had gezet. Hetzelfde hoofdstuk meldt dat 20 procent zei dat de samenwerking was afgenomen, tegenover 5 procent het jaar ervoor. Het rapport beweert niet dat het een het ander veroorzaakt, en ik ook niet. Maar ik lees de twee getallen naast elkaar, omdat ik denk dat ze bij dezelfde verschuiving horen: meer designers die hun eigen werk live zetten, en minder momenten waarop ze het samen met iemand anders moeten uitwerken.

Dit is geen pleidooi voor of tegen designers die zelf live zetten. Het is een inventaris van wat er ontbreekt als ze dat doen, en wat er met de hand terug moet.

De review die niemand inplande

Implementatie is de grondigste lezing die een design ooit krijgt. Een reviewer kijkt tien minuten naar een scherm. Een engineer die het bouwt, moet beslissen wat er gebeurt op elk pad erdoorheen, in elke toestand, met elke vorm waarin de data kan binnenkomen. Dat is een review, ook al noemt niemand het zo en boekt niemand er een zaal voor.

Ik heb eerder geschreven over waarom de overdracht beter werkt als gesprek dan als document. Het punt hier is smaller. Welke vorm de overdracht ook had, ze garandeerde één ding: een tweede persoon moest het werk goed genoeg begrijpen om het te laten draaien. Als de designer zelf live zet, is die garantie weg. De eerste lezer van de code is de agent die hem schreef. De tweede lezer is de gebruiker.

"Dit wordt traag"

De bezwaren die een engineer tijdens het bouwen opwerpt, zijn makkelijk om je aan te ergeren en moeilijk te vervangen. Deze pagina doet voor elke rij een aparte vraag aan de database. Deze afbeelding is vier megabyte. Deze lijst heeft geen lege toestand, het scherm dat iemand ziet voordat er iets in staat, en de meeste accounts zullen hem leeg zien. Dit scherm gaat ervan uit dat het geld binnen is, en dat is het niet.

Ze komen als wrijving, en precies daarom werken ze. Een agent die een scherm moet bouwen, bouwt het scherm, inclusief de delen waar nooit om gevraagd had moeten worden. Hij zal je niet vertellen dat de briefing het probleem was, want de briefing is het enige wat hij kreeg. Snelheid wordt al in het designbestand bepaald, lang voordat iemand haar meet, en het "dit wordt traag" van de engineer was het moment waarop een team ontdekte wat het bestand had besloten.

Code met één eigenaar

Het derde verlies is het minst zichtbare. Als een engineer een feature bouwt, weet het engineeringteam dat hij bestaat, weet het ongeveer hoe hij werkt en kan het hem repareren als hij kapotgaat. Als een designer hem alleen live zet, heeft de code precies één persoon die hem begrijpt, en dat is meestal degene die het minst waarschijnlijk wordt gebeld als hij 's nachts kapotgaat.

Bij een eigen product is dat prima. Jij bent de enige eigenaar en de enige die wakker wordt gebeld, dus de afspraak is eerlijk. In een team is het niet prima, want de code wordt onderdeel van een product dat andere mensen onderhouden, onder een rooster voor nachtelijke problemen waar degene die hem schreef niet op staat. Een feature die niemand anders begrijpt, is een kleine schuld met rente, en de rekening komt op het slechtste moment, gestuurd naar iemand die er nooit mee instemde.

Wat het team wint

Het zou makkelijk zijn om daar te stoppen en het een waarschuwing te noemen. Dat zou oneerlijk zijn, want de winst is echt.

De afstand tussen bedoeling en resultaat krimpt tot niets voor de delen die een designer bouwt. De witruimte is de witruimte die bedoeld was. De lege toestand zegt wat hij moest zeggen, omdat degene die hem schreef degene is die wist waarom. De meeste kleine meningsverschillen die vroeger als bug werden gemeld, gebeuren nooit, omdat er geen vertaling was die fout kon gaan.

De designer leert het materiaal kennen. Toestanden bouwen leert je welke toestanden er bestaan. Een formulier koppelen aan het systeem erachter leert je wat dat systeem niet kan. Die kennis komt terug in elk design daarna, ook in de designs die iemand anders bouwt.

En engineers krijgen tijd terug van werk dat vooral bestond uit een design overzetten in code, tijd die ze kunnen besteden aan de problemen die alleen zij kunnen oplossen.

Wat er bewust terug moet

De verliezen zijn specifiek, dus de reparaties kunnen dat ook zijn. Dit zijn de reparaties die het waard zijn om aan vast te houden, in een team en, waar ze gelden, alleen.

Een lezer die niet de auteur is

Elke wijziging die een designer uitbrengt, wordt door een engineer gelezen voordat hij live gaat. Niet op stijl, en niet als toets van wat de designer kan, maar met drie vragen: wat gebeurt er als dit traag is, wat gebeurt er als dit leeg is, en wie wordt er gebeld als het kapotgaat. Mijn coding agents werken met een vastgelegde set standaarden, en die vangen veel af. Maar een standaard controleert alleen op wat ik al bedacht had. Een collega controleert op wat ik niet bedacht.

Een eigenaar, benoemd voordat het live gaat, niet na het incident

Bepaal wie eigenaar is van de code zodra die erin zit. Als het antwoord de designer is, zeg dat dan, zet hem op het rooster en accepteer wat dat betekent. Als het antwoord het engineeringteam is, moeten zij hem gelezen hebben, en dan ben je terug bij de eerste reparatie.

In het systeem, nooit ernaast

De code van een designer gebruikt de bouwstenen van het team, de tests van het team en de manier waarop het team uitbrengt. Code die naast het systeem leeft in plaats van erin, is een kopie die stilletjes zijn eigen weg is gegaan, en dat merkt degene die hem later moet verplaatsen.

Het gesprek dat de overdracht vroeger afdwong

De overdracht liet, met al haar gebreken, twee mensen met elkaar praten. Zelf live zetten haalt de verplichting weg, niet de behoefte. Als de samenwerking afneemt, zoals die enquête suggereert voor een vijfde van de ondervraagden, dan neemt ze af omdat niets haar nog afdwingt. Dus moet iets dat doen: een vaste review, een uur samen aan iets werken, een kanaal waar half af werk delen normaal is.

Een grens rond wat je alleen live zet

Sommige onderdelen zijn goedkoop om fout te doen en sommige niet. Een layoutwijziging aan een zijproject is van de eerste soort: als hij kapotgaat, repareer je hem en verliest niemand iets. Alles wat geld verplaatst, is van de tweede soort, en de toestand die een designer daar vergeet, is iemands huur. Weten aan welke kant van die grens een wijziging zit, hoort bij het werk, en het is een oordeel dat je maakt voordat de code bestaat, niet nadat hij live staat.

Het werk was nooit het enige dat werd overgedragen

De overdracht leek een overdracht van bestanden. Het was ook het moment waarop iemand anders je werk goed genoeg moest begrijpen om er verantwoordelijk voor te zijn. Een designer die zelf live zet, heeft niemand meer nodig die dat doet. Een team wel.