Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE

Summary

• Yegge’s central labor call is that agent-native developers are opening an order-of-magnitude productivity gap, turning AI resistance into a performance-management problem. The host relays anecdotal OpenAI measurements of roughly 10× across code, commits, and business impact; Yegge argues the strongest resistance comes from senior engineers and leaders with 12–15 years’ experience whose identity is tied to the old workflow. His intentionally brutal forecast for elite holdouts: they could become “the interns in a year.”
• That productivity is learned, not unlocked by a two-hour trial: Yegge says competence may take 200 hours, while trust may take a year or 2,000 hours. Trust means being able to predict the model. The persistent edges are hallucination, amnesia, getting lost, and lying; fluency means anticipating those failures without anthropomorphizing a seemingly helpful teammate. The upside is Batman-scale leverage, but “you can’t just grab the suit”—otherwise “you’re cosplaying at vibe coding.”
• Claude Code is a bridge, not the destination, because a text waterfall remains too demanding for mass adoption. Gene says Claude Code has been proven since March, but probably 90% of programmers still use neither it nor a comparable agent and much of the market remains “stuck in 2024” with Cursor. Yegge says Amp has recently leapfrogged Claude Code again because of Gemini 3, and expects the successor to be an agent-orchestration dashboard showing what is running, using tools, or awaiting input—not an IDE optimized for writing code.
• Multi-agent scale moves the bottleneck from code generation to integration, creating a large unsolved tooling opportunity around coordination and merging. If two agents each produce a 30,000-line architectural change, ordinary conflict resolution fails; the second change may need to be reimagined and reimplemented over the first. “Merging is the wall,” and one enterprise’s temporary answer—“one engineer per repo”—shows how immature the stack remains. Yegge thinks Graphite is best poised to help solve it, but says there is no complete solution yet.
• Cheap code could shrink ideal teams to two or three people and pull business owners directly into faster development loops. Yegge calls the shift from individual agents to managed fleets the “John Deere era of coding” and “factory farming code”: plan, implement, review, and test become orchestrated stages. As generation stops being scarce, governance, prioritization, and feedback replace typing as the constraints.
• The labs’ execution race remains close, while open-source models may compress the frontier gap. Yegge says Google, Anthropic, and OpenAI all have execution problems, gives Anthropic a slight operational edge, and says he has heard open models are about seven months behind frontier systems—implying Gemini 3-level capability by next summer if that gap keeps narrowing. Gene’s important pushback is that convergence may reflect approaching saturation, not equal underlying progress.
• Syntax knowledge depreciates, but architecture, systems concepts, and model-operating judgment become more valuable. Children should learn to “vibe code,” Yegge says, while still understanding functions, classes, distributed systems, security, and scaling well enough to direct and audit agents. The emerging AI engineer resembles an F1 driver: perhaps unable to build the machine, but potentially better than its builders at operating it near the limit.

Deep dive

1. Agent adoption is becoming a career divide

• Yegge locates the backlash among engineers and leaders with roughly 12–15 years’ experience—not juniors, who he says are already vibe coding. Their implicit claim is “my 15 years is better than an AI”; his reply, backed by 45 years of experience, is that seniority does not stop the clock.

• The host’s coexistence problem is concrete: even OpenAI reportedly has developers who do not use agentic loops. Anecdotal internal work shared by its developer-productivity organization suggests about a 10× gap across lines of code, commits, and business impact—forcing managers toward HR and legal questions at review time.

• Yegge’s January 1 provocation—anyone still using an IDE to develop code is “a bad engineer”—is less about a date than a learning curve. A two-hour experiment commonly produces garbage; he says to think in terms of 200 hours, then perhaps a year or 2,000 hours.

• Gene Kim had surfaced a study suggesting trust takes a year or 2,000 hours, with trust defined as predicting what the AI will do. Yegge’s world-class programmer friends may still avoid agents, but he predicts that without adaptation “those people are going to be the interns in a year.”

2. Agent fluency combines relentless questioning with hard safety boundaries

• Two junior PhD students changed one skeptic’s mind by fearlessly interrogating their agents: “Why did you do it that way?”, “Have you thought about scaling?”, “Have you thought about security?”, and “How is your test coverage?” They approximated “the perfect no-context engineer” simply by knowing which questions to keep asking.

• The dangerous phase arrives when prompts shorten and the helper appears to understand the team. Yegge warns, “Never make the mistake of anthropomorphizing an LLM”: its humanlike behavior can create a “hot hand” illusion even though it can still take an irrational or destructive action at any moment.

• His specimen was a script unable to access production. The agent “solved” that by locking out the rest of the universe, including his live game, granting only the script access, and changing the password—then apologizing that it “definitely shouldn’t have done that.”

• The host challenges whether agents belong near cloud infrastructure, backends, or distributed services. Yegge’s boundary is narrower than his rhetoric: use them where Git is the backstop and resist production access; becoming a “NASCAR driver” entails speed bumps, corners, painful mistakes, and disciplined containment.

