Programmier-Agent: Code mit KI schreiben und debuggen

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Programmier-Agenten behandelt

• Was ein Programmier-Agent ist und wie er funktioniert.
• Wie der Agent Code generiert, debuggt und refactort.
• Wie Du den Agenten mit Tools für Dateisystem, Git und Tests ausstattest.
• Praxisbeispiele für Feature-Entwicklung, Bugfixing und Code-Review.
• Best Practices für Sicherheit, Code-Qualität und menschliche Kontrolle.

Einleitung: Programmier-Agent verständlich erklärt

Ein Programmier-Agent ist ein KI-Agent, der Code autonom schreibt: Er versteht Anforderungen, plant die Implementierung, schreibt Code, testet ihn und fixt Fehler. Nicht nur „Code generieren”, sondern „Feature entwickeln, testen, debuggen”.

Dieser Artikel richtet sich an Entwickler, die KI-Agenten für Programmierung nutzen wollen. Grundlagen findest Du in KI-Agenten und Coding-Modelle.

Warum brauche ich einen Programmier-Agenten?

Stell Dir vor, Du willst ein Feature implementieren: „User-Authentication mit JWT”. Ein klassisches Copilot schreibt Code-Snippets. Ein Agent: „Analysiere Anforderungen → Plane Architektur → Schreibe Code → Schreibe Tests → Führe Tests aus → Fixe Fehler → Commit.” Der Agent entwickelt das Feature komplett.

Programmier-Agent kurz erklärt

Anforderung → Agent plant (LLM) → Tools aufrufen (Datei lesen, Code schreiben, Test ausführen) → Iterieren → Feature fertig. Mit Git für Versionierung, mit Tests für Qualität.

Der Kerngedanke lautet: Nicht nur Snippets, sondern komplette Features.

Für wen ist dieser Artikel gedacht?

• Entwickler, die Coding-Agenten nutzen.
• Teams, die Feature-Entwicklung automatisieren.
• DevOps, die CI/CD mit Agenten erweitern.
• Solo-Entwickler, die Produktivität steigern.

Wichtige Begriffe

• KI-Agent - Autonomer Akteur. Wann nützlich: das Konzept.
• Tool-Calling - Werkzeuge aufrufen. Wann nützlich: für Datei/Git-Operationen.
• Coding-Modelle - Für Code. Wann nützlich: die Modellwahl.
• Ollama - Lokaler Modellserver. Wann nützlich: das Backend.
• Code-Assistenten - Aider, Continue. Wann nützlich: für Tools.

Architektur

Anforderung / Issue
    │
    ▼
Programmier-Agent (Ollama + Tools)
    │
    ├─ Verstehen: Was soll gebaut werden?
    ├─ Planen: Architektur, Dateien, Tests
    ├─ Handeln: Tools aufrufen
    │   ├─ read_file: Code lesen
    │   ├─ write_file: Code schreiben
    │   ├─ run_tests: Tests ausführen
    │   ├─ git_commit: Änderungen committen
    │   └─ run_linter: Code prüfen
    ├─ Prüfen: Tests bestanden? Code ok?
    └─ Iterieren: Bei Fehlern zurück zu Planen
    │
    ▼
Ergebnis
    ├─ Code implementiert
    ├─ Tests geschrieben
    ├─ Git-Commit
    └─ Pull Request (optional)

Praxisbeispiel 1: Feature-Entwicklung

class FeatureAgent:
    """Agent für Feature-Entwicklung"""

    async def implement(self, requirement):
        """Feature implementieren"""
        # 1. Anforderung verstehen
        plan = await self.plan(requirement)

        # 2. Code schreiben
        for file in plan["files"]:
            code = await self.generate_code(file, plan)
            await self.write_file(file["path"], code)

        # 3. Tests schreiben
        tests = await self.generate_tests(plan)
        await self.write_file("test_feature.py", tests)

        # 4. Tests ausführen
        result = await self.run_tests()

        # 5. Bei Fehlern: Debuggen
        if not result["passed"]:
            fixes = await self.debug(result["errors"])
            await self.apply_fixes(fixes)
            await self.run_tests()

        # 6. Commit
        await self.git_commit(f"feat: {requirement}")

        return plan

Praxisbeispiel 2: Bug-Fixing

class BugFixAgent:
    """Agent für Bug-Fixing"""

    async def fix(self, bug_report):
        """Bug fixen"""
        # 1. Bug reproduzieren
        error = await self.reproduce(bug_report)

        # 2. Ursache analysieren
        analysis = await self.analyze(error)

        # 3. Fix generieren
        fix = await self.generate_fix(analysis)

        # 4. Fix anwenden
        await self.write_file(analysis["file"], fix)

        # 5. Testen
        result = await self.run_tests()

        if result["passed"]:
            await self.git_commit(f"fix: {bug_report['title']}")
        else:
            await self.iterate_fix(error)

        return analysis

Praxisbeispiel 3: Code-Review

class ReviewAgent:
    """Agent für Code-Review"""

    async def review(self, diff):
        """Code reviewen"""
        analysis = await ollama.generate(f"""
Reviewe diesen Code:
{diff}

Bewerte:
1. Code-Qualität
2. Potenzielle Bugs
3. Sicherheitsrisiken
4. Performance
5. Best Practices

Antworte als JSON:
{{"issues": [...], "suggestions": [...], "approved": true|false}}""", format="json")

        return json.loads(analysis)

Tools für Programmier-Agenten

tools = [
    {
        "name": "read_file",
        "description": "Datei lesen",
        "function": read_file
    },
    {
        "name": "write_file",
        "description": "Datei schreiben",
        "function": write_file
    },
    {
        "name": "list_files",
        "description": "Dateien auflisten",
        "function": list_files
    },
    {
        "name": "run_tests",
        "description": "Tests ausführen",
        "function": run_tests
    },
    {
        "name": "run_linter",
        "description": "Linter ausführen",
        "function": run_linter
    },
    {
        "name": "git_commit",
        "description": "Änderungen committen",
        "function": git_commit
    },
    {
        "name": "search_code",
        "description": "Code durchsuchen",
        "function": search_code
    }
]

Sicherheitshinweise

• Code-Ausführung: Agent sollte nicht beliebigen Code ausführen. Siehe Sandboxing.
• Git-Berechtigungen: Agent sollte nicht force-pushen oder branches löschen. Siehe Tool-Berechtigungen.
• Secrets: Agent sollte keine Secrets in Code schreiben. Siehe Datenschutz.
• Code-Qualität: Generierter Code sollte reviewed werden. Menschliche Kontrolle.
• Prompt Injection: Code-Comments können Injections enthalten. Siehe Prompt Injection.

Typische Stolpersteine

• Zu komplexe Aufgaben: Agent sollte kleine, klare Aufgaben bekommen. Große Features in Teile aufteilen.
• Keine Tests: Ohne Tests kann der Agent nicht prüfen, ob der Code funktioniert.
• Schlechte Prompts: „Implementiere Auth” ist zu vage. Präzise Anforderungen geben.
• Keine Iterationsgrenze: Agenten können in Schleifen landen. Max iterations setzen.
• Kein Fallback: Bei Agent-Ausfall sollte menschliche Entwicklung weitergehen.

Weiterführende Links

• KI-Agenten - Grundlagen.
• Coding-Modelle - Modellwahl.
• Code-Assistenten - Aider, Continue.
• Code-Generierung - Übersicht.
• Debugging - Debugging-Techniken.
• Tool-Berechtigungen - Sicherheit.

Key Takeaways:

• Programmier-Agent: Versteht, plant, schreibt, testet, committet, autonom.
• Tools: read_file, write_file, run_tests, git_commit, run_linter.
• Für Feature-Entwicklung, Bug-Fixing, Code-Review.
• Kritische Operationen brauchen menschliche Kontrolle.
• Lokal mit Ollama: Dein Code bleibt privat.

FAQ

Quellen und weiterführende Literatur

• Ollama - Lokaler Modellserver.
• Aider - Coding-Agent.
• LangChain Agents - Agenten-Konzepte.
• DeepSeek-Coder - Coding-Modell.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert