Vorig jaar hebben we een platform geleverd ter waarde van $ 2 miljoen. Het hele engineeringteam? Eén senior architect en Claude Code. Geen offshoregebruikers. Geen leger van contractanten. Gewoon één persoon die wist wat hij aan het bouwen was, gekoppeld aan een AI die daadwerkelijk productioncode kon schrijven.

Ik schrijf dit niet om AI aan te prijzen. Ik ben genoeg door de hypertcyclus gebrand. Ik schrijf dit omdat wat op dit project gebeurde fundamenteel veranderde hoe ik denk over teamsamenstelling, projectschatting, en wat werkelijk mogelijk is als je diepgaande architectuurkennis combineert met AI-ondersteunde ontwikkeling. De cijfers liegen niet — we bereikten mijlpalen die een traditioneel team van 6-8 engineers ongeveer 18 maanden zouden hebben gekost, en we deden het in minder dan 5 maanden.

Laat ik je precies uitleggen hoe.

Inhoudsopgave

Het project: wat we werkelijk bouwden

Ik kan de klant niet noemen — NDA-terrein — maar ik kan het platform beschrijven. Het is een B2B SaaS-product in de logistiekruimte. Multi-tenant architectuur. Real-time tracking dashboards. Complexe op rollen gebaseerde toegangscontrole over organisaties, teams en individuele gebruikers. Integratie met 14 verschillende third-party API's (vervoerders, betalingsverwerkers, douanedatabases). Een klantgerichte portal en een intern beheersysteem.

Het soort project waarbij je in een typische agencysituatie zou werven met een tech lead, 2-3 senior devs, een paar mid-levels, een dedicated DevOps-persoon en misschien een QA-engineer. De originele schatting van de klant van een ander bureau was $ 3,2 miljoen over 20 maanden met een team van 9.

Wij stelden $ 2 miljoen voor, 5 maanden, één architect. Ze dachten dat we gek waren. Eerlijk gezegd, dat dacht ik ook, een beetje.

Waarom één architect in plaats van een volledig team

Dit is het tegenintuïtieve over kleine teams: de communicatieoverhead bij een 9-persoonsproject is enorm. Fred Brooks schreef hier in 1975 over en het is nog steeds waar. Met 9 engineers heb je 36 mogelijke communicatiekanalen. Vergaderingen vermenigvuldigen zich. Merge-conflicten worden een dagelijks ritueel. Iemand zit altijd vast en wacht op iemands PR-review.

Met één architect leeft de hele systeemtoestand in het hoofd van één persoon. Er is geen context-switching-belasting van het uitleggen van je aanpak in een pull request. Geen design-by-committee. Geen twee uur durende sprintplanningsessies.

Maar één persoon kan alleen maar zo snel typen. Één persoon kan alleen maar zoveel bestanden in werkgeheugen vasthouden. Één persoon wordt moe om 18:00 uur en maakt fouten om 20:00 uur.

Dat is waar Claude Code binnenkomt. Niet als vervanging voor de architect, maar als vermenigvuldiger van krachten. De architect neemt elke beslissing. Claude Code voert uit met een snelheid die anders 4-5 developers zou vereisen.

De rol van de architect

Onze architect — laten we hem Marcus noemen — heeft 15 jaar ervaring. Hij heeft systemen op deze schaal eerder gebouwd. Zijn taak op dit project was:

  • Systeemontwerp en architectuurbeslissingen
  • Modulegrenzen en datacontracten definiëren
  • De kritieke-padcode schrijven (auth, betalingsverwerking, data pipeline-orkestratie)
  • Alles wat Claude Code produceerde beoordelen en verfijnen
  • Infra- en implementatiearchitectuur
  • Beveiligingsaudits

Wat hij niet deed: boilerplate CRUD-eindpunten schrijven, UI-componenten uit ontwerpen samenstellen, unit tests voor eenvoudige logica schrijven, databasemigraties maken of nieuwe services scaffolden. Claude Code verzorgde dat allemaal.

Hoe Claude Code werkelijk in een echte workflow past

Laat me specifiek zijn over wat "Claude Code gebruiken" op dagelijkse basis werkelijk inhield, omdat de marketingmaterialen de werkelijkheid niet weergeven.

