aig: Versionskontrolle, die versteht wie AI Code schreibt

Vor ein paar Wochen habe ich einen PR reviewed, den Claude Code für mich geschrieben hatte. 40 Dateien geändert. Der Diff war eine Wand aus grün und rot. Die Commit-Nachricht: "refactor auth module." Ich wusste, was sich geändert hatte. Ich konnte den Code lesen. Aber die Begründung war weg. Warum JWT statt Sessions? Warum HS256 statt RS256? Die Konversation, in der wir diese Tradeoffs besprochen hatten, war geschlossen. Die Entscheidungsarchitektur, die den Code erzeugt hatte, hatte sich in Luft aufgelöst.

Das passiert mittlerweile jeden Tag. AI schreibt Code schnell. Git speichert, was sich geändert hat. Aber niemand speichert warum.

Also habe ich aig gebaut.

Git wurde 2005 designed. Menschen tippten Code, dachten darüber nach und committeten ihn mit einer Nachricht. Dieses Modell hat 20 Jahre gehalten. Aber AI-unterstützte Entwicklung bricht drei Annahmen, auf die Git aufbaut:

AI-Änderungen sind zu groß zum Reviewen. Wenn eine AI 30 Dateien in acht Sekunden umstrukturiert, ist der Diff nutzlos für menschliches Review. Man kann nicht erkennen, was wichtig ist und was mechanisch. Man winkt es durch, weil die kognitive Belastung zu hoch ist.

Commit-Nachrichten sind noch nutzloser. Sie waren schon ein Nachgedanke, als Menschen jede Zeile selbst geschrieben haben. Mit AI sind sie komplett von der Realität abgekoppelt. "refactor auth module" sagt nichts darüber aus, warum JWT statt Sessions gewählt wurde, warum HS256 statt RS256, oder welche Alternativen in Betracht gezogen wurden.

Die Konversation geht verloren. Der reichste Kontext in AI-unterstützter Entwicklung ist der Mensch-AI-Dialog. Die Einschränkungen, die man formuliert hat, die Ansätze, die man verworfen hat, die Tradeoffs, die man akzeptiert hat. All das verschwindet, wenn das Chat-Fenster geschlossen wird. git blame zeigt, wer eine Zeile vor sechs Monaten geändert hat. Aber diese Person hat eine AI gesteuert. Sie erinnert sich kaum an die Konversation.

aig baut auf Git auf. Jedes aig-Repo ist weiterhin ein gültiges Git-Repo. Du kannst pushen, pullen, branchen, mergen. Aber aig fügt drei Dinge hinzu, die Git nicht hat:

Bevor du Code schreibst, deklarierst du, was du erreichen willst:

bash
aig session start "JWT-Authentifizierung hinzufügen"

Das erstellt einen Intent-Eintrag bevor Änderungen gemacht werden. Die "Commit-Nachricht" wird zuerst geschrieben, nicht im Nachhinein. Wenn du fertig bist, setzt du einen Checkpoint:

bash
aig checkpoint

Keine Nachricht nötig. aig generiert sie automatisch aus dem semantischen Diff: "added generate_token, added validate_token, added AuthMiddleware". Der Code erzählt seine eigene Geschichte.

Statt zeilenbasiertem rot/grün zeigt aig, was sich in der Struktur des Codes geändert hat:

--- src/auth.py (semantic)
  + added `generate_token`
  + added `validate_token`
  ~ modified `authenticate`
--- src/middleware.py (semantic)
  + added `require_auth`

Funktionen hinzugefügt, Klassen entfernt, Parameter geändert. Unterstützt TypeScript, Python, Rust, Go, Java, C#, C++ und Ruby. Alles basierend auf Tree-sitter AST-Parsing.

aig erfasst AI-Konversationen automatisch in der Versionshistorie. Claude Code wird automatisch erkannt. Für andere Tools (Cursor, Copilot, etc.) exportierst du die Konversation als JSONL-Datei und führst aig capture --file chat.jsonl aus. Wenn du eine Session beendest, wird jede erkannte Konversation mitgespeichert. Kein manueller Aufwand.

Später kann jeder fragen:

bash
aig why src/auth.py:42

Und bekommt die komplette Kette: den Intent, die semantischen Änderungen und die Konversationsnotizen, die die Begründung erklären.

Ich habe aig in einer einzigen Claude-Code-Session gebaut. Die Ironie ist mir bewusst: Das Tool, das AI-unterstützte Entwicklung tracken soll, wurde selbst von der ersten Zeile an AI-unterstützt.

Der Stack:

• Rust für die Core-CLI. Schnell, plattformübergreifend, ein einzelnes Binary.
• Tree-sitter für Multi-Language AST-Parsing und semantisches Diffing.
• SQLite für den Intent-Graphen, Sessions, Checkpoints und Konversationen.
• Git Notes für Remote-Sync. aig push und aig pull übertragen Metadaten zusammen mit dem Code.
• TypeScript für die LLM-Integrationsschicht (Anthropic SDK für smarten Import).

Die Session, die aig selbst gebaut hat, wurde von aig erfasst. 98 Konversationseinträge aus genau diesem Dialog sind in der Versionshistorie gespeichert. Das ist der Proof of Concept: Das Tool funktioniert an sich selbst.

