Project Management for AI Coding Agents: A Practical Guide

Classical project management is a set of workarounds for human constraints: limited hours, context-switching costs, uneven skills, feelings about being reassigned. Coding agents delete some of those constraints and replace them with new ones, and the discipline changes shape accordingly. Four differences do most of the work:

The practical consequence: an “agent PM” spends almost no time on the middle of the process, the part traditional PM tools obsess over, and nearly all of it at the edges. Writing sharp stories on one side; reviewing diffs on the other. The infrastructure that makes the middle trustworthy is the tracker itself, covered in issue tracking for AI agents.

Strip away methodology branding and managing agents reduces to one loop, run per story. It is recognizably the old define-build-review cycle, but with the human effort redistributed to the first two and last two steps:

1. 1

   Define

   Break the goal into stories small enough that one agent can finish one story in one session. This is the highest-leverage human work in the entire loop: a story that is really three stories will come back as a diff that is really three diffs, and you will reject all of them at once.
2. 2

   Spec

   Turn the story into a written plan: scope, files in play, verifiable acceptance criteria, explicit exclusions. For a human this feels like bureaucracy; for an agent it is the target function. The spec is also your review contract, you will judge the diff against it, not against memory.
3. 3

   Assign

   Pick the agent and model for the story class, cheap and fast for mechanical work, frontier for ambiguous work, and hand it exactly the spec. Assignment is a craft of its own, covered in how to assign tasks to AI agents.
4. 4

   Isolate

   Every story runs on its own branch or git worktree. This is non-negotiable once more than one agent is active: isolation is what makes parallelism safe, keeps diffs attributable to stories, and makes a bad run disposable instead of contagious.
5. 5

   Review

   Read the diff against the spec's acceptance criteria. Accept, request changes, or discard and re-run with a better spec, with agents, throwing work away is cheap, so a re-run often beats a long correction thread.
6. 6

   Merge

   Ship the accepted diff as a PR tied to the story, and close the loop: the story, spec, diff, and PR form the durable record of why the change exists, which is the history the next agent session will not remember on its own.

Running this loop for one agent is easy in a terminal. Running it for five agents in parallel is a coordination problem, which is why teams converge on a board: one column per loop stage, one card per story. The pattern is explored in multi-agent coding workflow and AI kanban for developers.

With human teams, staffing means matching seniority to difficulty. With agents the same logic applies, but the axis is model tier, and the cost differences are large enough that routing everything to the frontier model is a genuine budget mistake. A sensible default mapping:

The tiers, prices, and benchmarks behind this table live in our models hub, which stays current as families change. The managerial point is stable even as the names rotate: route by story class, not by habit. In AIDEN, the CLI and model are picked per story on the card, so a Haiku cleanup and a Fable refactor run side by side on the same board.

The failure modes of agent management are consistent enough across teams to name. Three account for most of the damage:

The tooling market is converging on this space from two directions, and it helps to be clear about which direction each tool comes from: