waleedk
Joined 11 years ago
Joined 11 years ago
It was more of a conversation, but it was like: Hey I wrote these 6 points about what we're doing differently, please tailor them to be most useful to an HN audience.
Seriously, the agents managing agents thing works so well. When I'm working, I'll sometimes have 6 builder agents fixing different bugs, and I will lose state and I rely on the architect agent who doesn't have stupid limitations like 7 +/- 2 things in working memory.
Great suggestions. I will do that. Did you notice any specific issues in those?
Got it about the core flow. Appreciate it. I plan to record a video showing how to kick off a new project and another one showing how to use it in maintenance mode. Would that be helpful?
@yodon if you would like to reach out to me at [email protected] I'd love to get your feedback once those assets are ready.
Github: https://github.com/cluesmith/codev Tour + raw results: https://cluesmith.com/blog/a-tour-of-codevos/
The 106 PRs in 14 days was one person — me — with AI agents doing the implementation. The article walks through the ideas that make this work:
- Multi-model review: Three independent AI models (Claude, Gemini, Codex) review every phase. They catch different things — Codex finds security edge cases, Claude catches runtime semantics, Gemini catches architecture problems. No single model found more than 55% of the bugs.
- An agent that helps you organize agents. You work with an Architect agent that spawns Builder agents that work simultaneously in isolated git worktrees. While one is implementing a feature, another is fixing a bug, and you're reviewing a third's PR. Your job shifts from writing code to keeping the pipeline fed.
- Natural language is the source code. Specs, plans, and reviews are version-controlled in git alongside the source code — treated with the same rigor as the code itself. The AI's instructions live in the repo, not in someone's chat history that's already been compressed. You always know why something was built and how it was designed.
- Deterministic execution. Instead of asking the AI to follow a process and hoping it does, a state machine (Porch) enforces it. Human gates, build-verify loops, mandatory review phases. The AI can't skip steps, and if it exhausts its context window, the next agent picks up from the exact checkpoint.
- Annotation over editing. Most of the work is writing and reviewing these natural language documents — specs that define what to build, plans that define how. The documents guide the agents. You're directing, not coding.
- Whole lifecycle, git at the center. From idea through specification, planning, implementation, review, PR, and merge — the entire development lifecycle is managed. Git is the backbone: worktrees for isolation, branches for workflow, PRs for integration.
It's free and open source:
npm install -g @cluesmith/codev
(and https://github.com/cluesmith/codev for the code)
The article includes a controlled comparison against unstructured Claude Code — honest about the tradeoffs (costs more, takes longer, but catches more bugs and ships with tests).
I'm genuinely looking for feedback on this. What resonates? What doesn't? What would you do differently? This is still early and I want to hear what the HN community thinks. Happy to answer questions too.
GitHub: https://github.com/cluesmith/codev
Quick start: `npm i -g @cluesmith/codev && af start`
How it works:
The Architect window is your control center. You create specs (what to build) and plans (how to build it). Then with `af spawn --project 22`, a builder agent spins up and implements the spec. When it's done, it opens a PR – already reviewed by a panel of AI agents (Gemini, Claude, GPT). It notifies you, and you merge.
Meanwhile, you're not blocked. You can spawn more builders, design the next feature, or review what's already done.
How it's built:
Agent Farm runs in your browser, built on common infrastructure:
- tmux – each agent gets its own terminal session
- ttyd – exposes terminals to the browser (no Electron)
- git worktrees – each builder gets an isolated worktree on its own branch
~20K lines of TypeScript + HTML. VSCode is 2.7 million.
The workflow:
Codev structures the work: `codev init` sets up specs/, plans/, reviews/ folders. You write specs first, then plans. Once approved, spawn one builder per spec. Three specs? Three builders, parallel, isolated. Each opens a PR when done.
Opinionated design:
- Simple extensible implementation
- No chat sidebar – agents get full terminal sessions
- Specs and plans are markdown files
- Multi-agent review before human review
Live Demo: youtube.com/watch?v=0OEhdk7-plE
Would love feedback on it. Happy to answer questions.
Here's the original not tailored post: https://news.ycombinator.com/item?id=47167393