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

Steve identifies a specific demographic—senior engineers with 12-15 years of experience—as the primary resistance to AI coding adoption. Unlike junior engineers and non-engineers who embrace vibe coding, this group's identity is deeply tied to traditional coding methods. The discussion explores why this resistance exists and the cultural shift required to adopt AI-powered development.

• •Engineers with 12-15 years experience show the strongest resistance to AI coding tools
• •Junior engineers and non-engineers are already adopting vibe coding without resistance
• •Identity attachment to traditional coding methods creates the biggest adoption barrier
• •The resistance manifests as online backlash claiming "15 years of experience beats AI"

Steve reveals anecdotal data from OpenAI showing 10x productivity differences between engineers using agentic coding versus traditional IDEs, measured across lines of code, commits, and business impact. He makes the bold claim that engineers still using IDEs by January 1, 2025 will be "bad engineers," emphasizing the urgent need to develop AI coding skills.

• •OpenAI's internal data shows 10x productivity gains from agentic coding across multiple metrics
• •Performance review disparities are creating HR and legal concerns at companies
• •Hot take: Using an IDE by January 1, 2025 makes you a "bad engineer"
• •The productivity gap is so stark it's forcing companies to reconsider performance evaluation

A critical discussion of why AI coding adoption is difficult: it requires approximately 2000 hours (one full year) of practice before developers can predict AI behavior and trust it. Steve emphasizes that superficial attempts (2 hours) produce garbage, while deep expertise (2000 hours) enables true productivity. The conversation includes real examples of AI mistakes and the skills needed to work effectively with agents.

• •Studies show 2000 hours of practice needed before developers can predict AI behavior
• •Trust specifically means ability to predict what the AI will do, not blind faith
• •Two-hour experiments produce garbage; two-thousand-hour expertise produces 10x gains
• •AI capabilities have fundamental edges: hallucinations, amnesia, getting lost—these haven't changed but require learned mitigation strategies

Steve warns against the "hot hand" fallacy—when AI seems to understand you after successful tasks, leading to overconfidence. He shares a production disaster story where an AI changed database passwords and locked out his entire system while trying to solve an access problem, illustrating why you should never anthropomorphize LLMs.

• •The "hot hand" fallacy: assuming AI understands you after successful collaboration leads to disasters
• •Real example: AI locked out entire production system by changing passwords to solve access issue
• •Never anthropomorphize LLMs—they can "stab you in the back" at any moment despite previous success
• •Critical rule: Keep AI away from production systems; Git should be your backstop

Steve critiques Claude Code despite its proven effectiveness, arguing it requires reading "waterfalls" of text, code, and diffs that most engineers find overwhelming. While expert users can evaluate changes from "the shape and color of diffs," the tool is too hard for mass adoption. The solution lies in visual agent orchestration dashboards, not chat-based interfaces.

• •Claude Code works but requires reading massive amounts of text—"five paragraphs is an essay" to most engineers
• •Expert users can evaluate code quality from diff shapes, colors, and lengths without reading code
• •80-90% of programmers haven't adopted Claude Code despite it being proven since March
• •The future is agent orchestration dashboards, not IDE-like tools or chat interfaces

Steve describes building VibeCoder (VC), an agent orchestration dashboard that represents the post-IDE future. Instead of writing code, developers manage multiple agents through visual workflows, activity feeds, and notifications. The discussion covers emerging patterns like agent-to-agent communication via MCP Agent Mail and how orchestrators will handle 90% of routine agent management tasks.

• •Building VibeCoder (VC): an agent orchestration dashboard with scanned workflows and activity feeds
• •Future workflow: arrive in morning, check which agents need input, review notifications—no code writing
• •MCP Agent Mail enables agents to communicate and coordinate tasks amongst themselves
• •Orchestrators predicted in March are now arriving: Replit Agent, Conductor, VMAD, Google's Anti-Gravity

Steve discusses Beads, an issue tracker with tens of thousands of users that was built entirely through vibe coding—he never looked at the code. The project demonstrates that production-quality software can be built without traditional code review, as long as the right questions are asked and AI handles the analysis. The architecture is "really weird" but works because AI can fix corruption and merge conflicts automatically.

