Software Factories for Real Engineers

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:

Not to mention the waste of time and tokens.

And slop. Slop 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, Working Effectively With Legacy Code, 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 slop.

With these ideas fresh in my mind, I found it was entirely possible to…

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:

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.

Software Factories for Real Engineers kicks off on Monday November 9th. Join today.

My newest 2-week async cohort course is redesigned from the ground up, and it's all designed for you to apply to your real-world projects.

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 catch-up 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?

The goal of any software factory is speed. You and your team want to go fast. You want to delegate more work to the agent. And you want to get more done.

So most folks start building accelerators. They start “loop engineering”, building systems that trigger work without human intervention. They start building infrastructure to connect their agents to data sources, and to run them in sandboxes.

But speed without quality and control is how we end up with even more heaps of slop to clean up. That's why starting with accelerators is backwards.

Before you can trust your agent to go fast, you need to know that the quality of work is going to be high at any speed. You’ve gotta know how to use the brakes.

And the best brakes are the ones we’ve always had: codebase design, testing, adding guardrails to code. Applying the knowledge our industry has developed over the last 50 years.

In this cohort, we’ll spend a lot of our time learning and building your Software Factory's brakes.

You will…

1. Learn how to create and document the knowledge needed to keep everybody on the same page: ubiquitous language, the project map, ADRs, specs and tickets, and ever-improving code.
2. Create coding standards. From guidance through written instructions, to enforcement through tests, linters, type checks, automated review, and more.
3. Build 3 layers of safety and sanity checks: automated checks, automated review, and human review (when your priorities call for it, with incredibly readable PRs).
4. Make your codebase better than it's ever been before. For you, your team, your users, and your coding agents, using the Software Factory you've engineered and built.

You'll build a real, working Software Factory just like the one I work with every day, using a provided example code base (keeping your own codebase safe until you’re confident).

Then, you'll practice designing your own for your codebase, your team and your needs.

And by the end, you’ll know how to develop your custom brakes and steering systems that support your engineering choices, preferences, and goals.

No more chasing bugs: your factory triages them for you.

No more babysitting: your agents report back when work is done, or when they need your input.

And best of all, no more brain fry, so you can spend more of your precious brain juice thinking about building great software.

Full Schedule: What you'll be learning, doing, and building each week

On day one, you'll get full access to all of the lessons, letting you pick your pace and schedule. Rip through lessons, or take your time; revisit to make sure you understand, and bring questions to Office Hours!

For the best experience, here's my recommended schedule that starts the moment you join, and continues through both weeks of the cohort:

Before We Begin: AI Coding Crash Course (Included Free)

To help you hit the ground running on Day 1, once you enroll you'll get immediate access to my AI Coding Crash Course.

I launched this self-guided course over the summer to help folks get up to speed on the fundamentals of working with AI coding agents as quickly as possible: how AI models work, how coding harnesses work, and the importance of your agent’s environment.

Even if you’re already using AI coding agents every day, you do not want to skip this Crash Course! Treat it as a prerequisite for getting the most out of the cohort itself.

You can complete the Crash Course end to end in roughly three days, or use it as reference material to fill in the gaps you need the most.

The lessons and exercises inside will make sure you have all of the knowledge and understanding to build your own Software Factory.

Week 1: From Domain Language to Codebase Design

Kick off the cohort with a live Office Hours, giving you a chance to ask me your burning questions before you begin.

Then jump right in by getting you and your agent speaking the same language. You'll build a shared glossary and write ADRs with /grill-with-docs, so your agents (and your teammates) stop misunderstanding what you mean.

Next, learn to plan work far too big for one agent session. With the Wayfinder skill, you'll chart a map of the work, grill and prototype the risky parts, and turn it into specs your factory can build.

After that, focus on the best ways to create and use the brakes that will keep your agent in your control. You'll learn the three kinds of review, how to make human review faster and how to prioritize it, and how to run a retro that improves the system that wrote the code, not just the code itself.

Finally, we'll finish the week with codebase design. You'll learn what makes a codebase easy for agents to work in, from deep modules and enforced boundaries to rescuing legacy code and making it testable.

By the end of the first week, you'll be able to plan huge chunks of work, trust what comes back, and shape a codebase your agents can find their way around.

We'll wrap up Week 1 with Office Hours. Bring your questions, get direct answers. Can't make it live? Submit your question in advance and get the recording and transcript.

Week 2: Feedback Loops and Building Your Factory

Week 2 stacks on top of everything you learn in Week 1, introducing the automation that keeps a Software Factory safe and trustworthy at any speed.

First, you'll make bad code (nearly) impossible, with automated checks, custom lint rules, mutation testing and verification for frontend apps.

