I might be late to the AI agentic programming party—I only started embracing it properly a few weeks ago—but my god, the hype is real. I can confidently say I don’t want to write code by hand anymore. Not because I’m lazy, but because I find it inefficient and, honestly, boring.
I get the sentiment from people who think AI coding means losing the sense of craftsmanship, the personal touch. But here’s my controversial take: that kind of craftsmanship needs to die.
Let me be clear—I’m not talking about abandoning the desire to produce high-quality software that’s testable, secure, and bug-free. Those positive aspects must stay. What needs to go are the medieval notions of craftsmanship that still plague modern software development.
The Medieval Craftsmanship Problem
I’ve worked my entire career as an iOS developer, and iOS codebases are probably the definition of “medieval craftsmanship.” Every time you open a new project, move to a different company, or join a different team, you’ll discover yet another “new way” to render JSON on screen. This is exactly the kind of “craftsmanship” that should and will probably die.
In the guild system, craftsmanship was built around apprentice → journeyman → master progression. Craftspeople controlled the entire production process from raw materials to finished product. Their reputation tied directly to the quality of their individual work. There was pride in creating unique, lasting items—a chair, a sword, a pair of shoes—where you could point and say “I made that.”
But here’s where the analogy breaks down: medieval craftspeople made individual products. Each chair, each sword was discrete. Software is fundamentally different—it’s collaborative and long-lived. You’re not building a chair that gets sold and forgotten. You’re contributing to a codebase that dozens of people will touch over years, where consistency and shared understanding matter enormously.
The “my craft” mentality becomes destructive when everyone wants to express their individual style:
- Every module using a different architecture pattern
- Five different networking layers because each team wanted to “do it right”
- Inconsistent naming conventions, file structures, error handling
- People reinventing wheels because they don’t like how the existing wheel was crafted
Here’s the irony: medieval guilds actually did enforce standards. Apprentices learned to do things the guild’s way. Modern “software craftsmanship” somehow ended up meaning “every craftsperson does it their own special way”—the complete opposite.
The epitome of software “craftsmanship” in the iOS community is probably JSON parsing. When Swift came out, a new JSON parsing library appeared almost weekly. I understand people exploring the language and finding solutions with syntax sugar that wasn’t possible in Objective-C. But it became its own meme.
Why AI Changes Everything
The rise of AI-assisted development inverts traditional assumptions about flexibility versus rigidity.
Why strict patterns matter more with AI agents:
When humans encounter a new codebase, they adapt to inconsistency through context and reasoning. You see “oh, this team did dependency injection differently” and adjust. AI agents struggle with this—they pattern-match and extrapolate. If your dependency injection is done three different ways, the agent will confidently generate a fourth way, or worse, mix patterns incorrectly.
Consistency becomes a force multiplier. If every view model follows the exact same pattern, every network call uses identical error handling, every screen has the same lifecycle—AI can reliably generate correct code by following those patterns. It’s like having extremely detailed blueprints versus vague sketches.
The debates about TCA vs MVVM vs MVI are religious wars, but here’s the truth: it doesn’t matter what you choose. What matters is picking one and being dogmatic about it. A codebase that’s rigorously MVI will be more productive than one that’s “mostly TCA with some MVVM and a few coordinators someone tried once.”
This actually resembles factory production more than craftsmanship. We design the assembly line—the patterns and conventions—and then AI agents work efficiently within those constraints.
My Experiment: Building with AI Agents
I started a side project a few weeks ago to embrace AI agents completely and act purely as an architect. I wanted to see how far I could go and what rails I needed to establish for the agent to produce quality code meeting my standards.
Here’s what I’ve discovered:
1. Architecture skeleton and boundaries are essential
Define your app’s architecture down to the smallest important detail. But don’t set it in stone. As you work, you’ll discover imperfections or confusion. Every time an agent doesn’t follow my setup, I ask why and how we can improve the documentation to make it clearer, or whether we need a new pattern to make things easier.
2. One way of doing things
Everyone who’s worked in big teams with multiple squads knows they often have “their architecture.” A friend once worked somewhere with one team using MVC (old codebase), another using MVVM, and a few considering TCA or MVI. With humans writing code, this might be “fine.” But ask an agent to build a feature in such a codebase and it’ll hallucinate some monstrosity. Or you’ll spend ages explaining “for this part we do things this way.”
3. Good, reusable abstractions matter more than ever
This is what I’ve loved working on most in recent years: building abstractions that enable teams to focus on features rather than fighting Auto Layout or writing boilerplate to render JSON. Now I do the same for my AI agent, so it doesn’t reinvent the wheel every time. We should treat AI agents like an assembly line.
What Does the Future Look Like?
Remember that scene from Iron Man where Tony Stark is designing the Mark suit with Jarvis? He’s not writing code or even clicking through menus. He’s having a conversation: “Give me a hot rod red,” “Run a Level 3 diagnostic,” “Bring up the wireframe.” Jarvis translates intent into implementation.
That’s not science fiction anymore—that’s where we’re headed.
The developer of the future looks less like someone hunched over a keyboard debugging null pointer exceptions and more like an architect in conversation with their AI agent:
“Build a feed screen following our standard infinite scroll pattern. Use the Post cell we created last week. Handle the empty state with the standard illustration and message.”
The agent knows your architecture, your conventions, your component library. It generates the view model, the tests, the network layer integration—all following the exact patterns you’ve established. You review it, maybe refine the edge cases, merge it.
Your value isn’t in typing struct FeedViewModel { for the thousandth time. It’s in:
- Designing the system architecture that makes this possible
- Creating the reusable abstractions the agent leverages
- Making product and UX decisions
- Identifying what needs to be built
- Ensuring quality and coherence across the system
This is why the “industrial” framing matters. We’re not losing agency—we’re gaining leverage. Just like Tony Stark isn’t less of an engineer because Jarvis handles the implementation. He’s more effective because he can operate at the level of intent and design.
The Industrial Revolution for Software
We’re not losing craftsmanship—we’re evolving past an outdated model that never quite fit software anyway. The Industrial Revolution didn’t kill quality; it democratized production and forced standardization. The best factories still produced excellent products, but they did it through disciplined processes, not individual artisanship.
In the age of AI agent development, we’ll have to embrace specific, strict ways of doing things and follow exact patterns. Maybe not at an industry level, but at least at the project level. Strong boundaries and opinionated approaches based on your domain are more important than ever.
The craftsmanship that matters—quality, testing, security, continuous learning, mentorship—doesn’t die. It just finds a new expression: in the thoughtful design of systems that both humans and AI can navigate confidently.
Welcome to industrial software development. The assembly line is ready.
*What are your thoughts on AI-assisted development? Are you building with agents yet? I’d love to hear about your experiences—reach out on Twitter