So sieht es tatsächlich aus. Das ist echte Ausgabe von aig, ausgeführt auf dem Repo, das aig selbst enthält.

Wo git log eine flache Liste von Commit-Hashes liefert, gruppiert aig log nach Intent:

[44d3ab98] Rewrite docs for first-time visitors (active)
         7 checkpoint(s) | 2026-04-14
           (120ab1ee) Rewrite docs for first-time visitors
           (3e8142a2) Add Daily Workflow guide
           (ed3a9c5c) Add aig repair for rebase/cherry-pick
           (635eb923) Add Related Tools page
           (d802ad6a) Make checkpoint message optional
           (c0b46ad4) Update docs: checkpoint message is optional
           (2528a1a0) Fix CI: configure git identity for sync tests

[479d2692] Initial commit (active)
         12 checkpoint(s) | 2026-04-14
           (43ed4568) Initial commit
           (fd990ede) Add aig MVP: intent-based version control with docs site
           (6b42cef6) Add auto-generated CLI reference and CI sync check
           (7564dcaa) Complete the core loop: semantic changes, IPC, 18 tests
           (6bdca120) Add conversation capture, file watching, cargo install
           (7975e6d3) Add remote sync: aig push/pull via git notes
           (9ee934f1) Add 4 languages, aig review, incremental import
           ...

Zwei Intents statt 19 flacher Commits. Man sieht die Geschichte: Zuerst wurde das MVP gebaut, dann die Docs für Besucher umgeschrieben.

Frag warum eine Datei existiert:

$ aig why crates/aig-core/src/capture.rs:1

crates/aig-core/src/capture.rs:1

  Intent:     [479d2692] Initial commit
  Checkpoint: Add conversation capture, file watching, and cargo install support
  Commit:     6bdca120
  Time:       2026-04-14T01:06:24+00:00

Vergleich das mit git blame capture.rs, das nur 6bdca120 (Sascha Becker 2026-04-14) zeigt. Gleiche Daten, null Kontext.

Keine Commit-Nachrichten mehr schreiben. aig liest den semantischen Diff und schreibt sie selbst:

$ aig checkpoint

  auto-message: added generate_token, added validate_token, added AuthMiddleware
  semantic:
    + added generate_token (auth.py)
    + added validate_token (auth.py)
    + added AuthMiddleware (auth.py)
Checkpoint created
  message:    added generate_token, added validate_token, added AuthMiddleware
  intent:     Add authentication
  git commit: 8d5b5ff9
  checkpoint: 1d88ab07ccc1

Der Code beschreibt seine eigenen Änderungen. Du tippst nur aig checkpoint.

Statt 300 Zeilen rot und grün:

$ aig diff --semantic

--- auth.py (semantic)
  + added `generate_token` -- added function `generate_token`
  + added `validate_token` -- added function `validate_token`
  ~ modified `authenticate` -- modified function `authenticate`
--- middleware.py (semantic)
  + added `require_auth` -- added function `require_auth`

Vier Zeilen, die alles sagen. Funktionen hinzugefügt, Funktionen geändert. Kein Rauschen.

So sieht tägliche Entwicklung mit aig aus:

bash
aig session start "Payment-Timeout-Bug fixen"
# ... mit AI arbeiten ...
aig checkpoint                    # auto: "modified connect, added pool_limit"
aig checkpoint                    # auto: "added test_payment_timeout"
aig session end                   # erfasst automatisch Claude-Code-Konversation
git push && aig push              # Code + Kontext teilen

Dein Teamkollege später:

bash
git pull && aig pull
aig why src/payments.py:87
# Intent: "Payment-Timeout-Bug fixen"
# Semantic: modified `connect`, added `pool_limit`
# Conversation: "Ursache war fehlendes Connection-Pool-Limit..."

Keine Slack-Archäologie. Kein Rätselraten. Die Begründung ist direkt da.

aig ist Open Source und funktioniert mit jedem bestehenden Git-Repo:

bash
cargo install --git https://github.com/saschb2b/ai-git.git aig-core
cd dein-repo
aig import          # baut Intent-Graph aus Git-Historie
aig log             # Intents statt flacher Commit-Liste
aig why src/app.py:42  # jede Zeile bis zum Intent zurückverfolgen

Vier Befehle. Nicht-destruktiv. Deine Git-Historie bleibt unverändert.

aig ist heute ein MVP mit 17 Commands, semantischem Diff für 8 Sprachen, Remote-Sync, Claude-Code-Integration und File-Watching. Die Roadmap enthält semantisches Merging, Trust-Scoring, ein TUI-Review-Interface und IDE-Extensions.

Aber die Kernthese ist bewiesen: Versionskontrolle muss erfassen, warum sich Code ändert, nicht nur was sich geändert hat. Die AI schreibt den Code. Der Mensch liefert den Intent. Die Aufgabe des Tools ist sicherzustellen, dass die Verbindung zwischen beiden nie verloren geht.

• aig auf GitHub

  Quellcode und Dokumentation für aig.

• aig Dokumentation

  Getting Started Guide, Daily Workflow, CLI-Referenz und Roadmap.

• aig Research Document

  Das vollständige 5.000-Wort-Visionsdokument über Intent-basierte Versionskontrolle.