Punch Cards, Editors, Agents
Programming has had three eras: punch cards, editors and now agents. Each one changed the feedback loop and the medium. Agentic engineering is as large a shift as the move from punch cards to editors, and it is still programming, now in English.


There have been three eras of programming. In the first, programmers wrote on paper and the computer read punched cards. In the second, programmers read and wrote every line themselves in an editor. In the third, which started last year, programmers chat with AI agents that read and write the code for them.
I think the move to agents is as large a change as the move from punch cards to editors. It is a new paradigm for programming, not a better autocomplete. And it is still programming. We are still telling computers what to do. We are now doing it in English instead of in a high-level programming language.
Here is the case, era by era. The thread that runs through it is the feedback loop: how long it takes to find out whether a change worked, and who runs the loop.
The eras overlap
The dates I use are symbolic markers, not the moment one era ended:
- Punch cards: the 1950s, ’60s and ’70s.
- Editors: from the late 1970s until 2025.
- Agents: from 2025, when Claude Code launched, to now.
Each era had a long overlap with the one before it. Interactive editors existed in the early 1960s, and punched cards were still in use in the 1980s. I date the editor era from when interactive editing became the normal way to program, which the evidence below puts in the 1970s, unevenly by institution. Many people still use editors today. 2025 marks the start of the agent era, not the end of editors.
Punch cards: hours or days per change
In the punch-card era, a program started on paper. Dale Fisk, an IBM engineer who learned to program in about 1973, described the process: “Writing a program began with a paper tablet of coding forms.” Each line on the form would become one punched card.
Then he did something that surprised me. He didn’t punch the cards. He took his coding sheets to the lab’s keypunch operator, left them in her in-basket and was told to come back the next day for his deck.
That was common. Martin Gorfinkel, in a memoir held by the Computer History Museum that covers his work from 1960, wrote that a programmer “would write a program out on coding sheets; the keypunch shop would take the sheets and punch the cards.” Janice Silcox, who programmed at Sperry Rand’s UNIVAC division from 1968, recalled: “We’d write our code and then send our pages to the keypunch room.” At Cornell from 1962, students wrote programs on coding sheets that professional keypunch operators transferred to cards, according to the university’s computing history.
It wasn’t universal. Programmers kept a few keypunch machines for quick corrections, and many universities ran self-service keypunch rooms. But in a lot of shops, the programmer’s job was to specify the program precisely on paper, and someone else produced the artifact the machine would run.
Then the deck went into a queue. Cornell’s history describes the expectation: small jobs turned around “in minutes, long jobs in hours, and very long jobs overnight.” Its later priority-charging scheme ran down to low-priority work “where turnaround could be five days.” Silcox called a two-hour turnaround “amazingly quick.” A typo meant a new card and another run.
So the loop was: write on paper, wait for the punching, wait for the run, read the printout, find the mistake, and start again. Hours or days per change.
Editors: seconds per change
Interactive editing began with time-sharing. In 1962 Fernando Corbató and
his colleagues at MIT described CTSS, an early working time-sharing system,
motivated by how slow batch debugging had become. That same year Dan
Murphy wrote TECO on MIT’s PDP-1, where program source lived on punched
paper tape. QED followed at Berkeley in the mid-1960s, and in 1971 the
first Unix manual listed ed, “based on QED,” as the standard editor. The
full-screen editors vi and Emacs both trace back to 1976.
The switch to editors as the normal way to program happened through the 1970s. Fisk’s lab got shared terminals in about 1973. Within a month, he wrote, “I had set aside my punched cards.” The holdouts converted too, “however reluctantly,” because the productivity gain “was just too great to ignore.” At Cornell, about 150 terminals were connected to the main computer by 1978, half of them installed that year. Student batch jobs peaked in 1978–79 and then declined, which the university attributed in part to “the shift to more interactive use.”
Personal computers and integrated development environments finished the job. Borland’s Turbo Pascal, released in November 1983, put the editor and the compiler in one program. Microsoft announced Visual Studio Code in April 2015. In Stack Overflow’s 2025 survey, 75.9% of developers said they use it.
The loop collapsed from hours to seconds. Fred Brooks, in No Silver Bullet (1986), wrote that time-sharing preserves immediacy, and that the slow turnaround of batch work made programmers lose track of what they had been thinking. In the editor era, the programmer kept the whole loop in their head: write a line, run it, read the error, fix it.
And the programmer did all of it personally. The keypunch operator was gone. For decades, programming meant reading and writing every line of code yourself.
Agents: the loop moves up
On February 24, 2025, Anthropic launched Claude Code as a limited research preview: “our first agentic coding tool.” It could “search and read code, edit files, write and run tests, commit and push code to GitHub, and use command line tools.” It became generally available on May 22, 2025. OpenAI and Google released terminal coding agents of their own within months.
That list of capabilities is the editor-era loop. The agent writes the code, runs it, reads the error and fixes it. It runs the loop that the programmer used to run.
In Anthropic’s April 2025 analysis of coding conversations, 79% of Claude Code conversations were automation, “where AI directly performs tasks,” against 49% on Claude.ai. By February 2026, Claude Code’s run-rate revenue was over $2.5 billion, and its weekly active users had doubled since January 1.
The human’s loop didn’t disappear. It moved up. It is now about intent, review and the workflow that keeps the output correct. In my own work, a one-sentence request for a new tagline on this site went from filed issue to verified production in seven minutes and twelve seconds, with agents doing the coding, review and deploy. On one Saturday this month, I merged 141 pull requests across four repositories by directing teams of agents.
The medium changed, not the activity
Programming has always moved up a level of abstraction. Machine code gave way to assembly, and assembly gave way to high-level languages. Each step let the programmer say more with less, and each step was still programming.
English is the next layer. In January 2023, Andrej Karpathy put it in one line: “The hottest new programming language is English.”
Brooks saw this pattern decades ago. He quoted David Parnas: “automatic programming always has been a euphemism for programming with a higher-level language than was presently available to the programmer.” That is exactly what agents are. When I write an issue in English with a clear outcome and a way to verify it, I am writing a program in the highest-level language yet. The agent compiles it into code.
Put the two threads together and the eras line up:
| Era | Medium | Who runs the edit-run-fix loop | Time per change |
|---|---|---|---|
| Punch cards | Coding sheets and cards | Programmer, keypunch operator and machine room | Hours or days |
| Editors | High-level language in an editor | The programmer | Seconds |
| Agents | English | The agent | Seconds for the agent; the human reviews outcomes |
There is an irony in the first column. In the punch-card era, many programmers didn’t produce the artifact. They specified the program and someone else punched it. The editor era, when every programmer read and wrote every line personally, may turn out to be the exception, not the rule.
What the job is now
Reading and writing code is no longer the job. That is how I work now, and I think it is where the field is going.
Instead, I spend my time in two places. First, I chat with agents to decide what to build: the outcome, the constraints and how we’ll know it works. Second, I build and improve the software development workflow, so that the software gets built correctly and automatically, with every part automated by AI wherever possible. That is the work I described in I Built a Software Factory: issues as the unit of work, independent review, and the decisions I keep.
That puts the human in a director’s role, managing the AI rather than typing for it. The hard part moves from writing code to knowing whether the code is right, which is why I argued that verification is the new programming.
The objections
Agents still produce code someone has to trust. True. An agent’s output is only as good as the checks it has to pass. In Stack Overflow’s 2025 survey, 46% of developers said they distrust the accuracy of AI tools. But this is an argument about where the effort goes, not about whether the paradigm changed. In the punch-card era, when an error would matter, someone checked each punched card against the coding sheet. In the agent era, tests, review and deterministic workflows do that job.
Most developers still use editors. Also true. The same survey found only 14.1% of developers using AI agents at work daily, while three in four use VS Code. That is what the start of an era looks like. Cards lingered long after terminals arrived: Cornell’s student batch work didn’t peak until 1978–79, five years after Fisk’s lab gave up its cards.
We have heard “the end of programming” before. James Martin published Application Development Without Programmers in 1982. A British program generator released in 1981 was called The Last One, on the theory that it would be the last program anyone needed to write. Fourth-generation languages, CASE tools and low-code platforms all promised to remove the programmer, and none did. Edsger Dijkstra argued that natural-language programming was foolish, because the precision of formal notation is a feature.
Here is my argument for why this time is different. Those tools narrowed the problem to fit a generator, a form or a diagram, and they broke at the edges where real software lives. Agents work in the same general-purpose languages and codebases that programmers do, so there is no edge. And they run the edit-run-fix loop themselves, which no earlier tool did. The change is not that programming went away. It is that the medium moved up one layer and the loop moved to the machine, which is exactly what happened when editors replaced cards.
Dijkstra was right that precision matters. It still does. The precision just moved from the syntax into the specification and the checks.
Still programming
Every era of programming has been about telling computers what to do. On cards, we did it on paper, and waited a day to find out if it worked. In editors, we did it one line at a time, and found out in seconds. With agents, we do it in English, and the agent finds out for us.
The programmers who handed coding sheets to a keypunch operator were still programmers. So are the ones who now hand an issue to an agent. The job moved up a level, the same way it did when the cards went away.