Last Updated on 30. January 2026
Chris Gregori’s January 10 article struck a nerve. His point: Writing code is becoming a commodity. There’s a world of difference between a few working lines of code and a stable enterprise solution. While the tech bubble celebrates “vibe coding,” companies run mission-critical systems: ERP, core banking, insurance logic, and production control, to name a few. These systems need to run for years. Not weeks. Years.
Software isn’t “done” just because it works. It’s finished when it runs reliably and securely, is understood, and can be safely and continuously evolved.
The illusion of a productivity leap
AI can generate in minutes what used to take weeks, creating the illusion of a productivity leap. Impressive. But it’s irrelevant. In business, real costs don’t come from “typing too slowly.”
Real costs arise when software:
- encounters unexpected edge cases (there are always some).
- Must scale under load
- Must meet compliance and security requirements
- Has to fit into complex release processes
- Interacts with legacy systems
- It is maintained by changing teams over the years.
- It fails – and costs money, trust, and business.
That’s the difference between code and software.
The real costs: “The rest”
Enterprise software is in a constant state of flux. Business processes change, laws change, customer behavior shifts, partner APIs break, data volumes explode, security vulnerabilities emerge, and teams rotate.
“What worked yesterday” becomes: “Why does it only break in Region X, on Mondays, for certain customers?” This isn’t dramatic. It’s everyday reality.
Code is cheap. Software, however, stays expensive. Costs stem from edge cases, maintenance, user experience (UX) debt, data management, and external dependencies. In business, this “rest” isn’t incidental – it’s the main part.
Agentic Coding: Opportunity and Ticking Time Bomb
The Next Stage: AI systems that not only suggest, but also act independently by creating files, writing tests, performing refactorings, and preparing PRs.
This is great for routine tasks. But they’re dangerous without guardrails.
Agentic coding produces change quickly – and lots of it. In an enterprise environment, changes aren’t inherently good or bad; they’re risky when uncontrolled.
For example,
- Updating a dependency can change runtime behavior.
- Modify a data structure and reporting breaks.
- A seemingly harmless feature can cause performance to collapse.
- A clean refactor → missing logging → an incident that lasts hours.
- Adding a new library without security approval stops deployment.
The question isn’t, “How fast can we generate code?” It’s, “How reliably can we take responsibility for software?”
Software engineering isn’t dying – it’s evolving.
Value no longer comes from who can type the fastest. It comes from:
- Architecture that supports growth
- System understanding across teams and domains
- Decisions that seem costly today but will save in the long run.
- Operational accountability
- Controlled changes instead of creative chaos.
- Quality that holds up under pressure.
AI doesn’t take work off our plates. It takes execution off our plates. The bottleneck shifts from typing to thinking.
What businesses need: Enterprise experience.
Faster code doesn’t mean less engineering. It means better engineering. The question isn’t, “How do we implement this feature?” It’s: “How do we ensure that we will still understand it in 12 months and be able to run it safely in three years?”
This requires people who have seen deployments fail, systems break under load, bad data get written, interfaces fail, and incidents escalate at 2 a.m. Enterprise experience isn’t a brake; it’s what makes speed possible.
Conclusion: The new currency is control.
The code is getting cheaper. Fantastic! However, companies aren’t measured by lines of code. Rather, they’re measured by whether their systems are available, secure, and maintainable, and whether they enable growth rather than hinder it.
Three truths:
- AI makes code cheap. Good engineering remains essential.
- Second, software engineering isn’t dying—it’s evolving.
- Agentic coding without enterprise experience poses a risk, not an opportunity.
Those who understand this don’t use AI to code faster; they use it to build more stable, secure, and sustainable systems.
Not more code. Better software.
Join the discussion with Jan Jikeli — find him on LinkedIn or email the AI team to continue the conversation.
