Stop Nursing Your AI Outputs. Nuke Them and Regenerate.

Why the durable asset in AI-assisted systems is the generation recipe, not the output—and how to shift your investment accordingly.

12 minute read

The Confession

I built a proposal compiler that worked. Then I spent three days making it worse.

The system was supposed to generate bespoke consulting proposals—tailored to each prospect’s specific situation, industry, and pain points. And it did. Mostly. The outputs were solid 7s, maybe 8s on a good day.

So I started iterating. Added a clause here. Tweaked the structure there. Fixed a phrasing issue. Then another. By day three, I’d accumulated fifteen patches and the proposals had somehow gotten worse.

That’s when it hit me: I was nursing the outputs instead of fixing the recipe.

I’d forgotten to compile my marketing positioning (marketing.md) and my consulting frameworks (frameworks.md) into the builder itself. Every output was starting from scratch, missing the accumulated judgment I’d encoded in those files. No wonder each proposal felt slightly off-brand. The builder didn’t know my brand.

“In ephemeral development, code is the output, not the solution. The value is in the context, design, and guardrails that surround it.”

— Matt Baldwin, “The Premise: Code Is Ephemeral”

The fix wasn’t more patches. It was nuking the outputs, updating the recipe to include my kernel files, and regenerating from a better foundation.

The Pattern Most People Miss

Here’s the uncomfortable truth: most teams treat AI-generated outputs as the asset. They patch code. They edit proposals. They refine workflows. Each iteration makes the output slightly better—and slightly more divorced from any coherent design.

This made sense in the old world. Before AI, regeneration was expensive. A human had to rewrite everything. Patching was the only economical option.

That constraint has flipped.

AI can regenerate complex outputs—code, proposals, content, workflows—in seconds, at near-zero marginal cost. But human judgment? That’s still expensive to encode. When your insight lives only in a patch, it’s trapped in that one output. When it lives in the recipe, AI can apply it infinitely.

The Two-Stage Compiler Model

Every effective AI-assisted system is actually a two-stage compiler—but most people only run stage two:

Stage 1: Compile Your Worldview
Input: Your marketing position, frameworks, patterns, anti-patterns, constraints, style guidelines
Output: A builder that thinks in your dialect

Stage 2: Compile Their Context
Input: The specific situation, client, or use case
Output: A tailored artifact (proposal, code, workflow)

Most people skip straight to Stage 2. They prompt AI with the immediate context and hope for the best. When the output is off, they patch it. Then patch it again. Each patch encodes judgment that should have been in Stage 1.

“Specs should live longer than the code. Code becomes a by-product of well-written specifications.”

— Spec-Driven Development, Medium

The Economics Have Inverted

Let me show you the numbers that convinced me to stop nursing outputs.

The Cost of Patching

GitClear analyzed over 153 million lines of code and found a disturbing trend:²

• Code churn doubled between 2021 and 2024—lines reverted or updated within two weeks of being written
• 4x increase in code duplication—AI-generated code violates DRY at much higher rates
• For the first time in history, copy/paste exceeded refactoring as the primary code reuse pattern

This is what happens when you nurse outputs: complexity compounds. Each patch adds weight. The system becomes harder to reason about, harder to change, harder to improve.

A bug fixed in the specification costs $100. That same bug, left to accumulate as technical debt in production, costs $10,000. The 100x multiplier isn’t a metaphor—it’s the measured reality of software maintenance economics.

The Cost of Regeneration

Now consider the alternative. When you update the recipe and regenerate:

• The output incorporates all your accumulated judgment, not just the latest patch
• No archaeological dig through fifteen layers of edits
• New team members can read the recipe to understand intent
• Model upgrades produce better outputs automatically

That last point deserves emphasis.

The Free Upgrade Effect

When Anthropic released Claude Sonnet 4.5, teams using specification-first approaches got an instant boost:⁴

Same recipe. Better model. Better outputs. No additional work.

If your value is encoded in patches on outputs, you get none of this. You’re stuck with the capabilities of whatever model generated the original. But if your value is encoded in the recipe, every model upgrade is free improvement.

The Crossover Point

Not every edit needs a full regeneration. Sometimes a quick fix is the right call.

The question is: where’s the crossover point?

Based on my experience and the research, it’s around 3-5 patches. After that, you’ve encoded enough judgment in the output that it should be in the recipe instead.

What Belongs in Patches vs. Recipes

The rule of thumb: if you’re fixing the same category of issue multiple times, it belongs in the recipe.

The Brand Kernel: Your Regeneration Recipe

