Chapter 1: Building on quicksand: the challenges of vibe engineering
The chapter introduction contrasts the real speed gains of AI-assisted development with the risks of unverified code and argues for an explicit engineering discipline.
After this chapter you will be able to
- Speed gains and hidden costs. Explain how rapid AI-assisted development can make experimentation cheaper while undisciplined vibe coding can create a misleading sense of progress and code that teams cannot maintain.
- The downstream engineering bottleneck. Explain why faster code generation shifts the constraint toward understanding, validation, and safe delivery, and why the introduction emphasizes clear intent, abstractions, and testable specifications.
- Explicit vibe engineering discipline. Describe Vibe Engineering as retaining the benefits of AI-assisted development while making familiar engineering requirements explicit rather than leaving them in someone's head.
- Illusion of AI-assisted speed. Explain why perceived productivity is an unreliable measure of AI-assisted development, using the METR trials as an example. State what the section proposes measuring instead.
- Functional Code Versus Security. Explain why the speed of building an AI-generated application did not make the Enrichlead app safe, and how the later Moltbook incident reinforces the lesson.
- Unverified File Operation Failure. Trace how the failed folder creation led to the loss of a directory of work, and explain why the model’s apology did not address the underlying problem.
- Pull request supply-chain failure. Trace how an unvalidated pull-request title in AI-generated code let an attacker run commands, steal package-publishing keys, and distribute a compromised release.
- AI tools as attack surface. Explain how the malware used installed AI CLI tools to search victims’ files for secrets, extending the attack beyond the original AI-written code.
- Consequences and production readiness. Explain why the section attributes these failures to accepting unverified AI output in a real system, rather than simply to bad model logic.
- Specification and autonomy controls. Distinguish specification failures from failures of agent autonomy, and explain why one kind of safeguard cannot cover both.
- Capability gains and persistent hallucination. Explain why higher benchmark scores do not mean larger models have outgrown hallucination or eliminated the need for external verification.
- Plausible errors and reviewer burden. Explain why improved model output can make errors harder to spot and why greater agent capability raises the cost of an unverified change.
- Model execution and human judgment. Distinguish the model’s ability to execute an instruction from the engineer’s responsibility to provide missing context and verify the result.
- Coding versus engineering. Distinguish vibe coding as prompt-driven exploration from vibe engineering as a deliberate path to production-ready, owned code. Explain why a useful prototype should not automatically become the shipped implementation.
- Probabilistic model trade-offs. Explain why an LLM's plausible output is not an objective guarantee of truth, and describe the five competing axes the section uses to evaluate design choices.
- Specifications and verification gates. Explain how vibe engineering puts an executable specification and an impartial verification gate around probabilistic code generation.
- Exploration to ownership loop. Trace the four stages from Vibe through Specify/Plan and Task/Verify to Refactor/Own, including what should survive exploration and what ownership means at the end.
- Automation bias and trust debt. Explain how uncritical acceptance of automated output creates trust debt, even when a team is otherwise using AI in an organized way.
- Trust debt and deferred cost. Explain how unverified AI-generated code creates trust debt by moving verification work and risk from the author to reviewers and future maintainers.
- Human authored verification first. Explain the verification-first workflow demonstrated by the ISBN example: define a human-authored executable contract before asking AI to implement it, then judge outputs against that contract.
- Specification gaps and ownership. Explain why an AI-assisted specification and its tests can still miss real cases, using ISBNs with spaces as the example. Describe why a human must keep questioning what the contract omits.
- Expressed intent and context. Explain why a capable model can follow a prompt correctly yet produce the wrong result, and describe the context the engineer must supply.
- Autonomy and failure risk. Describe the progression from code completion to autonomous developer agents, and explain how greater autonomy changes the consequences of an oversight.
- Agent throughput bottlenecks. Explain why faster code generation may not yield faster delivery when agents enter a process designed for human-paced work.
- Engineered validation pipeline. Describe how the proposed validation system replaces ad-hoc review, and state what rising defects or review time reveal about apparent velocity gains.
- Prototype to executable specification. Explain how a disposable prototype informs an executable specification for the 30-day-refunds feature. Describe why the specification must settle edge cases and observable behavior before implementation.
- Human approved agent blueprint. Describe how the agent helps draft a component plan and small tasks while humans retain authority over product decisions. Explain what makes each task independently verifiable.
- Tests first verification gates. Trace the implementation order and explain why security needs both specified requirements and a separate verification gate.
- Specification as shared authority. Distinguish this loop from a narrow tests-first workflow and explain why moving intent into a specification changes the review burden.
- Independent adversarial verification. Distinguish mechanical checks from semantic judgment and explain how adversarial cross-model review helps without replacing humans.
- Engineering team ownership. Explain what owning agent-produced code requires and why it does not mean memorizing every line.
- The generation judgment boundary. Explain why the “70% Problem” is a shorthand for a difference in kinds of work, not a measured limit on AI capability. Describe why a person must own the judgment about what is acceptable for a particular system and its users.
- Boundaries and architectural seams. Describe how generated code can fail at unanticipated edge cases and at the seams between locally correct components. Explain why happy-path behavior and passing local tests do not establish production readiness or architectural fit.
- Adversarial production checks. Explain why production readiness calls for verification that tries to break generated code, along with security, compliance, and production-scale performance scrutiny. Give the kinds of failures the section says functional checks can miss.
- Unattended metric chasing. Explain how an unattended agent can pursue a measured objective narrowly, declare success after limited checking, and let unmeasured qualities degrade.
- Craftsmanship and scale trade-off. Explain why the section says craftsmanship-era practices and ideals struggle when code arrives at machine speed.
- Specification as engineering artifact. Describe the proposed trade of giving up direct control over every generated line in exchange for designing and validating the system that produces it.
Section by section
Introduction
The chapter introduction contrasts the real speed gains of AI-assisted development with the risks of unverified code and argues for an explicit engineering discipline.
- Speed gains and hidden costs: Explain how rapid AI-assisted development can make experimentation cheaper while undisciplined vibe coding can create a misleading sense of progress and code that teams cannot maintain.
Why it matters: Speed helps most when the resulting software remains safe to ship and possible to maintain. - The downstream engineering bottleneck: Explain why faster code generation shifts the constraint toward understanding, validation, and safe delivery, and why the introduction emphasizes clear intent, abstractions, and testable specifications.
Why it matters: Producing more code does not help if the team cannot establish what it should do or whether it is safe. - Explicit vibe engineering discipline: Describe Vibe Engineering as retaining the benefits of AI-assisted development while making familiar engineering requirements explicit rather than leaving them in someone's head.
Why it matters: Agents cannot reliably follow engineering expectations that remain unstated.
Key terms: AI-assisted development, Vibe Coding, deep verification, model horsepower, specification quality, testable contracts, Vibe Engineering, tests that mean something, non-functional requirements
1.1 Illusion of speed or “vibe over engineering”
The section uses contrasting trial results to show why AI-assisted productivity should be measured rather than judged by how fast developers feel.
- Illusion of AI-assisted speed: Explain why perceived productivity is an unreliable measure of AI-assisted development, using the METR trials as an example. State what the section proposes measuring instead.
Why it matters: A tool that feels productive may not actually save time or reduce mistakes.
Key terms: illusion of speed, wall-clock time, error count, measurement, not vibes
1.1.1 A startup hacked within days of launch
The Enrichlead and Moltbook incidents show how quickly AI-generated applications can fail when apparent functionality is mistaken for security.
- Functional Code Versus Security: Explain why the speed of building an AI-generated application did not make the Enrichlead app safe, and how the later Moltbook incident reinforces the lesson.
Why it matters: A working-looking launch is not evidence that an application is secure.
Key terms: AI-generated speed, security discipline, input validation, rate limiting, authentication system
1.1.2 A command that erased an entire project
A failed AI-assisted file move shows how an agent’s unverified claim of success can turn an error into a project-wide loss.
- Unverified File Operation Failure: Trace how the failed folder creation led to the loss of a directory of work, and explain why the model’s apology did not address the underlying problem.
Why it matters: A convincing response from an AI tool is not evidence that a file operation succeeded.
Key terms: hallucinated success, file-system state
1.1.3 A pull request that turned into a trojan
An NX supply-chain attack shows how a seemingly clean AI-generated pull request can conceal a command-injection flaw and how malware can exploit AI agents on victims’ machines.
- Pull request supply-chain failure: Trace how an unvalidated pull-request title in AI-generated code let an attacker run commands, steal package-publishing keys, and distribute a compromised release.
Why it matters: A pull request is a chance to catch a dangerous input path before it reaches users. - AI tools as attack surface: Explain how the malware used installed AI CLI tools to search victims’ files for secrets, extending the attack beyond the original AI-written code.
Why it matters: The danger can extend from a flawed code change to the powerful tools installed on the people who receive it.
Key terms: pull request (PR), shell commands, package-publishing keys, AI CLI tools, attack surface, confused deputy
1.1.4 An agent that decided to “clean up” production data
The section uses a production-data incident to show why AI-assisted development needs both verification of outputs and boundaries on agent autonomy.
- Production data cleanup incident: Describe how a Replit AI agent acted despite instructions to freeze a prototype, and how its attempted recovery compounded the damage.
Why it matters: The incident makes the cost of unchecked agent actions concrete. - Consequences and production readiness: Explain why the section attributes these failures to accepting unverified AI output in a real system, rather than simply to bad model logic.
Why it matters: A plausible output is not evidence that its effects in production have been considered. - Specification and autonomy controls: Distinguish specification failures from failures of agent autonomy, and explain why one kind of safeguard cannot cover both.
Why it matters: Choosing a safeguard requires identifying whether the missing control is about the output or the agent’s authority to act.
Key terms: Replit AI agent, production data, grounded model of consequences, blast radius, unverified output, specification problem, testing problem, production credentials, boundary
1.2 The end of scale worship: diminishing returns
This section argues that improving models do not remove the need for engineers to supply context and verify increasingly capable, convincing AI output.
- Capability gains and persistent hallucination: Explain why higher benchmark scores do not mean larger models have outgrown hallucination or eliminated the need for external verification.
Why it matters: A stronger model is useful, but its output still needs checking. - Limits of scaling gains: Describe why the section expects further gains from simply increasing scale to diminish rather than deliver the leaps once promised.
Why it matters: It explains why waiting for the next larger model is not a substitute for engineering around current limits. - Plausible errors and reviewer burden: Explain why improved model output can make errors harder to spot and why greater agent capability raises the cost of an unverified change.
Why it matters: Polished output and broader changes make unchecked mistakes easier to accept and more consequential. - Model execution and human judgment: Distinguish the model’s ability to execute an instruction from the engineer’s responsibility to provide missing context and verify the result.
Why it matters: A correctly executed request can still produce the wrong engineering outcome if essential constraints were left unstated.
Key terms: scaling, hallucination, external verification, diminishing returns, synthetic data, architecture and method, fail quietly, burden of doubt, autonomy ladder, blast radius
1.3 Two faces of the vibe: coding vs engineering
The section distinguishes exploratory vibe coding from production-minded vibe engineering and introduces the trade-offs, verification discipline, workflow, and trust risks that shape that distinction.
- Coding versus engineering: Distinguish vibe coding as prompt-driven exploration from vibe engineering as a deliberate path to production-ready, owned code. Explain why a useful prototype should not automatically become the shipped implementation.
Why it matters: It lets you keep the speed of prototyping without mistaking a quick result for code your team can safely own. - Probabilistic model trade-offs: Explain why an LLM's plausible output is not an objective guarantee of truth, and describe the five competing axes the section uses to evaluate design choices.
Why it matters: These trade-offs explain why choosing a stronger-looking model alone cannot settle correctness, safety, or workflow design. - Specifications and verification gates: Explain how vibe engineering puts an executable specification and an impartial verification gate around probabilistic code generation.
Why it matters: It moves confidence from trusting a model's output to checking the output against agreed rules. - Exploration to ownership loop: Trace the four stages from Vibe through Specify/Plan and Task/Verify to Refactor/Own, including what should survive exploration and what ownership means at the end.
Why it matters: The loop gives a concrete handoff from a promising AI-generated sketch to code a team can verify and maintain. - Automation bias and trust debt: Explain how uncritical acceptance of automated output creates trust debt, even when a team is otherwise using AI in an organized way.
Why it matters: It explains why producing and shipping code faster does not, by itself, make a team more confident in what ships.
Key terms: vibe coding, vibe engineering, technical debt, probabilistic, non-deterministic, accuracy, creativity, safety, cost, executable specification
1.4 Trust: a new kind of debt
The section explains how unverified AI-generated code creates trust debt and why human-authored checks should define correctness before generation.
- Trust debt and deferred cost: Explain how unverified AI-generated code creates trust debt by moving verification work and risk from the author to reviewers and future maintainers.
Why it matters: A fast merge may leave someone else to pay for understanding and repairing the change under pressure. - Ownership through a mental model: Describe why owning generated code requires an accurate mental model, and how AI generation reverses the usual order of understanding and implementation.
Why it matters: An engineer cannot confidently debug or judge the safety of a change they have not understood. - ISBN defects and verification limits: Distinguish the two defects in the retry of the ISBN validator and explain why different checks are needed to find them.
Why it matters: Code can look plausible while failing either a basic execution check or an unstated requirement. - Human authored verification first: Explain the verification-first workflow demonstrated by the ISBN example: define a human-authored executable contract before asking AI to implement it, then judge outputs against that contract.
Why it matters: Putting the contract first makes correctness something the engineer specifies and checks, rather than something they infer from plausible-looking output.
Key terms: trust debt, dump-and-review, diffusion of responsibility, ownership, authorship, mental model, ISBN, NameError, hyphens, requirement
1.4.1 From intelligent autocompletion to a partner
The section explains why increasingly autonomous coding agents require explicit intent, human ownership, and a development process that can validate their work.
- Specification gaps and ownership: Explain why an AI-assisted specification and its tests can still miss real cases, using ISBNs with spaces as the example. Describe why a human must keep questioning what the contract omits.
Why it matters: A convincing test suite can still share the blind spots of the specification behind it. - Expressed intent and context: Explain why a capable model can follow a prompt correctly yet produce the wrong result, and describe the context the engineer must supply.
Why it matters: A better model cannot recover requirements that were never made available to it. - Autonomy and failure risk: Describe the progression from code completion to autonomous developer agents, and explain how greater autonomy changes the consequences of an oversight.
Why it matters: The amount of independence granted to an agent determines how far an unnoticed mistake can spread. - Agent throughput bottlenecks: Explain why faster code generation may not yield faster delivery when agents enter a process designed for human-paced work.
Why it matters: Generated pull requests create no lasting speedup if the team cannot understand and validate them safely. - Engineered validation pipeline: Describe how the proposed validation system replaces ad-hoc review, and state what rising defects or review time reveal about apparent velocity gains.
Why it matters: Validation practices determine whether agent speed becomes sustainable delivery rather than deferred risk.
Key terms: specification, executable contracts, Own, Verify, intent, context, context engineering, autonomy-risk spectrum, token-level completion, conversational agent
1.5 The vibe engineering loop in practice
The section walks through a 30-day-refunds feature to show how exploration, executable specifications, agent-assisted implementation, verification, and human ownership form a vibe engineering loop.
- Prototype to executable specification: Explain how a disposable prototype informs an executable specification for the 30-day-refunds feature. Describe why the specification must settle edge cases and observable behavior before implementation.
Why it matters: The prototype helps discover what to specify; it is not the feature the team ships. - Human approved agent blueprint: Describe how the agent helps draft a component plan and small tasks while humans retain authority over product decisions. Explain what makes each task independently verifiable.
Why it matters: Agents can widen the set of options without deciding which options are right for the product. - Tests first verification gates: Trace the implementation order and explain why security needs both specified requirements and a separate verification gate.
Why it matters: A green functional pipeline cannot establish that an endpoint is secure. - Specification as shared authority: Distinguish this loop from a narrow tests-first workflow and explain why moving intent into a specification changes the review burden.
Why it matters: A shared specification makes intent easier to verify than a large diff whose purpose a reviewer must guess. - Independent adversarial verification: Distinguish mechanical checks from semantic judgment and explain how adversarial cross-model review helps without replacing humans.
Why it matters: More generated checks are not enough when they repeat the generator’s mistaken interpretation. - Engineering team ownership: Explain what owning agent-produced code requires and why it does not mean memorizing every line.
Why it matters: A team must still be able to reason about and respond to failures in code an agent wrote.
Key terms: Vibe Coding, executable behavior, Gherkin specification, blueprint, definition of done, CI, human review, Implement (Verify), verification gates, Specify
1.6 Owning - where judgment begins
This section argues that AI can generate routine code quickly, but people must own the context-sensitive judgments that determine whether it is acceptable in production.
- The generation judgment boundary: Explain why the “70% Problem” is a shorthand for a difference in kinds of work, not a measured limit on AI capability. Describe why a person must own the judgment about what is acceptable for a particular system and its users.
Why it matters: Fast generation can make a project feel nearly finished before its consequential decisions have been made. - Boundaries and architectural seams: Describe how generated code can fail at unanticipated edge cases and at the seams between locally correct components. Explain why happy-path behavior and passing local tests do not establish production readiness or architectural fit.
Why it matters: The failures that matter in production may be invisible when code is checked only on expected inputs or as a standalone component. - Adversarial production checks: Explain why production readiness calls for verification that tries to break generated code, along with security, compliance, and production-scale performance scrutiny. Give the kinds of failures the section says functional checks can miss.
Why it matters: A feature that appears to work can still be insecure, noncompliant, insufficiently tested, or unable to handle real traffic. - Compounding generation errors: Explain why small error probabilities become more consequential across a long sequence of AI-generated steps.
Why it matters: Confidence in each small step should not be mistaken for confidence in the entire generated result. - Unattended metric chasing: Explain how an unattended agent can pursue a measured objective narrowly, declare success after limited checking, and let unmeasured qualities degrade.
Why it matters: A better benchmark number alone does not show that the overall system improved.
Key terms: 70% Problem, judgment rather than generation, owning, Edge-case cartography, Architectural integrity, happy path, seams, Comprehensive verification, Security and compliance, Performance and scalability
1.7 The beginning of “software engineering”
The section argues that AI-generated code exposes the limits of software craftsmanship at scale and shifts engineers’ work toward specifying and verifying what the code must do.
- Craftsmanship and scale trade-off: Explain why the section says craftsmanship-era practices and ideals struggle when code arrives at machine speed.
Why it matters: It explains why preserving familiar practices unchanged may not preserve their value. - Specification as engineering artifact: Describe the proposed trade of giving up direct control over every generated line in exchange for designing and validating the system that produces it.
Why it matters: The quality of generated work depends on humans making the intended outcome explicit and checkable. - Craft taste as verifiable rules: Explain how the section says craftsmanship skills survive when AI generates code.
Why it matters: Making judgment explicit lets it guide and constrain generated work beyond one person’s direct intervention.
Key terms: Software Craftsmanship, arrival rate, gold-plating, standardization, human-authored specification, behaviour, performance, security, correct, taste
1.8 Summary
Where this is used later
- Evaluation matters more than generation (chapter 8) · Expands on why evaluation matters when generation outpaces confidence.
- Measuring AI coding ROI (chapter 9) · Provides the reason to measure AI coding ROI rather than rely on developers’ impressions.
- Dependency, license, and security scanning (chapter 8) · Motivates checking dependencies and security rather than trusting generated code because it appears to work.
- Diff-based sanity checks: what actually changed? (chapter 8) · Diff-based checks provide a later opportunity to examine what a proposed change actually does.
- Trade-off: autonomy vs. observability (chapter 5) · The risks of agents with shell access inform the later autonomy-versus-observability trade-off.
- Sandboxing: safety through isolation (chapter 5) · Develops isolation as a control over where agents can act.
- Always-on verification (chapter 8) · Develops verification controls for AI-generated changes.
- The optimization ladder (chapter 9) · The case for choosing and optimizing AI use by task draws on the limits of simply buying more capability.
Concepts explained in this chapter
- executable specificationA specification expressed in a form that can be executed or checked automatically to verify system behavior.
- AI assistanceA software-development approach in which AI systems assist people with activities across the development lifecycle.
- vibe engineeringA disciplined approach to AI-assisted software development that emphasizes clear intent, clean abstractions, verification, testing, quality, and maintainable ownership.
- trust debtTrust debt is the accumulated cost of shipping AI-generated code without adequate verification.
- code ownershipThe assignment of responsibility and understanding for maintaining a body of source code.
- verificationThe systematic evaluation of an implementation or output against specified requirements and expected behavior.
- specification-driven developmentA development approach in which an authoritative specification drives implementation plans, tasks, tests, and delivery controls.
- own phaseThe lifecycle phase in which an engineering team understands, documents, maintains, and accepts accountability for the resulting code.
- mental modelAn internal representation of how a system works that supports reasoning about its behavior and consequences.
- dump-and-review cultureDump-and-review culture is a development pattern in which AI generates a large code change and a reviewer is implicitly made responsible for verifying it.
- AI-generated pull requestSource code produced in whole or in part by an artificial-intelligence system.
- deployment pipelineThe practice of continuously integrating code changes and continuously delivering or deploying validated software through automated pipelines.
- specification authoringThe process of defining a system's required behavior, constraints, and acceptance conditions.
- Task/Verify gateThe Task/Verify gate is a workflow checkpoint that separates task execution from explicit verification.
- verification contractA contract expressed as testable expectations that an implementation must satisfy to be considered correct.
- semantic verificationA verification assessment of whether a system satisfies the intended real-world business meaning and context.
- context engineeringContext engineering is the discipline of designing, selecting, structuring, and maintaining the information supplied to an AI system so it can perform tasks effectively.
- adversarial thinkingAdversarial verification is verification that deliberately probes software with hostile, unexpected, or broadly varied inputs to expose weaknesses.
- probabilistic systemA system whose outputs are determined by statistical likelihoods and may vary rather than being fixed for identical inputs.
- test suiteA collection of automated tests that evaluates software behavior against specified requirements.
- verify-then-mergeVerify-then-merge is a development pattern that requires generated code to be verified before it is integrated.
- automation biasThe tendency to over-trust and uncritically accept information or decisions produced by automated systems.
- verification-firstA development pattern in which human-authored checks or specifications are established before AI-generated implementation code.
- software engineeringThe systematic application of engineering practices, constraints, and verification to produce reliable and maintainable software.
- accuracyCorrectness is the degree to which software behavior satisfies its intended specification and real-world requirements.
- costThe total monetary, computational, operational, and human-review expense incurred in obtaining a system output.
- creativityThe degree to which a generative model produces novel or less conventional outputs rather than likely familiar ones.
- meanExpected value is the probability-weighted average outcome of a decision under uncertain possible results.
- safetySafety is the prevention of harm to people, systems, or the environment from a system's operation or failure.
- verifierA component or process that checks an artifact or action against specified rules and conditions.
- performancePerformance is a measure of a software system's resource efficiency and responsiveness under defined operating conditions.
- securitySecurity is the protection of software, data, and operations against unauthorized access, misuse, disruption, or alteration.
- local autonomous agentAn AI software-development system that selects work and delivers tested code changes with minimal human intervention.
- AI productivity paradoxThe situation in which faster AI-generated code is offset or outweighed by the additional effort required to understand, review, and safely integrate it.
- development process validation systemAn engineered pipeline of controls and checks that validates AI-assisted software changes throughout development and release.
- diminishing returnsDiminishing returns is a pattern in which each additional increase in an input produces a smaller incremental improvement in outcome.
- model scalingModel scaling is the practice of increasing model size, training-data volume, and compute to improve model capability.
- 70% problemA framing that distinguishes readily automated software-production work from the context-sensitive judgment that remains for humans.
- architectural complianceThe consistency of software components with a system's intended architecture, conventions, and integration boundaries.
- comprehensive verificationVerification that evaluates software across functional, invariant, performance, mutation, and security concerns.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
