Retrospective
My AI engineering journey
From typing every line to pipelines that start themselves.
People ask me which tools I use. It is the wrong question, and the honest answer is that the tool almost never mattered. What moved me from one stage to the next was hitting a wall I could not get around, every single time.
So this is ten walls, in the order I hit them. Two things kept shifting the whole way down: how far I trusted what came back, and what was actually left for me to do.
- typist
- editor
- director
- coordinator
- orchestrator
- platform builder
- ignore most suggestions
- rewrite everything
- verify everything
- check actively
- spot check
- trust the pipeline
Era 1
Assisted coding
I write it. The model guesses what comes next.
By hand
There is a version of me who typed every character of this codebase, and it is not far back. The editor knew the shape of the file. It knew nothing about what I was trying to do with it, so the most it could offer was a name I had already used once. Everything past that was memory and speed.
Autocomplete
Then the editor began finishing the line I was halfway through. Right often enough to leave in, and never more than the line I was already on. My afternoons got a bit shorter. How I worked did not move at all.
Whole blocks at a time
Suggestions grew from one line to five. A five line guess is wrong far more often, and being wrong turned out to be worth something: even a miss showed me the shape of the answer, and rewriting from a shape beat starting from nothing.
That is where my job changed hands without anybody saying so. I stopped writing the first draft. I started marking one.
Chat beside the code
A panel next to the file, and the first time one of these felt like a colleague instead of a keyboard macro. It was also wrong about a third of the time, and it sounded exactly the same wrong as it did right. Nothing it said counted for anything until I had gone and checked it myself.
Era 2
Agentic coding
It does the work. I decide what the work is.
The first real agent
Claude Code. It opened the files itself, edited them, ran the suite, then read what the suite said back. Plenty of what it wrote that first month was wrong. The new part was that it found out it was wrong and went back, which nothing before it had ever done.
I was steering at almost every step. It is the stage where all of this stopped being autocomplete with a bigger window.
Letting go of the diff
Better models, and more to the point, better scaffolding around them. Instructions it genuinely reads. Skills for the jobs that come round every week. Subagents that go and find things, so the main thread never fills up with search results. A test suite with the final word.
Once it started checking its own work before handing it over, I stopped reading diffs and started reading outcomes.
Era 3
Parallel agents
More than one at a time, and I am the scheduler.
Juggling sessions
Two or three sessions planning while a fourth writes code, and the second the coder finished I set it going again on whichever plan was ready.
I held the whole schedule in my head, and I held it there for exactly one reason: two agents in one working copy will cheerfully edit the same file and hand me the mess.
A checkout each
Git worktrees. Every agent gets a checkout of its own, so no two of them can reach the same file, and the juggling act I had spent months getting good at simply stopped being necessary. Six terminals open, all of them moving, none of them aware of each other.
Era 4
Autonomous agents
The work opens its own sessions.
Nobody presses start
The last job left that only I could do was press start. So I gave that away as well. Schedules and webhooks open the sessions now, and things turn up already finished.
The weekly numbers get pulled, written up and posted into Slack before I am awake. What the report finds becomes an issue. The issue becomes a pull request. Some Mondays my first hour is spent reading work that happened without me.
Era 5
Platform
It stops being a thing I have and starts being a thing we run.
Off my machine
Where I am now. All of it is coming off the one machine. The prompts, the skills and the scheduled routines get written once, kept somewhere shared, pointed at whichever repository needs them, and run on hardware nobody has to leave awake.
That is the point this stops being a personal habit and becomes something a team can be handed. It is the work sitting on my desk this year.
I am here.
Ten walls, in order
Every stage, and the thing that put an end to it.
| # | Stage | My role | Trust | Bottleneck that ended it |
|---|---|---|---|---|
| 1 | By hand | Typist | n/a | How fast I typed |
| 2 | Autocomplete | Typist | Ignore most suggestions | Never questions the line |
| 3 | Whole blocks at a time | Editor | Rewrite everything | Take it or leave it |
| 4 | Chat beside the code | Editor | Verify everything | Reads, cannot touch |
| 5 | The first real agent | Director | Check actively | Cannot look away |
| 6 | Letting go of the diff | Director | Spot check | One thing at a time |
| 7 | Juggling sessions | Coordinator | Spot check | I was the scheduler |
| 8 | A checkout each | Coordinator | Spot check | I ran out of attention |
| 9 | Nobody presses start | Orchestrator | Trust the pipeline | One laptop, one codebase |
| 10 | Off my machine | Platform builder | Trust the pipeline | (open) |
Stage 5 onwards is what the class teaches. Not the tools, which change every few months, but the thing underneath them: how to hand work to an agent, how to prove it is right without reading every line, how to run more than one at a time without becoming the bottleneck yourself, and how to turn any of that into something a team runs rather than something you run.