For years, software development had a pretty simple advantage:
If you could code, you could turn ideas into software.
The person with the programming skills had the leverage.
A doctor might understand healthcare better.
A banker might understand finance better.
A warehouse manager might understand logistics better.
But if any of them wanted software built, they usually needed a developer.
That gave developers a powerful position.
Then AI coding arrived.
And suddenly, something changed.
People who aren't traditionally developers started building things.
Not necessarily production-grade systems.
Not necessarily beautiful architectures.
Sometimes, honestly, some absolute garbage.
But they could build.
And that matters.
Because AI has lowered one of the biggest barriers between knowing what you want and actually making it.
You Can Argue About AI Coding Forever
You can argue forever about whether coding with AI is good or bad.
Is AI-generated code maintainable?
Does it create technical debt?
Are junior developers losing fundamental skills?
Can AI actually understand a complex codebase?
Is vibe coding real programming?
Will AI replace developers?
There are legitimate arguments on both sides.
But while everyone is arguing, there's one thing that's already happened:
Coding became easier.
Not automatically better.
Not automatically safer.
Not automatically reliable.
Easier.
And that distinction is important.
The distance between:
"I have an idea."
and
"I have a working prototype."
has become much smaller.
You can explain what you want.
Generate an implementation.
Run it.
See what breaks.
Fix it.
Iterate.
Repeat.
Something that might have required hours of documentation, Stack Overflow searches, boilerplate, debugging and framework knowledge can sometimes be attempted in minutes.
That doesn't mean AI can build anything perfectly.
It means the cost of trying has dropped.
And when implementation gets cheaper, something else becomes more valuable.
Knowing what is actually worth building.
That's Where Subject Experts Become Dangerous
Imagine you're building software for a hospital.
A developer might know how to build:
- authentication
- APIs
- databases
- dashboards
- scheduling systems
But a doctor knows something much harder to acquire:
how the hospital actually works.
An appointment isn't simply:
Patient + doctor + time.
There might be:
- emergency slots
- follow-up windows
- different appointment types
- insurance authorization
- cancellations
- no-shows
- department-specific rules
- doctor availability
- regulatory requirements
The developer knows how to build the system.
The doctor knows what the system needs to represent.
That's a huge difference.
And historically, the doctor had a problem:
"I understand the problem, but I can't build the software."
AI reduces that gap.
Suddenly, domain knowledge becomes much more executable.
That's the real shift.
AI Didn't Make Domain Expertise Less Valuable
It made it easier to turn domain expertise into something tangible.
Think about someone working in logistics.
They know:
"Our delivery process is inefficient."
Previously, turning that observation into software might require:
Product → Design → Engineering → Data → Infrastructure → Deployment.
Now the logistics expert can potentially sit down with an AI system and start prototyping the workflow themselves.
Maybe the prototype is terrible.
Maybe it breaks immediately.
Maybe it unexpectedly works.
The important part is that they can experiment.
And experimentation is powerful.
The same thing applies everywhere.
A finance professional understands reconciliation.
A lawyer understands document workflows.
A salesperson understands where the CRM process sucks.
A teacher understands where students struggle.
A warehouse manager understands operational bottlenecks.
A developer understands software.
AI is increasingly helping the first group cross the gap toward the second.
The Competition Isn't Simply Developer vs. Developer Anymore
This is where things get interesting.
The competition can increasingly look like:
Developer + AI
versus
Domain Expert + AI
And sometimes the domain expert has an advantage.
Why?
Because they start with better information about the problem.
The developer might ask:
"What feature should I build?"
The domain expert might say:
"Here are the five things wrong with the existing workflow, why they happen, which users are affected, and what happens if we get them wrong."
That's incredibly valuable information.
AI can generate implementation.
It can't magically give someone ten years of experience working inside an industry.
But it can help turn that experience into software.
The Bottleneck Is Moving
Think about software development as a pipeline:
Problem → Requirements → Design → Architecture → Code → Testing → Deployment → Monitoring
Traditionally, developers were deeply involved across almost all of it.
AI is increasingly reducing the friction around parts of:
Design → Code → Testing
That makes the earlier stages more important.
Questions like:
- What problem are we actually solving?
- Who has this problem?
- Why does it exist?
- How often does it happen?
- What happens if we're wrong?
- What constraints exist?
- What edge cases matter?
- What data can we trust?
- What does success look like?
- What should the system never do?
These aren't syntax problems.
They're judgment problems.
And that's exactly where subject experts shine.
AI Can Build the Wrong Thing Really Fast
Here's the uncomfortable part.
AI can generate 500 lines of code before you've finished deciding whether those 500 lines should exist.
You can end up with:
- beautiful UI
- clean APIs
- automated tests
- impressive architecture
- documentation
- Docker
- CI/CD
- thousands of lines of code
…and still build something nobody needs.
The software can look professional.
The product can be completely wrong.
A subject expert can look at it and say:
"Technically correct. Operationally useless."
That sentence can be worth more than thousands of lines of code.
But Don't Make the Opposite Mistake
This doesn't mean subject experts are suddenly better developers.
They're not.
A doctor doesn't automatically understand distributed systems.
A finance expert doesn't automatically understand database design.
A warehouse manager doesn't automatically understand security.
Domain experts can still:
- create impossible requirements
- underestimate technical complexity
- ignore security
- misunderstand scalability
- accept AI-generated nonsense
- build fragile prototypes
- underestimate maintenance
And AI can make these problems worse.
Because bad ideas can now be implemented faster.
That's the irony.
AI doesn't just accelerate good ideas.
It accelerates bad ideas too.
So this isn't:
Subject experts are replacing developers.
The more interesting thing is:
The cost of implementation is falling, so domain knowledge is becoming more powerful.
Code Is Becoming Cheaper
For a long time, one of a developer's biggest advantages was implementation ability.
You knew how to turn a specification into working software.
But if AI can help produce that implementation much faster, then simply being the person who can type the code isn't as differentiated as it used to be.
The question becomes:
Can you make sure the right thing gets built?
That's harder.
And that's where experienced developers still have a massive advantage.
The Developer Advantage Is Moving Up
If AI can help with implementation, don't spend your entire career competing with it at implementation.
Move upward.
Learn:
Problem decomposition
Take vague problems and break them into solvable pieces.
System design
Understand how components interact and where systems fail.
Databases
Know why a schema works instead of accepting whatever AI produces.
Networking
Understand latency, retries, failures and distributed systems.
Security
Know when generated authentication or data-handling code is dangerous.
Testing
Don't just ask:
"Does it run?"
Ask:
"What happens when everything goes wrong?"
Observability
Know how you'll discover that your system is broken after deployment.
Domain knowledge
Understand the environment where your software actually operates.
These skills make AI more useful.
Because you can judge what it produces.
The New Developer Isn't the Person Who Types Everything
Imagine two developers.
Developer A says:
"I don't use AI. I write everything myself."
Developer B says:
"I use AI constantly. But I understand the architecture, review the output, test aggressively, benchmark it, and throw away anything that's bad."
I'd take Developer B.
Not because AI is always right.
Because Developer B knows how to use the tool without surrendering judgment to it.
The modern developer might spend less time manually writing every line and more time:
- defining requirements
- designing systems
- reviewing changes
- testing assumptions
- debugging failures
- evaluating trade-offs
- directing AI
- validating outputs
- communicating with users
The job isn't necessarily disappearing.
The center of gravity is moving.
The 10x Developer Might Become the 10x Problem Solver
The traditional idea of a 10x developer was someone who could produce an extraordinary amount of high-quality code.
But if AI makes implementation dramatically faster, the difference between:
"I can write this in two days."
and
"AI can generate this in twenty minutes."
becomes less interesting.
The valuable difference becomes:
"I know which solution we should build."
That's a much harder skill to automate.
The advantage moves toward the person who can:
- identify the real problem
- understand the users
- recognize hidden constraints
- choose the right abstraction
- evaluate trade-offs
- detect bad solutions
- use AI effectively
- verify the result
That's a different kind of technical excellence.
So What Should Developers Do?
Don't panic.
Don't stop learning to code.
And don't blindly outsource your brain to AI.
Instead, become a hybrid.
If you're a junior developer
Learn the fundamentals.
Understand:
- programming
- debugging
- databases
- networking
- Git
- testing
- system design
Use AI aggressively.
But if AI gives you code you can't explain, you haven't learned it.
You've borrowed competence.
If you're a mid-level developer
Pick a domain.
Don't just become:
"The React developer."
Become:
"The engineer who understands fintech."
Or:
"The engineer who understands logistics."
Or:
"The engineer who understands healthcare."
Or:
"The engineer who understands developer infrastructure."
Now you have two types of knowledge:
How software works.
and
How a particular world works.
That's much harder to commoditize.
If you're a senior developer
Move toward ownership.
Own:
- architecture
- technical strategy
- reliability
- security
- domain modeling
- product decisions
- engineering processes
- AI-assisted development
Your job isn't to personally type every line.
Your job is to make sure the right system gets built correctly.
And Here's the Part Developers Should Actually Learn From Subject Experts
This is where I think the biggest lesson gets missed.
Don't look at subject experts using AI and think:
"They're taking developer jobs."
Look at them and ask:
"What do they know that I don't?"
That's the gold.
Observe them.
Watch how they work.
Watch what problems they notice.
Watch what they consider obvious.
Watch the shortcuts they've developed from years of experience.
Watch where their current tools fail.
Watch what frustrates them.
Watch what they repeatedly do manually.
Watch what they know that isn't written down anywhere.
That's domain knowledge.
And domain knowledge is incredibly valuable.
Then Steal the Insight
Not their job.
Their knowledge.
If a doctor shows you a terrible healthcare workflow, understand why it's terrible.
If an accountant shows you a painful reconciliation process, understand why it exists.
If a warehouse manager shows you a broken inventory workflow, understand what actually happens on the ground.
Then take that understanding back to your engineering world.
Build it.
Automate it.
Simplify it.
Secure it.
Scale it.
Give it a better interface.
Integrate it with everything else.
Make it reliable.
And ultimately:
Build it better than they could.
That's the opportunity.
The subject expert has the context.
You have engineering knowledge.
AI gives both sides more leverage.
The strongest person is the one who can combine them.
The Real Future Isn't Developer vs. Expert
It's:
Domain expertise + Engineering + AI
That's the combination worth chasing.
A developer who only knows syntax is easier to replace.
A developer who understands systems is harder to replace.
A developer who understands systems and a domain is even harder to replace.
And a developer who understands systems, understands a domain, and knows how to use AI to multiply their output?
That's a completely different level of leverage.
The Takeaway
Don't be threatened by subject experts.
Study them.
Don't complain that AI made coding easier.
Use that advantage.
Don't compete with AI on how quickly you can type code.
Compete on how well you can solve problems.
Find people who understand a problem better than you.
Observe them.
Ask questions.
Understand their workflow.
Learn their constraints.
Then take everything you learned and turn it into something better.
Because AI has made implementation easier.
And that means you now have less excuse to stop at:
"I can code."
The bigger goal is:
"I understand the problem, I know what should be built, and I can build it better than anyone expected."
That's the developer worth becoming.
Top comments (0)