Context Engineering statt Prompting – Das mentale Modell des Agenten in Legacy-Codebases

Ein Entwickler öffnet Claude Code oder Cursor in einer gewachsenen Monolithen-Codebase mit 280.000 Zeilen Legacy-Code. Der Prompt lautet scheinbar harmlos: „Refaktoriere die Session-Verwaltung im Checkout“. Nach zwei Minuten liest der Agent blind 45 Dateien ein, flutet das Kontextfenster mit 180.000 Tokens, halluziniert veraltete Methoden und bricht mit Syntaxfehlern ab. Warum scheitert naives Vibe Coding in Brownfield-Projekten so spektakulär – und wie gibt man dem Agenten einen strukturierten Kompass, damit er nicht im Code-Dschungel ertrinkt?

Erfolgreiches Brownfield-Coding erfordert systematisches Context Engineering statt blindem Datei-Grepping: Graphify kartiert Code-Strukturen und Abhängigkeiten deterministisch als Wissensgraph, Obsidian fungiert als versioniertes Team-Gedächtnis für Architekturentscheidungen, und das Model Context Protocol (MCP) liefert dem Agenten punktgenaue Werkzeuge zur gezielten Abfrage. Die Grenze: Stark dynamischer Code ohne Typisierung erfordert weiterhin menschliche Leitplanken und lückenlose Testsuiten.

Die 100k-Token-Falle: Warum naives Prompting an Legacy-Code zerschellt

Während Greenfield-Projekte auf einem sauberen Reißbrett mit isolierten Modulen starten, sind Brownfield-Codebases von Jahren impliziten Wissens geprägt. Hier treffen Sprachmodelle auf drei strukturelle Sollbruchstellen:

1. Context Rot und die „Lost in the Middle“-Amnesie: Selbst bei Kontextfenstern von 200.000 bis zu einer Million Tokens sinkt die Aufmerksamkeitsdichte eines Modells massiv, wenn Hunderte Seiten unstrukturierter Quellcode, Boilerplate und Konfigurationsdateien in den Prompt gekippt werden (Context Poisoning). Randbedingungen in der Mitte des Textes werden systematisch übersehen.
2. Der Blast-Radius von God Nodes (Zentrales Modul oder Klasse mit extrem hohem Kopplungsgrad (In-Degree/Out-Degree), deren Änderung hohe Regressionsrisiken birgt.): In Legacy-Systemen existieren fast immer Klassen wie OrderManager oder SessionStore, an denen dutzende Subsysteme hängen. Ein unbedarfter Agent sieht beim Ändern einer Methode nicht, welche 14 Nebensysteme auf genau das alte Verhalten angewiesen sind.
3. Das Rätsel der impliziten Verträge (Invisible Contracts): Code verrät nur das Wie, aber fast nie das Warum. Ohne Zugriff auf historische Architekturentscheidungen und dokumentierte Eigenheiten refaktoriert der Agent scheinbar umständliche, aber überlebenswichtige Workarounds und Fallbacks einfach weg.

Context Engineering statt Prompting: Das mentale Modell des Agenten

In der modernen Agenten-Architektur gilt der Grundsatz: Prompt Engineering steuert, was das Modell sagt – Context Engineering kuratiert, was das Modell sieht.

Ein erfahrener Principal Engineer lädt bei der Fehlersuche in einem gewachsenen Monolithen niemals 300.000 Zeilen Code auf einmal in sein biologisches Arbeitsgedächtnis. Das menschliche Gehirn stützt sich auf eine bewährte kognitive Hierarchie:

1. Das topologische Schema: Eine mentale Landkarte der Systemgrenzen („Der Checkout-Service spricht asynchron über Kafka mit dem Buchungsjournal“).
2. Das episodische Gedächtnis: Dokumentiertes Team-Wissen („Achtung: Die Steuerberechnung enthält einen historischen Rundungs-Fix für Skandinavien“).
3. Das fokussierte Arbeitsgedächtnis: Nur die zwei bis drei tatsächlich geöffneten Dateien im Editor.

