Im letzten Jahr versendeten wir eine Plattform im Wert von 2 Millionen Dollar. Das gesamte Engineering-Team? Ein Senior-Architekt und Claude Code. Kein Offshore-Team. Keine Armee von Auftragnehmern. Nur eine Person, die wusste, was sie baute, kombiniert mit einer AI, die tatsächlich Production-Code schreiben konnte.

Ich schreibe das nicht, um AI zu hype-en. Ich wurde vom Hype-Zyklus schon oft genug enttäuscht. Ich schreibe das, weil das, was in diesem Projekt passierte, grundlegend verändert hat, wie ich über Teamkomposition, Projektschätzung und das, was möglich ist, wenn man tiefes architektonisches Wissen mit AI-gestützter Entwicklung kombiniert, denke. Die Zahlen sprechen für sich — wir erreichten Meilensteine, die ein traditionelles Team von 6-8 Ingenieuren etwa 18 Monate gebraucht hätte, und wir machten es in unter 5 Monaten.

Lasst mich euch genau zeigen, wie.

Inhaltsverzeichnis

Das Projekt: Was wir tatsächlich bauten

Ich kann den Client nicht nennen — NDA-Gebiet — aber ich kann die Plattform beschreiben. Es ist ein B2B SaaS-Produkt im Logistik-Bereich. Multi-Tenant-Architektur. Echtzeit-Tracking-Dashboards. Komplexe rollenbasierte Zugriffskontrolle über Organisationen, Teams und einzelne Benutzer hinweg. Integration mit 14 verschiedenen Drittanbieter-APIs (Carrier, Zahlungsverarbeiter, Zolldatenbanken). Ein kundengerichtetes Portal und ein internes Admin-System.

Die Art von Projekt, bei dem man in einer typischen Agentur-Einstellung mit einem Tech Lead, 2-3 Senior Devs, ein paar Mid-Levels, einer dedizierten DevOps-Person und vielleicht einem QA-Ingenieur besetzt würde. Die ursprüngliche Schätzung des Clients von einer anderen Agentur war 3,2M Dollar über 20 Monate mit einem Team von 9 Personen.

Wir schlugen 2M Dollar, 5 Monate, ein Architekt vor. Sie dachten, wir wären verrückt. Ehrlich gesagt? Das tat ich auch, ein bisschen.

Warum ein Architekt statt ein vollständiges Team

Hier ist das Kontraintuitive an kleinen Teams: Der Kommunikations-Overhead bei einem 9-köpfigen Projekt ist enorm. Fred Brooks schrieb 1975 darüber und es ist immer noch wahr. Mit 9 Ingenieuren haben Sie 36 potenzielle Kommunikationskanäle. Meetings vermehren sich. Merge Conflicts werden zum täglichen Ritual. Jemand ist immer blockiert und wartet auf die PR-Überprüfung von jemandem anders.

Bei einem Architekten lebt der gesamte Systemzustand im Kopf einer Person. Es gibt keine Kontext-Umschalt-Belastung durch die Erklärung Ihres Ansatzes in einem Pull Request. Keine Design-by-Committee. Keine zweistündigen Sprint-Planungssitzungen.

Aber eine Person kann nur so schnell tippen. Eine Person kann nur so viele Dateien im Arbeitsspeicher halten. Eine Person wird um 18 Uhr müde und macht Fehler um 20 Uhr.

Hier kommt Claude Code ins Spiel. Nicht als Ersatz für den Architekten, sondern als Force Multiplier. Der Architekt trifft jede Entscheidung. Claude Code führt mit einer Geschwindigkeit aus, die andernfalls 4-5 Entwickler erfordern würde.

Die Rolle des Architekten

Unser Architekt — nennen wir ihn Marcus — hat 15 Jahre Erfahrung. Er hat Systeme in dieser Größenordnung schon gebaut. Seine Aufgabe in diesem Projekt war:

  • Systemdesign und Architekturentscheidungen
  • Definition von Modulgrenzen und Datenverträgen
  • Schreiben des Critical-Path-Codes (Auth, Payment Processing, Data Pipeline Orchestration)
  • Überprüfung und Verfeinerung von allem, was Claude Code produzierte
  • Infrastruktur- und Deployment-Architektur
  • Security Audits