Then for the rest of the week, you'll put it all together and build a Software Factory like mine.

You’ll learn how I use GitHub Actions to automatically investigate, triage, assign, delegate, track and review units of work. And finally, you'll practice designing your own for your codebase and your team.

Week 2 Office Hours with Matt. Same format, deeper questions. By now you'll have real experience to draw from, so we can help you connect the dots between your practice and real work in your codebase!

Works with your favorite harness or model

This course focuses on the Claude Code CLI, which is where I've honed these skills and gotten the best results myself. So it's the best way for me to teach you!

But once you've practiced the skills here, you'll be able to use the same techniques and knowledge in just about any CLI coding assistant, with virtually any frontier AI model.

And the more you practice these skills, the more powerful your software factory can become.

Learn on your schedule, from anywhere

Software Factories for Real Engineers is the most flexible course I've ever offered:

Instead of being yoked to a semi-daily schedule, you'll receive all lessons on November 9th so you can work ahead or take it slow.

You'll gain access to 6 live Office Hours across 3 days, staggered for different time zones, to give you the most opportunity to get personal help directly from me. Ask ahead if you can't make it; recordings and transcripts are always included.

And, of course, you'll get invited to my private AI Hero Discord, with an exclusive channel for you to meet & learn along with your fellow attendees.

This way, you get the best of sync and async courses in one great experience.

Everything included

For $1,295, you'll learn everything you need to design and build a trustworthy and reliable Software Factory of your own.

Here's what you get when you enroll:

• All lessons and coding exercises. Nearly 60 tight, snappy videos and hands-on practice in a safe sandbox environment. Yours to keep forever.
• The course code repo. Clone it, reference it, build on it. It's yours.
• My AI Coding Crash Course ($299 value) included FOR FREE. Instant access to my three-day, self-guided course, available the moment you register so you're ready for Day 1.
• Live Office Hours with Matt. Live Q&A sessions on Monday November 9, Monday November 16, and Friday November 20, with two time-zone friendly options each office hours day. Submit questions in advance if you can't join live.
• All recordings and transcripts. Every office hours session, captured and available for replay.
• Exclusive Discord access. Learn alongside your fellow students, ask questions, share wins, and soak up the energy of a group of smart folks figuring things out together.

Everything listed here is yours to keep so you can revisit them any time as a reference, as a refresher, or to go deeper with exercises you didn't get to during the cohort.

Enroll today to gain the skills, workflows, and confidence to use AI coding tools the way they were meant to be used: as a force multiplier for real engineering.

Big Discounts for Early Adopters, Returning Students, and Teams

Clearly, I’m very excited for this cohort.

I want to get this material in the hands of everyone who’s been a part of the AI Hero cohorts and courses in the past, so we’re offering some of our biggest ever discounts:

• If you join before 11:59pm PST on Monday November 2nd, you will automatically save 30% just for joining early.
• If you are a returning student from either my previous Claude Code or AI Coding cohorts, you automatically save 40% on the full price. That means you pay $777, as a thank you for coming back to continue learning. Welcome back.
• And if you already purchased my AI Coding Crash Course anytime since it launched in August, we’ll apply a discount equal to the amount you paid for the Crash Course on top of the discounts above. We don’t normally stack discounts, but we’re making an exception for this one.
• A solo developer can do more now than ever before, but when your entire team is using the same Software Factory foundations, the results are incredible. Plus, you’ll get to practice designing your own to meet your team’s unique requirements and standards. Teams of 5 or more save 35% to 45%. See team pricing and invoices, or email team@aihero.dev.

Frequently Asked Questions

Which Claude plan do I need?

Claude Max ($100/month) works. It includes Claude Code and all models including Opus-class models, which this course is designed for. For your own real-world Software Factory, I recommend Max 20x ($200/month), which gives you 20x the usage limits and priority access.

Can I use a different AI coding tool?

You can use ANY tool you prefer. The engineering principles transfer to Copilot, Cursor, Windsurf, and others. Matt teaches with Claude Code. We recommend using Claude for the course, then applying what you learn to your preferred tool.

Do I keep access forever?

Yes. All lessons, exercises, the code repo, office hours recordings, and transcripts are yours to keep.

What if I can't attend live or have timezone conflicts?

Office hours are scheduled at morning and evening times (Matt's timezone) for global coverage. All sessions are recorded with transcripts. You can submit questions ahead of time.

All lessons drop on Day One, November 9th so you can work at your own pace.

More questions?

For pricing, PPP, team seats, invoices, gifting, and platform questions, see aihero.dev/faq. Or email team@aihero.dev.