← Patterns

AI-Ready Engineering

Pattern · systems-thinking

Core Concept

Your engineering practices determine how much leverage you get from AI. Code health, test discipline, and supervisory workflows aren’t just “good engineering” anymore — they’re prerequisites for AI-assisted development. Teams that invested in quality before AI arrived will extract disproportionate value from it. Teams that didn’t will find AI amplifies their existing dysfunction.

“AI may be dubbed the great disruptor, but it’s really just an accelerator of whatever you already have.” — Rachel Laycock (confirmed by 2025 DORA Report)

Three Key Findings

1. Code Health Determines AI Effectiveness (Tornhill)

Adam Tornhill’s research on “AI-friendliness” found that LLMs refactored healthy codebases 30% more reliably than degraded ones. The relationship between code health and AI error rates is non-linear — meaning degraded codebases don’t just get slightly worse results, they hit a cliff where AI becomes actively unreliable.

Implications:

• Every investment in code quality is now also an investment in AI capability
• Legacy systems with accumulated tech debt will get less benefit from AI, not more — the opposite of what many leaders hope
• “Let’s use AI to fix our bad code” is a trap — the bad code makes the AI worse at fixing it
• This creates a compounding advantage: clean codebase → better AI output → cleaner codebase → even better AI output

The argument for a VP Eng: When someone pushes back on refactoring time, the ROI now includes “enables AI-assisted development.” Code health is infrastructure, not vanity.

2. TDD as Prompt Engineering

Multiple leading-edge LLM users at the retreat independently reported that Test-Driven Development is essential for effective AI coding agents. Clear, well-written tests give LLMs the specification they need to produce correct code.

“TDD has been essential for us to use LLMs effectively.” — Anonymous retreat participant

Why this works:

• Tests are unambiguous specifications — exactly what LLMs need
• Red-green-refactor becomes red-generate-refactor: write the failing test, let the LLM generate the implementation, refactor the result
• Tests catch hallucinations and drift immediately, before they compound
• The human writes the what (test), the AI writes the how (implementation) — a natural division of labor that matches the Augmentation Over Automation pattern

The reframe: TDD is no longer just a quality practice — it’s a prompting strategy. Engineers who write good tests will get dramatically better AI output than engineers who don’t. This makes TDD advocacy easier: it’s not about dogma, it’s about results.

3. The Supervisory Engineering Middle Loop

The retreat identified a new work category between fully human development and fully autonomous AI: the supervisory middle loop. This is the engineer as operator — reviewing, directing, correcting, and approving AI-generated work rather than writing it from scratch or rubber-stamping it.

What the middle loop looks like:

• Reviewing AI-generated code for correctness, security, and architectural fit
• Directing agents with precise specifications (tests, constraints, context)
• Catching the subtle errors that AI produces confidently
• Maintaining system-level understanding that no agent has

Why it matters: This is a new skill that doesn’t map cleanly to either “writing code” or “managing engineers.” The best supervisory engineers will have deep technical knowledge (to catch AI mistakes) AND strong specification skills (to direct AI effectively). This is the exoskeleton operator in practice.

Connected concept — Risk Tiering: The retreat identified risk tiering as a new core engineering discipline. Not all AI-generated code carries the same risk. A CSS tweak and a payment processing function need fundamentally different levels of human review. Engineering teams need explicit frameworks for when AI output gets rubber-stamped vs. carefully reviewed vs. human-written entirely.

The Amplifier Thesis (DORA-Backed)

Rachel Laycock’s observation, confirmed by the 2025 DORA report: AI amplifies whatever you already have.

This is the empirical backing for what the Exoskeleton Model describes philosophically. An exoskeleton amplifies the wearer — if the wearer has bad form, you get amplified bad form.

Writing code was never the bottleneck. The retreat reinforced that velocity gains from AI become “debt accelerators” without sound practices underneath. Speed without direction is just faster wandering.

Open Questions from the Retreat

Fowler flags several unresolved questions worth tracking:

• Specialization vs. generalism: Will LLM capabilities elevate Expert Generalists by making it easier to work across the stack? Or will specialization deepen?
• Token economics: True costs are unclear post-subsidy. Will LLMs become cheaper than humans or will costs force careful usage?
• Waterfall risk: Will emphasis on upfront specifications (to prompt AI well) push teams back toward waterfall? Fowler suspects LLMs actually enhance evolutionary design cycles, increasing both release frequency and capability per release.
• Security gap: AI security practices are underdeveloped. Fowler asks whether AI vendors are being “irresponsible” by not baking safety into their platforms the way other engineering disciplines bake safety factors into designs.

Where This Applies

For Engineering Leaders (Immediate)

• Code health audit should be an early priority. Tornhill’s finding means the AI leverage you can offer the team depends on the state of the codebase they’re working in.
• TDD culture becomes dual-purpose: quality assurance AND AI effectiveness. If the team already practices TDD, lean into it. If not, this gives you a non-dogmatic argument for introducing it.
• Risk tiering is especially relevant in regulated work (sensitive financial or PII data). Some code paths need human-only development; others can be AI-assisted with review; still others can be mostly automated. Making this explicit prevents both under-use and misuse of AI.
• The middle loop reframes what “senior engineer” means. Senior engineers aren’t writing more code — they’re supervising more effectively.

In the Craft Identity Conversation

The retreat’s findings resolve a tension in the Craft Identity Grief pattern: senior developers fear being replaced, but Tornhill’s research shows they’re actually more valuable in an AI world because:

1. They write better tests (→ better AI prompting)
2. They understand code health (→ better AI output)
3. They catch AI mistakes that juniors miss (→ supervisory middle loop)
4. They have the architectural judgment to direct AI effectively

This is the data-backed version of “AI rewards your skill” from the Mega Maker thread.

Related Patterns

• Augmentation-Over-Automation — AI-ready engineering is the infrastructure that makes augmentation work. Without code health and test discipline, the augmentation model degrades.
• Craft-Identity-Grief — Tornhill’s findings give senior developers a concrete reason to embrace AI: their expertise makes AI better, not redundant.
• Doorman-Fallacy — The “Real Value” of code reviews, pair programming, and TDD now includes AI-readiness — another invisible layer of value to audit before optimizing away.
• Software-Laws — Lehman’s laws (software entropy) predict that without active investment, code health degrades — and now AI effectiveness degrades with it.
• Management-Philosophy#The Exoskeleton Model — The supervisory middle loop IS the exoskeleton in practice.
• Management-Philosophy#Electricity or Blood? — Risk tiering answers “can electricity do this?” with more nuance: “electricity can do this, but with what level of supervision?”

Cross-References

• Augmentation-Over-Automation — design philosophy this pattern operationalizes