1 Building on quicksand: the challenges of vibe engineering

AI-assisted development enables rapid prototyping guided by intuition, but speed without discipline breeds fragility. The chapter contrasts “vibe coding” (alchemy-like, ad hoc generation) with “vibe engineering” (applied, evidence-driven practice), showing how unverified AI output invites real failures: security breaches, destructive commands, supply-chain compromises, and autonomous agents making harmful choices. The core lesson is that the bottleneck isn’t bigger models but missing rigor: clear intent, clean abstractions, and verification. Teams that treat specifications as testable contracts, and non-functional requirements as first-class, convert the creative power of LLMs into reliable, maintainable systems.

Undisciplined workflows accumulate trust debt—the hidden organizational cost of shipping code no one truly understands or owns—amplified by automation bias and the “dump-and-review” culture. The antidote is a verify-then-merge pipeline that treats prompts, specs, and provenance as accountable artifacts; decomposes work into small, testable steps; and enforces guardrails through CI gates, sandboxing, canaries, and rollback. The chapter maps an autonomy-risk spectrum from token-level assists to near-autonomous agents and argues that higher leverage demands stronger governance and clearer contracts. It reframes developers as system designers and validators who wrap probabilistic AI with deterministic intent via executable specifications, retrieval grounding, checklists, incident triage, and guarded automation.

Even with better tools, the “last mile” remains: the 70% problem (AI accelerates the easy part, humans must deliver the hard, contextual 30%), rising cognitive load to build true mental models, and the AI productivity paradox where generation outpaces safe review. The proposed operating loop—Vibe → Specify/Plan → Task/Verify → Refactor/Own—balances exploration with ownership, turning intent into code that passes adversarial, performance, and security gates. Stepping beyond craftsmanship, the chapter calls for a repeatable, spec-first engineering discipline where reliability comes from process, not provider choice, and where human taste is codified as verifiable rules. AI is a force multiplier only when embedded in a rigorous, auditable workflow that keeps risk visible, trust debt small, and teams confidently on-call for what they ship.

The autonomy-risk spectrum: each step grants more leverage but demands tighter verification, governance, and engineering discipline

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.
• 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.
• AI 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).

FAQ