Marcus zou elke ochtend de werkzaamheden voor de dag op een gestructureerde manier definiëren. Niet vage prompts zoals "bouw me een gebruikersbeheerssysteem." In plaats daarvan stelde hij op wat we "architectuurbeknoptingen" begonnen te noemen — gedetailleerde documenten die specificeerden:

  1. De verantwoordelijkheid en grenzen van de module
  2. Gegevensmodellen met exacte veldtypen en relaties
  3. API-contract (eindpunten, request/response-vormen)
  4. Bedrijfsregels en randgevallen
  5. Verwachtingen voor foutafhandeling
  6. Met welke bestaande modules het moest integreren

Daarna zou hij deze aan Claude Code in chunks voeren. Een typische sessie zag er zo uit:

# Marcus werkte in de projectdirectory met Claude Code CLI
# Eerst context instellen
claude "Read through /src/modules/shipment/ and /src/lib/database/schema.ts. 
I need you to understand the existing patterns before we build the 
invoicing module."

# Daarna, de werkelijke bouwinstructie met de architectuurbeknotting
claude "Build the invoicing module following the architecture brief in 
/docs/briefs/invoicing.md. Follow the exact same patterns as the 
shipment module for service layer, repository layer, and route handlers. 
Use the existing error handling middleware. Write tests for all 
business logic in the service layer."

Claude Code zou dan de module genereren — meestal 15-30 bestanden inclusief types, schemas, services, repositories, route handlers, middleware en tests. Marcus zou de output beoordelen, correcties aanbrengen en herhalen. De hele cyclus voor een middelgroot complexe module duurde ongeveer 2-3 uur in plaats van 2-3 dagen die het een senior developer zou kosten.

De herhalingslus

Dit is wat niemand je vertelt over AI-ondersteunde ontwikkeling: de eerste output is zelden productieklaar. Het is misschien 70-80% daar. Maar die resterende 20-30% is waar de expertise van de architect het meest uitmaakt.

Marcus ontwikkelde een ritme:

  1. Genereren — Claude Code produceert de initiële implementatie
  2. Beoordelen — Marcus leest elk bestand door en markeert problemen
  3. Verfijnen — Specifieke correcties teruggevoerd naar Claude Code
  4. Versterken — Marcus handelt handmatig beveiligingskritieke secties af
  5. Testen — Voer de gegenereerde tests uit, voeg randgevallen toe die Claude miste

Deze lus ging meestal door 2-3 cycli per module. Tegen het derde maand van het project produceerde Claude Code eerste-pas-code die dichter bij 85-90% productieklaar was, omdat de codebase genoeg vastgestelde patronen had om te volgen.

De tech stack en architectuurbeslissingen

We kozen de stack doelbewust om AI-ondersteunde productiviteit te maximaliseren:

  • Next.js 14 (App Router) — voor de klantportal en admin dashboard
  • Node.js met Fastify — voor de API-laag (los van Next.js)
  • PostgreSQL — primaire database
  • Redis — caching, sessiebeheer, real-time pub/sub
  • Drizzle ORM — typeveilige databasetoegang
  • Turborepo — monorepo-beheer
  • Vercel — frontend-implementatie
  • AWS (ECS Fargate) — API en achtergrondworkers

We kozen Next.js specifiek omdat de patronen goed vastgesteld zijn en Claude Code diepgaande trainingsgegevens over App Router-conventies heeft. Dit is belangrijker dan mensen denken. Als we iets exotisch als een op Rust gebaseerde backend met HTMX hadden gekozen, zou de AI-outputkwaliteit aanzienlijk gedaald zijn. Je kunt meer leren over hoe we Next.js-ontwikkeling op schaal benaderen.

Drizzle ORM was een doelbewuste keuze boven Prisma voor dit project. Claude Code genereert betere Drizzle-schema's omdat ze gewoon TypeScript zijn — geen aangepaste DSL om fout mee te gaan. Plus, het verhaallijn van migratie is eenvoudiger wanneer je veel schemawijzigingen snel genereert.

