Migrate from Bug0 | TesterArmy: Documentation

Bug0 is a managed QA service: AI agents generate Playwright tests (via their open-source Passmark library), and a dedicated QA engineer reviews results and gates releases. That model fits teams who want QA done for them.

TesterArmy is the self-serve version of the same idea. Tests are plain-language steps executed by a vision-based AI agent, you create and run them yourself from the CLI or dashboard, and there’s no human-in-the-loop service layer between you and your test suite. If you want direct control over your tests, the migration is mostly one-to-one.

How concepts map

Bug0	TesterArmy
Plain-language test goals (Passmark)	A test with natural-language steps
Generated Playwright tests with smart selectors	`act` / `assert` steps - no selectors at all
Self-healing locators	Not needed - the agent finds elements visually every run
GitHub App PR checks	GitHub App + PR testing
Slack failure reports	Slack integration
Scheduled regression runs	Production monitoring and group webhooks
Cloud Chromium runs	TesterArmy cloud runs (`--remote`) or local runs via the CLI
Dedicated QA engineer triages failures	You review runs - with videos, screenshots, and logs per step
Managed service model	Self-serve - you create, edit, and run tests yourself

What translates and what doesn’t

This is the easiest migration on this list. Bug0 tests are already expressed as goals in plain language, which is exactly the TesterArmy test format - a goal becomes a test title and its checks become assert steps. If you have access to the generated Playwright specs (Passmark output in your repo or Bug0 Studio exports), those convert the same way Playwright specs do.

What you give up is the managed layer: nobody at TesterArmy reviews your failures for you. What you gain is direct control - you can create, edit, and run tests yourself in seconds instead of going through a service backlog.

Prerequisites

$ npm install -g testerarmy
$ ta auth

Get an API key from the dashboard. For non-interactive agent sessions, set TESTERARMY_API_KEY instead.

1. Gather your Bug0 test inventory

Collect whatever you have access to:

Passmark goal definitions or generated Playwright specs in your repository
The test plan / flow list from your Bug0 dashboard or your QA engineer’s reports
Slack/GitHub reports that list which flows are covered

If nothing lives in your repo, paste the flow list into a local file such as bug0-export.md with one section per test (goal + expected outcomes).

2. The migration prompt

Paste this into your coding agent in the repository (or directory containing your export file):

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> --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.

After the migration

Review the migrated tests in the dashboard and organize them into groups (smoke, regression) matching your Bug0 plan.
Add credentials for each test account.
Recreate the integrations: install the GitHub App for PR checks and connect Slack for failure notifications.
Schedule regression coverage with production monitoring, run both systems in parallel for a sprint, then wind down Bug0.

Next steps

CLI Getting Started

Install, authenticate, and run your first test.

Pull Request Testing

Replace Bug0’s GitHub PR checks.

Slack Integration

Get run results where Bug0 reports used to land.

Migrate from Playwright

Converting generated Playwright specs directly.