Testing is critical, and testers are left out of planning
By Soumen Sarkar · October 2026
Problem. "Testing is critical, but the people who test are left out of planning and see the work last."
Testers see the work last because the plan lives in a developer's session, where they can't read it. Publish the plan before the work starts, let testers answer the agents' assumptions, and publish test results as pages anyone can open. Campfyrr does those three things; it doesn't run your tests.
What does a tester see today?
A finished change. The plan was made in a developer's Claude Code session, the agent made a dozen small calls while it built, and the first thing a tester can open is a pull request or a build. By then the questions a tester asks best, such as "what happens when the refund is partial?" or "what if the user is offline?", can only find bugs. They can't shape the work any more.
That isn't anyone's fault. The plan lives where only the developer and the agent can read it. A tester can't join a session, and nobody routes the agent's open questions to the person who thinks about what could go wrong.
Why does it matter more now?
Agents are the best collaborators a team has had: they turn a plan into working code in an afternoon. So the plan is the cheapest place left to change anything, and it doesn't stay open for long. A plan can go from idea to pull request before a tester has seen it.
Testers have long argued for coming in early. The Agile Alliance describes the Three Amigos practice as looking at each piece of work before, during and after development through business, development and testing views, with the testing view asking what could possibly happen. ISTQB's testing principles say the same thing as "early testing saves time and money": start testing as early as you can, so problems are found before they're costly to change (ASTQB, the seven testing principles). What changes with agents is the pace. The window where a tester can still shape the plan is hours, not weeks.
What do teams do about it?
- They share the plan in chat. It gets lost in a thread, and the next session never sees the tester's reply.
- They add a tester to the review. That helps, but it's still the end of the work.
- They write acceptance criteria up front. Good, when someone has time. The agent still makes calls the criteria didn't cover.
What works is three habits: the plan is visible before the work, the agent's open calls reach the tester, and the results come back as something anyone can read.
What does Campfyrr do, and what doesn't it do?
- Plans published before the work. A session publishes its plan as a page with a link, plain words first (how publishing works). The tester reads it and says what's missing while it's still cheap to change.
- Assumptions testers can answer. When something is unclear, the agent states an assumption and keeps going. It goes to whoever made the closest decision or last worked in that area. Anyone can pass it on to the tester, who keeps it, picks one of the likely answers, or corrects it from its own page. The agent reads the answer at its next turn (see what your agents assumed).
- What testers know, where agents read it. A tester adds context to a part of the product, such as "partial refunds break here", and every agent working there gets it in its brief.
- Test results as pages. A session publishes its test results with the point first ("all refund tests pass, including partial refunds"), then the detail. They appear on the project's Activity and in its "Where are we?" view.
What Campfyrr doesn't do: it doesn't run tests, it isn't a test management tool, and it doesn't replace your CI or your tracker. Your tests run where they run today. Campfyrr makes the plan, the calls and the results visible to the people who check the work.
Where do I start?
- Install Campfyrr for the team from /connect.
- Invite your testers. People who only read and answer are free (pricing).
- Ask each session to publish its plan before it starts building.
- Share the plan's link with a tester.
- Ask the session to publish test results when a change is risky.
For more on showing work to people who don't read code, see showing non-technical teammates the work. For the idea behind it, read let the work speak.
Everything on this problem
- For you: For QA and testers: getting into the loop at the plan, not the end: 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.
- Story: The tester who saw it last: When testers first see agent-built work as a finished build, they can only find bugs, not prevent them. Publish the plan before the work starts, send the agent's assumptions to the tester, and let them answer from a link while the plan is still cheap to change.
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).