Every few years the tools change and people panic. Compilers were going to make assembly programmers obsolete. Garbage collection was going to make C programmers obsolete. Stack Overflow was going to make senior engineers obsolete. Now agentic AI is going to make all of us obsolete.
None of those predictions came true and this one won’t either. What did happen each time was more interesting: the floor rose: more people could build software, the problems we tackled got bigger, and the craft of software development — understanding what to build, why, and how to keep it running — became more valuable, not less.
Agentic AI is the latest chapter in a story that’s been unfolding since the 1950s. It is a profoundly capable productivity tool, not a replacement for thinking. And we will get used to it, just as we got used to everything that came before.
Part 1: The long march toward programming accessibility
Programming has been getting easier for seventy years and every step has followed the same pattern: remove a layer of incidental complexity so people can focus on the problem they actually care about.
The arc of programming: From punch cards to natural language
In the 1950s, programming meant wiring physical connections or punching holes in cards. FORTRAN, introduced in 1957, was the first high-level language and a scandal at the time. Real programmers wrote assembly. A language that compiled to machine code? That was cheating.
The 1970s and 80s brought BASIC, C, and Pascal. What had required a team of specialists could now be done by one person at a desk. The 1990s brought Java, which handled garbage collection and threading - whole categories of bugs that developers no longer needed to wrestle with. It also ran on a virtual machine, abstracting away the underlying platform. Write once, run anywhere (in theory).
Then came Ruby and Python, languages designed to read almost like English. Alongside them came the open-source movement, online tutorials, Stack Overflow, and package managers that gave every developer on earth access to battle-tested libraries.
The progression is visible in something as simple as Hello World:
“Hello World!” through the decades
FORTRAN (1957)
COBOL (1959)
BASIC (1964)
C (1972)
Python (1991)
English (2025, via agentic AI)
Each generation peeled away another layer of machine-facing syntax. And each time, sceptics said it wasn’t real programming. They were always wrong, it was always real programming, it was just programming with better tools.
Agentic AI: The next abstraction layer
In 2023, AI copilots arrived — autocomplete on steroids. They could generate a function from a comment. Useful, but fundamentally reactive: you typed, they suggested.
By 2025 and into 2026, the tools evolved into something qualitatively different. Agentic AI systems — Claude Code, Cursor, Windsurf, Devin, and others — don’t just complete your line, they take an objective, break it into steps, write the code, run it, read the error messages, fix the bugs, and iterate. They navigate codebases, understand context, and execute multi-step plans.
This is genuinely new but it isn’t magic and it isn’t replacing developers. It’s doing what every previous abstraction did: it’s removing incidental complexity (the syntax, the boilerplate, the Stack Overflow search) so developers can spend more time on essential complexity — the hard questions about what to build, how it should behave, and what happens when things go wrong.
Cutover’s own evolution reflects this pattern. As AI-assisted development makes automation more accessible across an enterprise, more teams are building their own integrations, scripts, and workflows. The barrier to creating software drops but the need for orchestrating, governing, and coordinating that proliferation of automation only grows.
Part 2: As we understand the problem, the problem evolves
The tools don’t just get better in isolation. As they improve, our understanding of the problem deepens, and the problem itself changes shape.
What the evolution of watching TV teaches us about agentic AI
Consider how something as simple as watching a TV show has evolved:
- 1970s: You watched what was on, when it was on. If you missed it, you missed it.
- 1980s: VCRs let you record, but you had to manually start and stop at the right time.
- 1990s: Programmable VCRs and VideoPlus codes automated the recording.
- 2000s: DVRs with electronic program guides let you record a show by name, not by time and channel.
- 2010s: Streaming services made recording irrelevant. Everything was on demand.
- 2020s: Recommendation engines don’t just serve what you ask for; they anticipate what you want before you know you want it.
Notice the pattern: each step didn’t just improve the previous step, it dissolved the previous problem. DVRs didn’t make VCRs better; they made the concept of “scheduled recording” irrelevant. Streaming didn’t make DVRs better; it made the concept of “recording” irrelevant.
Agentic AI does the same thing to software development. It doesn’t just make typing code faster, it dissolves some of the problems that made typing code necessary. Need a data migration script? Describe the shape of the data and the destination. The agent writes the script, runs it, and handles the edge cases. The problem of “how do I write this migration” is increasingly replaced by “what should this migration actually achieve?”
Infrastructure follows the same arc
The same evolution plays out in infrastructure. What started as a spreadsheet tracking a manual process migrated to an on-premises server, then to the public cloud, and is now moving toward cloud-native architectures with managed services and serverless functions.
Each step trades fine-grained expert control for broader accessibility and operational convenience. Managed services can run globally with minimal expertise, but when they fail, they’re harder for an individual organization to recover from. The Netflix analogy holds: enormous convenience when it works, limited control when it doesn’t. Agentic AI follows the same tradeoff curve: spectacular productivity when the problem is well-scoped but still requiring human judgement for the ambiguous, high-stakes decisions.
Part 3: Business users are increasingly self-serving
The marketing literature of each era tells you everything about who the technology was built for.
Then and now: FORTRAN to AI agents
A 1966 IBM brochure for FORTRAN boasted about “object decks that run at maximum speeds.” A 1981 Data General brochure for COBOL emphasized its ability to “handle large data-processing tasks” with no mention of non-technical users. The audience was specialists and the marketing spoke their language.
By 2018, Microsoft’s Azure Custom Vision was pitched with: “No machine learning expertise required. Start exploring your data and training models with just a few clicks.”
By 2025, the shift is even starker. Anthropic’s Claude is marketed as a tool where you “describe what you want to build and Claude builds it.” Google’s Gemini, OpenAI’s ChatGPT, and a growing ecosystem of agentic platforms all position themselves as tools for everyone, not just developers.
The marketing reflects a genuine reality: business users are building things that would have required an engineering team five years ago. Sales teams are creating their own data dashboards. Marketing teams are automating their own workflows. Operations teams are writing integration scripts by describing what they need in plain English.
The governance challenge of agentic AI
For an enterprise, this democratization brings enormous agility but it also brings risk. When anyone can create an automated workflow that touches production data, the questions shift from “can we build this?” to “should this run unsupervised? Who approved it? What data does it access? What happens when it fails?”
Agentic AI amplifies this challenge. An AI agent isn’t just executing a script, it’s making decisions, calling APIs, processing data, and iterating. The surface area for things to go wrong is larger and the need for guardrails, audit trails, and approval workflows is correspondingly greater.
This is where orchestration becomes essential. Cutover allows enterprises to create pipelines that request and provision segregated environments, route approvals to the right people, and maintain audit trails, all accessible to a non-technical audience. The agents do the work; the orchestration layer ensures the work is governed.
Part 4: Humans and AI agents are better together
The chess parallel with AI
In 1997, IBM’s Deep Blue defeated Garry Kasparov. It was framed as the end of human supremacy in chess. But in the years that followed, a more interesting phenomenon emerged: “centaur chess,” where human-computer teams consistently beat both pure humans and pure computers.
The AI could evaluate millions of positions per second. The human brought strategic intuition, creative patterns, and the ability to ask the right questions. The combination was more powerful than either alone.
Today’s chess engines like Stockfish and AlphaZero are dramatically stronger than Deep Blue ever was. A modern grandmaster can no longer beat a top engine. But the centaur principle still holds in the real world. AI can generate thousands of candidate moves and evaluate their outcomes. Human players study these patterns and improve faster than any previous generation. The AI raises the floor; the human provides the direction.
Agentic AI exhibits the same dynamic as software
Agentic AI and software development exhibit exactly this dynamic. The agent can write, test, and debug code far faster than a human but it doesn’t know why you’re building the product. It doesn’t understand your users’ frustrations and it can’t tell you whether the feature is worth building in the first place or whether the elegant technical solution misses the business problem entirely.
Development was always more than syntax, it was understanding requirements that users couldn’t articulate, designing systems that would survive contact with reality, and making tradeoffs between speed, cost, reliability, and maintainability. Those skills don’t become less valuable when the syntax writes itself, they become more valuable, because now you can act on them faster.
“A generation ago some people were saying there was no point in learning to program because all the programming jobs would be outsourced to India. Now they’re saying you don’t need to because AI will do it all. If you don’t want to learn to program, you can always find a reason.” — Paul Graham
“I’ve been reluctant to try ChatGPT. Today I got over that reluctance. Now I understand why I was reluctant. The value of 90% of my skills just dropped to $0. The leverage for the remaining 10% went up 1000x. I need to recalibrate.” — Kent Beck
Kent Beck’s observation is the most honest framing available. Agentic AI doesn’t eliminate 90% of what developers do, it dramatically reduces the cost of that 90% - the typing, searching, and debugging, the boilerplate. And it dramatically amplifies the remaining 10% - the judgement, architecture, and understanding of the problem domain.
The developers who thrive will be those who lean into that 10%. Who use agentic AI to move faster, try more ideas, iterate more quickly, and spend their time on the work that only humans can do.
Orchestrating the human-AI hybrid workforce
Cutover’s AI product line already demonstrates this symbiotic relationship. You can create a new runbook with outlined tasks in seconds, get suggested improvements, and refine the plan within minutes, or take existing content from spreadsheets and internal wikis and make it executable almost immediately. The AI accelerates the creation; the human provides the domain expertise and strategic judgement.
As agentic AI matures, the coordination challenge intensifies. A modern enterprise workflow might involve a human making a decision, an AI agent drafting a plan, a traditional API executing a deployment, another agent monitoring the outcome, and a human reviewing the result. Orchestrating that blend, with visibility, auditability, and the ability to intervene when things go sideways, is the real problem to solve.
The tools change, the craft remains
We’ve been here before. Every major advancement in programming tools was met with predictions that developers would become obsolete. Every time, the opposite happened: the tools made developers more productive, lowered the barrier for new people to join, and shifted the valuable work toward higher-order thinking.
Agentic AI is the most powerful productivity tool to arrive in a generation. It will change how we write software, how we think about problems, and who gets to participate in building solutions. It will not replace the need for people who understand what to build and why.
We will get used to it, just as we got used to compilers, IDEs, open source, cloud computing, and every other tool that made the old way of working feel primitive. The syntax changes, the craft endures.