// Voorbeeld: Claude Code genereerde dit facturaaschema 
// in eerste instantie met minimale correcties nodig
import { pgTable, uuid, varchar, decimal, timestamp, pgEnum } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
import { shipments } from './shipments';
import { organizations } from './organizations';

export const invoiceStatusEnum = pgEnum('invoice_status', [
  'draft', 'pending', 'sent', 'paid', 'overdue', 'cancelled', 'refunded'
]);

export const invoices = pgTable('invoices', {
  id: uuid('id').primaryKey().defaultRandom(),
  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
  shipmentId: uuid('shipment_id').references(() => shipments.id),
  invoiceNumber: varchar('invoice_number', { length: 50 }).notNull().unique(),
  status: invoiceStatusEnum('status').notNull().default('draft'),
  subtotal: decimal('subtotal', { precision: 12, scale: 2 }).notNull(),
  taxAmount: decimal('tax_amount', { precision: 12, scale: 2 }).notNull().default('0'),
  totalAmount: decimal('total_amount', { precision: 12, scale: 2 }).notNull(),
  currency: varchar('currency', { length: 3 }).notNull().default('USD'),
  dueDate: timestamp('due_date', { withTimezone: true }).notNull(),
  paidAt: timestamp('paid_at', { withTimezone: true }),
  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
});

export const invoiceRelations = relations(invoices, ({ one, many }) => ({
  organization: one(organizations, {
    fields: [invoices.organizationId],
    references: [organizations.id],
  }),
  shipment: one(shipments, {
    fields: [invoices.shipmentId],
    references: [shipments.id],
  }),
  lineItems: many(invoiceLineItems),
}));

Waar Claude Code goed in was

Laat me specifiek zijn. Dit is waar Claude Code werkelijk de ontwikkeling versnelde:

Boilerplate en CRUD-bewerkingen

Dit is de voor de hand liggende. REST-eindpunten genereren, requestvalidatieschema's (we gebruikten Zod), responsserializers, basismethoden van services — Claude Code sloeg dit in minuten uit. Over het hele project schatten we dat er ongeveer 180 API-eindpunten waren. Misschien 140 daarvan waren standaard CRUD- of querybewerkingen die Claude Code met minimale revisie genereerde.

Testgeneratie

Claude Code schreef ruwweg 2.400 tests over het hele project. Waren ze allemaal perfect? Nee. Ongeveer 15% had aanzienlijke herwerking nodig. Maar 85% van je testsuite gegenereerd en werkend hebben is een enorme tijdsbesparing. Marcus concentreerde zijn teststrategie op integratietests en de lastige randgevallen die Claude Code niet kon voorzien.

UI-componentontwikkeling

De klantportal had ongeveer 60 unieke paginaweergaven. Voor elk zou Marcus de Figma-ontwerpreferentie en het API-contract verstrekken, en Claude Code zou de React-componenten, hooks voor gegevensfetching (we gebruikten TanStack Query), formulierverwerking met React Hook Form + Zod, en laad-/foutstatussen genereren. De output was consistent goed — misschien 75% pixelnauwkeurig bij eerste generatie.

Databasemigraties en schemaëvolutie

Naarmate de vereisten zich ontwikkelden (en dat doen ze altijd), handelde Claude Code schemamigraties soepel af. Beschrijf de wijziging die je nodig hebt, en het genereert het migratiebestand, werkt het schema bij, werkt beïnvloede queries bij en past de TypeScript-types aan. Wat vroeger een voorzichtige refactoring van 45 minuten was, werd een 10-minuten beoordeel-en-goedkeuren-cyclus.

Documentatie

Claude Code genereerde API-documentatie, inlinecodecommentaar, README-bestanden en zelfs runbook-documenten voor bewerkingen. Marcus zou beoordelen en aanpassen, maar de basisoutput was werkelijk bruikbaar. We eindigden met betere documentatie dan 90% van de projecten die ik heb gezien, gewoon omdat de kosten van het genereren ervan zo laag waren.

Waar Claude Code faalde en wat we eraan deden

Dit gedeelte is belangrijker dan de succesverhalen. Als je van plan bent AI op deze manier te gebruiken, moet je weten waar de grenzen liggen.

