My AI Engineering Journey

Looking back, this wasn't really a sequence of tools. It was a sequence of bottlenecks. Each stage ended when I hit a new constraint, and the next stage was whatever removed it. Two things shifted along the way: how much I trusted the output (from ignoring suggestions, to rewriting everything, to actively checking, to spot checking, to trusting the pipeline), and my own role (typist → editor → director → coordinator → orchestrator → platform builder).

Role typist→ editor→ director→ coordinator→ orchestrator→ platform builder

Trust ignoring suggestions→ rewriting everything→ actively checking→ spot checking→ trusting the pipeline

Era 1: Assisted coding

The human writes, AI suggests.

Stage 01Typist

Stage 1: Manual coding

Pre-AI. IntelliSense hints in VS Code at best.

Bottleneck: typing speed and recall.

Stage 02Typist

Stage 2: Autocomplete

Copilot single-line completions. Already felt useful for contextual autocompletion, avoiding repetitive typing.

Bottleneck: it only saves keystrokes, not thinking.

Stage 03Editor

Stage 3: Block completion

Copilot larger multi-line completions. Often not correct, but wrong in a useful way. They frequently helped shape a solution that I then rewrote manually.

Bottleneck: no dialogue. I couldn't steer it, only accept or reject.

Stage 04Editor

Stage 4: Chat assistance

Copilot Chat. The first time AI felt like it could actually assist with coding rather than just typing. But it was very hit and miss and couldn't be trusted.

Bottleneck: unreliable, and it couldn't touch the codebase itself. I was still the hands.

Era 2: Agentic coding

AI does, the human directs.

Stage 05Director

Stage 5: Supervised agents

Claude Code with Sonnet 3.5. Almost immediately felt like a new world. An agent doing things by itself. The output was full of errors, but it actually tried to fix them along the way. I still more or less had to tell it what to do at every step, but it was the beginning.

session log

● editing src/api.ts ● running test suite ✗ 2 tests failed ● patching handler.ts ● re-running tests ✓ tests passed ● editing src/api.ts ● running test suite ✗ 2 tests failed ● patching handler.ts ● re-running tests ✓ tests passed

Bottleneck: output quality. Everything needs constant, active checking.

Stage 06Director

Stage 6: Trusted agents

As models and agent harnesses improved (Sonnet 4.5, then Opus), I learned more and more how much I could trust the output. The model self-validates its work and produces almost error-free code. I went hands-off on execution and shifted from checking code to reviewing outcomes.

Bottleneck: one agent at a time. My throughput was now capped by serialisation, not by the AI.

Era 3: Parallel agents

The human coordinates.

Stage 07Coordinator

Stage 7: Manual parallelism

Running two or three planning sessions while one agent codes, kicking off the next coding session from a completed plan when the first finishes. All choreographed by hand purely to stop agents tripping over each other in a shared working copy.

Bottleneck: coordination overhead and collision risk.

Stage 08Coordinator

Stage 8: Isolated parallelism

Git worktrees, via the wt CLI (worktrunk). Agents can no longer collide, so multiple coding agents run at once.

four to ten terminals

● build
✓ ok
● lint
● patch
✓ ok
● test
● build
✓ ok
● lint
● patch

● test
✗ fail
● retry
✓ ok
● push
● test
✗ fail
● retry
✓ ok
● push

● edit
● edit
✓ save
● run
● diff
✓ ok
● edit
● edit
✓ save
● run

● plan
● spawn
● code
✓ ok
● merge
● plan
● spawn
● code
✓ ok
● merge

● fetch
● build
✗ fail
● fix
✓ ok
● fetch
● build
✗ fail
● fix
✓ ok

● test
✓ ok
● test
✓ ok
● push
● test
✓ ok
● test
✓ ok
● push

Bottleneck: my own cognition. Four to ten terminals with text flying everywhere was exhausting. I'd become the overloaded component in the system.

Era 4: Orchestrated agents

The system coordinates, the human supervises.

Stage 09Orchestrator

Stage 9: Orchestration

So I built Otto, an orchestration tool and Claude Code UI on the Claude Agent SDK, fully integrated with worktrees. It hides the chat-scrolling nature of the CLI and makes everything feel calmer. The gain at this stage wasn't capability, it was calm: 10 to 20+ concurrent sessions without feeling completely drained at the end of the day.

Bottleneck: everything still needed me to initiate it.

Stage 10Orchestrator

Stage 10: Autonomous pipelines

I then added cron jobs and GitHub webhooks to Otto. Sessions spawn, run and complete without my intervention:

Issue assigned
agent implements and opens a PR
review agent spawned and pushes changes
Copilot leaves a PR comment
new session launched to validate and implement changes
PR merged
documentation agent spawned to update docs
loop

Repetitive and routine work runs itself.

This is where I am today.

Bottleneck: it all runs on my MacBook and is bespoke to my repo.

Era 5: Platform

The workflow becomes infrastructure.

Stage 11Platform builder

Stage 11: Cloud automation and distribution

The next step. Moving the whole workflow off my MacBook and into the cloud, making it available for all our repos and all teams, with reusable agent configurations, prompts and automations. The journey stops being personal capability and becomes organisational capability.

Bottleneck (open)

The journey at a glance

Eleven stages, each ended by a bottleneck
Stage	Name	Human role	Trust level	Bottleneck that ends it
1	Manual coding	Typist	n/a	Typing and recall
2	Autocomplete	Typist	Ignore most suggestions	Saves keystrokes, not thinking
3	Block completion	Editor	Rewrite everything	No dialogue
4	Chat assistance	Editor	Verify everything	Unreliable, can't act
5	Supervised agents	Director	Check actively	Constant supervision needed
6	Trusted agents	Director	Spot check	One agent at a time
7	Manual parallelism	Coordinator	Spot check	Collisions and choreography
8	Isolated parallelism	Coordinator	Spot check	Human cognitive overload
9	Orchestration	Orchestrator	Trust the session	Human-initiated only
10	Autonomous pipelines	Orchestrator	Trust the pipeline	Single machine, bespoke
11	Platform	Platform builder	Trust the system	(open)