Last week, AI generated 3,000 lines of code for me in under 10 minutes.
The week before that, it generated a complete feature specification.
Yesterday, it designed a database schema, wrote migrations, generated API documentation, and suggested a deployment strategy.
And somehow...
I'm shipping slower than I did two years ago.
This should not be mathematically possible.
Yet here we are.
The New Corporate Hierarchy
Back in the old days:
Junior Developer
↓
Mid-Level Developer
↓
Senior Developer
↓
Tech Lead
Today:
Claude
↓
GPT
↓
Copilot
↓
Cursor
↓
Senior Developer
I've become the intern.
My primary responsibility is reviewing AI-generated pull requests.
My New Job Title: Professional Doubter
When AI first appeared, I thought it would eliminate the boring parts of software development.
Turns out it eliminated the parts I was good at.
My typical day now:
09:00
Generate authentication system
09:01
Generate admin dashboard
09:02
Generate REST API
09:03 - 17:00
Why is this function recursively calling itself?
The strange thing is that coding was never the hard part.
Typing was not the bottleneck.
Remembering syntax was not the bottleneck.
The bottleneck was always understanding whether the thing you are building should exist in the first place.
AI removed the construction time.
It did not remove the thinking time.
Unfortunately, thinking does not scale horizontally.
AI Replaced Coding
Unfortunately, it did not replace thinking.
Before AI:
const productivity =
codingSkill *
architectureSkill;
After AI:
const productivity =
aiOutputSpeed *
understandingWhatTheAIActuallyBuilt *
architectureSkill *
emotionalStability;
The last variable keeps returning:
undefined
The Senior Developer Workflow
Ask AI
↓
Receive 900 lines
↓
Does it look correct?
├── Yes → Investigate anyway
└── No → Investigate immediately
↓
Find hidden disaster
↓
Refactor everything
↓
Question career choices
This is not a workflow.
This is a haunted house with TypeScript types.
The Infinite TODO List
Before AI:
| Metric | Value |
|---|---|
| Ideas per day | 5 |
| Things I could build | 2 |
| Things I shipped | 1 |
After AI:
| Metric | Value |
|---|---|
| Ideas per day | 5 |
| Things I could build | 500 |
| Things I understand | 0.8 |
| Things I finished | ??? |
This feels like a productivity improvement right until you realize you have created an infinite backlog.
Every time I solve one problem, AI gives me ten new opportunities.
I no longer suffer from a lack of implementation capacity.
I suffer from a lack of attention.
Which is a much more expensive problem.
Engineering Progress Chart
Ability to Generate Code
2022 ███████░░░░░░░░░░░░░░░░░░ 35%
2026 ██████████████████████████ 100%
Ability to Understand Entire System
2022 ████████████████████████░░ 95%
2026 █████████████░░░░░░░░░░░░░ 55%
One metric improved dramatically.
The other one filed a support ticket.
The Netflixification of Software Engineering
Something weird happened to me recently.
I spend more time deciding what to build than actually building it.
AI made every idea look possible.
It is the software equivalent of opening Netflix:
Thousands of options
Nothing feels right
Scroll for 40 minutes
Rewatch The Office
AI has done this to engineering.
Every architecture seems viable.
Every stack seems accessible.
Every framework can be learned in an afternoon.
Every prototype can exist by dinner.
The hard part is not creating options anymore.
The hard part is killing them.
The Curse of the Infinite Prototype
I have a folder on my laptop called:
final-project
final-project-v2
final-project-final
final-project-final-real
final-project-final-real-ai
final-project-final-real-ai-fixed
final-project-final-real-ai-fixed-clean
final-project-final-real-ai-fixed-clean-v2
This is not engineering.
This is digital archaeology.
Every folder is a fossil from a moment when I believed:
This will only take one weekend.
AI did not create this weakness.
It just gave it a jet engine.
Modern Software Architecture
Here is the most accurate ERD I have ever made:
+------------------+
| PROJECT |
+------------------+
|
| evolves into
v
+------------------+
| PROJECT_V2 |
+------------------+
|
| evolves into
v
+------------------+
| PROJECT_FINAL |
+------------------+
|
| evolves into
v
+----------------------+
| PROJECT_FINAL_REAL |
+----------------------+
|
| evolves into
v
+----------------------------+
| PROJECT_FINAL_REAL_FIXED |
+----------------------------+
|
| evolves into
v
+-------------------------------+
| PROJECT_FINAL_REAL_FIXED_AI |
+-------------------------------+
This database has no indexes.
Only regrets.
My Favorite AI Bug So Far
Recently, AI generated an absolutely beautiful solution.
It was:
- elegant
- clean
- well documented
- type-safe
- modular
- scalable
There was only one issue.
It solved the wrong problem.
Perfectly.
Human developers tend to create messy solutions to the correct problem.
AI frequently creates beautiful solutions to an incorrect one.
Guess which bug is harder to notice.
Demo: The AI-Generated Feature Nobody Asked For
I asked AI for a simple user lookup.
It gave me this:
type UserInsightScore = {
userId: string;
activityScore: number;
trustLevel: "low" | "medium" | "high";
predictedChurnRisk: number;
recommendedRetentionStrategy: string;
};
export async function analyzeUserBehavior(
userId: string
): Promise<UserInsightScore> {
const user = await db.user.findUnique({
where: { id: userId },
include: {
sessions: true,
purchases: true,
supportTickets: true,
loginEvents: true,
},
});
if (!user) {
throw new Error("User not found");
}
return {
userId: user.id,
activityScore: calculateActivityScore(user),
trustLevel: inferTrustLevel(user),
predictedChurnRisk: predictChurnRisk(user),
recommendedRetentionStrategy: generateRetentionStrategy(user),
};
}
What I actually needed:
export async function getUserName(userId: string): Promise<string | null> {
const user = await db.user.findUnique({
where: { id: userId },
select: { name: true },
});
return user?.name ?? null;
}
AI did not fail.
It simply became a product manager for 14 seconds.
Why Senior Developers Feel Weird Right Now
I think many experienced engineers are quietly experiencing the same thing.
Not because they are afraid of AI.
Because they are discovering that their most valuable skill was never coding.
It was judgment.
And judgment is difficult to demonstrate.
Nobody sees the 47 terrible architectural decisions you avoided.
Nobody celebrates the feature you refused to build.
Nobody tweets:
Today I prevented a future outage by saying no.
That work is invisible.
AI makes visible work faster.
It does not make invisible work easier.
The AI Productivity Paradox
Here is the paradox:
The faster AI gets at generating solutions, the more important it becomes to identify the right problems.
Imagine a world where building software costs nearly zero.
What becomes expensive?
| Still Expensive | Why |
|---|---|
| Choosing the right product | AI does not know your market deeply |
| Understanding users | Prompts are not customer interviews |
| Defining requirements | Ambiguity still exists |
| Managing complexity | AI can generate complexity very efficiently |
| Making tradeoffs | Tradeoffs require context |
| Saying no | AI almost never says no |
| Taking responsibility | Production has no sympathy |
In other words:
The things senior developers have always done.
The industry spent twenty years optimizing code production.
Then AI arrived and accidentally optimized it almost to infinity.
Now we are rediscovering that software was never primarily a coding problem.
It was a decision-making problem wearing a coding costume.
FAQ
Q: Is AI replacing developers?
Not exactly.
It is replacing:
- boilerplate
- StackOverflow tabs
- documentation searches
- regex experiments
- first drafts
- some meetings that should have been documents anyway
Developers are still needed to answer:
Should we build this?
Unfortunately, that is the hardest question.
Q: What skill became more valuable?
Judgment.
Especially the boring kind:
- Should this feature exist?
- Can we delete this abstraction?
- What happens when this fails?
- Is this actually solving the user's problem?
- Will future me hate current me?
That last question is the foundation of maintainable software.
Q: What does a senior developer do in the AI era?
Mostly this:
while (ai.isGeneratingCode()) {
askQuestions();
reviewAssumptions();
deleteComplexity();
preventDisasters();
drinkCoffee();
}
Q: What is the most expensive bug?
The bug that ships.
The second most expensive?
The feature that should never have existed.
AI helps us create both faster.
Q: Should we stop using AI?
No.
That would be like refusing to use a compiler because it makes assembly developers nervous.
AI is useful.
Very useful.
But useful does not mean automatic.
A chainsaw is also useful.
You still should not juggle three of them in production.
Maybe Slow Is Becoming Valuable Again
The AI world worships speed.
Build faster.
Ship faster.
Learn faster.
Prompt faster.
Pivot faster.
Everything is acceleration.
But expensive mistakes rarely happen because people move too slowly.
They usually happen because people move quickly in the wrong direction.
Direction still matters.
And direction is annoyingly human.
You cannot benchmark it easily.
You cannot measure it in tokens per second.
You discover it through context, experience, mistakes, and occasionally staring at a whiteboard wondering why everything feels wrong.
The Real Skill Nobody Talks About
I do not think the future belongs to the fastest coder.
Honestly, I am not even sure it belongs to the best coder.
I think it belongs to people who can answer a different question:
Given infinite implementation capacity, what is worth implementing?
That is a harder problem.
And strangely enough, AI makes it more important every month.
My Rule Now
I use a simple rule:
AI can draft, but I must own.
AI can write the first version.
AI can suggest the structure.
AI can explore alternatives.
AI can help me move faster.
But if the code ships, it is mine.
Not the model's.
Mine.
That means I need to understand it.
That means I need to test it.
That means I need to explain it.
That means I cannot hide behind:
The AI generated it.
Production does not care.
Users do not care.
Your database especially does not care.
Conclusion
Maybe I am not becoming slow.
Maybe the industry accidentally removed the wrong bottleneck.
For years we thought software development was constrained by writing code.
Now machines write code faster than humans can read it.
And we are discovering the real constraint:
const bottleneck = humansDecidingWhatMatters;
Which is inconvenient.
Because thinking has terrible throughput.
If AI writes the first draft, then senior developers are becoming editors of reality.
I am still deciding whether that is a promotion or a demotion.
Either way, my annual performance review is now being conducted by a stochastic parrot with a 200k context window.
And honestly?
The parrot is doing surprisingly well.
Top comments (0)