Was er nicht tat: Boilerplate-CRUD-Endpoints schreiben, UI-Komponenten aus Designs bauen, Unit Tests für unkomplizierte Logik schreiben, Datenbankmigrationen erstellen oder neue Services scaffolden. Claude Code kümmerte sich um all das.

Wie Claude Code tatsächlich in einen echten Workflow passt

Lasst mich konkret sagen, wie "Claude Code nutzen" im Alltag aussah, denn die Marketingmaterialien erfassen die Realität nicht.

Marcus würde jeden Morgen damit beginnen, die Arbeit des Tages auf strukturierte Weise zu definieren. Keine vagen Prompts wie "baue mir ein User-Management-System." Stattdessen erstellte er das, was wir "Architektur-Briefe" zu nennen begannen — detaillierte Dokumente, die Folgendes spezifizierten:

  1. Die Verantwortung und Grenzen des Moduls
  2. Datenmodelle mit exakten Feldtypen und Beziehungen
  3. API-Vertrag (Endpoints, Request/Response-Shapes)
  4. Geschäftsregeln und Edge Cases
  5. Fehlerbehandlungs-Erwartungen
  6. Welche vorhandenen Module es integrieren musste

Dann würde er diese in Chunks an Claude Code übergeben. Eine typische Sitzung sah so aus:

# Marcus würde mit der Claude Code CLI im Projektverzeichnis arbeiten
# Zuerst, Kontextherstellung
claude "Lesen Sie /src/modules/shipment/ und /src/lib/database/schema.ts. 
Ich muss, dass Sie die bestehenden Muster verstehen, bevor wir das 
Rechnungsmodul bauen."

# Dann, die tatsächliche Build-Anweisung mit dem Architektur-Brief
claude "Baue das Rechnungsmodul nach dem Architektur-Brief in 
/docs/briefs/invoicing.md. Folge den gleichen Mustern wie das 
Shipment-Modul für Service Layer, Repository Layer und Route Handler. 
Verwende die bestehende Error Handling Middleware. Schreibe Tests für alle 
Geschäftslogik in der Service Layer."

Claude Code würde dann das Modul generieren — typischerweise 15-30 Dateien einschließlich Types, Schemas, Services, Repositories, Route Handler, Middleware und Tests. Marcus würde die Ausgabe überprüfen, Korrektionen vornehmen und iterieren. Der gesamte Zyklus für ein mittel-komplexes Modul dauerte etwa 2-3 Stunden statt der 2-3 Tage, die ein Senior Developer brauchen würde.

Die Iterations-Schleife

Hier ist das, was niemand über AI-gestützte Entwicklung erzählt: Die erste Ausgabe ist selten produktionsreif. Sie ist vielleicht 70-80% da. Aber diese verbleibenden 20-30% sind dort, wo die Expertise des Architekten am meisten zählt.

Marcus entwickelte einen Rhythmus:

  1. Generieren — Claude Code produziert die erste Implementierung
  2. Überprüfen — Marcus liest jede Datei, kennzeichnet Probleme
  3. Verfeinern — Spezifische Korrektionen an Claude Code zurück
  4. Härten — Marcus handhabt sicherheitskritische Abschnitte manuell
  5. Testen — Führen Sie die generierten Tests aus, fügen Sie Edge Cases ein, die Claude verpasst hat

Diese Schleife durchlief typischerweise 2-3 Zyklen pro Modul. Im dritten Monat des Projekts produzierte Claude Code Code im ersten Durchgang, der näher an 85-90% produktionsreif war, weil das Codebase genug Muster hatte, die es befolgen konnte.

Der Tech Stack und Architekturentscheidungen

Wir wählten den Stack bewusst, um die AI-gestützte Produktivität zu maximieren:

  • Next.js 14 (App Router) — für das Kundenportal und Admin-Dashboard
  • Node.js mit Fastify — für die API-Schicht (getrennt von Next.js)
  • PostgreSQL — primäre Datenbank
  • Redis — Caching, Session Management, Echtzeit Pub/Sub
  • Drizzle ORM — typsicherer Datenbankzugriff
  • Turborepo — Monorepo-Verwaltung
  • Vercel — Frontend-Deployment
  • AWS (ECS Fargate) — API und Background Worker

Wir entschieden uns für Next.js speziell, weil die Muster gut etabliert sind und Claude Code tiefe Trainingsdaten zu App Router-Konventionen hat. Das ist wichtiger als Menschen denken. Wenn wir etwas Exotisches wie ein Rust-basiertes Backend mit HTMX gewählt hätten, würde die AI-Ausgabequalität erheblich sinken. Sie können mehr über unseren Ansatz zu Next.js Entwicklung im großen Maßstab erfahren.

