How to Keep Myself Relevant in the Age of Cheap Coding — slides
How to Keep Myself Relevant in the Age of Cheap Coding
What remains valuable when coding becomes cheap?
Four parts
- Where we are my story and the bigger picture
- Changing how we think identity and mindset
- What to do next skills and strategy
- The road ahead opportunity and relevance
Where we are
My own before and after, and what is really changing
The uncomfortable realization
A good harness plus a good specification. The implementation barrier is falling fast.
If the machine can write the code, what am I bringing to the table?
Before agents: how I built things
Many open source projects, end to end. Not advice. Just my story.
Coding was one step of five. But it was the fun part.
I learned new things by building them by hand.
After agents: same journey, new engine
At work, for many months, no hand-typed code:
Recent example: I added a Storybook testing gate to a Jenkins pipeline, in Groovy. I had never even seen Groovy before.
What I gained
I learn by reading agent responses, not by typing code.
A big win for future deliveries.
I am not complaining about the non-coding work.
What I worried I lost
Reading builds recognition
I can follow code and judge it.
Agents gave me much more of this.
Writing builds recall
I can produce it myself, under pressure.
Agents took most of this away.
So, am I missing the learning?
Your turn
There is no right answer. Start from your own level.
The identity crisis
We spent years learning:
We became valuable because we could turn requirements into working software.
The thing I spent years getting good at is becoming cheaper.
Scarcity made code valuable
The skill did not get worse. It got cheap.
The speed gap is too large
Tools improve every month. Our hands do not.
Illustrative, not to scale.
What is becoming cheap
Most of this is what Fred Brooks called accidental complexity. It comes from our tools, not from the problem.
Cheap implementation is not cheap engineering
Working code is not necessarily:
An app can be generated quickly. A reliable system is still difficult.
What does not become cheap
Knowing when the generated solution is wrong.
We have seen this pattern before
Each step made a lower-level activity cheaper.
Value moved up to higher-level decisions.
The new bottleneck
The value of typing code collapses.
The value of understanding code does not.
Changing how we think
If you loved coding, this change hurts.
It is fine to admit the loss.
Pretending it is not a loss only makes adapting harder.
Change the definition of a coder
Coding is still part of the skill. It is no longer the whole skill.
Experience does not disappear
Do not race the machine on speed. Compete on judgment and context.
Amplified by AI. Not replaced by AI.
A useful personal rule
Stop defending the old definition. Design the next version of your career.
What to do next
Watch or read this part
Watch the video ↗Read it in Bangla
Cheap Coding-এর যুগে, পার্ট ৩: What to Do Next
The full talk for this part, written up with the diagrams.
The new engineering loop
Traditional
- Understand
- Design
- Write code
- Debug
- Test
- Deploy
- Operate
Emerging
- Understand
- Specify intent
- Define constraints
- Decompose
- Delegate
- Generate
- Verify
- Inspect architecture
- Test adversarially
- Operate
- Observe
- Learn
- Iterate
Less typing. More judgment.
The scarce skills are changing
| Was scarce | Is becoming scarce | |
|---|---|---|
| Writing code fast | → | Specifying what to build |
| Knowing syntax and APIs | → | Knowing fundamentals deeply |
| Implementing features | → | Designing systems |
| Testing by hand | → | Building trust systems |
| Personal output | → | Multiplying people and agents |
Become exceptional at specification
Define
Separate
What the system must do
How the system may do it
Make ambiguity visible before implementation.
A better spec gives better delegation. It also makes verification possible.
Verification becomes a core skill
The senior engineer’s advantage
50,000 generated lines. Reviewed by another agent. Tests pass. It appears to work.
Experience contains patterns of failure.
Do not abandon coding
The purpose of coding changes. Do not compete on typing speed. Keep coding to keep your intuition:
Like a pilot who still practises flying by hand.
Not because it is faster. Because understanding still matters.
Move deeper into systems
The closer to fundamental constraints, the harder it is to replace understanding with prompting.
Operate AI as an engineering system
A reliable process around probabilistic systems.
Prompting is not the moat
Changes fast
- Models improve
- Harnesses improve
- Context management improves
- Today’s trick is tomorrow’s default
Durable
- Problem decomposition
- Specification and architecture
- Verification
- Systems thinking
- Domain and operational judgment
Who is at risk, and who gains
At risk
- Value is only turning tickets into code
- Thinks in lines of code
Gains
- Owns outcomes end to end
- Can deliver the work of a small team
The line is not age. It is outcomes versus lines of code.
A personal strategy
Where I want to invest my time
The numbers are not important. The direction is.
What I am trying right now
Node.js deep dive
Read the internals. Rebuild small pieces by hand.
An AI clone
Speech-to-text, text-to-speech, agent SDKs. Hand-written core, agents for the rest.
Write and share
Blog posts, experiments, and this talk.
Not a perfect plan. Just my current experiments.
The road ahead
The opportunity
Cheap coding means
- More people building software
- More software produced
- More experiments
- More poorly understood software
The senior engineer becomes
- Problem framer
- System designer
- Agent orchestrator
- Verification engineer
- Technical decision maker
- Production owner
Honest uncertainty
One future
Quality limits slow AI code. Hand-written code keeps a big role, especially in regulated fields.
Another future
Agents take over specification and review too. The human role shrinks further.
An uncomfortable but hopeful conclusion
I should not abandon coding. I should stop measuring myself by it.
My new definition of relevance
Not
- I code faster than AI
- I know more syntax
- I produce more lines
Instead, I know
- what should be built
- what can go wrong
- how to constrain the system
- how to delegate implementation
- how to verify the result
- how to operate it
- how to evolve it safely
Maybe software engineering is not dying.
Maybe one form of it is becoming cheap.
Writing code was never the whole profession. Now we get to rediscover what engineering really means.
Become the engineer who knows what to ask the machine to build, and how to know whether it deserves to be trusted.
blog.foyzul.com