Stop Asking Humans for Status Updates — In the AI Era, People Should Only Report the Future

“What I did yesterday, what I’ll do today, and what’s blocking me.” That’s the three-part chant of the daily standup, long recited in Scrum. Countless teams run their morning sync on this template, write weekly status documents, and assemble monthly slides listing what got done. Over my years in engineering management, I’ve received this kind of report more times than I can count, and asked for it just as often.

Lately, though, I’ve started to pause and reconsider. Of everything in these reports, the parts about the past and the present, do humans even need to say them out loud anymore? Commit history, pull requests, CI results, observability dashboards. “What happened” and “where things stand” already exist as artifacts in a machine-readable form, and an AI agent will summarize them on demand. Having a human spend time re-reporting the same thing is edging toward duplicated effort.

This post is an essay, written from the seat of a CTO at a fully remote organization, that takes apart the ritual of the status update. After establishing why information about the past and present has migrated to the machine side, I propose that the information only humans can hold lives on the side of the future, and I work through how to redesign meetings and reviews around it. First, here is the line of reasoning this article follows, laid out as a single flowchart.

flowchart TD
    Start["Information you want to report"] --> Q{"Is it past / present\nor future?"}
    Q -->|"Past / present\nwhat happened / where things stand"| Artifact["A trace is left in artifacts\ncommits, PRs, CI, observability"]
    Artifact --> Readable["Machine-readable state"]
    Readable --> Agent["Ask an AI agent and\nget a summary at any granularity"]
    Agent --> NoHuman["No need for a human to re-report it"]
    Q -->|"Future\nintent, judgment, concerns"| Head["Written nowhere yet\nlives only in the person's head"]
    Head --> OnlyHuman["Information only a human can hold"]
    OnlyHuman --> Meeting["Draw it out in meetings and reviews\nstandups / 1-on-1s / code reviews"]

What the Status-Update Ritual Assumed

Why did we report progress in the first place? The answer is simple: the information lived only in people’s heads. Who had gotten how far on what could only be learned by asking them. So we gathered on a schedule, shared verbally in turn, and the manager bundled it all into a picture of the whole. The ritual rested on an assumption: that information was scarce, and locked inside a single source, the person themselves.

Under that assumption, the report itself carried real value. Without it, a manager couldn’t get the raw material for decisions. Team members, not knowing what the others were doing, would duplicate work or miss dependencies. So saying “what I did yesterday” served a substantive purpose: closing an information asymmetry.

But that assumption has quietly collapsed over the past few years. Nearly every act of development now leaves a digital trace, as a Git commit, a GitHub pull request, a Linear or Jira ticket, a CI/CD pipeline run, and a production metric. Work is recorded somewhere the moment it’s done. The information no longer lives in heads alone. And yet the reporting ritual persists out of inertia, long after its premise changed. That’s the source of the unease.

The Past and Present Are Already Machine-Readable

Let me get more concrete. In software development, past and present progress is etched into artifacts with surprising completeness.

Past changes: what changed and when is all preserved in commit history and pull requests. Diffs, review threads, and merge timing can be traced in chronological order
Current state: whether CI is green, which branch has gotten how far, what status a ticket is in, all of it is visible on a dashboard
Operational reality: what’s happening in production streams continuously into observability platforms like Datadog or Grafana as latency, error rate, and throughput
Outcome trends: DORA metrics such as deploy frequency and change lead time assemble themselves automatically from these traces

What these share is that the facts are already there, without anyone re-reporting them. In fact, the records are often more accurate than spoken reports. Human memory is fuzzy, conveniently edited, and rounded off into “pretty much on track.” A commit log, by contrast, doesn’t lie. Increasingly, if you want to know “where things stand,” going to look at the artifacts is faster and more accurate than asking the person.

AI Agents Take Over the “Just Ask and You’ll Know” Layer

That said, artifacts being machine-readable is a different thing from being usable by a human. It isn’t realistic for a manager to eyeball hundreds of commits and dozens of dashboards one by one every morning. Until recently, even though the traces existed, the cost of bundling them into something a human could read was so high that the verbal report was cheaper after all.

AI agents are closing that last gap. Connect an agent like Claude Code or Codex to your repositories, issue trackers, and observability platforms over the Model Context Protocol (MCP), and it will answer questions like “summarize the changes this team merged last week in three lines, riskiest first” or “tell me the correlation between the services currently alerting and recent deploys,” reaching across the artifacts to do it. Summarizing scattered traces at whatever granularity you need, on the spot, is precisely the job that human status reports used to do.

In other words, the “just ask and you’ll know” layer of progress reporting can now be handed off wholesale to an agent. Instead of borrowing a team member’s time to recite the past, a manager can put the question to an agent and grasp the current state faster, more accurately, and without interrupting anyone’s work. The cost-benefit of gathering people together to share the past and present is shifting at the root.

I want to stress that this isn’t an argument for more surveillance. If anything, the opposite: it’s about reducing the burden on the person who keeps getting pulled away to report. Instead of stopping work to explain every time someone asks “how’s it going?”, let the artifacts speak. If an agent does the summarizing, both the reporter and the recipient get that time back for something else.

