We stopped doing sprint planning in September 2026. Not because we read a blog post about "post-agile" methodology. Because Claude Code made the planning-to-execution ratio so fast that the overhead of planning ceremonies became the bottleneck.

This isn't a story about AI replacing developers. Our developers are still here. It's a story about how AI compressed the implementation cycle to the point where the traditional planning→spec→build→review→deploy pipeline is no longer the right abstraction.

The old world

Here's what a typical feature used to look like in our workflow:

sprint plan 2h spec/design 1-2 days implement 3-5 days review 1-2 days deploy 0.5 day feedback ??? 7-12 days from idea to user feedback fig. 1 — traditional sprint cycle

7 to 12 days from idea to user feedback. In a 2-week sprint, that means you get feedback on maybe 2-3 features per cycle. And most of that time isn't spent building — it's spent planning, specifying, waiting for review, and coordinating.

What changed

Claude Code compressed the implementation phase from days to hours for most features. Not all features — complex system architecture still takes time. But the vast majority of product work — new screens, flow changes, copy experiments, API integrations, analytics events — went from "3-5 days of implementation" to "2-4 hours with Claude Code."

When implementation takes 2 hours instead of 4 days, the planning ceremony that takes 2 hours is no longer a rounding error. It's 50% of the total cycle time. The abstraction breaks.

describe intent 15 min claude code 2-4 hours review + ship 30 min user feedback same day 3-5 hours from idea to user feedback fig. 2 — current cycle

The new workflow

We replaced sprint planning with what we call intent documents. An intent document is 3-5 sentences describing what we want to change and why. Not how. No technical spec. No acceptance criteria. No story points.

# intent/2026-01-15-paywall-redesign.md

## What
Replace the current paywall screen with a minimal version.
Show daily price, one sentence of value prop, single CTA.
Remove feature comparison table and testimonials.

## Why
Current paywall has too much information. Hypothesis:
less deliberation = higher conversion. Test against current.

## Measure
Paywall → purchase conversion rate over 5 days.

That's it. The developer takes this intent document, opens Claude Code, and starts building. The intent is the spec. Claude Code handles the translation from intent to implementation. The developer's job shifts from "write code that implements a spec" to "guide an AI to implement an intent, then verify the output."

What the developer actually does now

This is the part most people get wrong when they hear "we use AI to code." They imagine the developer pasting a prompt and hitting enter. That's not what happens. The developer's workflow with Claude Code looks more like this:

Phase 1: Context loading (10 min). Feed Claude Code the relevant codebase context, the intent document, and any constraints. "Here's our React Native paywall component. Here's the current design. Here's what I want instead. We use Stripe for payments. Don't break the existing payment flow."

Phase 2: Iterative refinement (1-3 hours). This is the core work. Claude Code produces a first version. The developer reviews it, not for syntax but for product logic. "This CTA is too low on the screen. The daily price calculation needs to account for regional pricing. Add the analytics event here." Each iteration takes 2-5 minutes. A typical feature goes through 8-15 iterations.

Phase 3: Edge cases and polish (30-60 min). The developer tests edge cases that Claude Code wouldn't think about. What happens when the user has no internet? What if they're on a trial that's already expired? What does this look like on a small iPhone SE screen? Claude Code fixes each one in minutes.

Phase 4: Ship (10 min). Push, deploy, monitor.

The developer's core skill shifted from "can you write this code" to "can you evaluate whether this code does the right thing for the user." That's a harder skill, not an easier one.

What we lost

Sprint planning had one genuine benefit: it forced the team to think about dependencies and sequencing. Without it, we initially had collisions — two people working on the same screen, one person's change breaking another's feature. We solved this with a simple shared document that lists "what I'm working on today" updated every morning. It takes 30 seconds per person. The coordination cost went from 2 hours of meetings to 2 minutes of async writing.

We also lost the shared understanding that comes from spec reviews. When everyone reads the spec, everyone knows what's being built. We replaced this with short screen recordings. When you ship something, record a 60-second Loom showing what changed and why. It's faster to produce than a spec and faster to consume.

The numbers

Before Claude Code: ~3 features shipped per 2-week sprint, per developer. After: ~12-15 features shipped per 2-week period, per developer. That's a 4-5x increase in throughput. But the more important number is the feedback cycle. We went from getting user feedback every 1-2 weeks to getting it every day. That compounds.

A team that runs 3 experiments per sprint and another that runs 12 will diverge exponentially within a few months. Not because the second team is smarter, but because they've had 4x the learning opportunities. Product development is a search problem, and cycle time is your search speed.

We're not going back to sprint planning. Not because it was bad — it was the right abstraction for a world where implementation was the bottleneck. Implementation isn't the bottleneck anymore. Judgment is. The ability to decide what to build, evaluate whether it works, and iterate quickly on what doesn't — that's the bottleneck now. And no planning ceremony helps with that.