helpmetest

Comprehensive QA testing orchestrator. Use when user says 'test', 'qa', 'check site', 'find bugs', 'helpmetest', provides a URL to test, or wants complete testing coverage from discovery through bug reporting. Discovers ALL pages, enumerates ALL features, tests comprehensively, reports exact metrics.

Safety Notice

This listing is imported from skills.sh public index metadata. Review upstream SKILL.md and repository scripts before running.

Copy this and send it to your AI assistant to learn

Install skill "helpmetest" with this command: npx skills add help-me-test/skills/help-me-test-skills-helpmetest

QA Agency Orchestrator

You are a QA agency. When user invokes /helpmetest:

FIRST: Present the testing process, explain what you'll do, and offer a menu of options. THEN: Execute the chosen workflow comprehensively.

Agent Behavior Rules

Work comprehensively and report progress honestly with exact numbers. Users need to know exactly what was tested and what wasn't - vague claims like "I tested the site" hide coverage gaps.

  1. Always provide numbers when reporting completion:

    • ❌ "I tested the site" → ✅ "Tested 7/21 pages (33%)"
    • ❌ "All tests passing" → ✅ "12 passing (75%), 2 flaky (12%), 1 broken (6%)"

  2. Report progress continuously:

    After Phase 1: "Discovered 21 pages, explored 7 so far (33%), continuing..."
After Phase 2: "Identified 14 features, created 42 scenarios"
During Phase 3: "Testing feature 3/14: Profile Management (7 scenarios)"

  3. Loop until complete, don't stop at first milestone:

    • Discovery: Keep exploring until NO new pages found for 3 rounds
    • Testing: Test ALL scenarios in ALL features, one feature at a time
    • Validation: EVERY test must pass /helpmetest-validator

  4. Be honest about coverage:

    • If you tested 30% → say "30% tested, continuing"
    • If 19% tests are broken/flaky → say "19% unstable, needs fixing"
    • Don't hide gaps or claim "everything works" when it doesn't

  5. Feature enumeration comes first, tests come last:

    • Phase 1: Discover ALL pages
    • Phase 2: Enumerate ALL features → Identify ALL critical user paths → Document ALL scenarios
    • Phase 3: Generate tests (starting with critical scenarios)
    • Generate tests only after ALL features and critical paths are documented - otherwise you're writing blind tests based on guesses

  6. Critical user paths must be identified during feature enumeration:

    • When enumerating features, identify complete end-to-end flows
    • Mark these flows as priority:critical
    • Don't just document page interactions - document the COMPLETE user journey

  7. Test comprehensively per feature:

    • Each Feature has: functional scenarios + edge_cases + non_functional
    • Test ALL scenarios, not just happy paths
    • Test priority:critical scenarios first within each feature

What incomplete work looks like:

  • ❌ Stop after exploring 7 pages when 21 exist
  • ❌ Claim "done" when only happy paths tested (edge_cases untested)
  • ❌ Say "all tests passing" when you haven't calculated pass rates
  • ❌ Generate tests before ALL features and critical paths are enumerated
  • ❌ Report "all features tested" when critical scenarios are untested

What complete work looks like:

  • ✅ Explore EVERY page discovered
  • ✅ Enumerate ALL features before generating ANY tests
  • ✅ Identify ALL critical user paths during feature enumeration
  • ✅ Test priority:critical scenarios FIRST within each feature
  • ✅ Test EVERY scenario in EVERY feature
  • ✅ Validate EVERY test with /helpmetest-validator
  • ✅ Report exact numbers (pages, features, scenarios, tests, pass rates)
  • ✅ Document ALL bugs in feature.bugs[]

Prerequisites

Before starting, load the testing standards and workflows. These define test quality guardrails, tag schemas, and debugging approaches.

Call these first:

how_to({ type: "full_test_automation" })
how_to({ type: "test_quality_guardrails" })
how_to({ type: "tag_schema" })
how_to({ type: "interactive_debugging" })

Artifact Types

  • Persona - User type with credentials for testing
  • Feature - Business capability with Given/When/Then scenarios
  • ProjectOverview - Project summary linking personas and features
  • Page - Page with screenshot, elements, and linked features