So what goes in the recipe? I call it the Brand Kernel—the set of meta-files that encode your worldview and judgment.

The Four Essential Files

1. marketing.md — Your positioning and voice

• Who you serve (and who you don’t)
• The problem you solve in their language
• Your differentiation and point of view
• Voice and tone guidelines

2. frameworks.md — Your intellectual property

• Named frameworks and methodologies
• Diagnostic patterns you apply
• The structure of how you think about problems

3. constraints.md — Your guardrails

• What you never do (anti-patterns)
• Compliance requirements
• Brand red lines
• Technical or operational limits

4. style.md — Your aesthetic

• Formatting preferences
• Structural patterns
• Language rules (active voice, no jargon, etc.)

The Inversion in Practice

The Design-Compiler Pattern makes this inversion explicit:⁵

“The design document persists across changes that would normally require major rework: model upgrades, team changes, refactoring, bug fixes.”

— A Blueprint for Future Software Teams

When bugs are found in the new pattern, you don’t nurse the output. You ask: “What did the specification miss?” Then you update the spec and regenerate. The learning lives in the recipe, not trapped in one artifact.

The Infrastructure as Code Analogy

If this pattern sounds familiar, it should. DevOps figured this out years ago with Infrastructure as Code.

“Terraform builds on the concept of immutable infrastructure: servers are never modified after they’re deployed. If something needs to be updated, new servers are built from a common image, and old servers are discarded.”

— Codefresh, IaC with Terraform

In IaC:

• Configuration files (recipes) are versioned and durable
• Infrastructure instances are disposable and regenerable
• You never SSH into a server to patch it—you update the config and redeploy

The same principle applies to AI-assisted work:

• Kernel files (recipes) are versioned and durable
• Generated outputs are disposable and regenerable
• You don’t edit the output—you update the kernel and regenerate

The constraint that made “patch in place” sensible—regeneration being expensive—has evaporated. The discipline that made DevOps teams faster (immutable infrastructure) now applies to any AI-assisted workflow.

The Counter-Evidence (And Why It Still Supports the Thesis)

Here’s what skeptics point to: developer trust in AI outputs is declining.⁶

• Only 29% of developers now trust AI tool outputs (down from 40% a year ago)
• 66% report spending more time fixing “almost-right” AI code than they saved in initial generation

This sounds like a case against AI. It’s actually a case against nursing.

The “almost right but not quite” phenomenon is exactly what happens when you generate from underspecified recipes. The AI is missing context—your frameworks, your constraints, your patterns. So it produces something plausible but wrong in ways that require detailed human review to catch.

The solution isn’t to abandon AI. It’s to invest more in the recipe so the initial generation is right, not “almost right.”

How to Start

If you’re currently nursing outputs, here’s the migration path:

Week 1: Audit Your Patches

Look at the last 10 edits you made to AI-generated outputs. Ask: which of these encode judgment that should be reusable? Group them into categories.

Week 2: Create Your Kernel

Start with the four files: marketing.md, frameworks.md, constraints.md, style.md. They don’t need to be perfect. Rough captures beat no captures.

Week 3: Test Regeneration

Take one of your patched outputs and try regenerating it from your new kernel. Compare the result. What’s missing? Update the kernel.

Ongoing: Apply the Crossover Rule

For new work: patch small one-offs, but after 3-5 patches, ask whether you’re encoding judgment that belongs in the recipe.

The Bottom Line

AI has inverted the economics of artifact maintenance. Regeneration is now cheap; human judgment is still expensive to encode.

The teams that thrive in this environment will be the ones that recognize which layer to invest in:

• Invest heavily in the kernel—your marketing position, frameworks, constraints, and style
• Invest lightly in individual outputs—they’re proof the kernel works, not the product itself
• Regenerate when the kernel improves, rather than nursing old outputs to incorporate new thinking

Your competitors who figure this out will have systems that compound. Their kernel gets better, which makes every future output better, which generates feedback that improves the kernel further.

Your competitors who keep nursing outputs will have systems that accumulate. More patches, more complexity, more drift from intent. Every new output starts from scratch because the lessons are trapped in old artifacts.

Which system would you rather have in 12 months?

“Code has always been temporary. We deploy it, replace it and rewrite it sometimes within hours or days. Yet most organizations still treat it like a permanent asset, investing in its preservation instead of its adaptability.”

— Matt Baldwin, “The Premise: Code Is Ephemeral”

Stop nursing your AI outputs.

Nuke them and regenerate from a better recipe.