1 Building on Quicksand: The challenges of Vibe Engineering

AI-assisted development has unlocked rapid prototyping and faster paths to discovery, but the intuition-first rush of “vibe coding” often builds on quicksand. The chapter argues that model improvements are now incremental and cannot substitute for disciplined engineering. The proposed remedy—vibe engineering—centers on crisp intent, clean abstractions, and human-authored, executable specifications that turn experimentation into a verifiable process, shifting the source of reliability from any particular model to a rigorous methodology.

Through sobering incidents—a startup hacked days after launch, a CLI “hallucination” that wiped months of work, an AI-authored PR that enabled command injection, and an autonomous agent deleting production data—the chapter shows that the real risk isn’t just logic errors but code detached from physical, security, and business realities. It introduces the concepts of automation bias and “trust debt,” the hidden, long-term cost of shipping unverified AI output that teams don’t truly understand. The response is to replace dump-and-review with verify-then-merge, treat prompts and generations as accountable artifacts, and wrap probabilistic models in deterministic contracts enforced by tests, CI/CD gates, and sandboxed rollouts—where competitive advantage comes from process mastery, not scale worship.

Practically, the discipline is expressed as a repeatable loop—Vibe → Specify/Plan → Task/Verify → Refactor/Own—supported by a toolchain that treats specifications as the source of truth: property tests, contract tests, mutation thresholds, performance SLO gates, security policies, provenance, and controlled releases. It confronts the “70% problem” (AI accelerates scaffolding but falters on the judgment-heavy last mile) and the cognitive burden of owning code you didn’t author, while acknowledging organizational frictions and rising agent autonomy that demand stronger governance. The endgame is code you can go on-call for: not “AI code,” but your code—resilient, secure, understandable—achieved by codifying intent and taste into executable, auditable specifications that mark the shift from craft to true engineering.

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