For QA and testers: getting into the loop at the plan, not the end
By Soumen Sarkar · October 2026
For you. When agents build, a tester's best moment is the plan, not the pull request. With Campfyrr you read each plan from a link before the work starts, answer the calls agents make while they build, and share test results as pages anyone can open. It doesn't run your tests and it isn't a test management tool.
What does a tester's day look like right now?
The work arrives finished. A developer plans a change with Claude Code in the morning, the agent builds it by lunch, and the first thing you can open is a pull request, a preview build or a message saying "ready to test". The plan stayed in the developer's session. The small calls the agent made on the way, such as what happens on an empty list or a partial refund, are in the code, not anywhere you can read them.
So you do what testers do best, from the worst seat: you find the gaps after they're built. Each one goes back as a bug, the developer starts a new session, and the agent that made the call has already moved on. When nobody catches the gap, the review falls on support, sales or the customer instead (when review falls on the business).
None of this is anyone's fault. Agents are the best collaborators a team has had, and they build exactly what the plan says, fast. What breaks is that the person who asks "what could go wrong?" never sees the plan.
Why does the plan matter more now?
Because it's the cheapest place left to change anything, and it doesn't stay open for long. Testers have argued for coming in early for years. The Agile Alliance describes the Three Amigos as the business, development and testing perspectives looking at a piece of work before, during and after development. With agents, "before" can last an hour. If you aren't there in that hour, you're testing the result, not shaping it.
What changes for you with Campfyrr?
- You read the plan before the work. A session publishes its plan as a page with a link, the point first in plain words, then the detail (how publishing works). You open it, and you say what's missing while it's still a sentence to change, not a bug to file.
- You answer the agent's calls, not chase them. When something is unclear, the agent states an assumption and keeps building. Each assumption has its own page and link. If it's a testing question, it can be passed to you. You keep it, pick one of the likely answers, or correct it. Claude Code lets a hook add context before each prompt (Claude Code hooks), and Campfyrr uses that so the session reads your answer at its next turn. Nobody relays it.
- What you know reaches every agent. You add context to a part of the product from the project's "Where are we?" view, such as "exports break above a few thousand rows". The next agent working there is briefed on it before it changes anything.
- Your results are a page, not a paste. Ask a session to publish its test results, point first ("all checkout tests pass, two flaky on slow networks"), detail underneath. They show on the project's Activity, where the whole team sees them (showing the work).
What doesn't Campfyrr do?
Be clear about this before you try it:
- It doesn't run tests. Your tests run where they run today, in your CI, your test tools and your hands.
- It isn't a test management tool. It doesn't hold test cases, test runs or coverage reports.
- It doesn't replace your tracker. Bugs still go where your team files them.
- It has no audit logs yet. Don't use it as the sign-off record for a regulated release.
What it does is put the plan, the agents' calls and the results where you can read them, early enough to matter.
What are the first three things to try?
- Ask a developer to publish the plan for their next change. Read it and reply with one risk the plan doesn't cover.
- Open the project's assumptions. Answer one that touches testing, and check that the next change follows your answer.
- Add one thing you know about a fragile part of the product as context. Watch for it in the next agent's brief there.
If one of your answers turns out to be wrong, correct it the same way (when an assumption is wrong). The idea behind all of this is turn unknowns into calls: the agent doesn't stop to wait for you, and you don't have to be in the room for your answer to count.
What's free for testers?
Everything, right now: Campfyrr is free for everyone during early access. When paid plans start, teams pay for developers whose sessions connect. Anyone who only reads, comments or answers, which is most testers, stays free (pricing). A developer on your team installs it from /connect and invites you. For the wider problem and how teams handle it, read testers are left out of planning.
The problem this answers: Testing left out of planning: "Testing is critical, but the people who test are left out of planning and see the work last."
The principle behind this: Turn unknowns into calls: Nothing we don't know gets to stop us. We name our assumption, and we move.
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).