AI Engineer Code 2025

The Cure for the Vibe Coding Hangover

Corey Gallon· Managing Director, Rexmore57:02

Loading slides…

Read the talk

The Cure for the Vibe Coding Hangover

A working demo becomes maintainable software when architectural decisions, feature contracts, dependency order and runtime feedback guide what the coding agent does next.

From a talk by Corey Gallon

Before you start: Basic familiarity with coding agents, software tests, interfaces and Git commits will help you apply the workflow.

The app works—until Monday

Inspiration strikes. You open a coding agent, enter a few prompts and hand over the work. Soon the app runs, and it feels like a breakthrough. Then Monday arrives with a feature request. You discover that you cannot explain the implementation, change it confidently or maintain it. Much of the apparent progress has to be thrown away.

Corey J. Gallon calls this the vibe coding hangover: the maintenance cost of a low-specification, zero-planning approach that produces brittle demo software. The problem is not merely wasted code, time and tokens. It is losing ownership of the software—becoming the agent’s confused assistant instead of the engineer directing it. His framework is for developers who want to keep learning while building applications that do real work.

A tiger lies amid cans and scattered items while a person sits at multiple monitors beneath glowing hexagonal wall lights.Open full source frame
A cluttered coding workspace in the opening hangover sequence.
0:150:24
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:15 · section reference included

A framework for retaining ownership

This is a craft-oriented approach, not a judgment of everyone who uses agents differently. If generated software already meets your needs and understanding its internals is unimportant to you, Gallon acknowledges that you are taking a different path. He introduces himself as the operator of an AI-native holding company spanning technology, investments and education, and says he has been building coding agents since 2022. His personal introductions are equally hands-on: roasting Ethiopian Yirgacheffe from Misty Valley and preparing for a pickleball tournament the following day.

The framework has three pillars: principles establish how to divide responsibility, process turns those principles into a development workflow, and tools enable that workflow. Gallon reports using the approach for specialized litigation-support applications, real-time cooking-appliance monitoring and publishing systems that replatform dynamic content. The relevant property of these examples is continued use and maintenance by engineers applying the framework.

2:262:41
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:26 · section reference included

Keep learning and keep the architectural decisions

The ten principles fall into general, planning and implementation concerns. The first is AI engineering as accelerated learning. Treating an agent only as a faster code generator can leave an engineer no better equipped to debug, modify or design the next system. Gallon’s imagined failure is reaching a point months later where the software has grown but your understanding has not—and you now depend on the agent for decisions you previously could make yourself. Every development step should instead create an opportunity to learn. His mnemonic is A-B-L: always be learning.

Brain illustration beside the heading “AI Engineering is Accelerated Learning” and the mnemonic “A - Always. B - Be. L - Learning.”Open full source frame
AI engineering is accelerated learning: always be learning.

You are the architect; the agent is the implementer. You own system intent, structure, interfaces, design decisions and their trade-offs. The agent translates those decisions into code, follows established patterns, implements the tests you specify and handles boilerplate. It can assist your thinking, but delegating implementation does not transfer responsibility for architecture.

The third principle is to slow down enough to iterate on validated work. Repeatedly restarting a project discards both implementation progress and the understanding accumulated around it. Gallon describes an illustrative progression from a slow first week to growing momentum as later work builds on earlier checkpoints. The mechanism is compounding: one understood system becomes easier to extend than a succession of abandoned attempts.

4:535:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:53 · section reference included

Specify success before handing over implementation

Specification changes the task from finding effective prompt wording to communicating what correct behavior means. A specification records requirements, behavior, interfaces and acceptance criteria. Writing it forces you to resolve ambiguities, define boundaries and anticipate edge cases before an agent fills the gaps with its own interpretation.

Next, define done before implementing. Up-front tests and observable success criteria give the agent a stop condition and feedback it can use to correct mistakes. Gallon distinguishes formal tests from three kinds of runtime observation: visual feedback shows what renders, auditory feedback means logs and errors, and tactile feedback means interaction with the system. Tests check the implementation against the specification; observations expose what actually happens. Completion requires both passing tests and expected runtime behavior.

Feature atomicity makes that completion condition manageable. Decompose a feature during specification rather than leaving the agent to discover its architecture during implementation. An atomic feature is the smallest complete unit of work an agent can execute. Reduce the scope until it no longer contains separate capabilities that should have their own contracts.

Those units still form a dependency graph. Analyze their prerequisites explicitly so no feature is implemented on top of incomplete work. Within the implementation rhythm Gallon teaches, take one atomic feature, study the resulting code, validate it and commit a checkpoint before moving on. Sustained focus and a tight feedback loop preserve understanding while the codebase grows.

Context must survive beyond a conversation. Record architectural decisions in specifications, plans and design documents, then assemble the next session from those durable artifacts. Accumulating chat history is not a substitute for selecting the information that matters. Finally, follow make it work, make it right, make it fast in that order: first ship a simple functional implementation that passes its tests, then let actual usage reveal where refinement or performance work deserves investment.

8:378:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:37 · section reference included

Planning begins with a complete project vision

The process separates human-led planning from agent implementation with human oversight and validation. Planning produces the artifacts that implementation consumes. Its five steps proceed in order—vision, features, specification, dependencies and plan—with iterative refinement inside each step. Prepared templates guide the questions; completed templates capture the decisions. An agent can be a thinking partner throughout, but the engineer remains responsible for the answers.

Vision capture turns an incomplete idea into a master project specification, or MPS. Before decomposing the system, externalize the assumptions that are still in your head. Gallon recommends thinking aloud with an agent through five sections:

  1. Project purpose: Identify the problem, who experiences it and the value the software delivers.
  2. Essential functionality: Identify three to five fundamental workflows that solve the problem.
  3. Scope boundaries: Separate now, required for the first working version; not, explicitly out of scope; and next, possible future enhancements.
  4. Technical context: Specify where the software runs, how people interact with it and which systems it connects to.
  5. Workflow details: For each core workflow, record its goal, high-level steps and expected outcome.

The agent can probe assumptions, suggest edge cases and expose missing information. Iterate until the vision is clear enough to serve as the foundation for feature extraction. The process slides also identify which principles support each step, connecting the artifacts back to the framework’s philosophy.

16:4617:02
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:46 · section reference included

Extract functionality before organizing it

The MPS is too broad to hand directly to an implementation agent. First turn it into a feature inventory: a complete, externalized list of capabilities that can be analyzed without holding the whole application in your head. Work through the specification section by section, asking what each part requires.

For project purpose, extract foundational capabilities. For essential workflows, identify the discrete operations they need. Scope boundaries reveal infrastructure required now; technical context reveals platform, integration and interface work. For each workflow, examine input, processing, output, anticipated errors and feedback. Then look across the application for security, logging, configuration and testing needs. Record where each feature came from in the MPS so the inventory remains traceable.

Build the raw list before imposing categories. Challenge its completeness with questions such as what validates input, handles an error or tells the user what happened. Only then inspect the whole list for natural groupings. Gallon suggests roughly three to seven categories as a guideline, derived from the actual software rather than a fixed taxonomy. Assign each feature a category and a unique identifier such as Core001 or API101, then estimate complexity as easy, medium or hard. Each inventory entry ends with an ID, description, complexity estimate and source section in the MPS.

21:4121:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

21:41 · section reference included

Refine each feature into implementation and validation contracts

A feature inventory names capabilities; it does not yet tell an agent exactly how to implement them. Specification development fills that gap and tests whether each feature is truly atomic. Begin with a user story: as a particular user, I want to perform an action so that I obtain a benefit. That establishes who needs the capability, what they do and why it matters.

Refine the implementation contract through three levels:

LevelArtifactQuestion resolved
Plain EnglishBehavioral descriptionWhat does the feature receive, do and produce?
Logic flowInput–logic–output pseudocodeWhat steps transform input into output?
Formal interfacesSignatures, types and API contractsWhat exact inputs, returns and errors must components support?

Each level removes ambiguity left by the previous one. Formal interfaces include data structures and error contracts, not just function names.

Develop the validation contract through the same progression. First describe happy paths, errors, edge cases and security properties in ordinary language. Next express each scenario as Given–When–Then: initial setup, triggering event and expected result. Finally specify the exact test setup, inputs, assertions and teardown. Structured scenario text still needs test implementation before it becomes executable validation.

Now check atomicity against the specification you actually wrote. Can this be implemented in one focused session? If the document feels scattered or describes multiple capabilities, split the feature and repeat the refinement process. Then declare prerequisites as binary relationships: this feature requires another feature, or it does not. The completed specification bundles the user story, three-level technical blueprint, three-level validation strategy, dependencies and implementation notes.

25:3125:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

25:31 · section reference included

Make the dependency graph explicit and remove cycles

Individual specifications provide a local view of prerequisites. Dependency analysis combines them into a global view so you can detect cycles and identify implementation layers. Construct a matrix with features on both axes: an X means the row feature depends on the column feature.

Render the relationships with Graphviz or Mermaid, using features as nodes and dependencies as edges. For a small illustrative publishing workflow, suppose PublishArticle requires SaveDraft, which requires ValidateArticle. A Mermaid description makes the arrow convention explicit:

mermaid

flowchart LR
    PublishArticle[PublishArticle] -->|requires| SaveDraft[SaveDraft]
    SaveDraft -->|requires| ValidateArticle[ValidateArticle]

The diagram exposes the prerequisite chain; a closed loop would signal a dependency cycle.

Validate every marked relationship with a concrete test: does the row feature need the column feature’s specific output, configuration or functionality to work? If not, remove the edge and record the change. Coordination or shared tooling alone does not establish a hard technical dependency. Regenerate the graph after cleaning the matrix.

Resolve any remaining cycles in this order:

  1. Eliminate false dependencies: Reapply the binary dependency test.
  2. Revise contracts: Change interfaces so features no longer require each other’s outputs.
  3. Split features: Separate capabilities that should not have been grouped together.
  4. Consolidate only as a last resort: Gallon identifies this as the messier option and does not develop it further.

After each change, update the matrix, regenerate the graph and check again. The outputs are a validated matrix and a cycle-free graph that exposes the system’s implementation layers.

Five connected steps: Extract Matrix, Generate Graph, Validate & Clean, Update Graph & Matrix, and Detect & Resolve Cycles, with an iteration arrow and output definitions.Open full source frame
Dependency analysis turns atomic feature specifications into a dependency matrix and graph.
30:3430:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

30:34 · section reference included

Turn dependency layers into an execution plan

A validated graph still needs an execution policy: what comes first, how a group of features is validated together and when dependent work may begin. The implementation plan supplies that policy. Gallon acknowledges opportunities for parallel development, but leaves their analysis outside this walkthrough; the taught implementation rhythm remains one focused feature at a time.

Use a topological sort to organize features by dependency depth. Features without prerequisites form phase one. Features depending only on phase one can enter phase two, and later phases depend only on earlier phases. Verify that no features in the same phase depend on each other. In the publishing example, the proposed order is ValidateArticle, then SaveDraft, then PublishArticle. Identify the critical path—the longest dependency chain—as part of this sequencing.

For each phase, define binary success criteria: required tests, working integration points and evidence that the features behave correctly together. Track a feature as implemented or unimplemented, rather than assigning a partial-completion percentage. Then define the phase gates, how an agent selects its next eligible feature, how it handles blockers and how progress is recorded at feature, phase and critical-path levels. The result is a roadmap with explicit permission to advance, not simply an ordered task list.

34:5835:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

34:58 · section reference included

Give the agent feedback and a focused context package

Implementation replaces the five-step planning sequence with a repeated loop for each atomic feature. The agent writes code, executes it and collects three complementary kinds of feedback: what renders, what the system reports and how interactions respond. Formal tests identify failures against acceptance criteria; runtime observations help diagnose their causes. The loop continues until the criteria pass and the relevant observations show clean execution.

Slide titled “Multi-Sensory Feedback” with three circular illustrations depicting an eye, an ear, and a finger pressing a surface.Open full source frame
Multi-sensory feedback: the three senses coding agents need.

Before starting that loop, assemble its context deliberately. Dumping entire planning documents into a session consumes the context window without ensuring that the agent receives the details it needs. A focused package combines the feature specification, its referenced dependencies and only the implementation-plan guidance relevant to this feature.

Context assembly follows four steps:

  1. Include the complete feature specification. Supply its user story, technical contracts, acceptance criteria and dependency references.
  2. Follow dependency references. Include both prerequisite specifications and their already-implemented code. The agent needs to understand the actual interfaces it will integrate with.
  3. Extract implementation guidance. Include the feature’s phase, phase-completion criteria and validation strategy, rather than the entire implementation plan.
  4. Enable the required senses. Acceptance language such as sees, displays or renders calls for visual tools; logs and errors call for auditory tools; clicks, submits and completes call for tactile tools.

Gallon uses @ references to connect these artifacts. Write a reusable usage guide for each tool and reference the appropriate guides during assembly. The output is a context package containing the blueprint, integration context, execution guidance and validation instructions for this session.

38:2438:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

38:24 · section reference included

Write, observe, test, diagnose and commit

