-
-
One completed phase: nine tasks landed, 39 findings absorbed, and zero follow-up issues.
-
The WAR workflow: isolated work, independent audits, bounded fixes, verified integration, and shared lessons.
-
Independent audit agents review correctness, security, test fidelity, and plan adherence in parallel.
Track: Applied Intelligence
Inspiration
Generating code is only one part of software development. The harder work is deciding what should be built, checking whether an implementation satisfies that intent, and resolving defects without losing control of the scope.
I built WAR while working with existing production codebases serving Fortune 100 companies. As I delegated more development to AI agents, I kept encountering the same challenge: someone still had to connect the implementation, review, correction, and verification steps.
WAR grew from refining those handoffs. The goal is a work–audit–refine loop that reaches a checked result or an explicit stop for human judgment.
What it does
WAR is an open-source plugin that takes a development idea through planning, implementation, independent review, and pull-request preparation.
It interviews the developer to establish intent and produce an actionable plan. Workers implement tasks in isolated Git worktrees. Separate, read-only auditors review the same code revision through different lenses, including correctness, security, simplicity, and test-fidelity. Blocking findings return to the correction loop. A serial integration process reruns the project’s checks before merging approved changes.
The human remains responsible for direction and decisions outside the agreed scope. WAR bounds correction attempts and escalates problems that cannot be resolved within its rules.
WAR also retains lessons between runs, shares them across users/teams working in the target repo, and can grow beyond the 25KiB MEMORY.md limit. Individual lesson files form a searchable knowledge store, while a compact generated MEMORY.md index keeps the immediately loaded context bounded. Relevant lessons are retrieved for later agents, allowing accumulated knowledge to grow beyond the index’s size budget.
How I built it
WAR combines Claude Code agents and workflows with JavaScript orchestration, Git worktrees, GitHub issues, and shell hooks. Its memory retrieval uses Node.js and SQLite full-text search.
The coordination logic explicitly represents dependencies, review rounds, integration, and recovery. Workers and auditors have separate responsibilities, and approval is tied to a specific code revision. Project tests and acceptance checks provide evidence alongside the auditors’ judgments.
Development has followed a human-supervised improvement cycle: use WAR on real work, inspect failures and friction, refine the handoffs and controls, and carry verified lessons into subsequent runs.
Challenges I ran into
The difficult cases appear between agents: a reviewer identifies problems without providing a helpful root cause analysis and gives bad direction to the fixer, a correction introduces another defect, or individually valid changes interact badly during integration.
Another challenge is deciding when to continue. An autonomous system needs boundaries around correction attempts, scope changes, and unresolved questions. Defining those boundaries has been as important as improvements to the underlying models’ capabilities.
Memory brings a related problem: retaining useful experience without allowing stale assumptions or an ever-growing context window to dominate future work. Moreover, sharing these learnings across different engineers and teams working on the same repo ensures that valuable lessons are learned only once and are able to be leveraged by everyone who uses and contributes to the code.
Accomplishments I’m proud of
I’m proud of turning agent handoffs into an explicit engineering process with: independent review, bounded correction, audit/fix scope that scales-in and only focuses on what actually needs to be addressed next, maximal parallelization, verification before integration, and clear points for human intervention.
The planning, review, and memory capabilities also stand on their own. Developers can use WAR to sharpen a plan or audit a change before adopting the full execution workflow.
What I learned
Autonomy depends on the quality of the handoffs. Each agent needs a clear task, evidence for its decisions, and a defined next step when the work fails a check.
Useful memory also needs maintenance: where a lesson came from, whether it still applies, and when to retrieve it matter as much as storing it.
Hackathon contribution — planned; update before deadline
WAR existed before this event. The proposed hackathon additions are a parallel advisor session supporting the planning interview and additional tools for automated quality verification.
The advisor would investigate technical questions and develop recommendations alongside the interview, giving the supervising human better context for decisions. The intended outcome is less investigative burden on the user and more precise implementation plans. The additional verification tools would strengthen the evidence used to assess the resulting work.
Before the submission deadline, this section will identify the functionality actually completed during the event, link its commits, and describe the demonstrated results.
What’s next
Implement and evaluate the planning advisor and additional quality-verification tools, improve onboarding, and continue the Codex port. Evaluate whether advisor-assisted interviews reduce clarification cycles and unresolved assumptions while preserving the user’s control over design decisions.
Log in or sign up for Devpost to join the conversation.