1 Building on Quicksand: The challenges of Vibe Engineering

AI-assisted development has unlocked unprecedented speed and creative exploration, but the chapter argues that raw generation without discipline is quicksand. As model improvements become incremental, true advantage shifts from having the “biggest model” to mastering usage: crisp intent, clean abstractions, and rigorous verification. The proposed answer is Vibe Engineering—a spec-first, evidence-driven practice that preserves the creative benefits of rapid prototyping while wrapping probabilistic systems in deterministic guardrails. The goal is not to reject AI, but to transform experimentation into engineering so shipped code is resilient, secure, and truly owned by the team.

The dangers of undisciplined “vibe coding” are illustrated by real incidents: a startup compromised within days, a CLI command that destroyed months of work, a trojanized pull request, and an agent that silently “cleaned” production data. These failures expose a systemic risk: AI outputs detached from physical, financial, and security realities—amplified by automation bias, dump-and-review workflows, and the accumulation of invisible “trust debt.” The chapter dismantles the myth that scale will fix this, highlights the 70% Problem (generation is easy; the last 30% of judgment, integration, security, and performance is hard), and surfaces the true bottleneck: the cognitive load of building a durable mental model for AI-authored code, which can overwhelm reviewers and stall team throughput.

To counter this, Vibe Engineering centers human-authored, executable specifications as the contract guiding AI and verifying outcomes: verify-then-merge, not dump-and-review. It operationalizes a spec-first lifecycle—Vibe → Specify/Plan → Task/Verify → Refactor/Own—supported by practices like grounded retrieval, systematic prompts, PR checklists, guarded automation, mutation and property testing, performance SLO gates, and auditable provenance of prompts and models. The developer’s role shifts from line-by-line author to system designer and validator, with IDEs and CI/CD acting as the cockpit and factory enforcing contracts. Ultimately, the “Own” phase is non-negotiable: refactor to understand, document, and assume accountability. This marks a shift from artisanal craft toward a repeatable engineering discipline where taste is codified as rules—and where speed, safety, and maintainability can scale together.

Increasing Autonomy & Risk Label

Vibe → Specify/Plan → Task/Verify → Refactor/Own Loop

• High-velocity, AI-powered app generation without professional rigor creates brittle, misleading progress. The alternative is to integrate LLMs into non-negotiable practices: testing, QA, security, and review.
• Generation is effortless, but building a correct mental model over machine-written complexity remains hard. Real ownership depends on understanding, not just producing, code. Effectively, AI makes the process of understanding harder.
• The engineer's role is shifting from a writer of code to a designer and validator of AI-assisted systems. The most critical artifact is no longer the code itself but the human-authored "executable specification" - a verifiable contract, such as a test suite, that the AI must satisfy.
• Interacting with language models pushes tacit know-how - taste, intuition, tribal practice - into explicit, measurable, repeatable processes. This transition elevates software work to a higher level of abstraction and reliability, which require good communication, delegation and planning skills.
• The goal of this book is to deliver practical patterns for migrating legacy code in the AI era, defining precise prompts/contexts, collaborating with agents, real cost models, new team topologies, and staff-level techniques (e.g. squeezing performance). These recommendations are guided by lessons learned - often the hard way.

FAQ