Only now does the framework reach the step where the agent writes code. Writing everything before testing allows interconnected problems to accumulate; testing ad hoc can miss failures outside the tests’ field of view. Gallon gives concrete examples: tests pass but the UI renders incorrectly, a workflow completes while errors fill the logs, or a feature appears to work while user interactions remain broken. His implementation model assumes an atomic feature and its context can fit into one session, preserving continuity without reconstructing the work midway through.

The loop has a precise sequence:

  1. Write code to the contract. Match the specified interfaces, inputs, outputs and error handling across all three levels of the technical blueprint.
  2. Execute and sense. Immediately run the implementation and gather the observations required by its acceptance criteria.
  3. Test and validate. Run the validation-contract scenarios to obtain pass/fail results against the specification.
  4. Correlate the evidence. Agreement across observations strengthens a diagnosis; conflicting signals can reveal hidden complexity. Combine what failed in the tests with evidence explaining why.
  5. Refine and repeat. Continue until the tests pass, logs are clean, rendering is correct and interactions work as required.

This gives the agent a diagnostic process instead of asking it to guess at another patch after each failure.

Once those convergence criteria are met, create an atomic Git commit containing only the feature’s changes. Its structured message records the feature ID, specification summary, validation confirmation and implementation notes. These are workflow conventions: the checkpoint records completed, validated work and leaves the codebase ready for the next feature and broader integration.

43:3944:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

43:39 · section reference included

Build a workspace for thinking and execution

The tools portion organizes the requirements into four foundational capabilities. The first, the coding environment, must support both human architectural work and agent implementation. Its components are an AI coding agent, an execution sandbox, an IDE or text editor, and voice input. The sandbox provides an isolated place to execute code and run tests, with disposable resets that support experimentation. Its actual safety depends on the isolation provided; the talk does not establish a particular sandbox configuration.

Voice input supports the other half of the work: externalizing incomplete, exploratory architectural thinking. Speaking lets you capture ideas while refining them instead of interrupting that process to type everything. Gallon strongly recommends a good speech-to-text tool as part of applying the framework.

Coding Environment slide listing AI coding agent, execution sandbox, IDE or text editor, and voice input beside a geometric cube illustration.Open full source frame
The coding environment combines an agent, sandbox, editor, and voice input.
48:3249:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

48:32 · section reference included

Make runtime behavior observable

The second capability is the multisensory feedback system. Its categories describe ways to inspect software, not literal human senses:

  • Visual tools inspect screenshots, layout and styling, but also database contents, configuration, session data and code structure. They expose incorrect state and structural problems alongside broken rendering.
  • Auditory tools collect what the system reports: logs, errors, warnings, API responses and stack traces. These diagnostics explain failures rather than merely indicating that something failed.
  • Tactile tools actively exercise end-to-end workflows and API request–response cycles. They also support performance checks, resource-usage inspection, security checks and integration testing.

Together, these capabilities let an agent examine behavior under actual use as well as through isolated tests.

50:5851:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

50:58 · section reference included

Automate assembly without losing the structure

The third capability is context engineering and assembly. Declarative cross-references connect documents, code files and relevant sections, allowing context to be assembled by following dependency chains. Slash commands—or their equivalent in the chosen agent environment—can invoke multistep workflows such as context assembly, template instantiation and implementation-session initialization.

Templates standardize the master project specification, feature specifications, dependency matrix, implementation plan and implementation record. They preserve completeness without requiring the engineer to reinvent each document’s structure. Markdown supplies a consistent, agent-readable format, and Gallon recommends a toolchain that can quickly convert incoming material into it. The reusable structure is what makes repeated sessions predictable.

Context Engineering & Assembly slide listing @ cross-references, slash commands, framework templates, and Markdown beside a hexagonal illustration.Open full source frame
Context engineering and assembly uses cross-references, slash commands, templates, and Markdown.
52:4853:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

52:48 · section reference included

Track what changed and what is complete

The fourth capability pairs version control with progress tracking. Git records implementation history through atomic feature commits; the implementation plan records completion state. Gallon presents this as the simplest arrangement, while allowing for more elaborate integrations. A commit is like saving progress in a game, but history alone does not explain the project’s present state. Reuse the plan to show which features and phases are complete and what can happen next.

Gallon closes with a brief look at his personal tool stack, leaving the details for hallway discussion. He then points readers to the talk’s companion site for slides, additional resources and the soundtrack; the site currently offers the slides and soundtrack through an email signup.

54:4855:06
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

54:48 · section reference included

Resources

From the talk

  • Examples of Given–When–Then scenarios and how step definitions connect specifications to executable tests.

Updates since the talk

Transcript download
Full transcript

Loading transcript…