I had a call at noon yesterday. Technical, with somebody I needed to not look sloppy in front of. The conversation was going to hinge on what was actually live in Freebo right then — not what I had been working on, not what was in a branch, not what I thought I had shipped last week. What the current URL would do if the person on the other end hit it.
At 12:14 I opened Claude Code in the Freebo repo. By 12:20 I closed it. The session was six messages. I walked into the call forty minutes later knowing exactly what I was walking into.
That shape — short, bounded, briefing-not-building — is now at least half of how I use the agent. And it took me a long time to notice it was happening.
The shape I thought I was using
For about a year I used Claude Code the way you probably use it: as a builder. Give it a task, fan out a worktree, watch it edit files, run the tests, come back and review. The unit of work was a feature. The session lived as long as the feature did. Some of mine stayed open for days.
That is still what it is best at for actually shipping code. But it is the loud half. The quiet half, the half I kept doing without realizing, is this:
Where is main at?
Compare the latest commit on main to what's deployed to prod.
I'm about to walk into a call and I need to know what the person
on the other end would actually see if they used the app right now.
Group by: user-visible features (new flows, endpoints, pages),
anything shipped in the last week that might still have rough edges,
and anything half-shipped — code merged but behind a flag, or
depending on a migration not yet run in prod.
That is not a build prompt. There is no file being edited. No code is being written. The question is “what is the state of the world”, and the answer is a paragraph I read once and then close the window.

Three kinds of briefings I run now
Once I started paying attention, I noticed the pattern was not one prompt — it was a family. They all look like each other. Short, targeted, closed as soon as the answer lands.
State-of-the-world before a call. The one above. Twenty minutes before a meeting, I ask the agent to tell me what is live, what landed recently, and what is pending. It beats my own memory every time. My memory knows what I worked on. It does not know what shipped.
State-of-the-conversation before a reply. Before I answer a long thread, I’ll point Claude at the thread and ask it to summarize what I said last, what the other person said last, and what the open thread is. That takes ninety seconds and it stops me from replying to a message that is three replies stale.
State-of-the-task before I pick it up. When I come back to a feature after a weekend, I ask the agent to diff the branch against main, read the last few commits, and remind me what I was doing. It is cheaper than scrolling my own commit messages and it never editorializes about whether I was being clever.
None of these generate code. None of them do anything irreversible. All three save me from the specific failure mode of a solo founder: walking into a thing without being current on it.
If the question I am about to ask the agent would be answered by a human chief of staff instead of a human engineer, that is a briefing session, not a build session. It should be short, it should close, and it should not leave the room any different than it entered.
— the rule
Why this is different than a “quick prompt”
I want to be careful here, because this is not “oh just use Claude for small questions, cool.” Lots of people do that. I did that. It is not the same thing.
A quick prompt is generative — “write me a bash one-liner”, “summarize this docs page”, “what does this regex mean.” The answer is produced from training data and the context I pasted. That is useful. It is not what I am describing.
A briefing session is investigative. The agent has to actually go look. Open the deployment history. Diff two SHAs. Read the ten commits since. Open the feature flag config file. Check the migration directory. Then come back and tell me the state of the world right now, not the state of the world from training.
The move is the same as the one I made for deploys. I stopped trying to hold the state of the repo in my head. I let the agent be the thing that walks around, looks at files, and tells me what it saw.
Why six messages, not sixty
The shape I was missing for a long time is that these sessions should end. On purpose. Fast.
A build session gets long because you iterate. You run the tests, something breaks, the agent fixes it, you run them again. That is correct behavior for building.
A briefing session has no loop. You ask, the agent investigates, the agent answers, you read the answer, you close the window. The reason to close the window is that if you leave it open you start treating it like a conversation, and the next thing you ask is a build task, and now the context is poisoned with the briefing prompt and your build task gets worse at its job.
So I close it. Six messages is not a rule, but when I look at the recent ones they hover there. Four to ten. The ceiling is “I have my answer.” Anything after that is me being clingy.
The thing I would not have known otherwise
Yesterday’s call went fine. Nothing I would have been embarrassed by came up. The thing is, I would not know whether anything embarrassing was lurking if I had not asked. The whole value of the briefing is that most of the time it tells you nothing is on fire — and that “nothing is on fire” is itself information, confidently held, five minutes before you need it.
I don’t know what fraction of my next year of Claude Code sessions will be building versus briefing. I used to think the answer was 100/0. It turns out it is closer to 60/40, and the 40 is almost invisible from the outside, because it doesn’t leave any artifacts.
That is the giveaway, actually. If the session leaves no commits, no files, no diffs — only a decision I made differently than I would have — I was probably being briefed, not building. Those are the sessions nobody writes about, because they produce nothing to point at. But they might be the ones paying for the subscription.