VoDaiLocz Autonomous Code Agent Patterns
Overview
The code-agent-patterns skill provides a standardized architectural framework for building, maintaining, and scaling autonomous Software Engineering (SWE) agents. It focuses on reliability, precision, and contextual awareness, drawing heavily from industry benchmarks like SWE-Bench and modern LLM-driven development tools.
When To Use
- Implementing autonomous code editing agents.
- Designing specialized agents for bug localization or patch generation.
- Orchestrating multi-agent systems for code review or testing.
- Building tools that need to interface with existing large codebases.
Core Patterns
1. Minimal Context Assembly
Avoid dumping the entire repository into the LLM context. Instead:
- Use dependency graph analysis to identify "impact zones."
- Implement "Breadth-First Context Discovery" (start with high-level symbols, drill down only when necessary).
- Support dynamic file inclusion based on the specific task (e.g., test files, related interfaces).
2. Symbol-Level Repository Indexing
Build a robust index that enables the agent to navigate the codebase as a human developer would:
- Symbol Maps: Index classes, functions, and interfaces along with their file locations.
- Call Graphs: Track function calls and dependencies to understand side effects.
- AST Analysis: Utilize Abstract Syntax Tree (AST) parsing to ensure structural awareness during code modifications.
3. Unified Diff & Search-Replace Patching
To minimize hallucination and merge conflicts:
- Prefer "Search-Replace" blocks over entire file rewrites.
- Validate that the "Search" block matches exact file content before applying the "Replace" content.
- Use unified diffs as a secondary representation for human review.
TDD Fix Loop Workflow
Agents must follow a strict "Red-Green-Refactor" loop for any bug fix:
- Reproduce: Write a test case that captures the reported bug (assert failure).
- Localize: Identify the source using logs, stack traces, or symbol-level search.
- Patch: Apply minimal code changes to satisfy the failing test.
- Verify: Run the test suite.
- Rollback: If tests fail after patching, discard changes and restart the process.
Multi-Agent Coding Triad
To ensure high-quality output, structure teams as:
- Coder: Responsible for reading the codebase and proposing patches.
- Code Reviewer: Audits patches for logic errors, style violations, and architecture alignment.
- Test Engineer: Manages test execution and ensures sufficient coverage for the change.
Patch Validation Pipeline
Every proposed change must survive an automated gauntlet:
- Syntax Check: Ensure the code is parsable.
- Type Check: Validate against TypeScript/Python type definitions.
- Unit Tests: Pass local unit tests.
- Lint: Adhere to project linting standards.
- Security Scan: Check against common patterns like OWASP Top 10.
SWE-Bench Lessons
- Mitigation Strategy: The most common failure mode is "blind editing" without understanding global constraints. Ensure agents have access to
ADR(Architecture Decision Records). - Hard Fixes: Avoid over-complex regex. Use AST-based transformations whenever possible.
- Context Drift: Periodically refresh context maps when making many changes in a single session.