The Cure for the Vibe Coding Hangover — Corey J. Gallon, Rexmore

Key Concepts

• Vibe Coding: A low-spec, zero-planning approach to AI-accelerated development that feels productive but leads to brittle, unmaintainable code.
• AI Engineering: A paradigm shift where AI coding agents are used as tools for accelerated learning and building maintainable software, with the engineer retaining architectural control.
• Framework: A structured approach to building with AI coding agents, comprising Principles, Process, and Tools.
• Principles: The underlying philosophy guiding AI engineering, categorized into General, Planning-related, and Implementation-related.
• Process: The workflow for building software with AI, divided into Planning and Implementation phases.
• Tools: Accelerators and enablers of the process that also reflect the framework's principles.
• Multi-sensory Feedback Loop: A critical component of the implementation phase where AI agents gather feedback through visual, auditory, and tactile "senses" to validate code.
• Atomic Feature: An irreducible unit of functionality that can be implemented and validated in a single, focused session.
• Context Engineering: The deliberate curation of relevant information for AI agents to ensure focused and effective implementation.

Framework Overview

The framework for building with AI coding agents is comprised of three pillars: Principles, Process, and Tools. These pillars work together to enable the creation of production-ready, maintainable software. The framework is adaptive and has been used to build various real-world applications, including specialized litigation support, real-time appliance monitoring, and digital publishing systems.

Principles

The framework's principles are categorized into three groups: General, Planning-related, and Implementation-related.

General Principles

1. AI Engineering is Accelerated Learning:

   • Problem: Treating AI coding agents solely as productivity tools leads to dependency and a plateau in engineering skills.
   • Big Idea: The framework emphasizes learning through every step, making the engineer more valuable than just the software produced.
   • Motto: "Always Be Learning" (ABL).

2. You are the Architect, the Agent is the Implementer:

   • Problem: Using AI agents as replacements for architectural thinking.
   • Big Idea: Maintain a clear boundary: the engineer owns the thinking (architecture, interfaces, intent, design decisions), and the agent handles the doing (implementation, coding, pattern following, boilerplate).
   • Motto: "Delegate the Doing, Not the Thinking."

3. Slow Down and Iterate to Go Fast:

   • Problem: The cycle of starting over without deliberate iteration on validated work leads to repeated efforts and abandoned attempts.
   • Big Idea: Deliberate iteration enables compounding returns in understanding and productivity, leading to accelerated velocity.
   • Motto: "Compound Progress, Accelerate Velocity."

Planning-Related Principles

1. Specification is Far Greater Than Prompt Engineering:

   • Problem: Prompt engineering treats AI interactions as an optimization problem, seeking magic words rather than clearly defining "right."
   • Big Idea: Specifications are structured, precise definitions of requirements, behavior, interfaces, and acceptance criteria. They force architectural thinking and provide unambiguous direction to the agent.
   • Motto: "Write the Blueprint, Not the Prompt."

2. Define Done Before Implementing:

   • Problem: Starting implementation without executable tests and observable success criteria leaves agents without clear completion criteria and feedback mechanisms.
   • Big Idea: Defining "done" upfront (tests pass, sensors validate) keeps requirements clear and enables autonomous agent work with immediate feedback and self-correction.
   • Motto: "Specify Success, Then Build."

3. Feature Atomicity:

   • Problem: Non-atomic features leave decomposition work for implementation, forcing agents to make architectural decisions on the fly.
   • Big Idea: Feature atomicity forces complete decomposition during specification, enabling agents to implement within a manageable scope as irreducible work units.
   • Motto: "Reduce Until Irreducible."

4. Dependency-Driven Development:

   • Problem: Implementing without explicit dependency analysis treats features as independent when they form an interconnected graph.
   • Big Idea: Dependency-driven development ensures understanding of feature relationships and integration, preventing agents from implementing features that depend on incomplete work.
   • Motto: "Schedule Implementation by Dependencies."

Implementation-Related Principles

1. Implement One Atomic Feature at a Time:

   • Problem: Working on multiple features simultaneously fragments focus and reduces implementation quality due to context switching.
   • Big Idea: Agents implement one single, atomically defined feature. This rhythm creates momentum and deepens understanding.
   • Motto: "Complete One, Commit One, Continue."

2. Context Engineering and Management:

   • Problem: Treating context as something that passively accumulates rather than being actively engineered leads to loss of resilience and continuity.
   • Big Idea: Do not rely on conversational state persistence. Capture architectural decisions in persistent documents and build context from these artifacts, not memory.
   • Motto: "Curate Context, Don't Accumulate It."

3. Make It Work, Make It Right, Make It Fast:

   • Problem: Treating all three phases as equal from the start or trying to achieve them simultaneously.
   • Big Idea: Focus on "make it work" first (shippable, usable software). Only after real usage reveals what matters, selectively invest in "make it right" and "make it fast."
   • Motto: "Build, Learn, Improve."

Process

The framework process has two distinct phases: Planning and Implementation.

Planning Phase

This phase involves architectural thinking to define what to build, transforming a vague project idea into atomic, sequenced, fully specified features. This is primarily the engineer's work, with agents assisting as thinking partners.

1. Vision Capture:

   • Purpose: Transform a vague project idea into a complete, structured master project specification.
   • Steps:
     • Project Purpose: Clarify the problem, users, and core value.
     • Essential Functionality: Identify 3-5 fundamental workflows.
     • Scope Boundaries: Define "now" (must-have) vs. "next" (future enhancements).
     • Technical Context: Answer basic questions about environment, interaction, and integrations.
     • Workflow Details: Document goals, high-level steps, and expected outcomes for core workflows.
   • Output: Master Project Specification.

2. Feature Identification and Categorization:

   • Purpose: Systematically extract all units of functionality from the master project specification and organize them.
   • Steps:
     • Extraction: Analyze the master project specification with targeted questions to extract all capabilities.
     • Raw Feature List: Document each extracted feature with its source.
     • Analysis: Identify natural groupings based on features and project type (3-7 categories).
     • Categorization: Assign each feature to its best-fit category and create a unique feature ID.
     • Complexity Estimation: Assign an initial complexity estimate (easy, medium, hard).
   • Output: Feature Inventory (categorized list of discrete functionality units).

3. Iterative Specification Development:

   • Purpose: Transform each feature into a complete, atomic, implementation-ready specification.
   • Steps:
     • User Story: Draft a user story (As a [user type], I want to [perform action] so that [benefit]).
     • Implementation Contracts (3 Levels):
       • Level 1: Plain English description of what the feature does.
       • Level 2: Logic flow (input, logic, output) in structured pseudo-code.
       • Level 3: Formal interfaces (exact signatures, data structures, API specifications).
     • Validation Contracts (3 Levels):
       • Level 1: Plain English description of scenarios (happy path, error cases, edge cases).
       • Level 2: Test logic in "Given-When-Then" structure.
       • Level 3: Formal test definition (exact test interfaces, setup, assertions, tear-down).
     • Validate Atomicity: Ensure the feature can be implemented in a single session; split if necessary.
     • Identify Dependencies: Document explicit binary dependencies on other features.
   • Output: Complete Atomic Feature Specification (including user story, technical blueprint, validation strategy, dependencies, and implementation notes).

4. Dependency Analysis:

   • Purpose: Transform feature specifications into a validated dependency matrix to define the exact implementation order.
   • Steps:
     • Extract Matrix: Gather all dependencies from individual feature specifications into a grid.
     • Generate Graph: Create a visual diagram showing features as nodes and dependencies as edges.
     • Validate and Clean: Apply binary dependency tests to clarify true dependencies.
     • Detect Cycles: Visually inspect the graph for circular dependencies and apply resolution strategies (elimination, revised specification, feature splitting, consolidation as a last resort). Iterate until zero cycles remain.
   • Output: Validated Dependency Matrix and Dependency Graph.

