For agencies building with Claude Code for clients
By Soumen Sarkar · October 2026
For you. When an agency builds with Claude Code, the client often sees the work for the first time at delivery, and their feedback comes back by email a week later. With Campfyrr the client joins the project's team for free, reads the plan and sample outputs before you deliver, and answers the agents' assumptions from a link. It doesn't replace your contract, tracker or client portal.
What does an agency lead's week look like right now?
Your developers build in an afternoon what the statement of work gave two weeks. That's good news, and it moves the hard part. The client still sees the work at the demo or the delivery call. That is the first time anyone who knows their business checks it, so the review falls on them (when review falls on the business).
Then the feedback arrives the slow way. A long email, comments in a slide deck, a call where someone says "that's not how our refunds work". You translate it into a prompt for the next session. Claude Code's own docs say each session "begins with a fresh context window", so anything the client said that you didn't pass on is gone by the next change.
You become the router between the client and the agents. Agents are the best collaborators an agency has had: they build exactly what the brief says, fast. What breaks is the path between the person who knows the business and the work.
What changes with Campfyrr?
- The client reads the plan before you build. A session publishes its plan as a page with its own link (publishing plans and results). The page starts with the point in plain words. The client says "that's not how our refunds work" while it's still a sentence, not a delivered feature.
- The client judges a sample, not a diff. Ask the session to publish a sample output: an example email, an export, a screen. A client can judge that in a minute. Test results can be published the same way when a change touches money or their customers (showing the work).
- The client answers the agents directly. When an agent isn't sure, it states an assumption and keeps building. Each assumption has its own page. If it's a business call, send the link to the client. They confirm or correct it, and the session reads the answer at its next turn (feedback that reaches the agent).
- What the client says stays with the work. Their words can be recorded against the part of the product they affect. Before an agent changes that part, its area brief lists them. The next session doesn't depend on you remembering the call.
This is the idea in the Agile Manifesto's line "customer collaboration over contract negotiation" (agilemanifesto.org), at the speed agents build.
How does a client see the pages?
Be exact about this with your client. A team's pages open only for people signed in to that team. Pages don't go to strangers from a link, so a client's plans never leak to another client. To show the client the work, invite them to the team by email. People who only read and answer are free (pricing).
Everyone on a team sees that team's record. So give each client its own Campfyrr team, and use a team token for that client's work only. You switch between teams from the account menu.
What doesn't Campfyrr do?
- It isn't a client portal. It has no invoices, sign-off steps or contract scope.
- It doesn't replace your tracker or CI. Tickets, milestones and builds stay where they are today.
- It doesn't run tests. A session publishes test results when you ask it to.
- It has no audit logs yet. Don't use it as the record of what a client approved. Keep approvals in writing, where your contract says.
- Pages hold what the session publishes. Keep tokens and other clients' data out of them.
What are the first three things to try?
- Create a team for one client, and install Campfyrr from /connect.
- Invite the client's product owner by email.
- Ask the next session to publish its plan before it builds. Send the client the link.
Then, the next time an agent states an assumption about the client's business, send that link too. For how people outside engineering follow the work day to day, read following agent work from outside engineering.
What's free?
Everything, right now: Campfyrr is free for everyone during early access. When paid plans start, teams pay for developers. Your clients, who only read and answer, stay free.
The problem this answers: Review falls on the business: "Building is so easy that reviewing the output has fallen on our customers and business teams."
The principle behind this: Let the work speak: Our work explains itself, so nobody ever has to come and ask us.
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).