Coder

Dashboard
Preview of generated project
Demo Generated Project with proper File structure

Inspiration

Modern coding assistants can generate snippets of code. But we often need to guide the entire process of development manually through repeated refined prompts. We spend the most time in fixing the bugs. Sometimes we stuck to decide what to build, how to structure it, how to verify correctness, and how to fix mistakes.

This inspired us to think of a simple question:

Can we automate the work of an entire software engineering team instead of just building another code generator?

Coder is our answer.

Instead of acting as a simple code generator, it functions as an autonomous AI software engineer. The user only describes the application they want to build. Coder then plans the solution, designs the architecture, generates the complete project structure, writes the code, reviews its own output, executes the project, performs testing, identifies failures, and AUTOMATICALLY FIXES ISSUES THROUGH ITERATIVE FEEDBACK LOOPS UNTIL THE APPLICATION REACHES A FUNCTIONAL STATE and finally PUBLISHES THE COMPLETED PROJECT TO GITHUB.

The goal was no longer just to generate code, but to automate the complete journey from an idea to a working and publishable software project.

What it does

Coder converts a single natural language prompt into an entire software project using autonomous multi-agent collaboration.

The workflow follows a complete engineering lifecycle:

🧠 Planner Agent

Interprets the user's requirements and converts them into a structured software development plan.

Instead of ambiguous text, the output is transformed into strongly typed Pydantic models.

🏗 Architect Agent

Transforms the high-level plan into an implementation blueprint.

It decides:

Project structure
Required files
Implementation order
Responsibilities of each component

before any code is written.

💻 Coder Agent

Implements the project incrementally.

Rather than generating everything in one response, the coder works file-by-file, using external development tools such as:

read_file()
write_file()
list_files()
get_current_directory()

allowing the LLM to interact with a real filesystem.

🔍 Reviewer Agent

Acts as an independent senior code reviewer.

Instead of trusting generated code blindly, it performs structured analysis and identifies:

Missing functionality
Architectural issues
Implementation mistakes
Maintainability concerns

It returns a structured review report instead of plain text.

🔧 Fixer Agent

When review issues are detected, the Fixer Agent automatically modifies only the affected files.

Rather than regenerating the entire project, it performs targeted code repair, -preserving existing functionalities -saving token and time.

This introduces an autonomous self-healing development loop.

⚙️ Executor Agent

Determines how the generated project should be validated.

Depending on the detected technology stack, it can:

Execute Python projects
Build React projects
Intelligently skip execution for static HTML/CSS projects

using isolated subprocess execution.

🧪 Tester Agent

Evaluates the generated project against the original user intent.

Instead of verifying syntax alone, it validates:

Feature completeness
Implementation quality
Execution results
Functional correctness

This makes Coder capable of autonomous verification before final delivery.

🚀 Publisher Agent

Once the project successfully passes the validation pipeline, the Publisher Agent handles the final delivery step.

It can:

Initialize a Git repository for the generated project
Stage the generated files
Create a commit
Configure the main branch
Push the completed project to GitHub

This turns Coder's workflow from “generate and verify” into a complete “generate → verify → publish” pipeline.

How I built it

Coder is implemented as a LangGraph-based automated multi-agent workflow.
Each node inside the graph represents an independent AI engineer with a specialized responsibility.

Planner
      ↓
Architect
      ↓
Coder
      ↓
Reviewer
     ↙      ↘
 Fixer     Executor
     ↑       ↓
     └──── Tester
             ↓
         Publisher
             ↓
            END

Each agent communicates using strongly typed Pydantic schemas rather than free-form text.
The workflow maintains shared state across agents so that planning information, generated files, review results, execution results, and testing results can move through the complete engineering lifecycle.
Coder also supports multiple LLM models, allowing different models/providers to be used for different engineering responsibilities instead of making the entire system dependent on a single model.
This dramatically improves reliability by enforcing structured outputs throughout the pipeline.

The system uses:

LangGraph StateGraph for orchestration
LangChain Agents for tool calling
Multiple LLM models/providers for specialized agent tasks
Filesystem tools for real project generation
Subprocess execution for validation
Iterative feedback loops for autonomous refinement
Git for automatic project publishing

MOST IMPORTANTLY, instead of producing one massive response, Coder incrementally builds software exactly like a human engineering team.

Challenges I ran into

Building an autonomous AI engineer introduced several engineering challenges.

Multi-agent state synchronization

Passing structured information reliably across multiple autonomous agents while maintaining consistency required careful state management.

Tool reliability

Large language models occasionally generated malformed tool arguments or invalid tool calls.

We redesigned prompts and tool interfaces to improve execution robustness.

Rate limiting

Long multi-agent workflows rapidly consumed token budgets.

Handling API limits while maintaining uninterrupted workflows became one of the largest practical engineering challenges.

Recursive workflows

Reviewer → Fixer → Reviewer → Tester introduced cyclic execution paths.

Preventing infinite repair loops required introducing retry counters and execution limits.

Structured generation

Producing deterministic JSON schemas across multiple agents demanded extensive prompt engineering and validation.

File safety

Since the AI writes directly to disk, secure filesystem boundaries were necessary to prevent writing outside the project directory.

Accomplishments that I'm proud of

Built a fully autonomous multi-agent software engineering workflow where each agent has a dedicated responsibility - from planning and architecture design to coding, reviewing, testing and self-fixing.
Successfully connected the entire workflow into an end-to-end pipeline, from a single natural-language prompt to a working GitHub repository.
Reduced manual intervention by enabling the system to iteratively detect and resolve errors before presenting the final output.
Implemented specialized AI agents instead of relying on a single monolithic LLM.
Added multi-LLM support, making the system more flexible and allowing different models to be used for different tasks.
Implemented autonomous Git operations for initializing repositories, committing generated projects and pushing them to GitHub.
Designed a modular architecture that allows individual agents to be improved or replaced without affecting the overall workflow.
Integrated real filesystem operations through AI tool calling.
Created an extensible architecture where additional AI engineers can be plugged into the workflow with minimal changes.

What I learned

Building Coder fundamentally changed how we think about AI software development.

We learned that:

Autonomous AI systems benefit significantly from specialization.
Structured outputs outperform free-form responses in complex workflows.
Graph-based orchestration is more scalable than linear prompting.
Software engineering can be decomposed into independent AI responsibilities.
Iterative review and repair dramatically improve generation quality.
Tool-using LLMs are far more capable than text-only models.
Different LLMs can have different strengths, making model flexibility valuable in complex agentic systems.
Building a reliable autonomous system requires more than choosing a powerful model — state management, tool reliability, validation, error handling and workflow design are equally important.
The difference between a code generator and an AI software engineer is the ability to act, evaluate, recover and continue without constant human intervention.

Most importantly, we learned that the future of AI coding lies not in larger models, but in collaborative intelligent agents working together toward a shared objective.