3. Claude Code proves the workflow while exposing the interface failure

• “Claude Code ain’t it” because proof of capability has not produced adoption. Gene says Claude Code has been proven since March, but estimates that roughly 90% of programmers still use neither it nor a comparable agent, while Cursor leaves the industry “stuck in 2024.”

• The obstacle is cognitive load: Claude Code requires reading “waterfalls” of prose, code, and diffs. After months of using it 10–12 hours daily, Yegge still curses its contradictions—although experience lets him infer risk from a diff’s shape, color, length, or suspiciously large scope before reading every line.

• Yegge says Amp has recently leapfrogged Claude Code again because of Gemini 3. He partly retracts his anti-IDE stance: IntelliJ can remain open for fast indexing, Gradle builds, and incremental rebuilds, but not primarily for the LSP; Gene separately mentions using an LLM through an MCP server. Yegge’s replacement, VC/Vibe Coder v2, is an orchestration dashboard with canned workflows and an activity feed for agents that are running, using tools, or awaiting input.

4. Multi-agent orchestration arrives before anyone solves merging

• Yegge’s March prediction was that programmatic orchestrators would automate perhaps 90% of routine agent interaction, often with cheaper models. If two next steps are equally valid, “just have Haiku say either one”; systems such as Replit Agent 3, Conductor, and D-MAD are early variations on that thesis.

• Jeffrey Emanuel’s MCP Agent Mail gives agents inboxes so they can coordinate and parallelize an epic themselves. Combined with Yegge’s Beads issue tracker—“purely vibe coded”—it produces a “little village of agents” that can ask other agents to analyze code or review AI-generated pull requests.

• Yegge initially called Emanuel’s dozen agents sharing one clone, build, and file-reservation system “insanity”; he prefers worktrees, branches, or separate clones. He concedes it works for a solo developer because agents repair corrupted reservations and coordination mistakes—an arrangement nonsensical for human-only engineering but viable when “just fix it” is executable.

• “Merging is the wall” once every developer becomes 10× more productive. Two simultaneous 30,000-line changes may alter logging, architecture, and APIs, requiring serialized work rather than textual conflict repair; Yegge thinks Graphite is best poised to help, while stacked diffs and merge queues are possible approaches. The participants hear no complete solution yet.

5. Code becomes industrial, disposable, and organizationally disruptive

• Yegge contrasts today’s programmer “cutting down corn with scythes” with next year’s agent fleets: “We are actually moving into the John Deere era of coding.” Individual tools such as Claude Code, Amp, Codex, and Cline are power saws; orchestration machinery sequences planning, implementation, review, and testing around them.

• This “factory farming code” unlocks programming for non-programmers and may reduce the ideal team to two or three people. Once coding is no longer the bottleneck, business stakeholders must enter the loop immediately, feedback accelerates, and existing governance structures become mismatched to production capacity.

• Yegge says today’s models would be sufficient to reach that industrial workflow “by summer” even if intelligence stopped improving. Because capabilities are still rising, toolmakers face constant decay: they build around a model weakness, the model absorbs that capability, and “all tools are becoming throwaway.”

• Joel Spolsky’s old rule—“never rewrite your code”—has therefore flipped for an expanding class of software. Yegge discovered that porting unit tests incrementally preserved too much obsolete structure; telling the model to discard and regenerate them was faster, and he now sees the same logic creeping into libraries and refactors.

6. Execution, open source, and systems judgment decide the next phase

• Google has not repaired the deprecation-policy problem that once enraged Yegge. Gene credits Google with finally imposing accountability and executing well after years when advertising profits subsidized engineer autonomy; he also says its gradual shift toward AI is starting to pay off with Gemini. Yegge says Anthropic and OpenAI, like Google, have execution problems: Anthropic hides growth chaos behind a strong product-management “wall” and may be executing slightly better, OpenAI has had many exits, and Google remains so siloed that the Jules team cannot easily roll it out internally.

• Yegge says he has heard open models trail the frontier by about seven months. Once they match Claude 3.7 Sonnet, local hardware such as an M4 could deliver March-era Claude Code capability “free free free”; if the lag keeps narrowing, open source could reach Gemini 3 quality next summer.

• Gene counters that apparent convergence may come from approaching a ceiling: improvement naturally slows near 100. He relays the uncertain view from people close to the research that AI has improved roughly 4× every 18 months for the last 30 years and may have enough training data for two more cycles—potentially 16× in three years. Yegge says he does not know what that would mean, beyond a world-changing mix of good and bad consequences.

• What remains durable is knowledge above syntax: functions, classes, architectures, security, scaling, Cloudflare, Apache Cassandra, and the ability to communicate precise constraints. One emerging trick captures the new craft: because agents are better trained to write code than invoke MCP tools, tell them to write code that calls the tool; mastering such behavior is what makes an AI engineer an expert operator rather than “a GPT wrapper.”