Article illustration 1

Most developers know the agony of tech debt—that gnawing urge to torch a codebase and start over. In the AI era, this pain accelerates: large language models (LLMs) can churn out mountains of code in days, but without guardrails, the result is often unmaintainable spaghetti. As David Dodda recounts in his detailed case study, the key isn't smarter prompts; it's building infrastructure that forces AI to adhere to human standards.

The AI Coding Trap: Speed Without Discipline

LLMs like Claude or GPT-4 excel at generating code rapidly, but they're notoriously poor at consistency. Dodda compares handing an AI a vague task to "giving a talented intern a blank canvas and walking away." Without explicit guidelines, generated code drifts into inconsistency—random variable names, ignored patterns, and hidden architectural flaws. This isn't the model's fault; it's a failure of process. As Dodda bluntly states:

"LLMs don’t go off the rails because they’re broken. They go off the rails because you don’t build them any rails."

His wake-up call came after burning weeks on rewrites. The breakthrough? Investing a full week upfront to create four foundational documents before writing a single line of code—a strategy that slashed his costs to $450 for 100k+ lines across 10+ services.

The 4-Document Framework: Rails for the AI Train

Dodda’s system acts as a "source of truth" for LLMs, ensuring every generated artifact aligns with project standards. Here’s how each document works:

  1. Coding Guidelines: A living rulebook covering everything from folder structures to testing standards. Generated via LLMs using prompts specifying tools like ESLint, Prettier, and Jest, it enforces consistency. For example:

    - **Naming Conventions**: camelCase for variables, PascalCase for classes
- **Testing**: 80% coverage minimum, with Jest mocking patterns

    This doc feeds into tools like Cursor’s rulesets, anchoring all subsequent code.

  2. Database Structure: A DBML schema defining tables, relationships, and constraints upfront. Dodda uses a 4-phase LLM prompt to evolve from entities to visualized diagrams, preventing late-stage data model chaos.

  3. Master Todo List: A granular API-by-API breakdown of the entire application scope. It maps features to database interactions, updated in real-time to track progress and squash scope creep.

  4. Development Progress Log: A changelog of setup steps, decisions, and lessons—essentially the project’s "memory." LLMs auto-generate this during initial scaffolding.

Dodda loads all four into every IDE chat session, letting the LLM condense them contextually. The cost? Higher token usage, but the payoff is code that’s reviewable and extendable.

Plan-Then-Execute: The Prompting Strategy That Grounds Hallucinations

Even with documents, LLMs can veer off-course. Dodda’s two-stage prompting locks in focus:

  • Stage 1: Plan

    • Prompt: "Create a detailed plan for feature X, including files, DB changes, and endpoints."
    • Outcome: A blueprint reviewed by the developer for alignment.

  • Stage 2: Execute

    • Prompt: "Implement exactly as per the approved plan."
    • Outcome: Code generation tethered to the spec, minimizing surprises.

This mirrors software development’s design-then-code rhythm, shifting review from debugging spaghetti to validating architecture. As Dodda notes, it turns the developer into a "manager of AI interns," where planning is the quality gate.

The Reality Check: Gains, Pains, and Cultural Shifts

Adopting this framework yields tangible benefits:
- Code Quality: Adherence to standards reduces cognitive load during reviews.
- Velocity: Features deploy faster post-setup, with Dodda citing tasks completing in 30-60 minutes.
- Maintainability: Documented patterns let developers re-enter code weeks later without confusion.

But it’s not frictionless:
- Documentation Drift: Docs must sync with code continuously. Dodda dedicates hours weekly to a 4-phase Git diff analysis to update guidelines.
- Context Costs: Larger prompts increase expenses, though Dodda argues it’s cheaper than rewrites.
- Mindset Shift: Developers must embrace "AI team management," juggling tasks during LLM execution—what Dodda calls the "Zen or Hydra" approach.

Beyond the Hype: Why This Matters for Engineering Teams

Dodda’s experiment underscores AI’s role as a multiplier, not a magician. Tools like Claude 4.0 excel when bounded by human-designed systems. For developers drowning in tech debt, this framework offers a blueprint to scale AI use without sacrificing craftsmanship. As the industry races toward tool-augmented coding, Dodda’s closing advice resonates:

"Stop treating AI like magic. Start treating it like the powerful but inexperienced team member it is."

The era of garbage AI code isn’t inevitable—it’s a choice. Structure turns chaos into leverage.

Source: David Dodda's insights from Most AI Code is Garbage. Here's How Mine Isn't.