For those of us in software development, we are witnessing a shift that is hard to overstate. I don't know a single colleague who hasn't jumped on the AI-assisted development bandwagon. The names we're giving it are still settling: vibe coding, spec-driven development, agentic workflows. Honestly, the labels don't matter much. What matters is this: no one is coding like it's 2024 anymore.
I find myself delegating bigger and more complex tasks with less and less supervision, and not only getting the results I expected, but being genuinely surprised by how good they are. And the pace of learning required to keep up? Unlike anything I've experienced in my career. Models, agents, tools, context management, MCP… every day there's something new that needs to be mastered yesterday. Not just a new feature. A whole new thing.
AI-driven development is the present, not the future. It's here to stay. And this isn't a "will AI replace developers?" essay. It's about something more interesting: how the entire body of knowledge we've built around software development is going to have to change.
Rethinking the pillars
Let me start with reusability, one of the most sacred principles in our craft. The entire point of building reusable components was that coding was slow and expensive in human hours. Reusability came with a real cost: code had to be generic, extensible, and complex enough to handle edge cases you hadn't encountered yet. The tradeoff was worth it because the alternative, rewriting things from scratch, was simply too expensive.
With AI, that equation flips. When generating code is nearly free, why build cumbersome, generic components at all? Code written for a single, specific use case is simpler, more direct, and easier to reason about. The whole architecture of modern software, the plugin systems, the abstract base classes, the endlessly configurable libraries, was largely built to compensate for the cost of human labor. Remove that cost and a lot of that complexity just becomes overhead nobody asked for.
Reusability also gave us battle-tested code. Widely adopted libraries survived edge cases and had their bugs ironed out over years of real-world use. But as AI code generation improves, will bugs increasingly become a human-coder trait rather than an inevitable artifact of software? I think so. And if that's true, one of the strongest arguments for reusability quietly disappears.
Maintainability faces a similar reckoning. The idea, best captured by Harold Abelson in Structure and Interpretation of Computer Programs, was that:
"Programs must be written for people to read, and only incidentally for machines to execute."
Harold Abelson — SICP
I used to live by that. Maintainability existed because it takes time for a person to understand someone else's code, and that time was expensive. Code had to be legible to be modifiable.
In the age of AI, does this still matter the same way? If an AI can read, understand, and modify code faster than any human regardless of how it's written, then the case for human-readable code weakens considerably. Documentation, that perpetual holy grail that everyone wanted and no one had time to write, can now be generated on demand. The friction that made maintainability a virtue in the first place is being removed.
Practical? Maybe not yet. But it exposes something important: a lot of what we call "good software practice" is really "good software practice for humans working with software." Those aren't the same thing.
The most interesting open question
We've been through a lot of architectural paradigms. Mainframes, client/server, object-oriented monoliths, microservices, containerized deployments, serverless functions, event-driven systems. Each one was an attempt to help people better manage and scale software.
I was an early microservices adopter. Coming from the rise of object-oriented programming, it felt like the natural next step: decompose your monolith into focused, dedicated services. In retrospect, I can see how much hidden complexity that introduced. Service meshes, distributed tracing, coordination overhead, failure modes nobody anticipated. Some systems genuinely benefited from it. Many were simply over-engineered into failure.
With AI, I genuinely don't know what comes next. Will we return to monoliths, now that the complexity of managing them can be handled by agents rather than teams of engineers? Will microservices become trivially simple to build and orchestrate? Or will something entirely new emerge, architectures that none of us have thought of yet, conceived by the first generation of engineers working natively with AI from day one?
This is where I expect the most radical change. The architectural decisions we make today were all shaped by the constraints of human cognition and team coordination. When those constraints shift, the optimal architecture shifts with them.
The software market is going to look very different
Think about the logic of buying software today. You pay for a product that does roughly what you need, and you adapt your processes to fit it. The vendor builds for the widest possible market. You accept the parts that don't fit.
Now imagine building custom software becomes nearly free. Why would a mid-sized company, for example, pay for an off-the-shelf solution when it could build exactly the CRM it needs, with exactly the workflows it uses, in a fraction of the time? Why accept a product shaped for a thousand different customers when you can have one shaped for you?
Large organizations will be insulated for a while: legacy contracts, existing data, organizational inertia. But the smart ones are already identifying the gaps between what their software does and what they actually need. Startups are even better positioned. They can build precisely what they need right now and grow it as requirements evolve, rather than paying for headroom they may never use.
I'm not predicting the end of SaaS. Plenty of software solves problems at a scale or depth that no individual organization would want to reproduce. Cloud providers have an advantage too since they're renting hardware, not just software, and that's a different kind of moat. But a substantial portion of what fills the app stores and software catalogs today? That market is going to contract. The real question for every SaaS company is whether it's selling a commodity or something genuinely hard to replicate.
What comes next
The business of software, team structures, pricing models, job titles, career paths, will all look different within a decade. For a while "prompt engineer" seemed like the emerging role to watch. I think the truth is more nuanced. The skills that will matter are judgment, domain knowledge, and the ability to translate between human intent and machine capability. Those aren't new skills. They're the skills that have always differentiated great engineers from merely competent ones. The tools are just changing.
What I'm most certain of is the uncertainty itself. AI will bring innovation at a scale we haven't really processed yet. The software development lifecycle as we know it, the sprints, the PRs, the deployment pipelines, the architecture reviews, will be unrecognizable in five years. Features will move from idea to production in minutes. The steps in between will become invisible.
We built all of our practices to manage human limitations: the slowness of writing code, the difficulty of reading someone else's, the cost of coordinating across teams. As those limitations recede, the practices built around them will either evolve or become obstacles.