The aha moment is not that the machine writes code. It is that the machine, given a sentence, finds the thread.
You hand an agent a Linear ticket for a service you've never opened. It reads the code. It pulls the last three PRs. It finds the design doc buried in Notion. It asks you two sharp questions, drafts a plan, and starts. You glance at your dashboard and three more sessions are running work you didn't assign — a test-gap hunt, a slow-endpoint trace, a refactor draft. Those were scheduled.
The aha moment is integration, not generation. Once you see it, the job changes.
The job is orchestration now
I stopped handwriting code months ago. I run three or four agents at once, each with its own sub-agents. One is building. One is reviewing. One is on-call for the cron that watches the error log. I watch them the way a beekeeper watches bees — you don't steer every agent; you keep the colony alive.
The work is full-stack in the old sense: planning, shipping, reviewing, incidents, analytics, the Linear update, the weekly report. High-agency and a little solitary. Most of my day is a conversation with machines.
The obvious counter is that this is scaffolding — prompts and dashboards and skill files patched onto models that will eventually stop needing them. Maybe. But the primitives are asymptotic, not transitional. A fleet will always exceed any individual agent's context window, reliability budget, or tool access. The smaller the model gets, the more the primitives matter. The bigger it gets, the more agents you run. Either way, the shape holds.
Orchestration, context, skills — in that order
Name them fast. _Orchestration_ is the dashboard you watch while they work — not a chat window. _Context_ is what the machine knows before it starts. _Skills_ are what the system remembers after it fails.
The order matters. Orchestration makes the work legible. Skills make it cheap to repeat. But context is where optimization actually pays off — more than model choice, more than tool sprawl. Swap Sonnet for Opus and the session gets marginally better. Hand the same session the right `CLAUDE.md`, the right Slack thread, the right design doc, and it becomes a different session. _The Context Engineer_ and _Context Debt_ cover the architecture and the maintenance; _Managing Agents_ frames it as the managerial primitive. I won't re-argue any of it. The operational claim is simpler: context is the primitive where spend converts cleanly into leverage.
Name the stack once. Conductor runs mission control — parallel workspaces, one per agent. Claude Code and Codex do the writing. Cron-driven agents handle the maintenance passes: test-gap hunts, performance watches, refactor drafts. MCPs expose the surface — Linear, Datadog, the git history, internal search. `.claude/skills/` holds the durable instructions. _Personal Operating System_ covers how that skill layer actually works. Nothing here is exotic. The leverage is in the ordering, not the parts.
Retros with the machine
Tuesday, 10am. A session burns its entire tool budget on the Datadog MCP. It pages through four hundred log lines, hits a timeout, and hands me back nothing useful. Old reflex: curse, rerun, babysit. New reflex: retro.
I open the transcript. I hand it to the next agent with a short prompt:
Read the attached session log. Why did this run go poorly? What would have helped the previous agent succeed on the first attempt? Propose a minimal diff to a skill file that would prevent a repeat. Do not fix the incident. Fix the future agent.
Two minutes later I have a diff against `.claude/skills/datadog.md`. The previous session didn't know the Datadog MCP paginates and returns a cursor. It fetched ten pages where one call with a time-range filter would have answered the question. The diff adds three lines — the pagination pattern, a time-filter hint, a warning about the tool's default limit. I accept it. The next run answers in a single call.
That is the retro. You do it to your agents the way you do it to your team.
The frame that matters: _the session's own transcript is the training data_. Not for the model — for the system around it. Every failure is a skill waiting to be written. Every slow tool call is a prompt-template gap. Every hallucinated file path is a missing reference.
Nobody has shipped this as a product yet. There is no standard for agent transcripts as feedback corpora, no universal skill format, no cross-tool memory spec. Someone will. _The Compound Agent_ argues the principle; retros are how you make it material — by hand, one session at a time, until the tools catch up.
Skip the retros and every failure mode pays itself again next Tuesday.
The dividend
This is why the math works for a single engineer. While you ship a feature, a scheduled agent is hunting test gaps in the code you merged last week. Another is watching p95 latency on the endpoints you shipped last month. A third is drafting refactors for yesterday's hotspot. They file their findings in Linear. You triage between meetings.
Features and technical debt, at the same time. Incidents handled while roadmap work ships. _A New Paradigm_ lays out the case for continuous autonomous optimization; the shape of the work is what that looks like at a desk on a Tuesday. Most of it runs while you're doing something else. You spend judgment where judgment counts — the hard product call, the weird edge case, the commit nobody else can evaluate. The rest is sweeping.
The work is no longer the code. The code is what the agents produce. The work is the orchestration, the context, the skills, and the retros — the system that keeps the agents sharp when you aren't watching. Build that system, and the work compounds. Neglect it, and every failure pays itself again.
The easy mistake is to think the aha moment is the arrival. It isn't. It's the opening line. The engineer who stays there — still delighted, still demoing — is the one who never gets past session one. The engineer who keeps going builds the system that makes session two cheaper than session one, and session fifty cheaper than session ten.
The machine finds the thread. You build the loom.