E2e author
Use after the final phase of a feature is green — write the small set of end-to-end tests that prove the feature's goal holds through the whole assembled system, traced to the overview rather than to spec ids.From its SKILL.md
npx -y skills add szobonyaerik/agentic-avengers --skill e2e-authorAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
6.0 KB, as published. Nobody here has run it
e2e-author
Author the feature-level end-to-end suite, once, after the last phase of a feature is green. Every phase has proven its own slice at its own seam; nothing has yet proven the slices add up to the thing the feature was for. That is the only job here.
Runs once per feature, not per phase. Not selected by
work_kind— every feature gets this stage regardless of greenfield/migration/refactor. The implementer (backend or frontend, whichever owns the feature's primary surface) writes it at feature close.
This is not a red → green loop. The system already works — every phase is green and locked. These tests are written against the assembled, finished feature and should pass on the first run. One that fails has found a real integration defect between phases, which is the whole point of the stage.
Keep it small — this is a hard rule
Target 1-3 tests. More than 5 is a defect, not thoroughness. E2E tests are the slowest, flakiest, and worst-localizing tests in the repo: when one goes red it names a broken feature, not a broken line. They earn their keep only by being few and by covering the path that actually matters. If you want a sixth, the behavior you have in mind almost certainly belongs in a phase's integration suite — it belongs in a phase's integration suite instead — which means a new spec, not a sixth e2e test.
Do not enumerate edge cases here. Do not re-test what a phase already covers. Error paths belong at the phase level unless the feature's stated goal is about that error path.
Inputs
docs/features/<feature>/overview.md— the feature goal and the user-visible outcome. This is the source you trace to.docs/features/<feature>/plan.md— the phase list, to see what the assembled system now spans.- Each phase's
handover.mdcontract card — what was actually delivered. The card is the whole file (capped at 6 KB); its archive is off the read path and you do not need it.
Procedure
-
State the feature's goal in one sentence, quoted from
overview.md. If you cannot find a user-visible outcome to quote, stop and route back — an e2e with no goal to prove is theatre. -
Pick the critical path(s). Ask: if exactly one flow had to work for this feature to be worth shipping, which is it? That is your first test. Add at most two more, each justified by a distinct goal in the overview — not a distinct branch of the same flow.
-
Write them against the outermost boundary, with the real system assembled: the HTTP API, the CLI, the UI — whatever the actual caller touches. No mocks of anything internal. Mock only what you cannot run: third-party APIs, LLMs, payment providers.
- Files go in
tests/e2e/<feature>/(e.g.tests/e2e/clickup-sync/test_task_roundtrip.py). - First docstring line traces to the goal, not a spec id:
"""e2e: <feature> | goal — a task created in ClickUp appears in the dashboard.""" - When the outermost boundary is a browser, drive it with
npx -y chrome-devtools-axi(open <url>→ interact by@<uid>ref → assert with a freshsnapshotoreval). It is a CLI, so it works from an implementer subagent, which hasBashbut no MCP access — themcp__claude-in-chrome__*tools are unreachable there. Keep the assertion on what the user observes, never on internal state read througheval. Tear it down once, session-scoped: the CLI leaves a shared, process-wide background browser server alive after the invoking process exits, so callnpx -y chrome-devtools-axi stopexactly once after the whole browser e2e set — from a single session- or module-scoped fixture that yields and stops in its teardown /finally, so it still runs when a test fails. Never per test:stopkills the shared server, so a per-test teardown pays a full Chrome cold start on every test and, under a parallel runner like pytest-xdist, one test's teardown kills a sibling's live browser mid-assertion.
- Files go in
-
Confirm they pass. Unlike phase tests, these are written after implementation, so they must be green on first run. A red e2e here means either the feature genuinely does not work end to end — a real finding, route it back with the failure — or your test is wrong. Do not ship it red.
-
Record them in
docs/features/<feature>/e2e-mapping.md. E2E tests live undertests/, so they lock exactly as phase tests do (pipeline-conventions: locked-after-verify) — from feature close onward they are not edited to make a change pass.
Where e2e sits in the pipeline
- Excluded from the phase verifier hook.
scripts/hook_verifier.shscopes to the active phase and passes--ignore=tests/e2e; these never run on a code edit. - Excluded from the mutation gate. Mutation is diff-scoped per phase and judges phase suites. E2E tests are not there to kill mutants and must never be written to farm them.
- They run at feature close (and in CI), which is the moment they have something to say.
e2e-mapping.md format
---
feature: <feature>
stage: e2e-author
model: <model>
created: <date>
readers: feature close @ once
links: [overview.md]
---
| test | goal (from overview.md) | boundary |
|---|---|---|
| test_task_roundtrip | a task created in ClickUp appears in the dashboard within 60s | HTTP API + real Postgres |
| test_invalid_signature_never_persists | forged deliveries cannot reach the dashboard | HTTP API |
Done when
- 1-3 (max 5) tests exist under
tests/e2e/<feature>/, each tracing to a quoted goal inoverview.md. - Each drives the outermost real boundary, with nothing internal mocked.
- All are green, and
pytest -q tests/e2e/<feature>/proves it. e2e-mapping.mdexists and every test traces to the goal quoted fromoverview.md.