Skip to main content
Test planning, test analysis, test design, and test implementation — Bugzy covers the full test creation lifecycle. It explores your application, understands its features, and writes comprehensive tests, acting as a QA teammate who handles the heavy lifting of building and maintaining test coverage. The process runs in two phases: first a structured test plan, then executable test cases with automated Playwright scripts.

​
Phase 1: Test plan

The generate-test-plan task takes a product description and produces a comprehensive test plan. Inputs:
  • Product description (from dashboard)
  • Live application (Bugzy explores with a real browser)
  • Existing project context and docs
Process:
1

Browser exploration

The browser-automation subagent opens your app and systematically navigates pages, forms, and flows.
2

Cross-reference with product description

Bugzy compares what it finds in the live app with the product description you provided.
3

Identify test scenarios

Happy paths, edge cases, error states, and boundary conditions are catalogued.
4

Pull product specs

If Notion or Jira is connected, the documentation-researcher subagent pulls product specs for additional context.
5

Generate test plan

A structured test plan is generated and committed to the repo.
Output: test-plan.md — a markdown document with test areas, scenarios, and expected behaviors. Test plan structure:
ElementDescription
Test areasLogical groupings of related functionality (e.g., Authentication, Checkout)
ScenariosIndividual test scenarios within each area
Expected resultsWhat should happen when the scenario is executed
Priority levelsCritical, High, Medium, Low
Tags@smoke, @regression, @edge-case

​
Phase 2: Test cases and automation

The generate-test-cases task converts the test plan into two artifact types.

​
Manual test case documents

Located in test-cases/TC-XXX.md, each document includes:
  • Preconditions
  • Numbered steps
  • Expected results
  • Test data

​
Automated Playwright scripts

Located in tests/specs/*.spec.ts, each script follows these conventions:
  • TypeScript with Page Object patterns
  • Proper waits and assertions
  • Environment variables for secrets
  • @smoke and @regression tags
1

Read test plan

The agent reads the test plan and identifies testable scenarios.
2

Generate Playwright files

The test-engineer subagent generates Playwright test files area by area.
3

Create Page Objects

Shared interactions are extracted into reusable Page Object classes.
4

Validate against live app

Tests are run against the live application to verify they pass.
5

Auto-fix failures

Failing tests are automatically fixed — selectors updated, timing adjusted.
6

Commit artifacts

All artifacts are committed to the repo.

​
Output artifacts

ArtifactLocationDescription
Test plantest-plan.mdStructured markdown with test areas and scenarios
Manual test casestest-cases/TC-XXX.mdStep-by-step test case documents
Automated teststests/specs/*.spec.tsPlaywright TypeScript test scripts
Page Objectstests/pages/*.tsReusable page interaction classes
Test configtests/CLAUDE.mdFramework conventions and execution commands
Test data template.env.testdataNon-secret test data values

​
Browser exploration

The browser-automation subagent uses Playwright CLI to explore your application:
  • Navigates the base URL and crawls pages
  • Interacts with forms, buttons, and dropdowns
  • Takes screenshots of each page
  • Identifies dynamic content, auth walls, and multi-step flows
Exploration is bounded by the base URL domain — Bugzy does not navigate to external sites.

​
Knowledge base

During test generation, the agent builds a knowledge-base.md file that captures:
  • Application structure and navigation
  • Common selectors and interaction patterns
  • Authentication flows
  • Flaky areas and environment-specific behaviors
This knowledge base is consulted in future runs, so Bugzy’s understanding of your application improves over time.