Why vibe coding fails: too many agents
The intuitive scaling law of 2025–2026: one AI agent made you faster, so five agents will make you five times faster. Teams bought the intuition, spawned a swarm of subagents, and watched their codebases go sideways in ways that were somehow harder to debug than slow code. The industry’s best‑placed observer wrote down why — and it wasn’t a guess; it came from the company whose whole product is an autonomous engineer.
In short
- Parallel agents fail for a structural reason: they can’t share live context, so each acts on its own assumptions.
- Cognition’s law: “Share context, and share full agent traces, not just individual messages” — and “Actions carry implicit decisions, and conflicting decisions carry bad results.”
- Coordination, not typing, is the bottleneck. Splitting writing across agents splits the context and multiplies conflicts.
- Karpathy’s 2026 framing: professionals now “orchestrate agents who do [write the code] and act as oversight” — one place where decisions live.
- Multi‑agent works read‑only: parallel research and codebase scans are fine; parallel writes to one system are not.
- The fix is orchestration discipline, not fewer tools: one driver, full traces, tests and review as gates.
Why the swarm feels productive and isn’t
A swarm of agents produces activity at a rate humans can’t match: dozens of files touched, dashboards green, impressive demos. The problem shows up a step later, when the parts have to agree with each other.
Agent A builds the form against schema version one. Agent B, working in parallel, migrated the schema to version two. Agent C wrote tests that assume version one. Each of the three was locally correct; the system they jointly produced is not. This is not an implementation bug you can patch — it is what happens when teammates without shared context write to the same project. Humans avoid it through meetings, shared docs and being in the same room; agents have none of that by default.
Cognition — the company behind Devin — is the right source here, because nobody has a stronger incentive to believe the swarm works, and they published the opposite. Walden Yan’s Don’t Build Multi‑Agents distilled their experience into two principles. The first: “Share context, and share full agent traces, not just individual messages.” The second: “Actions carry implicit decisions, and conflicting decisions carry bad results.” Their own war story was a simple game project split across parallel subagents: the agents stepped on each other’s assumptions and the project collapsed into what they called flailing.
The real bottleneck was never typing
Ask why a feature takes three days and the honest answer is rarely keystrokes. It is deciding what the feature should do, reconciling it with everything already built, and verifying the result. Those steps scale poorly with headcount — human or artificial — because they all run through one shared understanding of the system.
Multi‑agent setups “solve” the typing, which was never the constraint, and scatter the shared understanding, which was. That is why the swarm pattern produces the specific smell of vibe‑coded failure: locally plausible code that disagrees with itself. A model’s attention is finite, too — a subagent that receives a summary of the plan instead of the full trace will confidently make decisions that the summary silently dropped. Context is the compute; summaries are lossy compression of decisions.
What Karpathy’s agentic engineering actually prescribes
In February 2026, a year after coining vibe coding, Karpathy published his retrospective. The professional version, he wrote, is that “programming via LLM agents is increasingly becoming a default workflow for professionals, except with more oversight and scrutiny. The goal is to claim the leverage from the use of agents but without any compromise on the quality of the software.”
And the mechanism, in his words: “‘agentic’ because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight.”
Read that carefully and the architecture falls out. One agent — or one human — holds the full context and the decision authority. Other agents are hands, not colleagues: they get briefs, they return artifacts, and the driver integrates them into a single coherent state. Oversight is not a rubber stamp at the end; it is the mechanism that keeps decisions in one place. This matches Cognition’s principles line for line, and it is how we run projects in our AI agent development service: a driver with the whole picture, structured input from helpers, and humans holding the pen on decisions that matter.
Where multi‑agent genuinely works
The pattern isn’t forbidden — it’s directional. Parallelism is cheap and safe when the tasks are read‑only: four agents researching four competitor sites, scanning a codebase from different angles, drafting three alternative designs. Divergence costs nothing if the outputs are opinions for a human to reconcile.
The failure starts exactly when parallel agents get write access to the same system with separate contexts. Read‑only parallelism, serialized writes. That one sentence prevents most of the incidents.
And the rails that keep any of this honest are the same as ever: tests as the merge gate, review before production, git history so every agent action is attributable and reversible. If your team is missing those, start with the basics in five vibe coding mistakes — the orchestration problem sits on top of them, not instead of them.
Summary
More agents means more coordination, and coordination is the part that was never cheap. The teams that win with AI in 2026 don’t run the biggest swarms; they run the clearest context loops — one driver, shared full traces, decisions in one place, tests and review as gates. Leverage without compromise on quality, as Karpathy put it.
If you want that architecture built for your product — agents that ship value instead of incidents — start at AI agent development, or see how we build web development with the same discipline.
Yuri Osipov
Founder, SEO & analytics
Runs Take the Space. Specialises in technical SEO, measurable analytics setups and AI search visibility.