Complexe bedrijfslogica met meerdere afhankelijkheden

De verzendingsrouteringsengine — die rekening moest houden met beschikbaarheid van vervoerders, kostenoptimalisatie, douanevereisten, bezorgingsvensters en capaciteitsbeperkingen tegelijkertijd — lag buiten wat Claude Code goed kon handelen. Het zou iets genereren dat plausibel leek, maar subtiele logicafouten had die echt geld konden kosten.

Marcus schreef deze module met de hand. Duurde ongeveer twee weken. Dit is precies het soort werk dat rechtvaardigt dat je een senior architect hebt in plaats van te proberen alles via AI door te voeren.

Beveiligingskritieke code

We hebben Claude Code nooit vertrouwd met auth-flows, betalingsverwerking of versleuteling zonder lijn-voor-lijn review. En terecht — het genereerde af en toe JWT-validatie die technisch functioneel was, maar subtiele cases miste zoals vervaltijd-klokscheve, of saniteerde inputs niet goed voor databasequeries ondanks het gebruik van een ORM.

Feitelijk: als een bug in deze code geld kon kosten of gegevens kon blootstellen, schrijft een mens het en beoordeelt een ander mens het.

Architectuurconsistentie op lange termijn

Tegen maand drie was de codebase groot genoeg dat Claude Code af en toe patronen zou "vergeten" die eerder waren vastgesteld, zelfs met gegeven context. Het zou bij één module een ander foutafhandelingspakket gebruiken versus een ander. Marcus moest waakzaam zijn over het vangen van deze inconsistenties.

We verminderden dit door een levend "conventies"-document te handhaven dat in elke Claude Code-sessie werd opgenomen. Denk eraan als een stijlgids, maar voor architectuurpatronen.

Prestatieoptimalisatie

Claude Code genereert code die werkt maar genereert niet altijd code die snel is. Databasequeries die N+1-fetches doen. React-componenten die onnodig opnieuw renderen. API-eindpunten die meer gegevens laden dan nodig.

Marcus besteedde ongeveer 20% van zijn beoordelingstijd aan prestatieoptimalisatie. Niet misdadig, maar iets om voor in te calculeren.

De economie: kostenoverzicht en rendement

Dit is het deel waar iedereen naar verlangt. Werkelijke nummers.

Kostencategorie Traditioneel team (schatting) AI-versneld (werkelijk)
Engineeringsalarissen (18 mnd / 5 mnd) $1.890.000 $175.000
Claude Code API / abonnement $0 $12.400
Infra (dev/staging) $48.000 $8.200
Projectbeheer $216.000 $0*
QA / Testen $180.000 $22.000**
Ontwerp (uitbesteed) $120.000 $95.000
DevOps / Infra-setup $96.000 $35.000
Totaal $2.550.000 $347.600

Marcus beheerde zelf met Linear voor taaktracking. Geen PM-overhead.

*Legde een QA-specialist voor de laatste 6 weken vast.

De Claude Code-kosten breken af tot ongeveer $ 2.500 per maand. Dat is het Max-plan ($ 100/maand voor het abonnement) plus API-kosten voor uitgebreide sessies. Sommige dagen zou Marcus $ 150-200 in API-oproepen verbranden tijdens zware generatiesessies. De meeste dagen was het $ 40-80.

Het project werd gefactureerd op $ 2 miljoen. Onze totale leveringskosten waren onder $ 350.000. Ik zal je de margeberekening laten doen.

Snelheidsverergelijking