Wenn Entwickler von einem KI-Agenten verlangen, 50 Quelldateien ungefiltert einzulesen, fordern sie etwas Kognitiv Unmögliches: Das Modell ertrinkt in syntaktischem Rauschen. Context Engineering rekonstruiert genau diese kognitive Hierarchie für den Agenten: Graphify liefert das topologische Schema, Obsidian das episodische Gedächtnis, und Repomix schützt das Arbeitsgedächtnis vor Rauschen.

Was brauche ich? (Prerequisites)

• Topologische Code-Landkarte: Graphify (CLI-Tool und Skill zur deterministischen Extraktion von Code-Topologien via Tree-sitter und Leiden-Community-Erkennung.) zur lokalen, deterministischen Analyse des Quellcodes über Tree-sitter (Parser-Generator-Tool für schnelle, inkrementelle Syntaxbäume (AST) von Programmcode ohne Compileraufruf.).
• Persistenter Wissensspeicher: Ein lokales Obsidian (Lokale Markdown-Wissensdatenbank mit bidirektionalen Wikilinks ([[Link]]) und Frontmatter-Metadaten.) Vault mit Architektur-Entscheidungen (ADR (Architecture Decision Record: Leichtgewichtiges Markdown-Dokument zur Festhaltung von Entwurfsentscheidungen und deren Kontext.)), Systemgrenzen und bekannten Schulden-Tags (#tech-debt).
• Werkzeug-Schnittstelle: Ein lokaler Model Context Protocol (Offener JSON-RPC-Standard von Anthropic zur Anbindung externer Tools, Datenquellen und Agent-Fähigkeiten.) Server (MCP), der den Wissensgraphen und das Vault für Claude Code, Cursor oder Antigravity exponiert.
• Subtraktive Kontext-Kompression: Ein Werkzeug wie Repomix (Kompakter Repository-Packer, der Codebasen token-optimiert und mit AST-Signaturfiltern für LLMs formatiert.) zum Slicen auf reine Typ- und Methodensignaturen.

Wie kann ich das prüfen? (Verification & Audit)

• Topologie-Audit: Führe graphify query "Welche Module rufen X auf?" im Terminal aus und verifiziere, dass alle statischen Abhängigkeiten im Output auftauchen.
• MCP-Konnektivität: Prüfe in den Agenten-Einstellungen (z. B. claude mcp list), dass graphify-mcp und obsidian-mcp aktiv sind und Werkzeuge wie get_neighbors und read_note anbieten.
• Token-Disziplin: Überwache bei einer Refaktorisierung, dass der Session-Footprint unter 10.000 Tokens bleibt, statt das Kontextfenster mit 100.000 Tokens zu überfluten.

Typische Praxisszenarien (Use Cases)

• Sichere Refaktorisierung: Vor dem Ändern einer Methode fragt der Agent den Graphen nach allen Aufrufern ab und schützt bestehende Verträge.
• Orientierung in fremden Monolithen: Schnelles Erkennen von Datenflüssen („Wie fließt ein Webhook durch das System?“) ohne manuelles Durchsuchen dutzender Dateien.
• Multi-Agenten-Handoffs: Ein Architektur-Agent dokumentiert seinen Plan in einer Obsidian-Notiz, die ein nachgelagerter Ausführungs-Agent verlustfrei übernimmt.

Die dreistufige Navigations-Kaskade: Von der Topologie zum minimalen Diff

Gutes Context Engineering arbeitet subtraktiv: Kontext entsteht durch das Weglassen von Rauschen. Statt die Codebase mit grep zu durchforsten, folgt der Agent einer dreistufigen Konsultationskette:

Werkzeug-Matrix: Volltext-Grep vs. Vector-RAG vs. GraphRAG

Kein Werkzeug löst alle Probleme allein. Die folgende Matrix vergleicht die gängigen Kontext-Strategien nach Skalierbarkeit, Token-Effizienz und Kopplungserkennung:

Kontext-Budget im Stresstest: Simulator für Token-Verbrauch und Regressionsrisiko

Erprobe selbst, wie sich unterschiedliche Kontext-Strategien in realen Legacy-Szenarien auswirken. Wähle ein Projekt-Szenario, schalte die Komponenten der MCP-Toolchain zu und beobachte, wie sich Token-Verbrauch, das Risiko für Kontext-Kollaps und die Erkennung versteckter Kopplungen verändern:

Was zeigt dieses Experiment?

Der Simulator demonstriert den Hebel von Context Engineering: Während naives Einlesen in einem 320.000-Zeilen-Projekt über 180.000 Tokens verbrennt und die Aufmerksamkeitsspanne des Modells überfordert, reduziert der 3-Tier-Stack den Footprint auf unter 4.000 Tokens. Gleichzeitig steigt die Erkennung versteckter Kopplungen von 14% auf 100%.

Was beweist das Experiment ausdrücklich nicht?

Das Experiment modelliert statische Aufrufbeziehungen via AST. Es beweist nicht, dass hochgradig dynamische Konstrukte (wie Reflection in Java, dynamisches eval() in JavaScript oder komplexe Dependency-Injection-Container zur Laufzeit) fehlerfrei aufgelöst werden. Solche dynamischen Bindungen erfordern weiterhin automatisierte Integrationstests und manuelle Code-Reviews.

Das Schutzgeschirr: Codebase-Zoning und Leitplanken gegen Kollateralschäden

In gewachsenen Systemen entscheidet das Schutzgeschirr (Agent Harness) über den Erfolg: Klare Zonen und deterministische Leitplanken verhindern, dass der Agent ungewollte Zerstörung anrichtet.

Das Agenten-Protokoll: Verbindliche Direktiven für AGENTS.md und CLAUDE.md

Damit Coding-Agenten wie Claude Code, Cursor oder Antigravity den Wissensgraphen und das Obsidian-Vault nicht ignorieren, müssen die Verhaltensregeln in Projektdateien wie AGENTS.md oder CLAUDE.md verbindlich verankert werden:

Vier Sicherheitsprüfungen vor dem ersten Brownfield-Commit

Verwende diese vier Prüfpunkte, bevor du ein KI-gestütztes Refactoring in die Produktion entlässt:

• Wissensgraph initialisiert: graphify wurde über das Projekt ausgeführt und graphify-out/graph.json ist aktuell.
• MCP-Tools verbunden: Der Agent hat im Session-Start Zugriff auf graphify_query und obsidian_search_notes.
• God-Node-Analyse erfolgt: Alle aufrufenden Module der Zielklasse wurden identifiziert und im Testplan berücksichtigt.
• Regressions-Suite grün: Unit- und Integrationstests laufen lokal erfolgreich durch, ohne dass verwaiste Abhängigkeiten verbleiben.

Quellen und weiterführende Kacheln

Primärquellen und Spezifikationen

• Anthropic: Model Context Protocol Architecture & Spec – Offizieller Standard für tool-basierte Kontext- und Tool-Integrationen für KI-Agenten.
• Tree-sitter: An Incremental Parsing System for Programming Tools – Technische Referenz für performante, lokale AST-Generierung in über 40 Programmiersprachen.
• Graphify: Knowledge Graph extraction via AST and GraphRAG – Werkzeug zur Extraktion strukturierter Wissensgraphen aus Programmcode und Dokumenten.
• Repomix: Pack your codebase into AI-friendly context – Open-Source-Standard zur Token-optimierten Bündelung und Signatur-Kompression von Repositories.

Verwandte Kacheln im Digital Garden

• Web MCP – Standardisierte Browser-Tools – Vertiefung in das Model Context Protocol und standardisierte Schnittstellen für Agenten.
• Enterprise Architektur im KI-Zeitalter – Wie sich Systemlandschaften, Architekturrollen und Governance durch autonome Agenten verändern.