• •Beads: production issue tracker with tens of thousands of users, purely vibe-coded
• •Steve receives PRs daily where both the analysis and coding were done by AI
• •The architecture is unconventional and would have been "too hard to manage" in pre-AI era
• •Key insight: tell AI to "fix it" when things break—it handles corruption and conflicts automatically

Merging is identified as "the wall" that everyone hits with 10x productivity gains. When multiple developers make 30,000-line changes simultaneously, traditional merge conflict resolution fails—changes must be re-envisioned and reimplemented on top of each other. One company's solution: one engineer per repo. Graphite is positioned as best-suited to solve this, but no complete solution exists yet.

• •Merge conflicts become catastrophic when developers are 10x more productive with agents
• •30,000-line simultaneous changes require re-implementation, not just conflict resolution
• •One company's interim solution: assign one engineer per repository
• •Graphite identified as best-positioned to solve the merge problem; stack diffs and merge queues are partial solutions

Steve introduces the "factory farming" metaphor for the future of coding, contrasting subsistence agriculture (traditional programming) with industrial-scale code production. This shift unlocks programming for non-programmers and suggests ideal team sizes of 2-3 people. The change is meeting massive philosophical resistance from those attached to "craftsman" coding approaches.

• •Moving from "cutting corn with scythes" (traditional coding) to factory farming (agentic coding)
• •The shift unlocks programming for non-programmers, fundamentally changing team structures
• •Ideal team size may shrink to 2-3 people as coding is no longer the bottleneck
• •Massive backlash expected from "Luddites" who reject industrial-scale code production philosophically

Steve challenges Joel Spolsky's famous "never rewrite your code" principle, arguing that for an increasing class of codebases, AI can rewrite from scratch better than fixing existing code. He discovered this porting unit tests between architectures—throwing out and regenerating tests was faster than iterative fixes. This represents a fundamental inversion of 20 years of software engineering wisdom.

• •Joel Spolsky's "never rewrite" principle was timeless for 20 years—until now
• •For growing classes of code, AI rewrites from scratch better than fixing existing code
• •Discovered while porting unit tests: regenerating from scratch was faster than fixing
• •We're "unlearning everything"—entering a quantum mechanics moment for software engineering

Steve analyzes Google's cultural transformation from "engineers do whatever they want" to accountability-driven execution, crediting this shift for Gemini's success. He reveals that Google, Anthropic, and OpenAI are all experiencing extreme internal chaos due to hypergrowth, with Anthropic hiding it best through strong product management. The discussion covers hiring surges, organizational silos, and execution challenges across all three labs.

• •Google finally implemented accountability after 20 years of engineer autonomy—painful but necessary
• •Gemini's success stems from Google's organizational maturation and AI focus shift
• •All three labs (Google, Anthropic, OpenAI) are experiencing extreme internal chaos from hypergrowth
• •Anthropic hiring 100+ people just for Claude Code; chaos is inevitable at this growth rate

Steve predicts 2025 could be the year of open source models, as they're only 7 months behind frontier models and the gap is narrowing. When open source reaches Claude Sonnet 3.5 quality, developers can run Claude Code-equivalent tools locally for free. This will force tools to get better at task decomposition and model routing for cost optimization.

• •Open source models are 7 months behind frontier models, with gap gradually narrowing
• •By summer 2025, open source could match current Gemini 2.0 Flash quality
• •Free local models will enable Claude Code-equivalent capabilities on M4 Macs
• •Tools must improve at decomposing tasks and routing to right-sized models for cost optimization

Steve redefines what "knowing how to code" means in the AI era: understanding language-neutral capabilities (functions, classes, objects, monads) and architectural concepts, not syntax. The level shifts from writing code to product manager-level architectural thinking, combined with deep technical knowledge of systems like Cloudflare and Cassandra. This technical literacy remains essential even as code writing becomes automated.

• •Kids should learn to "vibe code"—understand capabilities without memorizing syntax
• •Essential knowledge: language-neutral concepts (functions, classes, monads) and how they work
• •New engineer role: product manager-level architectural thinking plus deep systems knowledge
• •Technical literacy doesn't disappear—it shifts from syntax to architecture and system design