6 days ago
5
Wie du mit Antigravity + Claude Code ein echtes AI‑Engineering‑Team baust
(inkl. Praxis‑Workflow, Tipps & Token‑Strategie)
Einleitung: Warum ein einziges AI‑Tool heute nicht mehr reicht
Wenn du schon einmal versucht hast, ein komplettes SaaS‑Produkt nur mit einem einzigen AI‑Tool zu bauen, kennst du das Problem:
- Am Anfang denkt das Modell noch klar, plant sauber und schreibt guten Code.
- Nach einigen Iterationen wird der Kontext zu groß.
- Du stößt an Token‑Grenzen, Rate Limits und immer öfter passieren:
– merkwürdige Halluzinationen
– kaputte Refactorings
– übersehene Dateien oder vergessene Abhängigkeiten.
Du bist nicht allein, wenn du dich fragst:
> „Warum fühlt es sich so an, als würde ich mit einem Supergenie arbeiten, das sich aber alle 30 Minuten an nichts mehr erinnern kann?“
Genau hier setzt der Hybrid‑Workflow mit Antigravity und Claude Code an.
In diesem Artikel zeige ich dir Schritt für Schritt, wie du:
- Antigravity (Google) als Planungs‑ und Orchestrierungszentrale nutzt
- Claude Code (Anthropic) als präzise Ausführungsmaschine für deinen Code einsetzt
- beide Tools wie ein koordiniertes AI‑Engineering‑Team behandelst – statt wie zwei voneinander getrennte Chatbots
Am Ende weißt du:
- Wie du eine vollwertige, produktionsreife SaaS‑App mit diesem Setup baust
- Wie du Token‑Kosten und Rate Limits clever umgehst
- Wie du Qualität, Geschwindigkeit und Kontrolle deutlich steigerst
1. Das Grundprinzip: Rollen trennen statt „One Big Agent“
Viele Teams machen aktuell denselben Fehler:
Sie werfen eine riesige Anforderung an ein Modell und erwarten, dass es:
- Architektur plant
- Code schreibt
- Dateien verwaltet
- refactort
- und dann noch Deployment konfiguriert.
Das ist, als würdest du eine einzige Person bitten, gleichzeitig CTO, Lead Engineer, DevOps, QA und Designer zu sein.
Der Hybrid‑Ansatz geht genau anders herum:
-
Antigravity
– denkt groß, plant, orchestriert
– baut Task Trees und Architekturpläne
– steuert Browser, Terminal und IDE -
Claude Code
– arbeitet präzise in deinem Code‑Repository
– führt strukturierte Multi‑File‑Edits aus
– übernimmt Backend, Refactoring, Setup und Integration
Optional:
- Gemini 3.1 Pro (über Antigravity)
– spezialisiert auf Frontend / UI
– generiert saubere, oft visuell ansprechende Frontends
Kurz gesagt:
Du baust dir ein Team aus Spezialisten – mit klar getrennten Rollen.
2. Die Werkzeuge im Überblick
2.1 Antigravity – Googles kostenloses Multi‑Agent‑AI‑IDE
Was ist Antigravity?
Antigravity ist eine kostenlose, agentische AI‑IDE von Google, die darauf ausgelegt ist, mehrere AI‑Agenten zu orchestrieren und diese direkt an deinem Rechner arbeiten zu lassen.
Fähigkeiten von Antigravity:
- Steuert den Browser (z.B. Doku lesen, StackOverflow, API‑Docs)
- Führt Terminal‑Kommandos aus
- Kann dein IDE‑Fenster steuern und im Code navigieren
- Arbeitet mit mehreren Agenten gleichzeitig
- Nutzt große Kontexte, z.B. Opus 4.6 mit 1M Token Kontext
Stärken von Antigravity:
- High‑Level Orchestrierung: Wer macht was, in welcher Reihenfolge?
- Planung: Komplettpläne, Roadmaps, Task Trees
- Überblick über große Codebasen
- Refactoring und Debugging auf Systemebene
Du kannst dir Antigravity als eine Art AI‑Projektleiter + Systemarchitekt vorstellen.
2.2 Claude Code – Anthropic’s Agent fürs Terminal & die IDE
Was ist Claude Code?
Claude Code ist ein spezialisiertes Tool von Anthropic, das direkt in deiner IDE oder im Terminal läuft und deinen Code liest, bearbeitet und Befehle ausführt.
Fähigkeiten von Claude Code:
- Versteht deine komplette Codebasis (Repository‑Kontext)
- Bearbeitet mehrere Dateien gleichzeitig auf strukturierte Weise
- Führt Shell‑Kommandos aus
- Kann Sub‑Agents starten, die parallel an Aufgaben arbeiten
- Perfekt für:
- Routine‑Tasks (CRUD, Boilerplate, Config)
- komplexe Refactorings
- Migrations
- Backend‑Logik
Stärken von Claude Code:
- Hohe Präzision bei Datei‑ und Code‑Änderungen
- Deterministischere Multi‑File‑Edits
- Sehr gut für Backend, Projekt‑Scaffolding und Integration
- Du behältst feine Kontrolle über jeden Schritt
Kurz: Claude Code ist dein Lead Developer, der in deinem Repo arbeitet und Anweisungen akribisch umsetzt.
2.3 Warum die Kombination so stark ist
Alleine sind die Tools schon beeindruckend. Zusammen werden sie zu einem echten AI‑Engineering‑Team:
- Antigravity: plant und koordiniert
- Claude Code: implementiert und refactort
- Optional Gemini: liefert starken Frontend‑Code
Vorteile dieser Kombination:
- Schnellere Iterationen
- Weniger Halluzinationen, weil:
- Planung und Ausführung sauber getrennt sind
- klare Tasklisten statt vager „Mach mal alles“-Prompts genutzt werden
- Token‑Sparen & Rate‑Limit‑Umgehung durch Lastverteilung:
- Breite, kontextintensive Arbeit → Antigravity (z.B. mit Opus)
- Präzise Code‑Arbeit → Claude Code
- Besser skalierbar für komplexe Apps und große Codebasen
3. Setup: Was du installieren und vorbereiten musst
3.1 Antigravity installieren
- Verfügbar für macOS, Windows, Linux
- Du brauchst nur ein Google‑Konto
- Nutzung ist kostenlos, allerdings mit gewissen Rate Limits
Typische Schritte:
- Installer von der offiziellen Seite herunterladen
- App starten, mit Google‑Account einloggen
- Evtl. IDE / Editor konfigurieren (VS Code, JetBrains o.ä.), damit Antigravity den Code sehen kann
3.2 Claude Code installieren
Du kannst Claude Code auf zwei Arten nutzen:
-
Terminal‑Version
- Global installieren oder pro Projekt
- Direkt im Terminal laufen lassen
-
IDE‑Extension
- Z.B. VS Code‑Extension installieren
- Claude Code im Editor‑Panel ausführen
Vorteil IDE‑Extension:
Wenn du wenig Terminal‑Erfahrung hast, ist das die komfortable Variante.
3.3 Beide Tools parallel nutzen
Die ideale „Workbench“ sieht so aus:
- Rechts: Antigravity‑Panel mit Agenten‑Übersicht, Planungs‑Prompts etc.
- Unten: Terminal mit laufendem Claude Code (oder das Claude‑Panel deiner IDE)
- Mitte: Dein Editor / IDE mit dem eigentlichen Projekt
Du wirst im Alltag ständig zwischen Planungs‑Zentrale (Antigravity) und Code‑Ausführung (Claude Code) hin‑ und herwechseln.
4. Der Hybrid‑Workflow im Überblick
Lass uns den Workflow zunächst grob skizzieren, bevor wir tief einsteigen:
-
Planung in Antigravity (Opus 4.6)
– High‑Level Ziel definieren
– Architektur, Komponenten, Phasen planen
– Ergebnis: ein sehr detaillierter Umsetzungsplan -
Plan in eine ausführbare Taskliste umwandeln
– Weg von abstrakten Plänen
– hin zu einem konkreten Engineering‑Task‑Set (Phase 0–4) -
Taskliste an Claude Code übergeben
– Spezialisierte Sub‑Agents erstellen (z.B. Scaffolder, Backend, Integration, Deployment)
– Jeweils nur den relevanten Abschnitt der Taskliste geben -
Parallelisierung & Lastverteilung
– Antigravity für Planung, Frontend, High‑Level Refactorings
– Claude Code für Backend, Multi‑File‑Edits, Setup, Integration
– Optional Gemini (über Antigravity) für Frontend
Jetzt gehen wir jeden Schritt im Detail durch.
5. Schritt 1: High‑Level‑Planung mit Antigravity + Opus 4.6
5.1 Das Ziel formulieren
Starte in Antigravity mit einem klaren, aber hochrangigen Ziel.
Beispiel aus dem Video:
> „Erstelle einen detaillierten Implementierungsplan für eine produktionsreife, B2B‑fähige, multi‑tenant SaaS‑Aufgabenmanagement‑App mit:
> – Subscription Billing
> – Team‑Workspaces
> – Analytics
> – Aufgabenmanagement mit Prioritäten, Status und Assignees.“
Wichtig:
In dieser Phase nicht direkt nach Code fragen.
Antigravity / Opus 4.6 soll denken, nicht schon schreiben.
5.2 Was Antigravity/Opus dir liefert
Mit Opus 4.6 und großem Kontext bekommst du in dieser Phase:
- Mermaid‑Diagramm der Architektur (z.B. Microservices, DB, API‑Layer)
- Detaillierte Liste von Backend‑Komponenten:
- Auth, Tenant‑Trennung, Billing, Task‑Service, Analytics‑Service, Notifications …
- Liste von Frontend‑Komponenten:
- Dashboard, Projekte, Boards, Task‑Ansichten, Analytics‑Seiten …
- Überlegungen zu:
- Technologie‑Stack
- Sicherheit (z.B. JWT, RBAC)
- Datenmodellierung
- Deployment (z.B. Docker, Cloud‑Provider)
- Einen Phasenplan mit groben Blöcken:
- Projekt‑Setup
- Backend
- Frontend
- Integration
- Deployment
Das Ergebnis ist ein breites, tiefes Dokument, das dein gesamtes Projekt treffsicher beschreibt.
5.3 Warum du hier noch NICHT coden solltest
Viele machen jetzt den Fehler, direkt zu sagen:
„Okay, und jetzt: Implementiere das alles.“
Das Problem:
- Die Pläne sind zu komplex, um sie 1:1 im selben Run zuverlässig umzusetzen.
- Modelle neigen dazu, Schritte zu überspringen oder falsch zu priorisieren.
- Je größer der Plan, desto mehr riskierst du Halluzinationen und halbfertige Implementierungen.
Die Lösung:
Wir machen aus diesem Plan zuerst eine explizite, ausführbare Engineering‑Taskliste.
6. Schritt 2: Aus dem Plan eine ausführbare Taskliste machen
6.1 Vom Plan zur „Executable Engineering Task List“
Bleib in Antigravity und gib eine Anweisung in etwa dieser Art:
> „Nimm den obigen Implementierungsplan und wandle ihn in eine strukturierte, ausführbare Engineering Task List um.
>
> – Unterteile in klar definierte Phasen (Phase 0, Phase 1, …)
> – Jede Phase soll eine Liste von konkreten Schritten enthalten, z.B. ‚Initialisiere TypeScript‑Projekt mit [Framework X]‘
> – Formuliere so, dass ein AI‑Code‑Agent (z.B. Claude Code) diese Schritte nacheinander abarbeiten kann, ohne eigene Architekturentscheidungen treffen zu müssen.“
Das Ziel:
Wir wollen aus einem „Architektur‑Essay“ eine Checkliste machen.
6.2 Typischer Phasenaufbau
Ein sinnvolles Schema, das sich im Video bewährt hat:
-
Phase 0 – Projekt‑Scaffolding
– Repo anlegen
– Ordnerstruktur definieren
– Packages & Dependencies installieren
– Basis‑Config (TypeScript, ESLint, Prettier, Dockerfile, etc.) -
Phase 1 – Backend & Datenbank
– ORM / DB‑Layer konfigurieren
– Tabellen & Migrations erstellen (Tenant, User, Workspace, Task, Subscription, …)
– API‑Endpoints für Aufgaben, Projekte, Workspaces
– Auth & Multi‑Tenant Logik
– Unit‑/Integration‑Tests anlegen -
Phase 2 – Frontend
– Grundlegende Layout‑Struktur
– Komponenten für Board, Tasks, Analytics
– API‑Integration
– Zustandverwaltung (z.B. Zustand globaler User / Tenant) -
Phase 3 – Integration & Polishing
– Frontend Backend testen
– Edge Cases abdecken
– Error Handling
– Logging, Monitoring Hooks -
Phase 4 – Deployment
– Docker Compose / K8s‑Manifeste
– CI/CD‑Pipeline
– Env‑Variablen & Secrets Management (ohne echte Secrets im Repo)
Jeder Punkt sollte so formuliert sein, dass ein Agent keine Interpretationsfragen mehr hat.
6.3 Warum das so wichtig ist
Du erhöhst damit:
- Vorhersagbarkeit: Agenten folgen klaren Schritten
- Reproduzierbarkeit: Der Workflow ist dokumentiert und wiederholbar
- Qualität: Weniger Raum für spontane „kreative“ Entscheidungen der Modelle
Du baust im Prinzip dein eigenes leichtgewichtiges AI‑Scrum‑Board.
7. Schritt 3: Übergabe an Claude Code – aus Plan wird Code
Jetzt kommt der Punkt, an dem Code erzeugt wird.
7.1 Sub‑Agents in Claude Code definieren
Statt nur „Hier ist mein Projekt, mach mal“ wählst du einen rollenbasierten Ansatz.
Beispiele für Claude‑Sub‑Agents:
-
Project Scaffolder (Phase 0)
– Spezialist für Projekt‑Setup
– Kennt Best Practices für unterschiedliche Stacks
– Task: Nur Phase 0 ausführen -
Backend Task Executor (Phase 1)
– Fokus auf REST / GraphQL APIs, DB‑Integration, Multi‑Tenant‑Architektur
– Arbeitet ausschließlich an Phase 1 -
Integration / Polishing Agent (Phase 3)
– Fügt lose Enden zusammen
– Verbessert Fehlerbehandlung, Tests, Logging -
Deployment Agent (Phase 4)
– Docker, CI/CD, Cloud‑Config
Du kannst mehrere Claude‑Instanzen parallel laufen lassen, z.B.:
- Terminal‑Session 1: Project Scaffolder
- Terminal‑Session 2: Backend Executor
- IDE‑Extension: Integration Agent
7.2 Wie ein Agent‑Prompt aussehen kann
Ein Beispiel für den Project Scaffolder:
> „Du bist mein ‚Project Scaffolder‘ für dieses Repo.
>
> Deine Aufgabe: Nur Phase 0 der folgenden Taskliste umzusetzen.
>
> Phase 0 – Project Scaffolding
> 1. Lege ein neues Verzeichnis für das Projekt an (Name: b2b-multitenant-task-saas).
> 2. Initialisiere ein Node.js/TypeScript‑Backend mit [Framework X].
> 3. Richte grundlegende Ordnerstrukturen ein: /src, /src/api, /src/db, /tests, /config.
> 4. Installiere und konfiguriere: TypeScript, ESLint, Prettier, Jest, dotenv.
> 5. Erzeuge eine minimale README.md mit Projektbeschreibung.
>
> Prinzipien:
> – Arbeite schrittweise, kommentiere wichtige Entscheidungen.
> – Führe notwendige Shell‑Kommandos selbst aus.
> – Halte dich streng an diese Phase, nimm keine Aufgaben aus späteren Phasen vorweg.“
Claude Code generiert dann darauf basierend ein Agenten‑Profil und arbeitet Task für Task ab.
Für den Backend‑Agenten übergibst du danach nur Phase 1 usw.
7.3 Dateien und Referenzen übergeben
Nutze alle Möglichkeiten, die Claude Code bietet:
- README und Taskliste als Referenz anhängen
- ggf. Architektur‑Diagramme / Mermaid aus Antigravity beifügen
- Vorhandene .env.example oder docker-compose.example.yml bereitstellen
Je mehr kontextbezogene, konkrete Artefakte du lieferst, desto stärker sinkt die Halluzinations‑Rate.
7.4 Ergebnis nach Phase 0 & 1
Nach Phase 0 + 1 solltest du haben:
- Ein vollständig scaffoldetes Projekt
- Aufgesetztes Backend mit:
- Datenbankanbindung
- Tabellen / Migrations
- API‑Endpoints (z.B. CRUD für Tasks, Projekte, Workspaces)
- Basis‑Auth & Multi‑Tenant‑Logik
Was typischerweise noch fehlt:
- Konkrete .env mit echten Secrets / Credentials (bewusst ausgelassen)
- Detaillierte Frontend‑Implementierung (kommt in Phase 2)
8. Schritt 4: Frontend mit Antigravity + Gemini 3.1 Pro
8.1 Warum Gemini fürs Frontend?
Google Gemini 3.1 Pro ist aktuell sehr stark darin:
- UI‑Code zu generieren
- konsistente Komponentenstrukturen aufzubauen
- Design‑Systeme zu respektieren (wenn du eins vorgibst)
Über Antigravity kannst du Gemini als Modell für einen eigenen Frontend‑Agenten nutzen.
8.2 Setup des Frontend‑Agenten in Antigravity
Du definierst in Antigravity einen Agenten z.B. so:
> „Du bist der ‚Frontend‑Agent‘ für dieses Projekt.
>
> Ziel: Implementiere Phase 2 – Frontend der folgenden Taskliste.
>
> Randbedingungen:
> – Nutze Framework X (z.B. React + Next.js, Vue, Svelte, etc.).
> – Orientiere dich an folgendem Backend‑Schema / API‑Doku: [Dokument als Datei oder Beschreibung].
> – Erzeuge eine Dashboard‑UI mit Spalten: ‚To‑Do‘, ‚In Progress‘, ‚Review‘, ‚Completed‘.
> – Implementiere Seiten / Ansichten für:
> – Projektübersicht
> – Aufgaben‑Board
> – Analytics (Total Tasks, Completion‑Rate, durchschnittliche Bearbeitungszeit).
>
> Lies die Projektstruktur aus dem Repo und halte dich daran.“
Antigravity kann mit Gemini nun:
- den Code deines Repos lesen
- passende Frontend‑Ordner anlegen
- Komponenten strukturieren
- API‑Calls gemäß Backend‑API implementieren
8.3 Was du erwarten kannst – und was (noch) nicht
Im Video‑Beispiel erstellt der Frontend‑Agent:
- Ein funktionales Dashboard mit den Status‑Spalten
- UI‑Elemente für:
- Aufgaben mit Titel, Beschreibung, Priority, Assignee, Status
- Kennzahlen wie Gesamtanzahl Aufgaben, durchschnittliche Bearbeitungszeit
- Eine Funktion für AI‑vorgeschlagene Subtasks (ähnlich wie bei bekannten Tools wie „Dart“)
Was häufig (noch) fehlt:
- Hochpoliertes, „pixel‑perfektes“ UI‑Design
- Drag‑and‑Drop zwischen Status‑Spalten
- sehr ausgefeilte Interaktionsmuster
Das ist normal. Modelle generieren aktuell eher funktionale als ästhetisch perfekte UIs – außer du gibst extrem detaillierte Design‑Prompts und ggf. ein Design‑System vor.
9. Schritt 5: Integration, Polishing & Deployment mit Claude Code
Sobald dein Frontend von Antigravity / Gemini fertiggestellt ist, geht es zurück zu Claude Code.
9.1 Integration & Polishing
Teile deinem Integration‑Agenten etwa Folgendes mit:
> „Phase 2 (Frontend) wurde von einem anderen Agenten abgeschlossen.
>
> Deine Aufgaben:
> – Prüfe die Integration zwischen Frontend und Backend.
> – Stelle sicher, dass alle API‑Calls funktionieren (z.B. Tasks anlegen, updaten, verschieben).
> – Ergänze sinnvolles Error‑Handling und Logging.
> – Schreibe einige Smoke‑Tests / Integrationstests.
>
> Nutze die vorhandene Taskliste, um sicherzustellen, dass nichts fehlt.“
Claude Code kann nun sehr strukturiert:
- den Code des Frontends und Backends gemeinsam betrachten
- Schnittstellen prüfen
- Tests ergänzen
- Fehlende Kleinteile nachziehen
9.2 Deployment‑Schicht hinzufügen
Der Deployment‑Agent kümmert sich um:
- Dockerfile (Backend, ggf. Frontend)
- docker-compose.yml für lokale Umgebung
- Optionale Kubernetes‑Manifeste
- CI/CD‑Pipelines (GitHub Actions, GitLab CI, etc.)
- Skripte für DB‑Migrationen beim Deploy
Natürlich lässt du sensible Daten (API Keys, DB‑Passwörter) immer in .env‑Dateien oder einem Secret‑Store – hier liefert das Modell nur Vorlagen.
9.3 Endergebnis
Wenn du die Phasen sauber durchläufst, landest du bei:
- einer lauffähigen, produktionsnahen SaaS‑Task‑Management‑App
- mit:
- Multi‑Tenant‑Support
- Backend‑APIs & DB‑Integration
- funktionalem Frontend mit Analytics
- AI‑gestützten Features (z.B. Subtask‑Vorschläge)
- vorbereitetem Deployment
Und das Ganze weitgehend autonom – du bist primär derjenige, der:
- Ziele definiert
- Agenten orchestriert
- Qualität kontrolliert
10. Token‑ und Rate‑Limit‑Optimierung: So nutzt du beide Tools effizient
Wenn du mit großen Modellen arbeitest, ist Token‑Management kein Luxus, sondern Pflicht.
10.1 Wann solltest du Antigravity nutzen?
Nutze Antigravity (mit Opus 4.6 / Gemini) vor allem für:
-
Große Kontexte
– Architektur
– globale Refactorings
– lange Pläne -
Multimodales Arbeiten
– Browser‑Steuerung (Doku lesen)
– IDE‑Navigation -
High‑Level Debugging & Audits
– „Scanne das gesamte Repo nach Inkonsistenzen zwischen Frontend‑ und Backend‑API.“
Wenn du merkst, dass Claude Code im Kontext „eng“ wird, kannst du Teile der Diskussion in Antigravity auslagern.
10.2 Wann solltest du Claude Code nutzen?
Claude Code ist ideal, wenn:
- du genaue Code‑Änderungen brauchst
- du bestimmte Dateien bearbeitet haben willst
- du starke Kontrolle über jeden Schritt behalten willst
- du Rate Limits von Antigravity umgehen möchtest, indem du einen Teil der Arbeit auf Anthropic auslagerst
Gerade mit Claude Code Pro lohnt sich das Token‑Budget besonders, wenn du:
- viele Multi‑File‑Refactorings
- große Repos
- oder intensive Implementierungsphasen hast.
10.3 Lastverteilung als „Load Balancer“
Du kannst dir deinen Workflow wie einen Load Balancer vorstellen:
- Breite, konzeptionelle Last → Antigravity
- Tiefe, code‑nahe Last → Claude Code
Vorteil:
- Du vermeidest das „Überhitzen“ eines einzelnen Systems
- Du kannst parallel in beiden Welten arbeiten
- Du glättest Token‑Spitzen und verringerst das Risiko, irgendwo hart an Limits zu stoßen
11. Warum dieser Workflow zwar „schwergewichtig“ wirkt – aber in der Praxis überlegen ist
Vielleicht denkst du gerade:
> „Das sind ja extrem viele Schritte. Lohnt sich der Aufwand wirklich?“
Die ehrliche Antwort: Ja – vor allem bei allem, was über ein Mini‑Side‑Project hinausgeht.
11.1 Qualität vor Bequemlichkeit
Ein Ein‑Prompt‑„Mach mir eine komplette SaaS‑App“‑Ansatz sieht beeindruckend aus, ist aber:
- schwer reproduzierbar
- fragil
- voller verdeckter Annahmen
Der hier beschriebene Workflow liefert:
-
Höhere Output‑Qualität durch:
- mehrere Spezifikationsebenen (Plan → Taskliste → Umsetzung)
- klar getrennte Rollen
- explizite Phasen
-
Bessere Kontrolle:
- Du kannst jede Phase prüfen, bevor die nächste beginnt
- Fehler fallen früh auf
- Refactoring ist einfacher, weil du die Planungs‑Artefakte hast
11.2 Skalierbarkeit für echte Projekte
Wenn du:
- eine App von Grund auf baust
- ein bestehendes System skalierst
- oder ein Projekt produktreif machen willst,
dann brauchst du:
- Architektur
- sauberen Code
- Tests
- Deployment
- Dokumentation
Das ist mit einem monolithischen Agentenfluss kaum zuverlässig zu bekommen.
Mit einem Multi‑Agent‑Hybrid‑Setup ist es dagegen realistisch.
11.3 Das Mindset dahinter
Vielleicht der wichtigste Punkt:
> Hör auf, AI als „ein Tool“ zu sehen – und fang an, es als Team aus Spezialisten zu denken.
- Ein Planer
- Ein Scaffolder
- Ein Backend‑Engineer
- Ein Frontend‑Engineer
- Ein Integrator
- Ein DevOps‑Engineer
Und du selbst bist der Engineering Manager / Product Owner, der:
- Vision und Requirements liefert
- Grenzen setzt (Stack, Technologien, Deadlines)
- Qualität überprüft
Dieses Mindset macht den Unterschied zwischen „AI‑Spielerei“ und echter AI‑gestützter Softwareentwicklung.
12. Praktische Tipps & Best Practices für deinen eigenen Workflow
Damit du das Gelernte direkt anwenden kannst, hier einige konkrete Empfehlungen.
12.1 Formuliere Rollen immer explizit
Statt:
> „Mach bitte das Backend.“
besser:
> „Du bist mein Backend‑Agent für dieses Projekt.
> Deine Verantwortung: ausschließlich Phase 1 der folgenden Taskliste umzusetzen.
> Du triffst keine Architekturentscheidungen, sondern folgst der vorhandenen Spezifikation.“
Je klarer die Rolle, desto weniger „kreativ“ wird das Modell an Stellen, an denen es nicht kreativ sein soll.
12.2 Begrenze den Scope pro Agent & Session
Versuche nicht, eine ganze App in einem einzigen Agentenlauf abzudecken.
Besser:
- Kurz und fokussiert arbeiten
- Pro Run eine Phase oder sogar nur einen Teil einer Phase bearbeiten
- Ergebnisse committen, dann den nächsten Schritt angehen
So minimierst du:
- Kontextchaos
- widersprüchliche Änderungen
- schwer nachverfolgbare Diff‑Wüsten
12.3 Halte deine Artefakte sauber
Lege dir von Anfang an eine klare Struktur an:
- /docs/architecture.md – Output von Antigravity / Opus
- /docs/tasks-phase0-4.md – ausführbare Taskliste
- /docs/api-contracts.md – Schnittstellenbeschreibung zwischen Frontend & Backend
Diese Dateien sind Gold wert:
- für dich
- für neue Teammitglieder
- und für AI‑Agenten, die später Debugging oder Erweiterungen vornehmen sollen
12.4 Nutze Tests als Sicherheitsnetz
Lass Claude Code in jeder Phase:
- Unit‑Tests
- Integrationstests
- Smoke‑Tests
erzeugen und ausführen.
Gerade bei Multi‑File‑Edits ist das dein Frühwarnsystem.
Du kannst z.B. einen Agenten definieren:
> „Du bist der ‚Test & QA Agent‘.
>
> Aufgabe: Ergänze für alle kritischen Backend‑Funktionen Unit‑Tests. Führe sie aus und behebe Fehler gemeinsam mit dem Code‑Agenten.“
12.5 Sei transparent bei Limitierungen
AI‑Systeme sind mächtig, aber nicht magisch. Typische Grenzen:
- exotische Legacy‑Stacks
- proprietäre Tools / Systeme ohne Doku
- extrem strenge Sicherheitsanforderungen
In solchen Fällen:
- gib klare Rahmenbedingungen
- erwarte eher Vorschläge & Skeleton‑Code
- und plane menschliche Review‑Schleifen ein
13. Fazit: Dein Weg zu einem eigenen AI‑Engineering‑Team
Fassen wir die wichtigsten Punkte zusammen.
Mit Antigravity + Claude Code (und optional Gemini) kannst du heute:
- eine echte, verteilte AI‑Engineering‑Architektur aufbauen
- große, komplexe Projekte in Phasen & Rollen strukturieren
- Planung, Ausführung und Refactoring sauber trennen
- Token‑Kosten und Rate‑Limits durch clevere Lastverteilung reduzieren
- qualitativ hochwertigen, spezifikationsgetreuen Code erzeugen – reproduzierbar
Nutze:
-
Antigravity + Opus 4.6 für:
- Big‑Picture Planung
- Architekturdesign
- Umwandlung in ausführbare Tasklisten
- High‑Level Debugging / Refactoring
-
Claude Code für:
- strukturierte, präzise Implementierung
- Multi‑File‑Edits
- Backend, Scaffolding, Integration, Deployment
-
Gemini 3.1 Pro (via Antigravity) für:
- Frontend‑Entwicklung
- UI‑Code, Dashboards, Interaktionen
Wenn du bis hierhin gelesen hast, hast du im Grunde das Blueprint für ein eigenes, virtuelles AI‑Engineering‑Team in der Hand.
Der nächste Schritt?
- Such dir ein reales Projekt – z.B. dein nächstes internes Tool, ein Kundenprojekt oder ein SaaS‑Side‑Project.
- Richte Antigravity und Claude Code ein.
- Starte mit Phase 0: Architektur & Taskliste.
- Geh dann Schritt für Schritt durch die Phasen.
Wenn du möchtest, können wir im nächsten Schritt gemeinsam:
- einen konkreten Stack für dein Projekt auswählen (z.B. Next.js + NestJS + Postgres)
- eine individuelle Taskliste für deine Anforderungen entwerfen
- oder dir einen Muster‑Prompt‑Satz für deine Agenten bauen, den du immer wiederverwenden kannst.
Sag einfach, in welchem Tech‑Stack du baust – dann erstellen wir deinen ersten maßgeschneiderten Hybrid‑Workflow.
