The backlog is the prompt.

Sprint planning scopes work before a line of code is written. Backlog refinement chunks a big idea into pieces one worker can hold in their head at once. A PRD gets the picture out of one brain and into a format someone else can execute. Look past the ceremony and agile has always been a set of context-transfer mechanisms — disciplines for getting what's in one person's head into another's before work starts. The practitioner argument that named this cleanly is Josh Owens' “Your AI Doesn't Need Better Prompts. It Needs a Sprint Planning Session.” (Feb 2026).

Here is the reframe the whole leaf turns on: an agent is stateless. It holds nothing between sessions, and it starts every task cold. Where a human teammate accumulates context over months and can coast on it, an agent needs the full transfer on every single task. So the planning disciplines aren't obsolete in the agent era — they're load-bearing in a way they never quite were for humans. What changes is the medium: the context that used to live in a two-hour meeting and three people's memory now has to live in files an agent can read. Planning didn't die. It compiled down from meetings into artifacts under version control.

Those three failure modes: intent drift (the code slowly stops matching what anyone actually asked for), context decay (the “why” behind a decision evaporates the moment the session ends), and unverifiable output (you can't tell whether the agent did the right thing because “the right thing” was never written down). A working ticket in this model carries what a good agent brief always carried: outcomes, scope boundaries, constraints, prior decisions, a task breakdown, and verification criteria. That is not new project-management theology — it's the same brief a competent contractor would demand before quoting, made executable.

For the requirement statements themselves, EARS notation (Easy Approach to Requirements Syntax) gives a small, testable grammar — “When <trigger>, the system shall <response>” — that turns a vague wish into something an agent can build against and a reviewer can check.

Once the ticket is a structured spec, the backlog stops being a human-only list and becomes data an agent can operate on — issues in GitHub, Linear, or Jira reached over MCP, or plain markdown work items committed alongside the code. What that changes in practice is concrete: agents cluster duplicates, flag stale tickets, draft sizing, and produce the planning pre-read. The planning meeting stops being “let's build a plan while everyone watches” and starts from a complete draft — the question in the room becomes “do we agree?” instead of “let's write this from scratch.”

That item is small enough for one agent session, states its own acceptance criteria, points at the live code to ground against, and can be verified without a human reading the agent's reasoning — only its diff and its passing tests. A backlog full of items shaped like this is the prompt library the operator runs against.

The two-week sprint was calibrated to a human build loop. When spec-to-first-commit compresses to minutes, that unit stops being natural — you can cycle through several well-specified items in the time a planning meeting used to take. The habit is sticky, though: State of Agile data still shows roughly 59% of teams on two-week sprints, a share that has declined every year since 2022 (via Cadence, “How to plan a software development sprint in 2026”, June 2026). The mainstream alternatives are flow-based cycles (Linear-style continuous flow) and Shape Up appetites (fixed time, variable scope).

Story-point velocity is an estimate of how much a team can write in a cycle. When agents write most of the code, the constraint stops being how fast anyone types and shifts to spec quality and review capacity — and a metric calibrated on the old bottleneck goes haywire against the new one. What survives the shift is measurement of throughput and cycle-time on merged, verified work, and probabilistic forecasting off actual completion data, which beats ceremony-driven estimation precisely because it doesn't care who wrote the code, only what shipped and passed.

State the recalibration honestly, because someone will wave a chart: velocity numbers will move sharply, and stakeholder expectations need resetting. A bigger number is not a better forecast if review is the queue — code drafted but stuck behind a human reviewer isn't delivered, and counting it as velocity just moves the lie downstream. What to watch instead of raw velocity:

The throughline across this branch is the operator: one person commanding several agents in parallel, with human specialists in the loop for review and judgement. In that model, planning has a precise, humble job — keep the operator's queue full of well-specified, independently shippable work items, each small enough for one agent session and each gated by CI and PR review exactly as software/software-for-agents describes. Planning isn't running the build anymore; it's feeding it clean inputs.