The Information Only Humans Hold Is the Future

So what is the information that neither the artifacts nor the agent can stand in for, the information only a human can hold? My answer is that it lives on the side of the future.

The past and present are, by definition, things that have already happened or are happening now. That’s why they leave traces. The future, by contrast, is written nowhere yet. What someone is about to attempt, why they’ll do it in that order, what concerns they feel, what they’ve decided to cut. This “intent and judgment not yet turned into an artifact” exists only inside the person’s head. A commit comes into being only after it’s written, but the reason someone decided to write it is held by that person alone, before a single line exists.

Concretely, this is the kind of information that sits on the future side.

Intent and direction: the aim of a change about to be started, a concept that isn’t a line of code yet
Judgment and trade-offs: why choose B over A, what to prioritize, what to defer this time
Hunches and concerns: “this design will probably bite us right here later,” a danger signal before it’s even been articulated
Dependencies and coordination: how one’s next move might collide with someone else’s, which agreements to lock in first
Shifting priorities: the intent to re-sequence the original plan because the situation changed

None of these surface in the artifacts on their own. Left alone, they stay unshared forever while the code piles up as a fait accompli. Spending human time on reporting the past means having a person do what a machine can do. Asking someone to tell you the future, by contrast, is asking a person to do the one thing only a person can. What management should really be drawing out is the latter.

So Redesign Meetings and Reviews Around the Future

Accept this view and the design of how you run a team changes on its own. The gist is a re-sort: strip past-reporting out of the moments when people gather, and keep only the sharing of the future.

The daily standup is a textbook candidate for this. “What I did yesterday” can be learned by asking an agent, so there’s no need to share it out loud. What’s worth keeping is only the forward-looking side: “what am I about to do today,” “am I likely to collide with anyone along the way,” “where might I get stuck.” Turn a meeting for checking answers about the past into a meeting for aligning on the future. The same 15 minutes yields information of an entirely different quality.

The one-on-one is the same. The time spent retracing “last month’s output” can be left to the artifacts and the agent. In its place, ask what the person wants to take on next, what career direction they’re picturing, what they’d like to change about their current role. These are future information, and they will never emerge unless you ask. A manager’s scarce time should be invested in the future only the person can speak to, not the past a machine can answer.

The same idea applies to code review. What a diff does can be learned by reading the code and the agent’s explanation. What’s genuinely worth drawing out in review is the intent and outlook that don’t show up in the diff: “why this design,” “what other options did you rule out,” “where do you expect to extend this later.” In an organization that is fully remote and async by default, this norm of “writing down the future and the intent” is the team’s backbone. Leave the written past to the artifacts; have humans articulate the unwritten future. The division of labor splits cleanly right here.

Pitfalls — The Future Becomes the Past, and Intent Fades If You Let It

It’s a tidy picture, but taking it too literally will trip you up, so let me be honest about the pitfalls.

First, the future goes stale the moment it’s spoken and eventually becomes the past. The intent you shared today as “here’s what I’m going to do” starts getting implemented tomorrow and leaves a trace as an artifact next week. So “just report the future” only works when it’s paired with the ongoing practice of putting intent out there each time. Don’t treat it as a one-off plan share; update it whenever the direction changes. Neglect this and you slide right back to the usual state where the artifacts and the heads have drifted apart.

Second, the reasons behind intent and judgment, the why, fade fast inside a person’s head if left alone. “Why this design” is vivid right after the decision, but three months on even the author can’t recall it. That’s exactly why intent voiced as the future is worth transcribing to the artifact side, on the spot, as much as possible. Record decisions in something like an Architecture Decision Record and today’s future becomes, by tomorrow, a machine-readable past, an asset the agent can read too. Speaking the future and sinking it into a trace are not in conflict.

Third, not all of the past is covered by an agent. First-hand information that never fully lands in an artifact still exists, the raw chain of judgment during an incident, or the feel you get from a conversation with a customer. Apply “leave the past to the machine” too mechanically and you’ll drop this tacit knowledge. Of the past, send what leaves a trace to the machine, and have humans deliberately articulate what doesn’t. Not being sloppy about that line is what matters.

Conclusion

Here is what I’ve worked through about status updates in the AI era, in three points.

The past and present are already machine-readable: the facts are etched into commits, PRs, CI, and observability, and an AI agent returns a summary on demand. The cost-benefit of a human re-reporting them verbally has dropped
The information only humans hold is the future: what someone is about to do and why, what concerns they carry. Intent and judgment not yet turned into an artifact won’t emerge unless you ask
Redesign meetings and reviews around the future: strip past-reporting out of standups, one-on-ones, and reviews, keeping only alignment on the future, but transcribe the spoken future into artifacts each time

Having a person recite “what I did yesterday” is becoming an act of asking a human to do what a machine can. Human time, the scarcest resource, should be spent on the questions a machine can’t answer. Leave the past and present to the agent, and tell me, from the human side, only the future. Betting on this division of labor is, I think, one starting point for designing a team around AI.

That’s a reflection, from the seat of a CTO at a fully remote organization, on what a status update means in the AI era, sent from the field.