Keep moving: work that never waits
By Soumen Sarkar · October 2026
The work never waits, and neither do we.
Why does a team that builds with agents need to keep moving?
Because at agent pace, waiting is the most expensive thing a team can do. When one engineer directs four agents and a small team lands dozens of changes before lunch, a wait doesn't pause one person. It pauses everything that was about to be built on top of them, while the code around them keeps changing.
Keep moving is the first of the seven VibeFlock principles, and the others mostly serve it. Its promise is simple: nobody stops the work to wait for anybody else. Not for an answer, not for a review slot, not for a teammate on the other side of the world to wake up. The work moves, and the context moves with it.
What does a wait really cost?
A wait costs far more than the minutes on the clock. An agent that stops to ask a question is holding a half-finished change. By the time the answer arrives an hour later, forty other changes have landed, and some of them touched the same files. The agent picks up again from a picture of the code that is no longer true.
So the real cost shows up later, as work done twice. The change has to be redone against the code as it is now. The person who answered was pulled out of their own work to do it. And the session, which was full of useful understanding, has gone cold.
Multiply that across a team where every person runs several agents, and the waits stack. One stalled session holds up the two that were going to build on it. A team can be busy all day and still spend much of it standing still.
What does keeping moving look like in a working day?
Take a scenario. A four-person team runs about a dozen agents between them, and this week they're shipping a pricing change: a new annual plan with a discount, shown on the pricing page and charged correctly at checkout.
Maya leads the work from London. Tomás owns billing and starts his day in Lisbon. Priya builds the front end from Bengaluru, hours ahead of everyone. Sam, the tech lead, is in San Francisco and asleep for most of Priya's day.
Priya starts first. Her agent is building the plan picker on the pricing page, and it needs to know how the annual price should read: a monthly figure "billed yearly", or the full yearly total. Nobody who knows is awake. The agent doesn't stop. It checks what the team has already written, finds a decision from last month that prices are always shown per month, and builds to it.
A second agent of Priya's starts on the checkout summary. The first time it opens the billing code, it learns that Tomás has work in progress there: annual plans are being added to how prices are stored, with a plan and an expected finish by midday his time. It builds the summary against that plan, instead of guessing or waiting for him to sign in.
Tomás arrives to a short list rather than a queue of stalled sessions. One of Priya's agents assumed that annual discounts round to the nearest whole unit of currency. He confirms it with a click, and the agent hears it on its next turn. Another assumed that tax is shown separately on the annual total. That one is wrong, so he corrects it in a sentence, and the agent adjusts the moment it hears.
By the time Sam wakes up, the plan picker, the checkout summary and the billing change have all moved. He reads what landed and why, and starts his own agents from where everyone else stopped. At no point did anyone's work sit still, waiting for someone else to be awake.
What do people do?
People keep moving, and trust their teammates to keep moving too. In practice that comes down to a few habits:
- Say what you're doing before you're done. A goal and a plan, written when the work starts, let others build on it hours before it lands.
- Make the calls that are yours to make. If the decision sits in your area, decide it and say why in a sentence.
- Answer from where you are. When an assumption reaches you, confirm it or correct it. It doesn't need a meeting.
- Leave your work ready. When you stop, say what's done, what's left and what to watch out for.
None of these needs a tool. They're the practice. A tool can make them happen without anyone having to remember.
What do agents do?
An agent finishes what it can with what it knows, and leaves the rest ready for whoever comes next. Concretely:
- It looks at what the team already knows before it changes anything.
- When something is unclear, it states its assumption and keeps going instead of stopping to ask.
- It builds on unfinished work by its plan, rather than waiting for that work to land.
- When its session ends, it leaves a handoff that someone else can pick up without asking.
Doesn't keeping moving mean working blind?
No, and that's the heart of the principle. Moving without context is just guessing quickly. The commitment is that the work moves and the context moves with it. An agent that charges ahead without checking what's changing around it isn't keeping moving. It's creating the rework that stops everyone else.
It also doesn't mean nothing ever gets a second look. Some calls are high stakes: money, data, access, public interfaces, deleting things. Those still get a person's attention, and they get it first. What changes is that the agent doesn't sit idle while it waits. It names the assumption, carries on with the work around it, and adjusts if the answer comes back different.
And it isn't speed for its own sake. A team that keeps moving is measured in less waiting time, less rework and faster pick-up, not in how many changes it ships. If moving faster produces more work done twice, the context isn't travelling with the work yet.
How does Campfyrr make it hold?
Campfyrr brings the context to the work at the moment it's needed, so nobody has to go and fetch it. In Claude Code, hooks do this without anyone remembering:
- When a session starts, it gets a brief of what changed since the last one, with its own unfinished work and any handoffs to it at the top.
- 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 to follow, what changed this week, what was tried and dropped, and the open assumptions.
- Each turn, it hears answers and corrections to its assumptions, and news of work it built on that has landed.
- When it stops, a handoff is written from the session.
Codex, Cursor and other MCP clients call the same tools, such as state_assumption, wait_on and hand_off, following the instructions the server gives them. People see one Activity page per project: a feed of what happened and why it matters, with a weekly card at the top of what Campfyrr caught.
What does a team gain?
A team that keeps moving spends its day building, not waiting to build. The context arrives with the work, unknowns become calls, and the person who knows the answer gives it from wherever they are, whenever they're awake.
That is the first promise of VibeFlock. The work never waits, and neither do we.
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).