👨💻🤖 The 8 Stations of AI: Beyond the Code Generation Hype
We need to talk about the elephant in the IDE. According to the latest DORA report, nearly 90% of us are using AI tools daily. We’re generating boilerplate, refactoring functions, and maybe even writing entire microservices with a few keystrokes.
But here’s the rub: we still don’t trust it. And honestly, nor should we. Even if the model was perfect (which it isn’t), blindly trusting the output is a dangerous game. Maybe it’s because I’m from the North of England and we’re naturally born with a healthy dose of [skepticism | cynicism | realism] (depending on your perception of us), but I believe there is huge value in the “trust but verify” mindset. We need that human in the loop to validate, question, and guide the process.
DORA calls this the “Trust Paradox.” We’re adopting these tools at breakneck speed—heck, you might even be out there “vibe coding” your way through a prototype with nothing but good intentions and a few prompts. But let’s be real: moving from a vibe-based prototype to a production-ready system still requires years of software engineering experience. We’re often treating AI like a junior typist whose only job is to hammer out syntax faster than we can think, handing it a keyboard but not the context.
Imagine hiring a world-class barista for your coffee shop but only allowing them to pour the milk. You wouldn’t let them touch the espresso machine, adjust the grind size, or talk to customers. You’d get your lattes faster, sure, but would they be any better? Probably not. And if the shots are pulling bitter (bugs), pouring the milk faster just means you’re serving bad coffee at scale.
To break this paradox, we need a shift in perspective. We need to move from being Coders (focused on syntax) to Conductors (orchestrating systems). We need to invite our AI partner out of the IDE and into the rest of the shop.
I’ve been thinking about this a lot, referencing my earlier thoughts on the psychology of this shift. If we look at the software delivery lifecycle (SDLC) not just as “coding” but as a complete operation, we can identify 8 distinct phases—or stations in our coffee shop—where AI can amplify our capabilities.
Here is the framework I’ll be using to explore the future of AI-assisted engineering.
The 8 Phases of AI-Assisted Engineering
1. Discover: Unearthing the Order
Before we write a single line of code, we need to know what we’re building and why. This is the market research phase. Often, requirements are buried in user sessions, support tickets, or vague Slack messages.
- The AI Advantage: AI excels at synthesizing vast amounts of unstructured data. It can analyze user feedback to find friction points or summarize internal documentation to answer “How do I…?” questions (what DORA calls “AI-accessible internal data”).
- The Goal: To turn noise into signal before we start brewing.
2. Plan: Crafting the Recipe
Once we have the “what,” we need the “how.” This is architectural reasoning—the difference between a home cook and a head chef.
- The AI Advantage: We can use AI to convert natural language specs into technical blueprints. It can help us analyze trade-offs (e.g., “Compare Postgres vs. Firestore for this specific data model”) and even predict project timelines based on historical velocity.
- The Goal: To reduce ambiguity and estimate complexity accurately.
3. Create: The Brew
This is the station we all know and love: the coding phase.
- The AI Advantage: It’s about flow. AI handles the scaffolding, the boilerplate, and the “ghost text” completion that anticipates our next move.
- The Goal: To reduce the friction of syntax so we can focus on logic.
4. Review: The Taste Test
In late 2023, I built a code review agent because I realized that while AI is great at writing, it might be even better at reading.
- The AI Advantage: AI acts as the first line of defense. It can perform automated first-pass reviews for style, security, and pattern violations. It can also summarize complex Pull Requests for human reviewers, reducing their cognitive load.
- The Goal: To catch the bitterness (bugs) before it reaches the cup.
5. Migrate: The Renovation
Legacy code is the tech debt interest rate we pay every day. Migrating it is often tedious, dangerous, and unglamorous—perfect for AI.
- The AI Advantage: AI acts as a translator and archaeologist. It can automate language translation (e.g., Java 8 to Java 21), identify patterns in undocumented legacy logic, and safely manage dependency updates.
- The Goal: To modernize our codebase and infrastructure without grinding feature work to a halt.
6. Verify: The Health & Safety Inspection
Testing is often an afterthought, or worse, a “happy path” checklist.
- The AI Advantage: Unlike ‘Review’ which is about human judgement, ‘Verify’ is about automated execution. AI is fantastic at generating edge-case unit tests, synthesizing privacy-safe test data, and performing automated security scanning in real-time.
- The Goal: To ensure robustness and security are baked in, not bolted on.
7. Deploy: Serving the Customer
Getting code from localhost to production should be boring. Ideally, you have a platform that is well-engineered, simplifies deployment, and is delightful to use (as DORA research highlights, platform engineering is a key enabler for AI success). But if you don’t, AI can help bridge the gap.
- The AI Advantage: AI can smooth the path to production by generating Infrastructure-as-Code (IaC) from architecture diagrams, drafting release notes from commit history, and analyzing deployment scripts for potential failure points.
- The Goal: To make deployments a non-event.
8. Operate: Keeping the Lights On
This is the SRE station. When things go wrong (and they will), speed is life.
- The AI Advantage: In an incident, AI can summarize flood-logs to find the root cause signal, draft post-mortems based on chat logs, and even analyze performance trends to predict outages before they happen.
- The Goal: To minimize downtime, maximize learning, and feed operational data back into the ‘Discover’ phase, closing the loop.
The New Measures of Success
DORA 2025 talks about the “amplifier” effect: AI makes good engineering practices better and bad ones worse. If we only use AI to code faster, we might just be amplifying our chaos.
The real metric isn’t Speed; it’s Reliability and Rework Rate. If we brew 100 cups an hour but 20 of them come back because they’re wrong, we haven’t improved efficiency; we’ve just increased our waste.
This brings me to Value Stream Mapping (VSM). To effectively apply AI, we must first identify our biggest friction points. There is no point in speeding up the brewing process if the bottleneck is washing the cups. This systemic view is vital, and it’s why I was so thrilled to author the VSM chapter in this year’s DORA report (and sneak in a few questions!). We have to narrow our focus to where it matters most.
Over the coming months, I’ll be diving deep into each of these 8 phases, sharing experiments, code, and yes, probably more coffee analogies.
But for now, take a look at your own software factory. You’ve got the AI barista behind the espresso machine. Where else could they be helping you run the shop?