Standup in the Agentic Age

If your standup is still a tour of what everyone — or everyone's coding agent — did yesterday, you're doing it wrong.

That format made sense when yesterday's work was hard to reconstruct. It made sense when the ticket board was the shared memory of the team. It made sense when "progress" meant someone manually saying, out loud, what changed since the last time everyone got in a room.

That is not how our team works anymore.

At Ariso, standup is not a status-report ceremony. Ari already knows most of the work. So why restate the obvious?

"Yesterday I asked Claude Code to…"

I'm sure we've all heard this one by now, it's a waste of time. We do not spend standup walking through yesterday's tickets.

Ari's journal and meeting notes already capture what happened: what got discussed, what got shipped, what got blocked, what follow-ups were created, and what patterns are emerging across the team. If someone wants to know what happened yesterday, they should not need five engineers to recite it from memory over coffee.

The journal is the memory layer. Standup is the steering layer.

So the question is not: "What did you do yesterday?"

The question is: "What are we doing today, and what should Ari help move forward right now?"

Also, fewer people pretending to remember Jira ticket numbers is a mercy.

The PRs are the board

Things move fast enough that we rarely use a traditional ticketing system as the center of gravity. If it takes just as long to write the spec and hand it off to an agent to build, why add an extra middle layer just to feel organized?

Instead, our real work in progress is visible in open and draft PRs. Those PRs are both our backlog and our operating surface. They show what is actually being built, reviewed, stuck, or ready to merge.

A ticket can say anything. A PR has code attached. We are simple creatures. We like the one with code attached. The board is not the source of truth. The system is.

Catch it in the moment or lose it

The useful part of standup is not the talking. It is the action that follows.

Ari sits inside that loop.

During standup, we commonly notice tasks from support, product conversations, or live PR review. Instead of hoping someone remembers them later, we ask Ari to remind us. The reminder gets created in the moment, while the context is still fresh.

Example:

"Ari, remind me today to look into the verify node issue from the support ticket."

No archaeological dig through Slack later. No "wait, who had that?" No sticky note slowly dying on someone's desk.

Skip the ticket, ship the thing

The bigger shift is that some standup decisions do not become tasks for later. They become work immediately.

If we identify something small enough, Ari can call our enhance product flow and kick off a coding agent right there. The agent gets the prompt, creates the implementation path, and opens a PR.

That is the agentic standup pattern:

1. Identify the work.
2. Decide if it is small and bounded.
3. Ask Ari to start the implementation flow or hand it off to a human.
4. Let Ari keep track of the follow-up if it is not finished.

If we are not ready to build yet, Ari can still capture the follow-up in Slack and keep it from disappearing into the void. Miracles, etc.

What we actually do in the 15 minutes

Our standup is closer to an operating room than a status meeting.

The agenda looks roughly like this:

• Review any issues or bugs that cropped up yesterday and pass them to Ari or a human to resolve.
• Talk about what is happening today, since yesterday is already captured or knowable.
• Kick off agent-sized work when it is clearly bounded.

The purpose is not to perform productivity. The purpose is to create forward motion.

Why it's worth the rewire

Agentic standup gives us a few concrete advantages:

• Less repetition: yesterday's work is already captured by Ari.
• More accurate context: journals, meeting notes, PRs, and support threads are better memory than humans at 9:30 AM.
• Faster execution: small work can be started during the meeting instead of dumped into backlog purgatory.
• Cleaner accountability: reminders and follow-ups are captured as they appear.
• Better leverage: humans make judgment calls; agents handle bounded execution.

That last point matters. Standup should not be where humans become routers for stale information. It should be where humans apply judgment.

One question, every morning

A modern standup should answer one question:

Given everything Ari already knows, what do you want to inform the team of?

Not what happened yesterday. Not what the ticket says. Not whether everyone can successfully summarize their own calendar.

What should happen next?

That is the difference between a traditional standup with agents bolted on and a standup built for the agentic age.

If your coding agents are producing work, your standup should become more decisive, not more ceremonial.

If you are still spending the meeting asking what your agents did yesterday, congrats — you automated the wrong part.