Your Sprint Planning Meeting Is Already Dead. You Just Haven’t Noticed.
I’ve been watching software teams work for years, and here’s what I keep coming back to: we spent two decades perfecting a system for managing human coders, and now the coders are increasingly not human.
This should terrify anyone whose job title includes the word “process.”
The uncomfortable math
At Cursor, autonomous cloud agents now generate roughly 35% of merged pull requests. Not suggested code. Not autocomplete. Merged, shipped PRs. Some engineering teams report that their humans write zero lines of code, spending their days instead directing agents, reviewing outputs, and arguing about specs.
Let that sit for a second. If a third of your production code is written by machines that don’t attend standup, what exactly is your Scrum Master doing?
I’m not trying to be glib. (Okay, maybe a little.) But there’s a real question here that most organizations are dancing around: the entire scaffolding of modern software project management, the sprints, the story points, the velocity charts, the retros, was built for a world where writing code was slow and humans were the bottleneck. That world is ending.
What’s actually changing
The shift isn’t just “AI writes code faster.” It’s deeper and weirder than that.
Engineers are turning into something closer to product owners. When you can spin up 16 parallel agents in isolated environments and have an AI orchestrator handle conflicts, you’re not really “coding” anymore. You’re speccing, prioritizing, reviewing, and deciding. That used to require a PM, an engineering manager, and three junior devs. Now one person does it before lunch.
PMs, meanwhile, are splitting into strange new subspecies. Some become “Agent Supervisors,” monitoring fleets of AI workers and their KPIs (hallucination rates under 2%, agent acceptance rates, cycle time). Others drift toward governance, figuring out when a human needs to step in and what “done” means when your QA agent says everything’s fine but nobody actually looked at it.
Teams shrink. The old “two-pizza team” of 6 to 10 people compresses to 3 or 4, or even one person who owns an entire product lifecycle with AI filling every gap. There’s something exhilarating and something lonely about that.
The ceremony graveyard
Here’s where I get opinionated. Agile’s principles, the actual values in the manifesto about individuals, working software, and responding to change, those hold up fine. Maybe better than ever, actually. But the practices? The rituals we layered on top?
Sprint planning when agents can execute a full feature in hours instead of days is like scheduling a weekly meeting to discuss what your dishwasher should wash. The dishwasher doesn’t care about your two-week cadence.
Story points were always a bit of a fiction. Now they’re complete theater. How do you estimate effort when the “effort” is writing a good prompt and reviewing the output? The variance between tasks collapses. Everything is either “trivial for the agent” or “the agent can’t do this and a human needs to think hard.”
Daily standups where half the work was done by machines that don’t have feelings or blockers. Retros where the main takeaway is “the agent hallucinated again, we should add a guardrail.” Velocity charts that spike to infinity because 16 agents ran overnight.
None of these ceremonies are designed for this.
What’s filling the vacuum
The honest answer is: nobody knows yet. But some patterns are forming.
What people are calling “Agentic Flow” is basically Kanban without the board. Agents pull tasks continuously. There’s no sprint boundary. There’s no standup. There’s a stream of work flowing through, and humans intervene when something looks wrong or needs a decision. The focus shifts from “are we on track for the sprint?” to “are the agents producing value and not breaking things?”
Some teams are building what amounts to persistent memory systems for their AI collaborators. Because here’s the thing nobody talks about enough: AI agents are stateless. They don’t remember what happened yesterday. Every session starts from zero. So teams are creating git-versioned markdown files, things like learnings.md and decisions.md, that serve as the project’s institutional memory. It’s an odd inversion. We used to rely on humans to remember context and wrote documentation grudgingly. Now we write documentation obsessively because the AI literally can’t function without it.
The most interesting experiments I’ve seen involve solo developers or tiny teams running what amounts to their own AI project management layer. Three commands to start a session, end a session, and groom the backlog. Auto-generated plans with confidence intervals. Built-in retrospectives that actually feed back into how the agents work. It’s lightweight to the point of being invisible, which is probably the right direction.
What worries me
I’d be lying if I said I was purely optimistic.
The “apprenticeship gap” is real. Mid-level engineering tasks, the ones where junior developers used to learn their craft, are exactly the tasks agents handle best. If nobody writes those CRUD endpoints by hand anymore, how does the next generation learn to think about software? We might be building a system that produces brilliant orchestrators who can’t debug a null pointer exception.
There’s also the amplification problem. Good organizations will get faster. Dysfunctional ones will get more dysfunctional, faster. If your team already ships buggy code without tests, giving them agents that produce code 5x faster just means 5x more buggy, untested code. And 5x more incidents. AI accelerates whatever you already are.
Over-trust is the quiet killer. I’ve caught myself waving through agent-generated PRs because “it passed CI” and the diff looked reasonable. That’s the same mistake we make with any tool that works well 95% of the time. The 5% is where the damage happens, and it’s exactly where your attention has drifted.
Where this actually lands
My best guess for the next couple of years: most teams will settle into something messy and hybrid. Sprints won’t disappear overnight, because organizations have inertia and middle management needs something to put on a slide. But the teams that actually ship will increasingly operate in continuous flow, with humans doing strategy, specification, review, and the occasional hard problem that agents can’t crack.
The PM role survives but barely resembles its current form. More governance, more agent supervision, less Jira grooming. The engineering role survives but looks more like “agentic engineering,” where the core skill is translating business intent into precise enough specs that machines can execute without going off the rails.
Traditional Agile isn’t dead. It’s being hollowed out from the inside. The shell stays. The meetings continue. But the actual work happens in a parallel stream that those ceremonies were never designed to manage.
The winners won’t be the teams with the best process. They’ll be the ones with the clearest intent. Because when code is nearly free, the only bottleneck left is knowing what you actually want to build, and having the judgment to know when the machines got it wrong.
That’s a harder skill than it sounds. And no framework is going to teach it to you.
