The narrative around AI often swings towards hyperbole, with headlines frequently proclaiming the imminent demise of various professions. Software development is no exception. However, a recent article by Tim O’Reilly, “The End of Programming as We Know It”, offers a more nuanced and historically grounded perspective. While AI will profoundly change software development, O’Reilly argues it’s not an ending, but another transformation in a long line of them.
O’Reilly’s Take: Evolution, Not Extinction
O’Reilly compellingly argues that the history of programming is one of continuous abstraction and evolution, not replacement. Key points from his article include:
- Historical Parallels: Just as assembly language gave way to compiled languages (Fortran, C++) and later interpreted languages (Python, JavaScript), and just as operating systems abstracted away low-level hardware details, AI represents the next layer of abstraction. Each shift made some skills obsolete but ultimately expanded the scope and accessibility of programming, leading to more developers, not fewer.
- Programmers as Managers: In the age of large-scale web services, programmers already act as “managers” of automated systems and algorithms – the “digital co-workers”. AI accelerates this trend, positioning developers to oversee, direct, and integrate AI agents.
- Increased Ambition: AI tools don’t just automate grunt work; they allow developers like Simon Willison (whom O’Reilly cites) to “be more ambitious” with their projects, tackling complexity that was previously prohibitive. The focus shifts from writing boilerplate code to higher-level design, problem-solving, and value creation.
- The “Journey to Production”: Echoing Palantir’s CTO Shyam Sankar, O’Reilly emphasizes that moving from an AI-generated prototype to a robust, production-ready system still requires human expertise. Understanding workflows, handling edge cases, integrating systems, and ensuring reliability remain critical human tasks. AI liberates developers to focus more on business value and integration.
The core insight is that technology which makes development easier doesn’t eliminate developers; it changes their focus and increases demand by making software solutions feasible for a wider range of problems.
A Personal Take: The Coming Standardization
Building on O’Reilly’s perspective, I believe one significant consequence of AI’s deeper integration into development will be a radical standardization of technology stacks.
For decades, tech stack choices have often been influenced by team preference, familiarity, historical reasons, or the specific nuances of a framework. While performance and suitability matter, there’s been significant latitude. AI changes this equation.
If AI agents are writing, deploying, and managing significant portions of our code and infrastructure, they will inevitably optimize for factors they deem important:
- Performance & Efficiency: Specific languages excel in certain domains.
- Ecosystem & Tooling: Robust libraries and mature tooling are easier for AI to leverage.
- Predictability & Simplicity: Standard patterns reduce the complexity AI needs to manage.
- Scalability & Concurrency: Architectures that scale reliably are preferred.
This optimization pressure will likely lead to a convergence around a smaller set of “best-in-class” technologies for common tasks:
- Backend Languages:
- Go: For highly concurrent, networked services where performance is paramount.
- Python: Dominating data science, machine learning workflows, and scripting.
- TypeScript (Node.js): For standard web APIs (REST, GraphQL) and potentially front-end frameworks, benefiting from strong typing and a vast ecosystem.
- Infrastructure Orchestration:
- Kubernetes: While complex for humans, its declarative nature is ideal for AI management. The mechanics of defining services, scaling, and managing deployments will become largely automated, abstracting the underlying complexity away from most developers.
- Databases:
- PostgreSQL: As the default, robust relational database, offering stability and a rich feature set.
- Neo4j (or similar): For graph-specific problems where relationships are key.
- DynamoDB (or similar): For NoSQL use cases demanding high scalability and flexible schemas.
Developer preference for niche languages or frameworks might become less relevant. The AI co-developer, optimizing for the end-to-end workflow, will strongly favor the stacks it can most effectively and reliably work with. The creation of microservices, the definition of boundaries, and the underlying infrastructure management will happen behind the scenes, guided by AI analyzing the requirements.
The Future is Different, Not Gone
AI won’t make programmers obsolete, echoing O’Reilly’s conclusion. Instead, it elevates the role. We shift from intricate implementation details to becoming architects, integrators, and directors of AI-powered development processes. The focus becomes understanding the business problem, designing the high-level solution, and ensuring the AI-generated components work together effectively and safely. The tools change, the skills evolve, but the need for human ingenuity in building the future remains. The stack we use to build it, however, might look a lot more uniform.
[Citation: O’Reilly, Tim. “The End of Programming as We Know It.” O’Reilly Radar, 4 Feb. 2025, www.oreilly.com/radar/the-end-of-programming-as-we-know-it/.]