Recently, a question has been coming up more and more at work.
Everyone is using AI to write code, and on the surface, productivity seems to have taken off:
- Pages are built faster
- API layers are implemented faster
- Even unfamiliar tech stacks can be “stitched together” quickly
But when it comes to deployment, things suddenly slow down:
- Extra rounds of review
- More test cases to write
- Repeated validation of edge cases
- Sometimes even rewriting parts of the core logic
And when you actually calculate the time spent, people start to wonder:
“Are we really faster than before?”
I’ve been struggling with this question myself.
A Subtle Illusion of Efficiency
The productivity gains from AI are real.
But the problem is:
It only accelerates one part of the process: writing code.
Software development has never been just about writing code.
A typical workflow looks like this:
- Understanding requirements
- Designing the solution
- Writing code
- Reviewing
- Testing
- Deploying
- Maintaining
AI is currently best at step three:
“Writing code”
So what happens is:
- Step three becomes extremely fast
- But everything after that becomes heavier
Why Does It Feel Slower?
From my experience, there are three main reasons.
1. You Save Implementation Time, But Increase Cognitive Load
Before, coding was a synchronous process:
Think → Implement → Validate (all in one flow)
Now it looks like:
AI generates → You understand → Then validate
The issue is:
Understanding someone else’s code is harder than writing your own.
Even if that “someone” is AI.
2. Uncertainty Gets Amplified
Most of the time, AI-generated code is correct.
But the real problem is:
You don’t know when it’s wrong.
So naturally, you compensate by:
- Writing more tests
- Adding more validation
- Introducing more safeguards
This is essentially risk hedging.
But the side effect is:
Heavier processes and slower flow.
3. We’re Using Old Processes with New Production Power
Many teams today are in this state:
- Production method: AI generates code at scale
- Process method: Traditional human-driven workflows
These two don’t match.
Before:
Write 200 lines/day → One round of review
Now:
Generate 2000 lines/day → Still one round of review
The result?
Reviews become superficial, or completely overwhelmed.
So, Are We Actually Faster?
There’s no absolute answer.
But here’s a more accurate way to think about it:
AI brings structural efficiency, not linear efficiency.
Where AI Clearly Speeds Things Up
- Bootstrapping projects and scaffolding
- Writing repetitive code
- Rapid prototyping (PoC)
- Exploring unfamiliar stacks
In these scenarios, the improvement is massive.
Where Things Get Slower (or Riskier)
- Core business logic
- Systems with complex edge cases
- High concurrency or state-heavy flows
- Long-term maintainable code
In these areas:
AI amplifies risk more than it improves speed.
The Real Problem Isn’t AI
At some point, I realized:
The problem isn’t AI.
It’s that:
We haven’t adapted our development workflow to AI yet.
We’re just plugging AI into an old system.
It’s like putting a race car on a narrow country road.
How Do We Actually Get Faster?
After some trial and error, I started adjusting how I work with AI.
Here are a few things that made a real difference.
1. Don’t Use AI Just to Write Code
This is the most important shift.
Most people use AI like this:
“Write code for me.”
But its real value is broader:
- Analyzing problems
- Identifying edge cases
- Generating test cases
- Even doing code reviews
I often ask things like:
What are the potential risks in this code?
Generate test cases that cover edge scenarios.
👉 The goal is:
Use AI to reduce uncertainty, not introduce it.
2. Break Down Large Generations into Small Steps
A key lesson:
Don’t generate large chunks of code in one go.
Because they are:
- Hard to understand
- Hard to review
- Hard to debug
Instead:
- One small feature at a time
- Validate each step
- Then move forward
It feels slower, but the overall flow becomes much more stable.
3. Build a Trust Layer
Not all code deserves the same level of trust.
I categorize things like this:
- 🟢 Low risk: UI, utilities → AI can handle freely
- ⚠️ Medium risk: business logic → must review
- 🔴 High risk: core logic → human-led
This prevents both blind trust and over-paranoia.
4. Shift Testing Earlier
Before:
Write code → then write tests
Now:
Define tests first → then let AI implement
Sometimes I directly ask:
Design test cases based on this requirement.
👉 This helps the generated code stay more constrained and reliable.
5. Accept the Trade-off: Less Execution, More Judgment
Many people expect AI to reduce workload.
But in reality:
It reduces manual work, and increases decision-making.
You now need to decide:
- Is this logic sound?
- Are edge cases covered?
- Is it safe to deploy?
And that part cannot be outsourced.
A Deeper Shift
Before, writing code was about:
“How do I implement this?”
Now it’s more about:
“Can I trust this implementation?”
That’s a fundamental change.
Final Thoughts
So back to the original question:
Are we really faster after AI started writing our code?
My answer:
If you only use AI to generate code, not necessarily.
But if you adapt your workflow, then yes — significantly.
One last thought that stuck with me:
AI doesn’t automatically make you faster. It amplifies how you work.
- Messy workflow → more chaos
- Clear thinking → massive acceleration
So the real question isn’t about AI.
It’s about:
Are you in control of it?
Top comments (0)