The short version
- User acceptance testing means the people who will use the software try it on realistic tasks before launch and say whether it is good enough.
- An AI agent can run tests and check its own work, but only you know what 'right' means for your business, so the final yes belongs to a person.
- Write the acceptance criteria before the work starts, as plain 'when I do this, I should see that' sentences.
- Test on a staging copy with made-up data, ask for evidence rather than 'it works', and sort every problem into blocker or can-wait.
- A good test round does not find zero problems; it leaves you knowing exactly what risk remains when you say go.
On this page
If an AI coding agent builds your feature, who decides it is actually right? You do, through user acceptance testing (UAT): the people who will use the software try it on real tasks before launch, and then say yes or no. The agent can test its own work, but it cannot know what "right" means for your customers.
This guide explains UAT in plain words, what to prepare, how to run a round in an afternoon, and how to sign off without guessing.
What is user acceptance testing?
User acceptance testing is the last stage of testing before launch. Marker.io's guide describes it as real users or stakeholders checking that the product works in real-world conditions and meets the business requirements. It happens after the team's own internal quality checks, when the product is stable enough to judge.
The key idea is who does it. Engineers, or in your case AI engineers, test whether the software works as built. UAT asks a different question: is this what we actually needed? A booking form can work perfectly and still ask for the wrong things in the wrong order.
You, a product owner, an analyst or a real customer representative are the right people. Testers can organise the round, but the final validation comes from the people the software is for.
Why does AI-built software still need it?
AI agents are good at checking what they can measure. Anthropic's Claude Code best practices say that when Claude reports it is done and it is not quite, the usual cause is that it had no way to check its own work. Give it a pass-or-fail check, such as a test, and it can find and fix its own mistakes without you watching.
That solves one problem and leaves another. A test checks the thing someone thought to test. It cannot check the thing nobody wrote down, such as:
- The refund rule your finance lead assumes but never mentioned.
- The word your customers use for "invoice", which is not the word in the code.
- The step that is technically correct but takes a nervous first-time user five confusing clicks.
An agent can only be checked against what you tell it. A person who approves the result, rather than glancing at the agent's own summary, is the safer final step. UAT is that person doing the job properly.
How do I run user acceptance testing without writing code?
You need no technical skill, only a clear head and a little preparation. Here is a simple routine.
1. Write the acceptance criteria first
Acceptance criteria are the plain statements that define "done" for a feature. A common format is: given a situation, when I do something, then I should see a result. For example:
- Given I am a customer with an unpaid invoice, when I click Pay, then I see the amount and the due date, and I can pay by card.
- Given I enter an expired card, when I submit, then I see a clear message and my invoice stays unpaid.
Write these before the work starts, not after. They are also the best brief you can hand an agent. If you want help, our guides on how to write a spec with an AI coding agent and how to brief an AI coding agent cover the writing part.
2. Test on a safe copy with made-up data
Do not run your acceptance round on the live product. Use a staging environment, a private copy that mirrors the real thing. Marker.io's guide says teams typically use masked or synthetic test data rather than real customer data, so no real customer details are exposed. If staging is new to you, read What Is a Staging Environment? first.
3. Turn criteria into scenarios
A scenario is a short story from real life: "A customer returns an item bought three weeks ago." Each one has steps and an expected result. Aim for the tasks people do most often, plus a few awkward ones: a mistyped email, a double click, a very long name.
Keep the list short. Ten good scenarios are more useful than sixty vague ones.
4. Ask the right people to try it
Pick testers who resemble real users, ideally someone who has not seen the feature being built. Tell them what to try and how to report a problem. The report should say what they did, what they expected and what happened, with a screenshot. Our guide on how to report a bug to an AI coding agent has a template you can copy.
Marker.io makes a point worth remembering: the goal is not to collect the most tickets, but to gather feedback someone can act on.
5. Triage what you find
Sort every problem into groups:
- Blocker: launch must wait. Payments fail, data is lost, a core task cannot be completed.
- Important: fix soon, but launch can go ahead if you accept it.
- Later: an improvement, not a fault.
Then ask the agent to fix the blockers. A fix is only done when the original scenario is run again and passes. Do not accept "I fixed it" without that retest.
What should I ask the AI agent for?
Ask for evidence, not reassurance. A bare "all tests pass" tells you very little, so ask what was run and what it showed, or ask for a screenshot.
Useful requests before your round starts:
- "List each acceptance criterion and show which test or screenshot proves it."
- "Which criteria have no test?"
- "What did you assume that I did not tell you?"
That last one often surfaces the gaps you are about to test for. If you are unsure how to write the criteria, you can also ask the agent to interview you about what you want and then write them down. Having a second, separate reviewer compare the work to your written spec is another useful step before UAT. It clears the obvious faults so your testers' time goes on real questions.
When is it safe to sign off?
Sign off when the main business needs are confirmed, the blockers are fixed or knowingly accepted, and the people responsible are comfortable with what is left. Marker.io is blunt on this: a successful UAT does not mean finding zero problems. It means you understand the remaining risk before go-live.
Write down three things at sign-off: what you tested, what is still open, and who accepted that. A short note is enough. It protects you later and it feeds your next brief.
Before any release, also check that you can go back. See Rollback Explained for what to ask.
How Atlas fits
Atlas is a team of AI engineers built on Claude Code, and you can read more at the Atlas home page. Today it helps with the surrounding evidence: its Tests screen holds a library of test cases, runs, screenshots and a step-by-step replay of a person's run, and "done" is refused until a screen has its test cases and screenshots. You can also record a walkthrough call instead of writing an issue list; Atlas lists the issues raised, and nothing is fixed until a person reviews and approves them.
A dedicated acceptance sheet where you tick pass or fail per scenario and record the sign-off is not something Atlas does yet. It is coming to Atlas, built in, so it needs no setup on your side. Until then, keep your criteria and results in a simple shared document and use a recorded walkthrough to hand problems to the team.
Conclusion
User acceptance testing is how a non-coder keeps the last word on AI-built software. Write the criteria first, test on a safe copy with made-up data, run realistic scenarios, sort problems by how much they matter, and retest every fix. Then sign off knowing exactly what is still open. An afternoon spent this way costs far less than a bad launch.
Questions people ask
What is user acceptance testing in simple terms?
It is the final check before launch, where the people who will use the software try it on real tasks and decide whether it meets the business need. It is done by users or stakeholders, not only by engineers.
Can an AI agent do user acceptance testing for me?
An agent can run tests and check its work against your written criteria, and a separate reviewer can compare the work to your spec. But the final judgement of whether it is right for your business should come from a person.
Where should I run acceptance testing, on the live product?
No. Use a staging environment, a private copy that mirrors the real product, with made-up or masked data so no real customer details are exposed.
What are acceptance criteria and who writes them?
They are plain statements of what 'done' looks like, such as 'when I click Pay, I see the amount and can pay by card'. You or your product owner should write them before the work starts.
How do I know when to sign off?
Sign off when the main needs are confirmed and the blockers are fixed or knowingly accepted. A good round does not find zero problems; it leaves you clear about the risk that remains.
Sources
Researched and drafted with Claude, then checked against the sources above. Atlas is an independent product, not affiliated with Anthropic or OpenAI. Claude and Claude Code are trademarks of Anthropic; Codex is a product of OpenAI.