Software Craftsmanship Isn’t Dead. AI Just Moved the Bottlenecks.

Every few months, someone announces the death of Software Craftsmanship.

• First it was low-code.
• Then no-code.
• Then GitHub Copilot.
• Now it’s AI agents capable of designing, implementing, testing, reviewing, and even deploying software.

The conclusion seems obvious:

I believe the opposite.

AI hasn’t killed Software Craftsmanship.

It has simply exposed what the craft was really about all along.

We Confused Craftsmanship with Coding

For years, many developers unconsciously equated Software Craftsmanship with writing beautiful code.

Clean Code.
SOLID.
Design Patterns.
TDD.
Refactoring.

These practices matter.

But they were never the goal.

They were tools for achieving something much bigger.

The Software Craftsmanship Manifesto begins with a simple but powerful idea:

Notice what it doesn’t say.

It doesn’t say “writing code.”

It says developing professional software.

That distinction becomes incredibly important in the age of AI.

Code Is No Longer the Scarce Resource

Writing software used to be expensive.

Today, generating code is becoming almost free.

A single AI agent can scaffold an application, implement features, write tests, migrate frameworks, and fix bugs in minutes.

Tomorrow, multiple specialized agents will collaborate together.

When something becomes abundant, it stops being the source of competitive advantage.

Code is becoming abundant.

Engineering judgment is not.

Bottleneck #1: Understanding the Problem

AI removes friction.

It doesn’t remove complexity.

Customers still change their minds.

Business rules are still ambiguous.

Distributed systems are still difficult.

Trade-offs still exist.

Eric Evans taught us that the hardest part of software development is not implementation.

It is building the right model.

An AI can generate an OrderService.

It cannot decide whether your domain model makes sense.

The first bottleneck has shifted from writing code to understanding what should actually be built.

Bottleneck #2: Reviewing AI

Here’s the irony.

AI can now generate code faster than humans can review it.

A team of agents can produce the equivalent of several weeks of work before lunch.

Someone still has to answer the difficult questions.

• Does this respect our architecture?
• Are our domain boundaries still intact?
• Did the agent introduce hidden coupling?
• Is the implementation secure?
• Are the assumptions correct?
• Will this still make sense in two years?

Unlike AI agents, reviewers become tired.

They lose context.

They miss subtle design flaws hidden inside thousands of generated lines.

For the first time in our industry, code generation is scaling faster than engineering review.

The bottleneck has moved.

Not to production.

To validation.

Tomorrow’s senior engineers will spend less time writing code and far more time reviewing the decisions made by AI agents.

Architecture Becomes the New Superpower

AI is remarkably good at making local decisions.

It is much less reliable at protecting global system integrity.

Without clear boundaries, agents happily create tightly coupled systems at extraordinary speed.

Technical debt can now accumulate faster than ever before.

The developers who create the most value won’t necessarily be the fastest coders.

They will be the people who define:

• domain boundaries,
• ubiquitous language,
• architectural constraints,
• invariants,
• deployment strategies,
• quality standards.

In other words…

The future belongs to architects who still know how to code.

Tests Become Specifications

Many people ask whether Test-Driven Development still matters.

I think it matters more than ever.

When AI writes the implementation, tests stop being just a safety net.

They become the specification.

Instead of describing behavior in a prompt, we express it through executable examples.

The discussion changes completely.

Instead of asking:

“Did the developer write good code?”

we ask:

“Does this implementation satisfy the specification?”

That is a much healthier conversation.

AI Doesn’t Replace Craftsmanship. It Requires More of It.

One interesting observation is emerging across teams using AI extensively.

Generating software has become dramatically faster.

Understanding it has not.

Maintaining it has not.

Reviewing it has not.

If anything, those activities have become even more important.

Software Craftsmanship has always been about professionalism.

Professionalism means making deliberate decisions.

It means protecting long-term maintainability over short-term speed.

It means accepting responsibility for software that will still evolve years from now.

AI can generate solutions.

It cannot own responsibility.

People still do.

The Craftsman of Tomorrow

The craftsman of tomorrow will write less code.

But their impact will be greater than ever.

They will orchestrate multiple AI agents.

They will define architectural guardrails.

They will build rich domain models.

They will encode engineering principles into agent instructions.

They will challenge AI decisions instead of accepting them.

Most importantly, they will know when the AI is wrong.

That may become the rarest engineering skill of all.

Final Thoughts

Software Craftsmanship is not disappearing.

It is evolving.

The easy part of software development is increasingly automated.

The difficult part remains profoundly human.

As code becomes cheaper, judgment becomes more valuable.

As implementation accelerates, review becomes the constraint.

As AI grows more capable, responsibility grows more important.

The future of Software Craftsmanship isn’t about competing with AI.

It’s about ensuring that all the software AI helps us build remains understandable, maintainable, and worthy of the people who will inherit it.

Because in the end, software isn’t judged by how quickly it was generated.

It’s judged by how well it survives the next ten years.