AI Isn't Replacing Coding. It's Replacing the Friction Around It.
AI's greatest contribution isn't writing code—it's removing the friction that prevents developers from doing their best work.
When large language models first appeared, I wasn't particularly impressed by their ability to generate code.
That might sound strange coming from a software engineer, but I genuinely enjoy programming. Writing code has never been the part of the job I wanted to eliminate. It's the creative part. It's where ideas become real. It's where design decisions, trade-offs, and craftsmanship come together.
So when people became excited about AI writing functions, components, and entire applications, I never felt the same enthusiasm.
The promise seemed to be: "What if you never had to code again?"
My reaction was always: "Why would I want that?"
Code Was Never the Problem
Most experienced developers know that typing code is rarely the bottleneck.
The difficult parts of software development are understanding requirements, making architectural decisions, validating assumptions, balancing trade-offs, communicating intent, and maintaining quality over time.
The actual implementation is often the easiest and most enjoyable part.
That's why the early wave of AI code generation felt somewhat disconnected from the reality of day-to-day engineering work. It optimized something that wasn't causing me much pain in the first place.
If writing code takes twenty minutes and understanding what should be written takes two hours, making the coding phase faster doesn't fundamentally change the equation.
It just gets you to the wrong solution more quickly if the thinking isn't done first.
What Changed My Mind
My perspective changed when agentic workflows started appearing.
Not because they could generate more code.
Because they could automate the work surrounding code.
Suddenly AI wasn't acting like a junior developer producing implementations. It was acting more like an assistant helping orchestrate the development process itself.
That was interesting.
For the first time, I could offload the parts of software development that I had always considered necessary but tedious.
Tasks like:
- Creating test cases before implementation
- Generating acceptance criteria
- Breaking large features into vertical slices
- Creating implementation plans
- Mapping dependencies
- Reviewing architecture decisions
- Identifying edge cases
- Drafting technical documentation
- Creating refactoring strategies
- Maintaining consistency across a project
None of these activities are difficult individually.
They're just cognitively expensive.
They require context switching.
They consume attention.
And they often get skipped because deadlines push implementation ahead of discipline.
AI Made Good Practices Easier
One unexpected outcome was that AI made it easier to follow practices I already believed in.
For years, the industry has advocated things like:
- Test-driven development
- Vertical story slicing
- Domain-driven design
- Documentation-first thinking
- Architectural decision records
- Continuous refactoring
Most developers agree these practices are valuable.
The problem is that they introduce overhead.
Not technical overhead.
Mental overhead.
When you're already juggling product requirements, technical constraints, meetings, bug fixes, and deadlines, it's easy to convince yourself that you'll write the tests later.
Or split the story later.
Or document the decision later.
Usually later never arrives.
Agentic workflows changed that dynamic.
Suddenly the cost of doing the right thing became dramatically lower.
I could ask an agent to generate a test plan before I started coding.
I could brainstorm architecture options in minutes.
I could transform a vague feature idea into a structured set of vertical slices almost instantly.
The result wasn't less engineering.
It was more engineering.
More thoughtfulness.
More planning.
More quality.
The implementation remained mine.
The process became easier.
The Real Value Is Context
This is why I believe the biggest opportunity for AI isn't code generation.
It's contextual workflow automation.
Code is ultimately just an output.
What matters is everything that happens before and after the code exists.
The ability to understand goals.
The ability to reason about a product.
The ability to connect business needs to technical decisions.
The ability to identify risks.
The ability to organize work.
The ability to preserve context.
These activities create leverage because they multiply the effectiveness of human judgment instead of trying to replace it.
The best AI experiences I've had weren't moments where the AI wrote something impressive.
They were moments where the AI removed friction.
Moments where I stayed in flow.
Moments where I spent more time solving problems and less time managing process.
The Freedom Problem
Unfortunately, that freedom feels increasingly fragile.
As more AI providers move toward aggressive usage-based pricing, something important is changing.
The cost isn't just financial.
It's behavioral.
When every prompt, every workflow, every iteration, and every agent execution becomes something you're actively monitoring, experimentation starts to disappear.
You begin optimizing usage instead of optimizing outcomes.
You stop exploring.
You stop refining.
You stop using the tools as extensions of your thinking.
Instead, you start treating them like scarce resources.
That changes the experience dramatically.
The value of workflow automation comes from abundance.
It comes from knowing that asking ten questions is acceptable.
That exploring five approaches is acceptable.
That iterating repeatedly is acceptable.
The moment every interaction carries visible cost, the natural tendency is to reduce usage.
Ironically, that often means abandoning the workflows that created the most value in the first place.
It Feels Like Losing Time
What concerns me isn't paying for AI.
Useful tools should cost money.
What concerns me is losing the freedom these tools introduced.
Over the past year, I found myself spending less time on administrative engineering work and more time on actual engineering.
Less time organizing.
More time building.
Less time preparing.
More time thinking.
Less time managing process.
More time improving developer experience and user experience.
That shift felt significant.
It felt like recovering hours that had slowly been consumed by the growing complexity of modern software development.
When usage constraints discourage those workflows, it feels less like losing a tool and more like losing time.
Time that had finally been returned.
The Future I Want
The future I'm excited about isn't one where AI writes all the code.
It's one where developers spend more of their day doing the work they actually enjoy.
Designing systems.
Solving problems.
Improving products.
Creating better experiences.
Making decisions.
Thinking deeply.
Coding.
The greatest contribution AI can make isn't replacing developers.
It's removing the friction that prevents developers from doing their best work.
That's the future that feels empowering.
Not because it eliminates engineering.
Because it creates more space for it.
#ai #engineering #software #agentic #productivity