Drizzle ORM war eine bewusste Wahl über Prisma für dieses Projekt. Claude Code generiert bessere Drizzle-Schemas, weil sie nur TypeScript sind — keine benutzerdefinierte DSL, die falsch gemacht werden kann. Außerdem ist die Migrations-Geschichte einfacher, wenn Sie schnell viele Schema-Änderungen generieren.

// Beispiel: Claude Code generierte dieses Invoice-Schema 
// im ersten Durchgang mit minimalen Korrektionen erforderlich
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),
}));

Was Claude Code gut konnte

Lasst mich konkret sagen. Hier ist, wo Claude Code die Entwicklung wirklich beschleunigte:

Boilerplate und CRUD-Operationen

Das ist die offensichtliche. Generierung von REST-Endpoints, Request-Validierungsschemas (wir verwendeten Zod), Response-Serialisierer, einfache Service-Methoden — Claude Code erledigte diese in Minuten. Im gesamten Projekt schätzen wir, dass es etwa 180 API-Endpoints gab. Etwa 140 davon waren Standard-CRUD oder Query-Operationen, die Claude Code mit minimaler Überarbeitung generierte.

Test-Generierung

Claude Code schrieb etwa 2.400 Tests im gesamten Projekt. Waren sie alle perfekt? Nein. Etwa 15% brauchten erhebliche Überarbeitungen. Aber 85% Ihrer Test Suite generiert und funktionierend zu haben, ist ein massiver Zeitsparfaktor. Marcus konzentrierte seine Test-Energien auf Integrationstests und die kniffligen Edge Cases, die Claude Code nicht antizipieren konnte.

UI-Komponenten-Entwicklung

Das Kundenportal hatte etwa 60 eindeutige Seitenansichten. Für jede würde Marcus die Figma-Design-Referenz und den API-Vertrag bereitstellen, und Claude Code würde die React-Komponenten generieren, Hooks zum Abrufen von Daten (wir verwendeten TanStack Query), Form-Handling mit React Hook Form + Zod und Lade-/Fehlerzustände. Die Ausgabe war konsistent gut — vielleicht 75% pixelgenau im ersten Generation.

Datenbankmigrationen und Schema-Entwicklung

Als sich die Anforderungen änderten (und sie ändern sich immer), handhabte Claude Code Schema-Migrationen reibungslos. Beschreiben Sie die Änderung, die Sie brauchen, und es generiert die Migrationsdatei, aktualisiert das Schema, aktualisiert betroffene Abfragen und passt die TypeScript-Typen an. Was früher eine 45-minütige sorgfältige Refactoring-Sitzung war, wurde zu einem 10-minütigen Review-and-Approve-Zyklus.

Dokumentation

Claude Code generierte API-Dokumentation, Inline-Code-Kommentare, README-Dateien und sogar Runbook-Dokumente für Operationen. Marcus würde überprüfen und anpassen, aber die Baseline-Ausgabe war wirklich nützlich. Wir endeten mit einer besseren Dokumentation als 90% der Projekte, die ich gesehen habe, einfach weil die Kosten für das Generieren so niedrig waren.

Wo Claude Code scheiterte und was wir dagegen taten

Dieser Abschnitt ist wichtiger als die Erfolgsgeschichten. Wenn Sie planen, AI auf diese Weise zu verwenden, müssen Sie wissen, wo die Wände sind.

Komplexe Geschäftslogik mit mehreren Abhängigkeiten

Die Shipment-Routing-Engine — die Carrier-Verfügbarkeit, Kostenoptimierung, Zollanforderungen, Lieferfenster und Kapazitätsbeschränkungen gleichzeitig berücksichtigen musste — war jenseits von dem, was Claude Code gut handhaben konnte. Es würde etwas generieren, das plausibel aussah, aber subtile Logikfehler hatte, die echtes Geld kosten könnten.

Marcus schrieb dieses Modul von Hand. Dauerte etwa zwei Wochen. Das ist genau die Art von Arbeit, die rechtfertigt, einen Senior-Architekten zu haben, statt zu versuchen, sich mit AI durch alles zu quetschen.

Sicherheitskritischer Code