Mijlpaal Traditionele tijdlijn AI-versnelde tijdlijn
Architectuur & ontwerp 6 weken 3 weken
Kernplatform (auth, multi-tenancy, basis API) 10 weken 3 weken
Functieeontwikkeling (alle modules) 32 weken 10 weken
Integraties (14 third-party API's) 12 weken 4 weken
Testen & QA 8 weken 3 weken
Implementatie & verharding 4 weken 2 weken
Totaal 72 weken 25 weken

Lessen voor teams die AI-versnelde ontwikkeling overwegen

Na dit project ben ik veel nagedacht over wat dit betekent voor hoe we software voortaan bouwen. Dit zou ik tegen elk team of bureau zeggen dat dit benaderen overweegt.

Je hebt nog steeds een senior architect nodig. Misschien meer dan ooit.

AI elimineert niet de behoefte aan expertise — het versterkt wat voor expertise (of gebrek daaraan) je meebrengt. Een junior developer die Claude Code gebruikt, zal junior-kwaliteitscode sneller verzenden. Een senior architect met Claude Code verstuurt senior-kwaliteitscode met een snelheid die eerder onmogelijk was.

Het slechtst mogelijke scenario is een mid-level developer die denkt senior te zijn en die AI gebruikt om code te genereren die ze niet goed kunnen evalueren. Dat is hoe je een codebase krijgt die oppervlakkig goed uitziet, maar instort onder belasting.

Conventie boven configuratie, overal

Hoe voorspelbaarder je codebase-patronen zijn, hoe beter AI functioneert. We gebruikten dezelfde bestandsstructuur, naamconventies en codeorganisatie in elke module. Deze consistentie leverde massale dividenden op naarmate Claude Code leerde bestaande patronen te evenaren.

Als je werkt met een headless CMS-architectuur, hebben strikte conventies voor inhoudstypen, API-routes en componentstructuren AI-gegenereerde code dramatisch betrouwbaarder.

Investeer in architectuurbeknoptingen

De kwaliteit van Claude Code's output correleerde direct met de kwaliteit van Marcus's architectuurbeknoptingen. Vage instructies produceerden vage code. Gedetailleerde beknoptingen met expliciete gegevensmodellen, bedrijfsregels en integratievereisten produceerden code die dicht bij productieklaar was.

We schatten dat Marcus ongeveer 30% van zijn tijd aan het schrijven van architectuurbeknoptingen en het beoordelen van output besteedde, en 70% van de tijd die een traditioneel team voor werkelijke implementatie nodig zou hebben, werd door Claude Code afgehandeld.

AI-ondersteunde ontwikkeling verandert prijsmodellen

Als je een bureau bent, dit is het ongemakkelijke gesprek. Wanneer één architect kan leveren wat vroeger een team van 8 vereiste, hoe prijs je? Wij geloven in waarde-gebaseerde prijsstelling — de klant betaalt voor het resultaat, niet voor de uren. Het platform is $ 2 miljoen waard ongeacht of het 1 persoon of 10 kostte om het te bouwen.

Als je geïnteresseerd bent in hoe dit soort benadering voor je project zou kunnen werken, onze prijspagina geeft uiteen hoe we denken over projectomvang in deze nieuwe werkelijkheid.

Niet elk project past in dit model

Dit werkte omdat:

  • De vereisten waren goed gedefinieerd (logistiek is een volwassen domein)
  • We hadden een werkelijk senior architect beschikbaar
  • De tech stack was mainstream (goede AI-trainingsgegevens)
  • De klant vertrouwde ons om zonder micromanagement van de teamgrootte te leveren

Projecten met vage vereisten, zware R&D-componenten of gespecialiseerde domeinen (medische apparaten, financiële instrumenten met regelgevingsvereisten) hebben meer menselijke oordeelsvorming nodig en moeten dienovereenkomstig worden bezet.

Voor projecten gebouwd met frameworks als Astro waar het ecosysteem nieuwer is en AI-trainingsgegevens dunner, zul je minder versnelling van AI-hulpmiddelen zien vergeleken met React/Next.js-projecten.

Veelgestelde vragen

Hoeveel kost Claude Code werkelijk per maand voor intensieve ontwikkelingsbehoefte?

Op dit project gemiddeld $ 2.500/maand all-in. Het Claude Max-abonnement is $ 100/maand (of $ 200/maand voor de hogere laag vanaf begin 2025), en API-gebruik voor Claude Code's agentische sessies loopt op naargelang je hoeveel code genereert. Zware dagen raakten $ 150-200 in API-kosten. Lichte herzienings- en verfijningsdagen waren $ 40-80. Anthropic heeft ook het Max-plan geïntroduceerd op $ 200/maand wat aanzienlijk gebruik bevat dat variabele kosten zou kunnen verminderen.

Kan een junior developer Claude Code op dezelfde manier gebruiken?

Nee, en dit is belangrijk. Claude Code versterkt je bestaande vaardigheidsniveau — het vervangt architectuurkennis niet. Een junior developer die Claude Code gebruikt, genereert code sneller, maar ze vangt niet de subtiele bugs, beveiligingskwesties, prestatieroblemen of architectuurinconsistenties op die een senior engineer onmiddellijk opmerkt. Je hebt iemand nodig die de output kan evalueren, niet alleen maar accepteren.

Hoe zit het met codekwaliteit — is AI-gegenereerde code onderhoudbaar?

Het hangt volledig af van de beperkingen die je eraan geeft. Onze gegenereerde code sloot aan op dezelfde linting-regels, typechecking en code-beoordeelingsstandaarden als mengeschreven code. Het trucje is om vroeg in het project sterke patronen in te stellen zodat de AI goede voorbeelden heeft om te volgen. We behielden een live "conventies"-document dat in elke Claude Code-sessie werd opgenomen. Zes maanden na lancering heeft het team dat het platform onderhoudt geen ongebruikelijke onderhoudsbelasting gerapporteerd.

Werkt deze aanpak voor frontend-zware projecten?

Ja, met kanttekeningen. Claude Code is uitstekend in het genereren van React-componenten, formulierverwerking, data-fetching hooks en state management code. Het is minder betrouwbaar in het produceren van pixelperfecte CSS-indelingen uit ontwerpen — je hebt meer herhalingscycli nodig voor visuele fijnslijping. We vonden het ongeveer 75% nauwkeurig bij eerste-pas UI-generatie vergeleken met 85-90% voor backend-code.

Hoe ga je met code-review om wanneer er maar één developer is?

Marcus beoordeelde elk regelje AI-gegenereerde code zelf. We brachten ook een gelegde beveiligingsspecialist voor twee gerichte auditsessies tijdens het project in (week 12 en week 22). Voor de eindcyclus sloot een QA-specialist zich voor zes weken aan. Het gebrek aan peer code review is een werkelijk risico — we beperken het met geautomatiseerde tools (TypeScript strikte modus, ESLint met agressieve regels, Vitest met dekking-drempels) en externe audits.

Wat gebeurt er wanneer Claude Code buggy code genereert?

Het gebeurt regelmatig. De eerste pass is zelden perfect. We bouwden deze verwachting in de workflow in — genereren, beoordelen, verfijnen, versterken. De meeste bugs werden opgemerkt door Marcus' beoordelingscyclus. De geautomatiseerde testsuite (ook grotendeels door AI gegenereerd maar mensbeoordeling) ving terugvalbaarskwesties op. Het sleutelinzicht is dat debuggen van AI-gegenereerde code sneller is dan correct code van nul af aan schrijven, omdat je begint met iets dat grotendeels juist is.

Is dit alleen haalbaar voor greenfield-projecten, of werkt het met bestaande codebases?

Claude Code werkt werkelijk goed met bestaande codebases omdat het bestaande patronen kan lezen en begrijpen. Op dit project profiteerden latere modules van eerdere modules als referentie. We hebben Claude Code sindsdien voor toevoeging van functies op bestaande klantprojecten met goede resultaten gebruikt. Het sleutelstuk is het geven van genoeg context over bestaande conventies en patronen. Als je codebase inconsistent of slecht gedocumenteerd is, zullen AI-gegenereerde toevoegingen die inconsistentie erven.

Zou je dit opnieuw doen?

Absoluut. We doen het al. Twee meer projecten draaien nu met dit model — een met een enkele architect, een ander met twee engineers voor een complexer systeem. De economie is te fascinerend om te negeren. Maar ik wil duidelijk zijn: dit gaat niet om developers vervangen. Het gaat om het veranderen van de verhouding van senior architects tot output. Je hebt nog steeds menselijke expertise nodig. Je hebt alleen minder menselijk typen nodig. Als je een project overweegt en wilt verkennen hoe dit model voor je zou kunnen werken, neem contact met ons op — we helpen graag door te spreken of het een geschikt moment is.