5. Implementation Plan Development:

   • Purpose: Transform the dependency matrix into a phased implementation roadmap.
   • Steps:
     • Phase Organization (Topological Sort): Sequence features into implementation phases based on dependency depth.
     • Parallel Analysis: Identify opportunities for parallel development (skipped in this talk).
     • Validation Strategy Planning: Define binary success criteria for each phase (tests, integration points) and establish feedback loops.
     • Implementation Sequencing: Define phase gates, task assignment guidance for agents, blocker management, and progress tracking mechanisms.
   • Output: Implementation Plan (phased execution strategy, validation gates, guidance for autonomous implementation).

Implementation Phase

This phase involves transforming specifications into working, tested software through a tight, rapid loop executed for each atomic feature.

1. Context Assembly:

   • Purpose: Transform planning artifacts into a curated context package for autonomous feature implementation within a single coding session.
   • Steps:
     • Feature Specification Assembly: Include the complete feature specification (user story, technical contracts, acceptance criteria, referenced dependencies).
     • Dependency Context Gathering: Pull in the specification and actual implemented code for all referenced dependencies.
     • Implementation Guidance: Extract relevant sections from the implementation plan (phase, completion criteria, validation strategy).
     • Sensory Capabilities Enablement: Reference appropriate tool usage guides based on acceptance criteria (visual, auditory, tactile).
   • Output: Curated Context Package (focused assembly of feature spec, dependency code, guidance, and sensory tool instructions).

2. Implementation Loop:

   • Purpose: Transform an atomic feature specification into working, tested code using a multi-sensory feedback loop.
   • Steps:
     • Write Code: The agent implements code following the feature specification's technical contracts.
     • Execute and Sense: The agent immediately executes the code and gathers comprehensive sensory feedback (visual, auditory, tactile) based on acceptance criteria.
     • Test and Validate: The agent runs all test scenarios from the validation contract.
     • Correlate and Refine: The agent correlates signals from sensors and test results to diagnose issues and refine the code.
   • Loop Condition: The loop continues until all tests pass and all sensors report clean execution.
   • Output: A fully working, tested feature that has passed all acceptance criteria and has been validated by all three digital sensors. The agent creates an atomic Git commit for the feature.

Tools

The framework requires four foundational capabilities enabled by specific tools:

1. Coding Environment: A complete development workspace supporting both architectural thinking (engineer) and autonomous implementation (agent).

   • Components: AI Coding Agent, Execution Sandbox (safe, isolated environment), IDE/Text Editor, Voice Input (for rapid capture of thinking).

2. Multi-sensory Feedback System: Comprehensive validation infrastructure for agents to observe implementations.

   • Visual Sense Tools: Observe UI rendering, system state, and code structure (e.g., screenshots, layout styling, database contents).
   • Auditory Sense Tools: Monitor system reports (e.g., logs, errors, warnings, API responses, stack traces).
   • Tactile Sense Tools: Enable active interaction testing (e.g., simulating user workflows, API interactions, performance validation, security checks, integration testing).

3. Context Engineering and Assembly Tools: Systematic approach to assembling focused context packages for AI agents.

   • Cross-referencing System: Declarative linking mechanism for referencing documents, code files, or sections.
   • Slash Commands: Process automation mechanisms to trigger multi-step framework workflows.
   • Template System: Structured document templates for all framework artifacts (ensures consistent format and completeness).
   • Markdown Documentation Format: Vital for rapid conversion of inputs to markdown, which agents are highly literate in.

4. Version Control and Progress Tracking:

   • Git: For implementation history through atomic feature commits.
   • Implementation Plan: Used for feature completion tracking, providing project provenance and current state visibility.

Conclusion

The framework presented offers a structured and principled approach to AI-accelerated software development. By emphasizing engineer-led architecture, deliberate planning, atomic feature implementation, and multi-sensory validation, it aims to overcome the pitfalls of "vibe coding" and enable the creation of maintainable, production-ready applications. The core idea is to leverage AI agents as powerful implementers while the engineer remains the strategic architect, fostering continuous learning and ownership of the software development process.