For most of my career, being a good developer meant being good at producing code. Fast, correct, idiomatic. That skill still matters, but it’s quietly stopped being the one that sets you apart. An agent now produces code fast, correct, and idiomatic on demand. The part of the job that got scarce, and therefore valuable, is the part that decides what should be produced and how it should be shaped.
That’s not a small shift. It relocates where a developer’s value lives: from the keyboard to the design. And it has an uncomfortable implication for a whole category of developers who built their identity on implementation speed. This is the case for why architecture and craft are the skills that just appreciated, and why “classic” developers should start learning them now rather than later.
AI is good at exactly the part that was never the hard part
Here’s the thing we don’t say often enough: writing a function was rarely the hard part of software. Knowing which function, where it belongs, what it should and shouldn’t touch, and how it fits the rest of the system: that was always the hard part. AI is spectacular at the first and structurally weak at the second.
An agent generates locally-plausible code. Ask it for a feature and it will produce something that looks right and often works. What it does not have is taste at the system level: a sense of what to protect, which coupling will hurt you in six months, where a boundary should go, what the domain actually means underneath the tickets. It optimizes for “make this task pass,” not “keep this system coherent.” (I’ve watched that exact gap break a ten-year-old business rule in production.)
So the capability didn’t disappear. It inverted. The cheap thing became abundant. The expensive thing, judgment about structure, became the bottleneck. And bottlenecks are where value concentrates.
Architecture is the steering wheel
Here’s the practical reason this isn’t abstract career philosophy. If you can’t describe the shape you want, you can’t direct an agent. You can only accept whatever it hands you.
Working with a coding agent well is an act of direction. You tell it: put the business logic in a pure core, keep the Slack call behind a port, don’t let the persistence layer leak into the domain. That instruction is only available to you if you understand ports and adapters, coupling, cohesion, where boundaries belong and why. Architecture is what makes an agent safe and fast, but only in the hands of someone who can name the target.
The developer who knows architecture treats the agent as a very fast implementer of their design. The developer who doesn’t treats the agent as an oracle, accepts its output, and slowly accumulates a system nobody understands. Same tool. Opposite outcomes. The differentiator is entirely the human’s design literacy.
That’s the reframing: AI didn’t replace the architect’s judgment. It made that judgment the interface through which everything else gets built.
The uncomfortable part for the “classic” developer
I want to be direct, because vague optimism doesn’t help anyone plan a career.
If your value to a team was implementing tickets that someone else designed (turning a well-specified task into working code, quickly), that is precisely the layer AI is absorbing fastest. Not because you’re not good; because that’s the part of the work that’s most compressible into “generate plausible code for a clear spec.” The implementer who only implements is standing exactly where the water is rising.
That’s not a doom prophecy. It’s a direction sign. The move is up a layer: from “I can build what I’m told to build” to “I can decide what should be built and how it should be structured.” From implementer to designer. From code-writer to code-director. And the skills that get you there aren’t more typing speed or another framework: they’re the durable, unglamorous ones the industry has undervalued for years because they don’t demo well.
The people who spent the last decade dismissing “architecture astronauts” and “craft is overkill, just ship” are about to find that the overkill was the moat.
What “learn craft” actually means (not buzzwords)
“Get into craftsmanship” is easy to say and easy to turn into a reading list you never apply. Concretely, here’s what appreciates in value:
- Boundaries and coupling. Ports and adapters, dependency direction, what belongs in the domain versus the edges. This is the vocabulary you steer an agent with. Start here.
- Testing as a design tool, not a chore. Not chasing coverage, but using tests to pin down behavior and to catch the silent changes an agent makes. The test that would have caught the broken business rule is a design skill, not a QA task.
- Domain modeling. Understanding the business deeply enough to name things correctly. Ubiquitous language isn’t ceremony; it’s the map you and the agent both navigate by.
- Reading and reviewing code critically. The single most important skill in an AI-heavy workflow is telling good code from plausible code. If you can’t spot a confidently-wrong diff, the agent’s speed is a liability, not leverage.
- System-level thinking. How a change ripples. What to protect. What “coherent” means for this codebase specifically. This is the taste AI doesn’t have, and it’s learnable: through exposure, reading great codebases, and getting things wrong on purpose in low-stakes places.
None of that is a new hotness. All of it is what senior engineers have quietly always done. The difference is that it’s no longer the hidden part of the job behind the visible act of typing. It is the job now.
The optimistic version (because it is optimistic)
I don’t think this is a bad time to be a developer. I think it’s the best time to be a developer who can architect, and a nervous time to be one who only implements. And those are two very different sentences.
For anyone willing to level up, the leverage is extraordinary. An architecturally-literate developer with a good agent is doing the work of a small team: they design, the agent implements, they review, they steer. The ceiling on what one person can build just went up dramatically, but only for people whose skill is deciding the shape, not filling it in.
So if I could give one piece of career advice to a “classic” developer right now, it would be short: stop competing with the agent on the thing it’s better at. It types faster than you and never gets tired. Move to the thing it can’t do: hold the whole system in your head, know what to protect, decide the structure, and tell good from plausible. Learn architecture. Learn craft. Not because it’s virtuous, but because it’s the part of your job that just became the whole job.
If you want the concrete version of “structure your code so an agent thrives,” I wrote about why hexagonal architecture is the best gift you can give an AI agent. And for the war story behind all of this, here’s how AI broke our production code, and the craftsmanship rule that would have prevented it.