Wir vertrauten Claude Code nie mit Auth-Flows, Payment Processing oder Verschlüsselung ohne Zeile-für-Zeile-Überprüfung. Und mit Recht — es generierte gelegentlich JWT-Validierung, die technisch funktional war, aber Edge Cases wie Token-Verfallsuhr-Skew verpasste oder keine Eingaben vor Datenbankabfragen bereinigt, trotz Verwendung eines ORM.

Faustregel: Wenn ein Bug in diesem Code Geld verlieren oder Daten preisgeben könnte, schreibt ein Mensch ihn und ein anderer Mensch überprüft ihn.

Langfristige architektonische Konsistenz

Bis Monat drei war die Codebasis groß genug, dass Claude Code manchmal die früher etablierten Muster "vergessen" würde, selbst wenn Kontexte bereitgestellt wurden. Es könnte einen anderen Fehlerbehandlungsansatz in einem Modul gegenüber einem anderen verwenden. Marcus musste wachsam sein, um diese Inkonsistenzen zu fangen.

Wir verminderten dies durch die Verwaltung eines lebendigen "Konventionen"-Dokuments, das in jede Claude Code-Sitzung aufgenommen wurde. Denken Sie daran als einen Style Guide, aber für architektonische Muster.

Performance-Optimierung

Claude Code generiert Code, der funktioniert, aber nicht immer Code, der schnell ist. Datenbankabfragen, die N+1-Abrufe durchführen. React-Komponenten, die unnötig neu rendern. API-Endpoints, die mehr Daten laden als nötig.

Marcus verbrachte etwa 20% seiner Überprüfungszeit auf Performance-Optimierung. Kein Dealbreaker, aber etwas zum Budget.

Die Wirtschaftlichkeit: Kostenaufschlüsselung und ROI

Hier ist der Teil, den jeder sehen möchte. Echte Zahlen.

Kostenkategorie Traditionelles Team (Est.) AI-Beschleunigt (Aktuell)
Engineering-Gehälter (18 Mo / 5 Mo) $1.890.000 $175.000
Claude Code API / Abonnement $0 $12.400
Infrastruktur (dev/staging) $48.000 $8.200
Projektmanagement $216.000 $0*
QA / Testen $180.000 $22.000**
Design (kontrahiert) $120.000 $95.000
DevOps / Infrastruktur-Setup $96.000 $35.000
Gesamt $2.550.000 $347.600

Marcus verwaltete sich selbst mit Linear für Task-Tracking. Kein PM-Overhead.

*Konzertierte einen QA-Spezialisten für die letzten 6 Wochen.

Die Claude Code-Kosten belaufen sich auf etwa $2.500/Monat. Das ist der Max-Plan ($100/Monat für das Abonnement) plus API-Kosten für erweiterte Sitzungen. An manchen Tagen würde Marcus $150-200 in API-Aufrufen während schwerer Generierungssitzungen verbrennen. Die meisten Tage waren $40-80.

Das Projekt wurde mit $2M abgerechnet. Unsere Gesamtlieferkosten waren unter $350K. Ich lasse Sie die Margin-Mathematik machen.

Geschwindigkeits-Vergleich

Meilenstein Traditionelle Timeline AI-Beschleunigte Timeline
Architektur & Design 6 Wochen 3 Wochen
Kern-Plattform (Auth, Multi-Tenancy, Base API) 10 Wochen 3 Wochen
Feature-Entwicklung (alle Module) 32 Wochen 10 Wochen
Integrationen (14 Drittanbieter-APIs) 12 Wochen 4 Wochen
Testen & QA 8 Wochen 3 Wochen
Deployment & Härten 4 Wochen 2 Wochen
Gesamt 72 Wochen 25 Wochen

Lektionen für Teams, die AI-beschleunigte Entwicklung in Betracht ziehen

Nach diesem Projekt habe ich viel darüber nachgedacht, was das für die Art bedeutet, wie wir Software in Zukunft bauen. Hier ist das, was ich jedem Team oder jeder Agentur, die diesen Ansatz in Betracht zieht, sagen würde.

Sie brauchen immer noch einen Senior-Architekten. Vielleicht mehr denn je.

AI beseitigt nicht die Notwendigkeit für Expertise — sie verstärkt jede Expertise (oder deren Mangel), die Sie mitbringen. Ein Junior Developer, der Claude Code nutzt, wird Junior-Qualität Code schneller versenden. Ein Senior-Architekt, der Claude Code nutzt, wird Senior-Qualität Code bei einer Geschwindigkeit versenden, die vorher unmöglich war.

