Agentic engineering: finding my role in the loop
Six months of AI coding have made it obvious that the human is the bottleneck. Where that leaves my role — closer to managing a small team of agents than to doing QA on their output — and the practical questions that follow from it.
We have been coding with AI for about six months now, since roughly the start of the year. It has been good. It has also made something uncomfortable obvious: we are the bottleneck. I spend a lot of the day waiting for a model, and then I am the slow step once it comes back. That is not a complaint about the models. It means my role has to change, and figuring out what it changes into is the interesting part of Agentic engineering: the work moves to the harness.
Every signal I see points the same way: I stay in the loop, but not as QA. The shape is closer to managing a small team. That framing has been around for a while — you manage your agents — but nobody has told me how it actually works day to day. This note is the list of things I want to work out.
Where the agents run
If the agents run on my local machine, I am betting the work on one laptop staying awake, plugged in, and coming with me. That is a bad bet and a daily annoyance. A team I manage should keep working when I close the lid, which pushes toward agents running somewhere that isn't my desk.
Memory across sessions
Agents need to carry something between sessions — a memory system, notes, a shared scratchpad, some form of cross-session communication. Without it every session restarts from zero and I become the memory, which is exactly the bottleneck I am trying to get out of.
Long-running, and taking decisions off me
Related but separate: I want them running long enough to finish something, and I want them making some of the calls themselves. Delegating tasks is easy. Delegating decisions is the part that actually buys me time, and the part I don't yet know how to scope.
Quality control and review
If I am not writing the code, review is where my judgment goes — so the PR review process has to be good. The hard case is the one the Anthropic post starts from: frontend design, where quality is a matter of taste more than of anything you can verify. That is the case I care about, because it is the one where "the tests pass" tells you nothing.
Linting
Linting is newer to me as a lever, and it looks more promising than I expected. The OpenAI post describes a repository whose custom linters carry the architectural rules and the house style — checks that catch what tests structurally cannot. Encoding taste and structure as something an agent runs before it asks for review, rather than something I say in a comment afterwards, is worth investigating properly.
Related
- The harness is a skill issueA piece by Anton Leicht on sovereign AI sent me looking for how the frontier labs actually run their internal coding agents. The answer is that they are still experimenting — nobody has Auto Research — which means the harness is mine to build, and building it well is a skill worth training.
- The claw layer: an agent that persists when you close the lidKarpathy's name for the layer above a coding session — something that keeps looping in its own sandbox, remembers more than a compacted context, and answers on one messaging channel. The home-automation example he built, and why it is a partial answer to two open questions in this notebook.
Linked from
- Agentic engineering: the work moves to the harnessThe emerging discipline around long-running coding agents — designing the scaffolding, feedback loops and environments that let an agent do reliable work, rather than writing the code yourself. Entry point for the harness-design cluster in this notebook.
- Building a generator–evaluator harness: A practical implementation recipeA staged plan for building the Anthropic generator/evaluator harness myself, cheapest step first — starting with the rubric alone and only adding orchestration where it earns its keep. Plus what's changed since the March post, and the third-party implementations worth reading.
- Code is not cheap: software fundamentals against spec-to-codeA conference talk arguing that the spec-to-code loop degrades a codebase on every pass, that the reason is ordinary software entropy, and that five failure modes of AI coding each have a fix sitting in a twenty-year-old book. The first source in this notebook that locates the harness inside the code rather than around it.
- Deep modules, and designing the interface you delegate behindOusterhout's deep modules, repurposed as an agent-legibility property and as the line between what a human designs and what an agent is allowed to write unread. Why the boundary is the unit of delegation, and the one place this collides with the notebook's other evidence.
- Keeping an agent running: goals, loops, hooks and schedulesFour mechanisms decide what starts an agent's next turn and what stops the sequence — /goal, /loop, Stop hooks and scheduled runs. Notes on the /goal documentation, including the constraint that shapes everything else: its evaluator has no tools and can only judge what the transcript shows.
- Loop engineering: from writing prompts to writing loopsThe claim that the unit of work is shifting from the prompt to the loop — Cherny, Osmani and Guzman all saying a version of it — and why the interesting question is not how to keep an agent running but who decides what "done" means.
- The claw layer: an agent that persists when you close the lidKarpathy's name for the layer above a coding session — something that keeps looping in its own sandbox, remembers more than a compacted context, and answers on one messaging channel. The home-automation example he built, and why it is a partial answer to two open questions in this notebook.
- The LLM-wiki pattern: the idea this notebook runs onAndrej Karpathy's pattern for an LLM-maintained personal wiki — kept verbatim at the repo root as LLM_Wiki.md — is the founding idea mantua.io itself instantiates. What the pattern claims, and where this repo's implementation matches or departs from it.