Let’s face it: the loudest voices in tech right now are shouting one of two things:
“AI is going to replace all developers.”
“Just drop a giant prompt in and let the AI do the work.”
Here’s the thing: neither of those ideas reflect how real engineering actually works.
Tools Change, Principles Don’t
In mid-2024, I was teaching a system I called chained prompt workflows. The principle was straightforward: don’t throw a giant problem at an AI and hope for magic. Break it into phases — plan, implement, test, review — and move through them step by step. Back then, I was working with Claude 3.5 (an LLM) and assistants like Aider (a coding assistant), and I was already extending them with custom command-line tools to cover gaps in capability.
Today, the tools look different. I use Claude Code with Claude 4.1 (Opus and Sonnet) along with Cursor running Claude 4.1, Cursor Rules, and MCP tools. Instead of bolting on command-line helpers, I now provide my assistants with MCP servers — the industry’s de facto standard for giving tools to AI agents. And I’ve built custom slash commands, rules, and agent/subagent patterns that chain together into workflows.
But here’s the thing:
- 👉 The fundamental practice hasn’t changed. I still use repeatable, chained workflows — and so do most advanced AI-native engineers and thought leaders today.
That’s the evergreen point: tools evolve. Workflows endure.
A Concrete Workflow: Feature Development Done Right
Let’s make this real.
Imagine you need to add pagination to an admin list in a web app. That’s a feature every engineer has tackled at some point.
The hype-driven way would be to fire off a giant prompt: “Hey AI, add pagination to my admin lists.” You might get some code back, but you won’t know if it duplicates existing work, if it fits your UI framework, or if it quietly breaks something else.
Here’s how my DevFlow cycle handles it instead:
- fetch-issue → Pull in requirements and context from JIRA.
- analyze-feasibility → Scan the codebase. In this case, it spotted partial pagination logic already in place — preventing duplicate work.
- create-branch → Open a feature branch and update JIRA to “In Progress.”
- plan-implementation → Research and design. The workflow pulled in the correct UI library patterns so we aligned with best practices.
- implement-plan → Execute the approved plan — but only after I explicitly signed off.
- test-issue → Run targeted tests. This phase surfaced a missing “total count” — something a one-shot prompt almost certainly would have skipped.
- complete-issue → Create a PR with the full context carried forward.
- post-merge → Sync the main branch and clean up.
At three different points, the workflow stopped and waited for me:
- After feasibility.
- After planning.
- After testing.
That’s the human-in-the-loop principle in action. The system does the heavy lifting, but it never runs ahead without my review, judgment, or approval.
The result? Pagination was implemented faster, cleaner, and more reliably than if I had just thrown the problem into a black-box prompt.
The Principles Behind the Practice
That feature dev story highlights the deeper, evergreen principles of AI-native engineering:
- Workflows > one-shot prompts
- Complex tasks need systematic decomposition.
- Workflows reduce cognitive overload for both AI and humans.
- Human-in-the-loop, always
- Explicit triggers, hard stops, approval gates.
- This isn’t temporary scaffolding until AI “gets smarter.” It’s permanent, because humans are the ones who imagine, frame, course correct, and change their minds.
- Systematization beats novelty
- Clever one-off prompts might look flashy.
- But systematized workflows (slash commands, MCP integrations) are reliable, repeatable, and teachable.
Why Human-in-the-Loop Will Never Go Away
Some people argue that human oversight is only necessary until AI becomes “good enough.” I disagree.
Even if AI reaches the point where it can generate anything we imagine — even if it could read our minds — the human role doesn’t vanish. Why?
- Because we still have to imagine in the first place.
- Because we still have to communicate clearly what matters.
- Because we don’t think of every detail up front — we discover them along the way.
- Because we change our minds, often — and that’s not a failure, it’s part of creative engineering.
That’s why human-in-the-loop is not a temporary necessity. It’s a permanent standard.
AI doesn’t replace imagination, judgment, or iteration. It amplifies them.
The Evergreen Truth
Good engineering has always been about managing complexity with principles and systems:
- Separation of concerns.
- Explicit approval gates.
- Small tools that compose well.
AI doesn’t erase those principles. It makes them more important.
The hype says: “AI will replace developers.”
The reality is: AI is a cognitive exoskeleton. It extends what principled engineers can do, but it doesn’t replace the need for engineering discipline.
That’s what I teach at Coding the Future with AI — on YouTube, in my School community, and now here on the blog. If you’re tired of the hype and ready to build a principle-first, repeatable AI-native engineering practice, join us.
Because tools evolve. Workflows endure.
