Answer it yourself: look first, then decide
By Soumen Sarkar · October 2026
Look first. If the answer isn't there, assume it or decide it.
What does "answer it yourself" mean?
Answer it yourself means that before you ask anyone anything, you look for the answer where the team has already written it down. If it isn't there, you state an assumption, or you make the call that is yours to make. The question still gets settled. It just doesn't wait on someone else's calendar to get settled.
That's the principle in two sentences. This essay is about why it matters so much when agents do most of the typing, what it looks like across a working day, and where it stops.
Why does it matter at agent pace?
Because a question is a wait, and at agent pace no wait is small. One person directing four agents can see each of them hit a dozen small unknowns an hour. If every unknown became a message to a teammate, that teammate's day would be nothing but answering, and the agents would spend most of theirs idle.
The cost isn't only time. An agent that stops to ask loses its momentum. A teammate pulled out of their own work to answer loses theirs. And an answer given in a chat thread is usually gone by the next session, so a different agent asks the same thing tomorrow.
Most of these questions already have answers. Someone decided how money is stored last week. Someone tried a caching approach in the search code and dropped it, with a reason. Someone set a rule that public interfaces never change without a new version. The answer exists. It just isn't where the asker is looking. So the first move is to look, and the team's job is to make looking cheap enough that it always comes first.
What does it look like in a working day?
Here's a scenario, to make it concrete. Picture a four-person team building a subscription product, each person running two or three agents. It's mid-morning. Priya has asked one of her Claude Code sessions to add annual plans to the billing code, an area the team calls "Billing · lib/billing".
The agent has three questions before it writes a line.
Should annual prices be stored as a yearly total, or as a monthly price times twelve? It doesn't ask Priya. It looks. The team's record holds a decision from eight days ago, made by Tom while he was adding coupons: prices are stored as whole cents for the exact amount charged, never derived. So the agent stores the yearly total in cents and moves on. Nobody was interrupted, and the answer it used is one the team had already agreed.
Should an upgrade from monthly to annual be prorated? The record is silent. Nobody has decided it. So the agent states its assumption in one line: "Assuming upgrades are prorated to the day, because the existing plan-change code already does that." Then it keeps building on it. This isn't guessing in silence. The assumption is written where someone who knows can see it and set it right.
Should the annual plan carry a "two months free" label? That's a product call, and on this team Priya owns how prices are presented. So the agent leaves the label out, notes the open call in its plan, and keeps going. At her next turn Priya reads it and says, "No label for now, we're testing the page without one." That sentence, with its reason, goes into the record as a decision.
Three questions. One answered from the record, one turned into a stated assumption, one decided by the person whose call it was. Nothing waited. By lunch the annual plans are in review, and Tom, who made the closest decision in that area, has confirmed the prorating assumption with a single click.
What do people do?
People do two things: they look first, and they decide what's theirs to decide.
Looking first is a habit, and it lives or dies on where the team's knowledge is kept. Decisions with their reasons, rules, handoffs, approaches tried and dropped: if they're scattered across chat threads, looking is expensive and people stop doing it. If they're kept in one place every person and agent can search, looking takes seconds.
Deciding what's yours is the harder habit. Most people know their own area better than anyone else on the team. When a question falls inside it, the right move is to make the call and say why in a sentence, not to gather opinions. You never need to ask permission to make a call that's yours to make.
What do agents do?
Agents follow the same order, and they can follow it more reliably than people do. Before anything else, an agent searches the team's record. If it finds a decision, it follows it. If it finds a rule, it keeps it. If it finds a handoff in the area it's about to touch, it picks up from there instead of starting over.
When the record is silent, the agent doesn't stop. It states the assumption it's working on, plainly, and keeps going. A team can put this in its agent instructions in two lines: search the record first; if nothing answers it, state your assumption and continue. The team agent instructions template has a version to copy, and how agents search what the team already decided goes into the searching itself.
Isn't this just working alone?
No, and this is the objection worth taking seriously. Answer it yourself is not a rule against talking to people. It's a rule against spending their time when you don't need to.
The answer still comes from the team. When Priya's agent used Tom's decision about cents, it was building on Tom's work, more faithfully than if it had asked Priya, who might have remembered it differently. When it stated its assumption about prorating, the assumption went to the person most likely to know. The team was involved at every step. It just wasn't made to wait.
There are limits, and they're worth naming:
- Some calls aren't yours. An agent changing how customer data is deleted should not settle that on its own. It states the assumption, marks the stakes as high, and the right person sees it first. The work can continue, but the decision belongs to someone else.
- The record can be out of date. A decision from months ago might not hold anymore. Looking first means reading what you find with judgement, not obeying it blindly.
- Some questions are conversations. Whether to build a feature at all, or how two parts of the product should fit together, deserves people talking. Answer it yourself handles the hundred small questions a day, so there's room for the few big ones.
How does Campfyrr make it hold?
Campfyrr makes looking first the default, rather than a habit people have to keep.
In Claude Code, hooks bring the answers before an agent would think to ask. Each session starts with a brief of the team's state since its last one. The first time a session reads or edits a part of the code, it gets an area brief: what's being changed there right now and by whom, the decisions made there, what changed this week, approaches tried and dropped, and open assumptions. Decisions that are recent or still in use come first; one nobody has relied on for four months is shown with "check it still holds".
Any connected agent, Codex and Cursor included, can search what the team wrote with search_memory and recall. When an agent calls state_assumption and the team record already answers it, the answer comes straight back. When it doesn't, the assumption goes to whoever made the closest decision or last worked in that area. It shows in the Activity feed with an "Answer it" link to its own page, with one-click answers: "Right, keep going", the likely answers, or "Correct it…". The agent keeps going either way, and a correction reaches it at its next turn.
Each week, Activity shows how many questions were answered from the record, and how many assumptions were stated instead of stopping to ask. That's the measure of this principle: more answers found, fewer people interrupted, nobody waiting on either.
What changes when a team works this way?
Questions stop being interruptions. The team's knowledge gets used instead of rediscovered. And the people on the team get their attention back for the calls that truly need them.
Answer it yourself is a small discipline with a large effect. Look first, then decide. It's how a team respects each other's time at a pace where time is the scarcest thing it has.
Questions this answers
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).