• CLI subcommands: name + args + file:line
• API endpoints: method + path + file:line
• UI routes: path + component + file:line
• Database migrations: filename + what they create/alter
• Configuration: env vars and config files that affect behavior

Step 4: Trace Changes to Entry Points

For each changed file, determine if it affects user-facing functionality:

• Direct entry point change — File contains route definitions
• Import chain analysis — Find what imports the changed file and trace up to entry points
• Architecture-aware tracing — Read the project's CLAUDE.md, README, or architecture docs to understand data flow and module relationships, rather than relying solely on grep
• Document the trace path in test context

Import Chain Analysis by Ecosystem

# Rust — use/mod/crate references and workspace deps
grep -rn "use.\|mod " --include=".rs"
grep -rn "" --include="Cargo.toml"
# Python — from/import
grep -rn "from.\|import." --include=".py"
# TypeScript/JavaScript — import/require
grep -rn "from.\|require." --include=".ts" --include=".tsx" --include=".js" --include=".jsx"
# Elixir — alias/import/use
grep -rn "alias.\|import.\|use." --include=".ex" --include=".exs"
# Go — package references
grep -rn "\." --include=".go"

If the ecosystem is not covered above, or grep results are inconclusive, read the project's CLAUDE.md, README, or architecture docs to understand the module graph and trace the data flow from changed files to user-facing entry points.

Classify Affected Entry Points

After identifying all affected entry points, classify each one:

• Ask: "If a user wanted to use this feature (not configure it), which entry point would they interact with?" — that's core functionality
• A settings page that adds a new dropdown option is configuration; the endpoint that actually uses* that option is core functionality
• The same changed file (e.g., a new provider module) may affect both a settings page and a functional endpoint — both must be traced

Requirement: At least one test must target a core functionality entry point before generating configuration/admin tests. If no core functionality entry point can be identified, explicitly document why and flag this for manual review.

Output: For each affected entry point, document:

• Which changed files affect it
• The import/dependency chain
• Classification: Core functionality or Configuration/admin
• Why this entry point needs testing

Step 5: Generate Test Cases

See references/test-case-generation.md for the detailed API/browser templates, prioritization rules, and test-case guidelines.

Step 6: Write YAML Test Plan

Create the test plan file:

mkdir -p docs/testing

Write to docs/testing/test-plan.yaml:

version: 1
metadata:
  branch: 
  base: 
  generated: 
  changes_summary: |
    
setup:
  stack:
    - type: 
      package_manager: 
  prerequisites:
    # Services or infrastructure the tests need running
    - name: 
      check: 
  build:
    # Commands to build the project artifacts (binaries, assets, etc.)
    - 
  services:
    # Long-running processes to start before tests (servers, watchers, etc.)
    # Omit if the project is a CLI tool or library with no server component
    - command: 
      health_check:
        url: http://localhost:/health
        timeout: 30
  env:
    # Environment variables needed by tests (use ${VAR} for secrets)
    DATABASE_URL: "${DATABASE_URL}"
tests:
  # CLI test example — run the built binary with real arguments:
  - id: TC-01
    name: 
    context: |
      
    steps:
      - run: 
      - run: 
    expected: |
      
  # API test example:
  - id: TC-02
    name: 
    context: |
      
    steps:
      - action: curl
        method: GET
        url: http://localhost:/
    expected: |
      
  # Database verification example:
  - id: TC-03
    name: 
    context: |
      
    steps:
      - run: 
      - run: psql "${DATABASE_URL}" -c "SELECT ... FROM ... WHERE ..."
    expected: |
      
  # Browser test example (always use agent-browser CLI commands):
  - id: TC-04
    name: 
    context: |
      
    steps:
      - run: agent-browser open http://localhost:/
      - run: agent-browser snapshot -i
      - run: agent-browser click @
      - run: agent-browser snapshot -i
      - run: agent-browser screenshot evidence/tc-04.png
    expected: |
      
    evidence:
      screenshot: evidence/tc-04.png

Step 7: Report Summary

After generating the test plan:

## Test Plan Generated
File: docs/testing/test-plan.yaml
Branch:  → 
Detected Stack
Component
Type
Port

Tests Generated
ID
Name
Type
Affected By
TC-01
curl/browser

Entry Point Coverage
Covered:  entry points with tests
Unchanged:  entry points not affected by this PR
Next Steps
Review the generated test plan at docs/testing/test-plan.yaml
Adjust test values and expectations as needed
Run tests with:
   

Step 8: Verification

Before completing:

# Verify file was created
ls -la docs/testing/test-plan.yaml
# Validate YAML syntax
python3 -c "import yaml; yaml.safe_load(open('docs/testing/test-plan.yaml'))" && echo "Valid YAML"
# Check required fields
grep -E "^version:|^metadata:|^setup:|^tests:" docs/testing/test-plan.yaml

Verification Checklist:

• [ ] Test plan file created at docs/testing/test-plan.yaml
• [ ] YAML is syntactically valid
• [ ] At least one test case generated
• [ ] Setup commands match detected stack
• [ ] Each test has id, name, steps, and expected fields
• [ ] No automated test duplication: Grep every run: and command: step in the plan for test runner invocations (cargo test, pytest, npm test, go test, mix test, jest, vitest, mocha, etc.). If ANY step invokes the project's test runner, the plan fails verification. Remove those steps and replace them with real E2E actions.
• [ ] Behavioral coverage: At least one test exercises the primary behavioral change described in changes_summary. Re-read the changes_summary and commit messages — if they describe a capability (e.g., "adds Claude Code as a new LLM provider") but no test invokes that capability (e.g., sends a message through the provider), the plan fails verification. Add the missing core functionality test before completing.
• [ ] No config-only plans: If all tests target configuration/admin entry points and zero tests target core functionality entry points, the plan is incomplete. Go back to Step 4, identify the core functionality entry points, and add tests for them.

Rules

• E2E only — every test step must exercise the real built artifact (binary, server, UI) as a human would. Never wrap automated test suites.
• Always create docs/testing/ directory if it doesn't exist
• Generate at least one test per affected entry point
• Include context explaining why each test matters (trace from changes)
• Use natural language for expected field (agent will interpret)
• CLI projects: Test steps should invoke the actual binary with real arguments and verify stdout, stderr, exit codes, and side effects (files created, database rows written, processes spawned)
• Server projects: Start the server in setup, test via curl/agent-browser
• Library-only projects with no binary or server: If the change is purely internal library code with no user-facing entry point (no CLI, no server, no UI), state this explicitly and generate tests that exercise the library through its public API via a small driver script — not by running the test suite
• Default to conservative port detection (8000 for API, 5173/3000 for frontend)
• Browser automation steps MUST use agent-browser CLI commands (e.g., agent-browser open, agent-browser snapshot -i, agent-browser click @ref) — never use abstract action syntax
• Always agent-browser snapshot -i before interacting with elements and after navigation/DOM changes
• Use agent-browser screenshot to capture evidence for browser tests
• Use ${ENV_VAR} syntax for secrets, never hardcode credentials
• If no user-facing changes detected, explain why and suggest manual verification