I type less and review more

In 2012 the editor argument was Sublime Text 2 versus Vim, with a few people still loyal to TextMate and the Java crowd in Eclipse or IntelliJ. Sublime was fast and it had that minimap I barely used. You paid for it, or you didn’t and got the popup every few dozen saves. Vim people were insufferable and also right about a few things.

GitHub was already the centre by then. The pull request turned code review from an email thread into a page with a green button, and that was enough. I started looking there first when I wanted to read a project’s code.

Containers, and the end of “works on my machine”

Docker showed up in March 2013 as a demo at a Python conference. Containers weren’t new, but the Dockerfile was: a text file that said how to build the machine your code runs on, checked in next to the code. It made environments easier to reproduce, though I still found ways to break them. Kubernetes followed in 2014 and turned that idea into a whole career path.

CI went the same way. In 2012 continuous integration meant a Jenkins box under someone’s desk, with a red and green lava lamp if you were fancy. Travis CI made it a file in the repo, and later GitHub Actions (general availability in 2019) made it the default. Now a project without a pipeline feels unfinished, like a house without a door.

The editor wars, round two

GitHub released Atom in 2014. A text editor built out of web technology, which sounded ridiculous and was a bit slow, but it was hackable in JavaScript and it gave us Electron, which is the reason half your desktop apps are secretly browsers today.

Then Microsoft released Visual Studio Code in 2015 and, honestly, won. Same Electron trick, but with a team that cared about startup time. The thing that mattered underneath was the Language Server Protocol in 2016: a standard way for any editor to talk to any language’s brain. Autocomplete and go-to-definition stopped being an IDE feature and became a protocol. That’s the bit I think was clever.

TypeScript rode the same wave. It came out in 2012 and I noticed it much more around 2015 and 2016, when Angular went all in on it and VS Code made the tooling nice. By 2020 writing plain JavaScript for anything bigger than a script felt like leaving the seatbelt off.

Atom was retired in 2022. I was a little sad about it. It was the messy one, and messy things are where the ideas come from.

Then the models arrived

June 2021, GitHub Copilot preview. A model trained on public code, sitting in the editor, finishing your line. The first week was magic. The second week you started noticing it confidently invented functions that didn’t exist. Both of those things stayed true for a long time.

2023 was the ChatGPT year for code. You pasted an error in and pasted the fix back out. The editor stayed the same; the browser tab next to it did the work. A lot of people learned more about regular expressions in 2023 than in the previous decade, because now they could ask.

2024 was Cursor and the agentic editors. Instead of finishing your line, the model edited across files and you accepted or rejected diffs. That was the year the editor stopped being a text editor with a model attached and started being a model with a text editor attached.

2025 and 2026, agents

And then the loop closed. Coding agents like Claude Code and Codex take a task, read the repository, make the changes, run the tests, read the failures, fix them, and open a pull request. In 2025 that was a thing you tried. As I write this in September 2026 it’s how a lot of work gets done, and the interesting arguments have moved to review.

In the diagram above, the human sat at every box in 2012. In 2026 the human sits at two: describe and review. Everything in between still happens, it’s just not you typing it.

What I think

The best editor was always the one you stopped thinking about. Sublime for a few years, then VS Code for a lot of years. I want to think about the code, and an editor that keeps interrupting makes that harder.

The other thing: every tool on that timeline moved work away from the keyboard and toward reading. GitHub meant reading pull requests instead of emails. Docker meant reading logs instead of installing things. CI meant reading a red cross instead of running the tests yourself. Agents mean reading diffs instead of writing them. Fourteen years of tools and the job is increasingly to be a good reviewer, which I’m still learning to do well.

I’m not sure that’s bad. But I do notice that I type less and squint more.