> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.tester.army/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.tester.army/_mcp/server.

# Migrate from Bug0

> Move from Bug0's managed QA service to self-serve AI testing with TesterArmy. Convert Passmark goals and generated Playwright tests with a single agent prompt.

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](/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](/run/pull-request-testing)                                          |
| Slack failure reports                           | [Slack integration](/integrations/slack)                                                      |
| Scheduled regression runs                       | [Production monitoring](/run/production-monitoring) and [group webhooks](/run/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](/run/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](/guides/migrate-from-playwright).

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

```bash
npm install -g testerarmy
ta auth
```

Get an API key from the [dashboard](https://tester.army/dashboard/profile/api-keys). 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):

```txt
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

1. Review the migrated tests in the [dashboard](https://tester.army/dashboard) and organize them into groups (smoke, regression) matching your Bug0 plan.
2. Add [credentials](/auth/credentials) for each test account.
3. Recreate the integrations: install the [GitHub App](/run/pull-request-testing) for PR checks and connect [Slack](/integrations/slack) for failure notifications.
4. Schedule regression coverage with [production monitoring](/run/production-monitoring), run both systems in parallel for a sprint, then wind down Bug0.

## Next steps

Install, authenticate, and run your first test.

Replace Bug0's GitHub PR checks.

Get run results where Bug0 reports used to land.

Converting generated Playwright specs directly.