Das schlimmste mögliche Szenario ist ein Mid-Level Developer, der denkt, er sei Senior und Claude Code nutzt, um Code zu generieren, den er nicht richtig bewerten kann. So entsteht eine Codebasis, die an der Oberfläche gut aussieht, aber unter Last zusammenbricht.

Konvention über Konfiguration, überall

Je vorhersehbarer die Muster Ihrer Codebasis sind, desto besser funktioniert die AI. Wir verwendeten die gleiche Dateistruktur, Naming-Konventionen und Code-Organisation in jedem Modul. Diese Konsistenz zahlte sich massiv aus, als Claude Code lernte, bestehende Muster zu folgen.

Wenn Sie mit einer Headless CMS-Architektur arbeiten, haben strikte Konventionen für Content Types, API Routes und Component Strukturen AI-generierten Code dramatisch zuverlässiger.

Investieren Sie in Architektur-Briefe

Die Qualität von Claude Codes Ausgabe korrelierte direkt mit der Qualität von Marcus's Architektur-Briefen. Vage Anweisungen produzierten vagen Code. Detaillierte Briefe mit expliziten Datenmodellen, Geschäftsregeln und Integrations-Anforderungen produzierten Code, der nah an produktionsreif war.

Wir schätzen, dass Marcus etwa 30% seiner Zeit mit Architektur-Briefen und Überprüfung von Ausgaben und 70% der Zeit, die ein traditionelles Team auf tatsächlicher Implementierung gebraucht hätte, brauchte, wurde von Claude Code gehandhabt.

AI-Gestützte Entwicklung ändert Preismodelle

Wenn Sie eine Agentur sind, ist das das unbequeme Gespräch. Wenn ein Architekt liefern kann, was früher ein Team von 8 brauchte, wie preisen Sie? Wir glauben an wertebasierte Preisgestaltung — der Client zahlt für das Ergebnis, nicht die Stunden. Die Plattform ist $2M wert, unabhängig davon, ob es 1 Person oder 10 zum Bauen brauchte.

Wenn Sie daran interessiert sind, wie diese Art Ansatz für Ihr Projekt funktionieren könnte, zerlegt unsere Preisseite wie wir über Projekt-Scoping in dieser neuen Realität denken.

Nicht jedes Projekt passt zu diesem Modell

Das funktionierte, weil:

  • Die Anforderungen gut definiert waren (Logistik ist ein reifer Bereich)
  • Wir einen wirklich Senior-Architekten verfügbar hatten
  • Der Tech Stack war Mainstream (großartige AI-Trainingsdaten)
  • Der Client vertraute uns, ohne die Teamgröße zu mikromanagen, zu liefern

Projekte mit mehrdeutigen Anforderungen, schwere R&D-Komponenten oder spezialisierte Domänen (medizinische Geräte, Finanzinstrumente mit Regulatory-Anforderungen) benötigen mehr menschliches Urteilsvermögen und sollten entsprechend besetzt werden.

Für Projekte, die mit Frameworks wie Astro gebaut werden, wo das Ökosystem neuer ist und die AI-Trainingsdaten dünner sind, sehen Sie weniger Beschleunigung aus AI-Tools verglichen mit React/Next.js Projekten.

FAQ

Wie viel kostet Claude Code tatsächlich pro Monat bei schwerer Entwicklungsnutzung?

In diesem Projekt haben wir durchschnittlich $2.500/Monat all-in gemacht. Das Claude Max-Abonnement ist $100/Monat (oder $200/Monat für die höhere Stufe ab Anfang 2025), und API-Nutzung für Claude Codes agentic Sitzungen addiert sich je nachdem, wie viel Code Sie generieren. Schwere Tage erreichen $150-200 in API-Kosten. Leichte Review-and-Refine-Tage waren $40-80. Anthropic hat auch den Max-Plan bei $200/Monat eingeführt, der erhebliche Nutzung umfasst, die variable Kosten reduzieren könnte.

Kann ein Junior Developer Claude Code auf die gleiche Weise nutzen?

