An opinionated essay argues that in agentic coding systems, no single agent should both write code and judge its correctness; when the separation between author and judge becomes expensive, the solution is to narrow the judge's scope rather than merging roles, illustrated by the author's six-agent Claude Code setup called Squid.
I built an opinionated multi-agent setup on top of Claude Code. I was proud of two agents in particular: a software engineer doing red-green TDD, and a separate tester running the adversarial edge-case pass. The system worked. It was also painfully slow. Every time the agents ping-ponged, the tester re-ran the linter, type checker, formatter, and happy-path suite that the software engineer had just run. I was paying for the same checks twice. This overlap was the number-one source of having a system that worked but was too slow to use. The obvious move was to merge the two agents and kill the duplication. That's the wrong move. The reason why is the one rule that separates agentic coding from vibe coding. No single agent should both write code and decide whether it's correct. There are four reasons why this structural separation is critical. 1. **The line is structural, not stylistic.** The moment one agent is the author and the judge, you stop verifying and start trusting your own output. That's vibe coding with extra steps, no matter how many tools the agent has. 2. **Merging the roles when the split gets expensive undoes the rule.** Collapsing the agents brings you back to one agent grading its own homework. The cure is worse than the disease. 3. **Keep the agents separate; move the boundary of trust instead.** The right move is not to merge roles, it is to narrow what each agent trusts from the other. The author is never the right party to attack their own work. That is the failure mode the separation exists to prevent. 4. **Generalize the rule.** When you give an agent two responsibilities and one of them is "decide if this is good", split the agent. When the split is expensive, don't undo it. Narrow what the judge re-runs to the part the author can't credibly self-verify. The work-author and the work-judge stay separate. The boundary of trust moves. When the tester re-ran the linter, type checker, formatter, and the happy-path suite that the software engineer had already run, we paid for everything twice. This was the number-one source of having a system that works but is too slow to use. The fix wasn't to merge the roles. It was to bound trust: the tester now only runs the part the software engineer can't credibly self-verify. This rule sits at the center of a six-agent Claude Code setup I run called Squid. It uses a PM/architect, a software engineer, a tester, a PR reviewer, an on-call, and an optional self-improve meta-agent. I use two human gates and five retry caps across the lifecycle. The full team and lifecycle are in the linked piece. Honest caveat: naming exactly what the software engineer can credibly self-verify is itself a judgment call. Getting it wrong means false confidence. The worst failure mode in a system like this. I'm still iterating on where that line sits. In your own agent setup, which agent both writes the work and decides it's correct? And when the separation got expensive, did you merge? **TL;DR:** The structural line between agentic coding and vibe coding is that no single agent both writes code and judges if it's correct. When that separation gets expensive, narrow what the judge re-runs. Don't merge the roles.
Simon Willison reflects on how vibe coding and agentic engineering are converging in his own workflow, raising concerns about code review responsibilities as AI coding agents like Claude Code become increasingly reliable. He explores the ethical tension between trusting AI-generated code in production and maintaining software engineering standards.
The article argues that agentic coding, where AI generates code and humans act as orchestrators, is a trap due to increased system complexity, skill atrophy, and vendor lock-in. It highlights the negative impact on developer learning and critical thinking, contrasting this new abstraction with historical programming shifts.
This article outlines best practices for using Claude Code, an agentic coding environment by Anthropic. It emphasizes managing context windows, providing verification criteria for code, and separating exploration from execution to improve performance.
Describes a specialized multi-agent system for code review with distinct roles and persistent state, open-sourced as agile-team-skill, which separates reviewer and decision-maker roles to improve code quality and process memory.
The author argues that heavily relying on AI coding agents causes human developers to lose critical technical intuition and code review skills over time, proposing measures like mandatory hands-on coding days to maintain supervisory competence.