A Claude Code skill that turns "QA the customer + admin loop" from a recurring weeklong project into a single autonomous run.
1. DISCOVER — maps the target system: domain, auth, surfaces, data layer
2. GENERATE — synthesizes 5–10 diverse personas appropriate to that domain
3. DISPATCH — spawns one autonomous tester subagent per persona
4. VERIFY — spawns a verifier subagent to cross-check admin-side state
5. REPORT — produces a triaged findings list with reproductions + cleanup
The skill never assumes it knows the app. It explores first, generates testers second. Drop it on any chat / marketplace / support / SaaS app that has a customer-facing surface paired with an admin/back-office surface — it'll figure out the rest from there.
Most QA tooling tests a single user flow with a hardcoded happy-path persona. The interesting bugs hide in the seams:
- A customer's chat ends up under the wrong customer's name after logout/login.
- A high-severity complaint mints two handoffs instead of one.
- A customer-side action that should trigger an auxiliary record on the admin side (audit log, follow-up task, downstream artifact) confirms on the customer side but never lands.
- A returning customer gets a fresh customer record instead of reusing their profile.
These bugs need diverse personas exercising the system in parallel and a verifier looking across all of them to spot drift. That's the loop this skill automates.
This skill is a plain directory of markdown. Drop it wherever Claude Code finds skills on your platform:
# clone into your global skills directory
mkdir -p ~/.claude/skills
git clone https://github.com/ShivamShrivastava18/persona-driven-e2e-testing.git \
~/.claude/skills/persona-driven-e2e-testing# Once published as a plugin, install via your harness's plugin command.
# Until then the CLI-clone path above is the supported install method.Skills are just markdown — most harnesses support a similar
discoverable-skills directory. Adjust the location per your tool's
convention. The SKILL.md frontmatter (name, description) is the
contract.
> /skill persona-driven-e2e-testing
# or just describe the task; Claude will load the skill itself
> simulate users on our staging chat app at <url> and validate the admin dashboard
The skill will:
- Ask for the customer-side + admin-side URLs.
- Confirm the environment is staging (refuses to run on production).
- Visit each surface, map the auth flow + data layer.
- Propose 5-10 personas.
- After your confirmation, dispatch the tester subagents.
- Run the verifier.
- Hand you a markdown report with findings sorted by severity, plus exact cleanup commands.
- A Claude Code harness with the
Tasktool (for dispatching subagents). - A browser automation tool — Playwright MCP is the reference implementation; Puppeteer / Selenium MCPs work if they expose equivalent navigate/click/type/snapshot primitives.
- Read-access to the target system's data layer (DDB credentials, DB connection string, admin API token) so the verifier can cross-check.
persona-driven-e2e-testing/
├── README.md ← this file
├── SKILL.md ← the skill entrypoint (5 phases)
├── LICENSE ← MIT
└── references/
├── discovery-protocol.md ← archetype-specific Phase 1 checklists
├── persona-templates.md ← 7 persona shapes + diversity matrix
├── agent-design.md ← tester + verifier subagent prompts
├── verification-rubric.md ← cross-surface drift patterns
└── safety-rails.md ← staging-only, hygiene, stop conditions
| Tool / pattern | What it does | What this skill adds |
|---|---|---|
| Playwright Test | Scripted browser tests of pre-defined flows | Auto-generates the personas + flows from discovery |
| Cucumber / Gherkin BDD | Persona-style scenarios as test cases | Doesn't require hand-writing scenarios; verifies cross-surface state, not just per-page |
| Synthetic monitoring (Datadog, Checkly) | Pre-recorded happy-path checks | Generates diverse journeys; finds bugs across customer+admin pair |
| LLM-driven test generation (e.g. Mabl, TestRigor) | AI writes selectors / steps | Goes further: discovers the domain, generates personas, dispatches autonomous agents |
The contribution isn't browser automation. It's the discovery → persona generation → autonomous dispatch → cross-surface verification orchestration.
"I already have an E2E test suite."
Great — keep it. This skill targets the gap your suite doesn't cover: emergent bugs from diverse personas. Your Cypress tests verify the golden path; this skill stress-tests the periphery.
"Won't this just produce a wall of noise findings?"
The verifier severity rubric and the test-data sweep section in Phase 5 are designed against this. Every finding has a reproduction; every record created is one cleanup-line away. Run it on a quiet staging environment and the signal-to-noise ratio is usable.
"What about flakiness?"
The skill's stop conditions (max retries per step, hard timeout,
HALT on 5+ critical findings) cap runaway flakiness. A flaky test
fails as a finding, not as a hung orchestrator.
"Why not just have a human QA team?"
You probably should. This skill complements them — it surfaces candidate findings the human team triages, instead of replacing the human judgement.
Battle-tested on a real production-bound SaaS over a multi-week iteration loop. The discovery checklists, persona diversity matrix, and cross-surface verification rubric were each shaped by classes of bugs that hand-rolled E2E suites consistently missed — the patterns are generalized in the reference files; specific findings stay private to the systems they came from.
If you publish your own run reports, open a PR linking them — the rubric gets better with more examples.
Open issues / PRs against this repo for:
- New persona templates (a journey class we haven't covered).
- Domain-specific verification rubrics (a new archetype's drift patterns).
- Bug fixes in the SKILL.md orchestration logic.
Out of scope for this repo:
- Domain-specific test fixtures (your app's data is your business).
- Integration with proprietary CI systems (the skill is harness- agnostic; CI wrappers live in your CI repo).
MIT — see LICENSE.
This skill is the precipitate of a long collaboration between an engineer iterating on a real customer-facing SaaS and Claude. The patterns were learned the hard way — bugs surfaced, fixes shipped, patterns crystallized — and the skill is the durable form of those lessons.