Nein, und das ist wichtig. Claude Code verstärkt Ihr existierendes Skill-Level — es ersetzt nicht architektonisches Wissen. Ein Junior Developer, der Claude Code nutzt, wird Code schneller generieren, aber sie werden nicht die subtilen Bugs, Sicherheitsprobleme, Performance-Probleme oder architektonischen Inkonsistenzen fangen, die ein Senior Engineer sofort sieht. Sie brauchen jemanden, der die Ausgabe bewerten kann, nicht nur sie akzeptieren.

Was ist mit Code-Qualität — ist AI-generierter Code wartbar?

Es hängt ganz von den Einschränkungen ab, die Sie geben. Unser generierter Code bestand die gleichen Linting-Regeln, Type-Checking und Code-Review-Standards wie von Menschenhand geschriebener Code. Der Trick ist, starke Muster früh im Projekt zu etablieren, damit die AI gute Beispiele zum Folgen hat. Wir unterhalten ein lebendes "Konventionen"-Dokument, das in jede Claude Code-Sitzung aufgenommen wurde. Sechs Monate nach dem Launch hat das Team, das die Plattform wartet, keine ungewöhnliche Wartungslast berichtet.

Funktioniert dieser Ansatz für Frontend-schwere Projekte?

Ja, mit Caveats. Claude Code ist hervorragend beim Generieren von React-Komponenten, Form-Handling, Data-Fetching Hooks und State-Management Code. Es ist weniger zuverlässig bei der Erzeugung pixel-perfekter CSS-Layouts aus Designs — Sie benötigen mehr Iterations-Zyklen für visuelle Politur. Wir fanden, es war etwa 75% genau im ersten Durchgang UI-Generierung verglichen mit 85-90% für Backend-Code.

Wie handhaben Sie Code-Review, wenn es nur einen Developer gibt?

Marcus überprüfte jede Zeile AI-generierten Code selbst. Wir brachten auch einen konzierten Sicherheitsspezialisten für zwei fokussierte Audit-Sitzungen während des Projekts ein (Woche 12 und Woche 22). In der Endphase schloss sich ein QA-Spezialist für sechs Wochen an. Der Mangel an Peer-Code-Review ist ein echtes Risiko — wir verringerten es mit automatisiertem Tooling (TypeScript Strict Mode, ESLint mit aggressiven Regeln, Vitest mit Coverage Thresholds) und externen Audits.

Was passiert, wenn Claude Code fehlerhaften Code generiert?

Es passiert regelmäßig. Der erste Durchgang ist selten perfekt. Wir bauten diese Erwartung in den Workflow ein — Generieren, Überprüfen, Verfeinern, Härten. Die meisten Bugs wurden in Marcus's Review-Zyklus gefangen. Die automatisierte Test Suite (auch weitgehend AI-generiert, aber von Menschen überprüft) fing Regressions-Probleme. Der Schlüssel-Einblick ist, dass Debugging AI-generierten Codes schneller ist als das Schreiben von korrekt Code von Grund auf, weil Sie von etwas Großteils Richtigen beginnen.

Ist das nur für Greenfield-Projekte, oder funktioniert es mit bestehenden Codebases?

Claude Code funktioniert tatsächlich gut mit bestehenden Codebases, weil es bestehende Muster lesen und verstehen kann. In diesem Projekt profitierten die späteren Module von früheren Modulen als Referenz. Wir haben seitdem Claude Code für Feature-Ergänzungen auf bestehenden Client-Projekten mit guten Ergebnissen verwendet. Der Schlüssel ist, es genug Kontext über bestehende Konventionen und Muster zu geben. Wenn Ihre Codebasis inkonsistent oder schlecht dokumentiert ist, werden AI-generierte Ergänzungen diese Inkonsistenz erben.

Würden Sie das wieder tun?

Absolut. Wir tun es bereits. Zwei weitere Projekte laufen mit diesem Modell jetzt — eines mit einem einzelnen Architekten, ein anderes mit zwei Ingenieuren für ein komplexeres System. Die Wirtschaftlichkeit ist zu verlockend zum Ignorieren. Aber ich möchte klar sein: Das geht nicht darum, Entwickler zu ersetzen. Es geht um die Änderung des Verhältnisses von Senior-Architekten zu Output. Sie brauchen immer noch menschliches Fachwissen. Sie brauchen nur weniger menschliches Tippen. Wenn Sie ein Projekt in Betracht ziehen und erkunden möchten, was dieses Modell für Sie bedeuten könnte, kontaktieren Sie uns — wir sind gerne bereit, zu besprechen, ob es eine Anpassung ist.