Migrate from Bug0 to TesterArmyYour Bug0 test suite,
minus the service layer
Bug0 goals are already plain language, which is exactly the TesterArmy test format. Paste one prompt into Claude Code, Cursor, or Codex and the agent converts every goal into a test you create, edit, and run yourself.
Takes less than 2 minutes. No credit card required.
QA done for you means
waiting on someone else's queue
Bug0's managed model fits teams who want QA done for them. If you want direct control over your tests, the service layer between you and your suite is exactly what the migration removes.
Every change goes through a service backlog
In a managed model, the service generates and reviews tests for you, so adding a flow or editing a step means going through the service rather than doing it yourself. Self-serve control means you create, edit, and run tests in seconds instead.
Smart selectors are still selectors
Bug0's generated Playwright tests run on smart selectors and self-healing locators, an automated layer that keeps patching itself as your UI changes. A vision-based agent needs none of it, because it finds elements visually on every run.
Failure triage lives with someone else
A dedicated QA engineer reviews your results and gates your releases, so the judgment call on every failure happens inside the service. In TesterArmy you review runs yourself, with videos, screenshots, and logs per step.
Your coverage inventory is scattered
The test plan lives across the Bug0 dashboard, your QA engineer's reports, and Slack or GitHub notifications, with only the Passmark output sitting in your repository. The first step of the migration is gathering that inventory into one place.
What your suite reads like
after the conversion
A Bug0 goal becomes a test title and its expected outcomes become assert steps, almost one-to-one. This is the same checkout flow in both formats.
## Checkout with saved card Goal: A returning customer buys the desk lamp with their saved card and reaches the order confirmation page. Expected outcomes: - The desk lamp is added to the cart from its product page - Checkout accepts the saved card ending in 4242 - An order confirmation page with an order number appears - The order total shows $49.00 Notes: covered by a generated Playwright spec (smart selectors, self-healing locators), runs on cloud Chromium, failures triaged by the assigned QA engineer.
The conversion drops the generated Playwright layer - smart selectors and self-healing locators - because the agent finds elements visually every run. The goal and its expected outcomes survive intact as steps you own and edit yourself.
The whole migration
is one prompt
Paste this into your coding agent in the repository, or in the directory that contains your export file. It discovers your Bug0 coverage, creates a TesterArmy project, converts each goal, and verifies every test locally with real exit codes.
Migrate my Bug0 test suite to TesterArmy using the TesterArmy CLI (`ta`).
Verify auth first with `ta status --json`, and use `ta --help` plus
subcommand help to discover commands. Prefer --json output.
1. Discover the Bug0 coverage: look for Passmark goal definitions or
generated Playwright specs in this repo, and read bug0-export.md if
present. Each goal/flow becomes one TesterArmy test.
2. Create a TesterArmy project (skip if one exists in `ta projects list`):
echo '{"name":"<app name>","url":"<app URL>","projectType":"web"}' | ta projects create --json
3. Save durable context as project memories (category site_structure,
importance high): key routes, the login URL, and any app facts the
Bug0 test plan documented.
echo '{"category":"site_structure","title":"...","content":"...","importance":"high"}' | ta memories create --project <projectId> --json
4. Convert each Bug0 goal/flow into a TesterArmy test:
- Plain-language goals map almost directly: break the goal into
concrete steps with type "act" and turn its expected outcomes into
steps with type "assert" (e.g. "An order confirmation page with an
order number appears").
- For generated Playwright specs, extract the USER INTENT and drop all
selectors, waits, and self-healing locator logic - the TesterArmy
agent finds elements visually.
- Login setup -> one step with type "login"
- Keep tests focused: 3-10 steps. Split broad goals covering multiple
flows into separate tests.
Create each test:
echo '{"title":"<goal name>","description":"Migrated from Bug0","steps":[{"title":"Visit the home page","type":"act"},{"title":"Order confirmation shows an order number","type":"assert"}]}' | ta tests create --project <projectId> --json
Step types: act, assert, login, screenshot.
5. Never hardcode passwords in test steps. List the credentials the Bug0
suite used and I will add them with:
echo '{"kind":"login","label":"...","username":"...","password":"..."}' | ta projects credentials-create <projectId> --json
6. Verify: run each migrated test locally with
`ta tests run <testId> --local --url <app URL> --json` and report results.
Exit code 0 = pass, 1 = fail.
7. Report a summary table: Bug0 goal/flow -> TesterArmy test ID -> run
result, plus anything you intentionally skipped and why.Everything you built
has a place to land
This is the easiest migration on this list. Bug0 tests are already expressed as plain-language goals, the same format TesterArmy tests use, so almost every concept maps one-to-one.
Bug0 and TesterArmy,
row by row
Bug0's managed tier genuinely earns its keep: a dedicated engineer verifies your failures, and the price is a published flat rate rather than a quote. This table is about what the service layer between you and your tests costs, and where each side wins.
- Who maintains the testsTesterArmyYou own plain-English steps and the agent finds elements visually, so there is no selector layer for anyone to maintain.Bug0On the Managed tier a forward-deployed engineer and AI maintain the generated Playwright suite for you, built on their open-source Passmark library.
- What breaks on a UI changeTesterArmyUsually nothing - the agent works from vision on every run, with no selector or locator layer at all.AdvantageBug0Bug0 tests are TypeScript Playwright with plain-English steps. The AI resolves those steps against the accessibility tree by default, with computer-use vision as an opt-in, so re-resolution handles many UI changes without an edit from you.
- Writing a new testTesterArmyYou write 3-10 plain-English steps yourself, from the dashboard or CLI, and see the first result in minutes.AdvantageBug0Studio lets you author self-serve in plain English or from a video, while Managed coverage goes through the service, whose onboarding promise is 100% of critical flows covered within 7 days.
- Flaky failuresTesterArmyThe agent waits like a human, and every failure comes with a video, screenshots, and logs per step for you to review.Bug0Bug0 advertises a zero-flake guarantee, with the managed engineer absorbing noisy failures before they reach your team.
- Run verdictsTesterArmyThree verdicts - passed, failed, or blocked. Environment and setup stops land in blocked with the reason attached, so the failure count only holds real product failures.Bug0Bug0 filters noise with its managed engineer's judgment, on their timeline; the verdict itself stays pass or fail.
- Human-verified failuresTesterArmyThere is no human layer - you make the judgment call on every failure yourself, with full artifacts.Bug0A dedicated QA engineer triages every failure for you, so what reaches your team has already been verified as a real bug.Advantage
- Pricing modelTesterArmySelf-serve subscription tiers you can start and scale without talking to anyone.Bug0Managed is a published flat $2,500 per month covering up to 500 flows with a 60-day pilot, which is rare transparency for a managed QA service.Advantage
- Pull request workflowTesterArmyPR testing is built in - runs trigger from the GitHub App and report back on the pull request.Bug0GitHub App PR checks are part of the service, with results reported back to your repository by Bug0.
- Native mobile appsTesterArmyThe same plain-English tests run on iOS and Android via managed cloud simulators.AdvantageBug0Web only - Bug0's own homepage FAQ says they are not a fit for mobile-native apps.
- Entry priceTesterArmyFree trial without a credit card; Hobby is $99 per month with 250 test runs included.AdvantageBug0Passmark is free open source; the paid entry point is Managed at $2,500 per month booked through a call, and Studio's $250 per month appears on their blog but not on their pricing page.
Facts checked August 2026. Spotted something out of date? Tell us and we will fix it.
From Bug0 goals to green runs in four steps
Gather your test inventory, hand the prompt to your coding agent, and review what comes back. Bug0 keeps running in parallel until every migrated test is green.
Gather your inventory and point the agent at it
Install the TesterArmy CLI and authenticate, then collect your Passmark goals, generated Playwright specs, or the flow list from your Bug0 dashboard into the repo. The agent reads the coverage and creates a matching web project.
The agent converts every goal
Each Bug0 goal becomes a test of 3-10 plain-English steps: the goal breaks into act steps, expected outcomes turn into assert steps, and login setup becomes a single login step backed by encrypted credentials.
Every migrated test runs locally
The agent verifies each test against your app with ta tests run --local and reports pass or fail through real exit codes, plus a summary table mapping every Bug0 goal to its TesterArmy test and run result.
Recreate the integrations, then wind down Bug0
Install the GitHub App for PR checks, connect Slack for failure notifications, and schedule regression coverage with production monitoring. Run both systems in parallel for a sprint, then wind down Bug0.
What comes with you,
what stays behind
Because Bug0 goals are already plain language, almost everything of value translates directly. What you trade is the managed layer for direct control over your own suite.
When Bug0 is still the right call
- Nobody on your team wants to own QA at all - Bug0's Managed tier exists precisely so a forward-deployed engineer builds the coverage and triages every failure, and nobody at TesterArmy reviews your failures for you.
- Human-verified failures are a hard requirement for you - if every result must be checked by a person before it reaches your engineers, the managed layer is exactly the product you are paying for.
- The published flat rate fits how you budget - $2,500 per month for up to 500 flows with a 60-day pilot is a predictable line item, and you are getting real value from the human layer it pays for.
- You rely on Passmark's generated Playwright specs as portable open-source code in your repository, and your product is web only with no native mobile app on the roadmap.
The guide's own advice is to run both systems in parallel for a sprint, with TesterArmy's PR checks, Slack notifications, and production monitoring in place, and to wind down Bug0 only once the migrated coverage is proven green.
Frequently Asked Questions
A one-line test edit
should not wait on a service backlog
Your Bug0 test plan already describes your critical flows in plain language, which is exactly the TesterArmy format. The migration keeps that plan and removes the layers around it - the generated selectors, the self-healing locators, the managed triage - so you can create, edit, and run tests yourself in seconds, with videos, screenshots, and logs per step when something fails.