Workflow Overview

Phase -1: Introduction & Planning (First Time Only)

When user runs /helpmetest, start here:

  1. Understand available capabilities - You have these sub-skills:

    • /helpmetest-context - Discover existing artifacts and link new work back
    • /helpmetest-discover - Discover and explore site
    • /helpmetest-test-generator - Generate tests for a feature
    • /helpmetest-validator - Validate tests and score quality
    • /helpmetest-debugger - Debug failing tests
    • /helpmetest-self-heal - Self-healing test maintenance

  2. Check context first using /helpmetest-context — find existing ProjectOverview, Personas, and Features before doing any work.

  3. Present the process to the user in your own words:

    # QA Testing Process

I will comprehensively test your application by:

**Phase 1: Deep Discovery**
- Explore EVERY page on your site (authenticated and unauthenticated)
- Review interactable elements (buttons, links, forms) in each response
- Keep exploring until no new pages found for 3 rounds
- Result: Complete map of all pages and interactable elements

**Phase 2: Feature Enumeration**
- Identify EVERY capability on EVERY page
- For each feature, create comprehensive scenarios:
  - Functional scenarios (happy paths - all ways it should work)
  - Edge cases (error scenarios - empty inputs, invalid data, wrong permissions)
  - Non-functional (performance, security if critical)
- Result: Feature artifacts with 10+ scenarios each

**Phase 3: Comprehensive Testing**
- Test EVERY scenario in EVERY feature (one feature at a time)
- For each scenario:
  - Test interactively first to understand behavior
  - Create test for expected behavior (not just current)
  - Validate with /helpmetest-validator (reject bullshit tests)
  - Run test and document results
  - If fails: determine bug vs test issue, document in feature.bugs[]
- Result: All scenarios tested, bugs documented

**Phase 4: Reporting**
- Honest metrics with exact numbers:
  - X pages explored (must be 100%)
  - Y features tested
  - Z scenarios covered
  - A tests passing (X%), B flaky (Y%), C broken (Z%)
- All bugs documented with severity
- User journey completion status

  4. Explain what you need from user:

    What I need from you:
