Let's talk about the real promise of AI coding, and how you and your engineering team can cut through the hype to do more of what Real Engineers actually care about: building better software.
The simple truth about coding agents is that they're entropy-generating machines. Even in tiny code bases — even in one line changes — the agent can produce garbage. They don't think, they don't have judgment, and so it's so easy for agents to produce rubbish… even really smart, powerful agents, even with the latest harnesses.
This is why there will always be work for engineers: systems are big and complicated and messy and human, and coding agents by default can only chew on the problem you place in front of them and they can only see the narrow little window of what they're working on. They can't "get the big picture" unless you give it to them.
So, if you just sit down and start using a coding agent, you inevitably find yourself in an unpleasant position:
- You're a Bug Catcher: you find your role reduced to code review and bug-finder
- You're a Babysitter: you spend all day juggling terminal windows and switching context, correcting and giving feedback live, as it happens
- You get Brain Fry: You end your work day feeling like spreadable goo
Not to mention the waste of time and tokens. And quality. Quality is always a problem.
But there's good news:
Quality, reliability, and waste (of time, tokens, and brainpower) are engineering problems.
And that means you can find engineering solutions to each of them.
Even better, we don’t need to start from scratch. We can look at decades of the best engineering thinking — the rules and practices that work with huge human teams, like DDD, deep modules, tracer bullets — and adapt them to build a system that actively helps you by anticipating problems, solving emergent ones, and cleaning up after itself.
Classic Concepts + Coding Agents
Earlier this year, I was thumbing through the classic programming books where these battle-tested ideas originated. Books like The Pragmatic Programmer, Xtreme Programming, a Philosophy Of Software Design.
I found myself nodding along, and realized that while everyone was saying we need to throw out the old rules because “AI changes everything” these classic engineering concepts were exactly the solutions to agentic entropy.
With these ideas fresh in my mind, I found it was entirely possible to…
- Automate low-end tasks
- Delegate well-spec'd work to a system you can trust
- Assign your coding agent to chew through tickets, and come back to clean code and informative PRs for your review
- Spend more time on the higher-level thinking that really matters
- Tackle optimizations and refactors your team could never find time for before
- Increase you & your team's codebase and domain knowledge
- Make your large, complex, evolving codebase the best it's ever been
In the real world: with a team, with brownfield codebases, and with a budget.
In other words, you can build a working Software Factory.
One where you can elevate your role:
- Be a Strategic Thinker
- Be an Skillful Delegator
- In other words… be a Real Engineer
It's not easy or obvious how to get to this level. It's certainly not a feature of coding agent harnesses — /goal simply will not get the job done. And most of the folks who talk about closing thousands of tickets in a month work at AI labs or companies with unlimited tokens. It seems like even when it works, it's still a fantasy.
But this is an engineering problem. And you're an engineer.
I've already helped thousands of engineers like you apply a Real Engineering approach to AI coding, achieving excellent quality using my Real Engineering Loop. And this is a fantastic approach for new projects, exploratory work, and highly complex moving parts.
But it's not necessary for more mundane stuff like stacks of tickets. That's where a Software Factory approach can really shine.
I've built and battle-tested a working Software Factory.
And in my brand new 2-week cohort course, you'll learn how to do it for yourself.
I redesigned the entire course from the ground up.
You'll learn how to build an end-to-end system you can trust. You'll learn how to explore, specify, and document large chunks of work to your agent, and have it work — persistently and thoroughly — until it's done. You'll learn how to set up a series of guardrails and cross-checks like hooks to enforce code quality and automated adversarial review.
Instead of playing endless chase and catchup on your stacks of PRs, you'll be able to delegate with confidence.
Your Software Factory will even help you improve your codebase over time. Agents, after all, never get tired or bored, and they have no egos.
That's how you can wrap up your work day feeling relaxed and satisfied instead of feeling like your brains got scooped out by a melon baller.
You'll learn how to build a Software Factory tuned for you, your codebase, your team, your needs, and your standards. Which is no problem when you approach it like you'd design any new system: like a Real Engineer.
So what do you need to build a real, functioning, economical Software Factory for you and your team, to expand and improve your existing codebase?
Think of your future Software Factory as a system with two players (your team, and the agent) and two layers: The Environment + Process layer, and the Strategic Layer.
The Environment + Process Layer is the more obvious one. Especially if you've been following my teachings, using my skills, or taking one of my courses, you've got a lot of that part down. Of course, to go from live coding sessions to a hands-off Software Factory, you'll need to make some renovations to this layer.
It's the lack of a Strategic Layer that causes most Software Factory attempts to fail.
The Strategic Layer is a set of tools, practices, processes, and documents that keep you, every member of your team, and your respective coding agents on the same page: plans, decision maps and records, a universal glossary of terms that keep communication clear and code easier to read, tacit domain expertise turned into explicit records, and the practices that keep these things up-to-date.
In my new cohort course, you'll learn — and build — both.
If you want to apply Real Engineering to the dream of a Software Factory, drop your email in the box below. You'll be the first to hear (and you won't miss out on the early bird price!).