In June 2021, a developer on Twitter posted a screenshot of GitHub Copilot completing a for-loop and wrote: “impressive, but it’s just autocomplete.” That take was correct and completely missed the point. What Copilot started was not a feature — it was the first turn of a loop that would, five years later, produce autonomous agents writing, testing, and shipping software while the engineer supervises from a terminal.
I’ve been here for the whole ride. And the most important thing I can tell you is that this evolution was not smooth. There was a rupture. And most of the tools you’re familiar with are on the wrong side of it.
2021–2022: The Autocomplete Era#
GitHub Copilot launched its private beta in June 2021 on top of OpenAI Codex. The experience was genuinely magical in a narrow way: you typed a comment describing what you wanted and ghost text appeared, offering a plausible completion. Functions filled themselves in. Boilerplate evaporated.
But the paradigm was firmly tab-to-accept. The model was passive. It waited for you to type, offered a suggestion, and disappeared until you typed again. The human was the engine; the AI was the turbocharger. Amazon CodeWhisperer followed the same template. The competitive question was which model produced more accurate completions, not what the model was capable of doing on its own.
The discourse of this era aged badly. “It’ll just write buggy code you’ll have to fix anyway.” “It’s a Clippy for developers.” “It trains on your private repo.” Some of these concerns were legitimate; none of them engaged with the trajectory. Copilot went generally available in June 2022 and immediately became the most widely adopted developer tool in a generation. The tool was limited. The appetite it revealed was not.
2022–2023: The Chat Era#
GPT-4 landed in March 2023 and broke the autocomplete paradigm. Not because GPT-4 was better at completing lines — though it was — but because it could sustain a coherent conversation about a codebase across hundreds of turns. Developers stopped asking “complete this function” and started asking “why does this fail, what should I change, how would you design this differently.”
This was the era of vibe coding, a term that emerged to describe a workflow that was equal parts productive and reckless: paste the error message, accept the fix, run it again, don’t read the diff. Engineers started shipping features faster than they could reason about what they were shipping. Technical debt accumulated at AI speed.
SWE-bench was created in late 2023 by Princeton NLP researchers, and its arrival mattered more than most people realized at the time. For the first time there was a structured benchmark measuring something close to real software engineering — resolving GitHub issues in real Python repositories. The initial numbers were humbling: state-of-the-art models solved less than 5% of tasks. That number would become a speedometer for the entire field.
The chat era was real progress. But it still kept the human firmly in the loop. The model reasoned; you acted. The model suggested; you typed. The computer did not do anything you didn’t explicitly ask for.
2023–2024: The Agent Experiments#
In March 2024, Cognition AI launched Devin with a claimed 13.86% on SWE-bench — more than double anything that had come before — and a press release that called it “the world’s first AI software engineer.” The backlash was immediate and partly warranted: independent researchers found the methodology questionable and real-world performance disappointing. But the significance of the moment had nothing to do with Devin’s actual capabilities. It had to do with the framing.
For the first time, a serious company shipped a product positioned not as a tool for engineers but as a replacement agent. The Overton window shifted. “AI software engineer” stopped being science fiction and started being a product category.
Cursor launched around the same time as an AI-first fork of VS Code, and it was genuinely good. Context-aware edits, inline chat, codebase indexing — it pushed the IDE model further than Copilot had. Developers who lived in VS Code found it transformative. The model had also improved dramatically: Claude 3 Sonnet and Opus raised the quality ceiling on what an AI could reason about code.
But Cursor’s architecture made a bet: that the right interface for AI-assisted development was still the IDE. That developers would stay in their editor, and the AI would work within that frame. It was a defensible bet. It was also, I’d argue, a ceiling.
2024–2025: The Terminal-Native Rupture#
Claude Code launched in early 2025 and it was architecturally different from everything that came before. Not marginally different — structurally different. It ran in the terminal. It had no IDE dependency. It could read your entire repository, plan across files, run tests, interpret the output, iterate, and complete a multi-step task without asking for confirmation at every turn.
The IDE-vs-terminal debate that followed was widely misread as a UI preference war. It was not. It was a debate about who holds the steering wheel.
In Copilot, in Cursor, the human is always in the critical path. You accept or reject suggestions. You trigger actions. The model is a very powerful tool you’re operating. In Claude Code — especially after MCP shipped in late 2024 — the model can hold the plan across a long-horizon task. You can describe what you want, walk away, and come back to a pull request. The human is a supervisor, not an operator.
MCP (Model Context Protocol) deserves more credit than it gets in this story. Shipping in late 2024, it gave Claude Code — and any conforming agent — a standardized way to plug into external tools: databases, APIs, file systems, CI pipelines. By mid-2025 it had 97 million downloads. MCP turned Claude Code from a capable terminal agent into an extensible platform.
SWE-bench Verified hit roughly 60% in this period, up from under 20% two years earlier. The benchmark was moving fast enough that researchers started debating whether it was still measuring the right thing.
2025–2026: The Agentic Era Is Not Coming — It’s Here#
Claude Opus 4.7 scores 87.6% on SWE-bench Verified and 64.3% on SWE-bench Pro. The Stanford AI Index 2026 notes that SWE-bench Verified is approaching the human performance baseline. Google announced at Cloud Next 2026 that over 75% of its new code is AI-generated. Claude Code crossed $2.5B ARR. Managed Agents, Code Review GA, and Agent Teams shipped.
Let me sit with those numbers for a moment, because if you’d shown them to the engineer who posted that Copilot screenshot in 2021, they would have assumed you were describing a dystopian film.
The workflow that’s emerging — not at some companies, but at most serious engineering organizations — looks like this: the engineer writes a spec or describes a task, an agent implements it, runs the tests, opens a PR, and flags edge cases for human review. The engineer’s primary interface is no longer the editor. It is increasingly the spec, the review, the judgment call on ambiguity.
This is not the elimination of software engineers. It is the elimination of a large fraction of the work software engineers have historically done. The implementation layer is being automated. What remains irreducibly human is the part that was always undervalued: understanding why the system should exist, what it should do in cases the spec didn’t anticipate, and whether the thing the agent built is actually what the business needed.
What Is the Software Engineer’s Irreducible Role?#
I don’t have a clean answer, and I’m suspicious of people who do.
The honest version is that the industry is mid-restructuring and anyone claiming to know the stable endpoint is extrapolating from incomplete evidence. What I can say is that the engineers thriving right now are the ones who have shifted their leverage point. They are writing fewer lines and making more consequential decisions per day. They are treating AI agents as junior engineers who need clear requirements, good test coverage to catch regressions, and explicit feedback loops — not as autocomplete on steroids.
The engineers struggling are the ones who experienced Copilot as the destination and Cursor as the upgrade, and don’t understand why they feel like they’re falling behind despite using good tools. The tools are good. But they were optimized for a paradigm that is being superseded.
Five years ago, the question was whether autocomplete was cheating. Today, the question is what judgment, taste, and systems thinking look like when implementation is nearly free. That is a much better question to be asking. The industry took five years to get here. I don’t think it’ll take five more to find the answer.
Sources#
- GitHub Copilot General Availability — GitHub Blog, June 2022
- SWE-bench: Can Language Models Resolve Real-World GitHub Issues? — Princeton NLP, October 2023
- Introducing Devin — Cognition AI, March 2024
- Stanford AI Index Report 2026 — Stanford HAI
- Google Cloud Next 2026 — AI-generated code keynote announcement
- Anthropic Claude Code ARR reporting, 2025–2026