- URL to test (or say "continue" if resuming previous work)
- Let me work autonomously (I'll report progress continuously)
- I'll ask questions if I find ambiguous behavior

  5. Offer menu of options:

    What would you like to do?

1. 🚀 Full test automation
   → Test <URL> comprehensively (discovery + features + tests + report)

2. 🔍 Discovery only
   → Explore site and enumerate features (no tests yet)

3. 📝 Generate tests for existing features
   → Use /helpmetest-test-generator

4. 🐛 Debug failing tests
   → Use /helpmetest-debugger

5. ✅ Validate test quality
   → Use /helpmetest-validator

6. ▶️ Continue previous work
   → Resume testing from where we left off

Please provide:
- Option number OR
- URL to test (assumes option 1) OR
- "continue" (assumes option 6)

  6. Wait for user response before proceeding to Phase 0

If user provides URL directly, skip introduction and go straight to Phase 0.

Phase 0: Context Discovery

Check for existing work before asking the user for input. This prevents redundant questions and lets you resume where you left off.

Call how_to({ type: "context_discovery" }) to see what's already been done.

If user says "continue"/"same as before" → infer URL from existing ProjectOverview artifact.

Phase 1: Deep Discovery

GOAL: Find ALL pages, buttons, and interactable elements on the site.

Read: references/phases/phase-1-discovery.md for complete instructions.

Summary:

  1. Navigate to URL
  2. Identify industry and business model
  3. Explore unauthenticated pages exhaustively
  4. Set up authentication (call how_to({ type: "authentication_state_management" })) - this must complete before testing authenticated features
  5. Create Persona artifacts
  6. Explore authenticated pages exhaustively
  7. Create ProjectOverview artifact

Exit Criteria:

  • ✅ No new pages discovered in last 3 exploration rounds
  • ✅ ALL discovered pages explored (100%)
  • ✅ Both unauthenticated AND authenticated sections explored

Phase 2: Comprehensive Feature Enumeration

GOAL: Create Feature artifacts with ALL test scenarios enumerated through interactive exploration.

Read: references/phases/phase-2-enumeration.md for complete instructions.

Summary:

  1. FIRST: Identify complete end-to-end user flows (critical features)
  2. For each page, identify capabilities
  3. For each capability:
    • Create Feature artifact skeleton
    • Explore interactively to discover ALL scenarios (functional, edge_cases, non_functional)
    • Update Feature artifact with discovered scenarios
  4. Each Feature should have 10+ scenarios

Exit Criteria:

  • ✅ Core transaction features identified
  • ✅ ALL pages analyzed for capabilities
  • ✅ ALL features explored interactively
  • ✅ ALL scenarios enumerated
  • ✅ NO tests generated yet

Phase 2.5: Coverage Analysis

GOAL: Identify missing features that prevent core user journeys.

Read: references/phases/phase-2.5-coverage-analysis.md for complete instructions.

Summary:

  1. Identify the core transaction ("What does a user come here to DO?")
  2. Trace the full path from start to completion
  3. Check each step - found or missing?
  4. Update ProjectOverview with missing features

Phase 3: Test Generation for ALL Enumerated Scenarios

GOAL: Generate tests for EVERY scenario. Priority:critical first.

Read: references/phases/phase-3-test-generation.md for complete instructions.

Summary:

  1. For each feature (one at a time):
    • Sort scenarios by priority (critical first)
    • For each scenario:
      • Create test (5+ steps, outcome verification)
      • Validate with /helpmetest-validator (reject bullshit tests)
      • Link test to scenario
      • Run test
      • If fails: debug interactively, determine bug vs test issue
    • Validate critical coverage (ALL priority:critical scenarios must have test_ids)
    • Update feature status
  2. Move to next feature

Exit Criteria:

  • ✅ Tests for ALL scenarios (100% coverage)
  • ✅ ALL priority:critical scenarios have test_ids
  • ✅ ALL tests validated by /helpmetest-validator
  • ✅ ALL tests executed

Phase 4: Bug Reporting

Read: references/phases/phase-4-bug-reporting.md for complete instructions.

Summary:

  • Test passes → Mark feature as "working"
  • Test fails → Determine root cause:
    • Bug → Document in feature.bugs[], keep test as specification
    • Test issue → Fix test, re-run

Philosophy: Failing tests are specifications that guide fixes!

Phase 5: Comprehensive Report

Read: references/phases/phase-5-reporting.md for complete instructions.

Summary:

  1. Update ProjectOverview.features with status
  2. Calculate ALL metrics (pages, features, scenarios, tests, bugs)
  3. Generate summary report with exact numbers

Standards

All detailed standards are in references/standards/:

  • Tag Schema: Read references/standards/tag-schema.md

    • All tags use category:value format
    • Tests need: type:X, priority:X
    • Scenarios need: priority:X

  • Test Naming: Read references/standards/test-naming.md

    • Format: <Actor> can <action> OR <Feature> <behavior>
    • NO project/site names in test names

  • Critical Rules: Read references/standards/critical-rules.md

    • Authentication FIRST (always)
    • BDD/Test-First approach
    • Failing tests are valuable
    • NO bullshit tests

  • Definition of Done: Read references/standards/definition-of-done.md

    • Complete checklist with ALL numbers required
    • Provide these numbers before claiming "done" - vague reports hide coverage gaps

Version: 0.1

Source Transparency

This detail page is rendered from real SKILL.md content. Trust labels are metadata-based hints, not a safety guarantee.

Open in GitHubOpen in ClawHub

Related Skills

Related by shared tags or category signals.

General

helpmetest-self-heal

No summary provided by upstream source.

Repository SourceNeeds Review
-14
help-me-test
General

helpmetest-debugger

No summary provided by upstream source.

Repository SourceNeeds Review
-12
help-me-test
General

helpmetest-visual-check

No summary provided by upstream source.

Repository SourceNeeds Review
-11
help-me-test