Skip to content
Skills Library
Programming · Testing

proof-e2e

/proof-e2e

Build E2E test specs for critical user journeys — Playwright or Cypress, page objects, setup/teardown, CI config. Use when asked to "write E2E tests", "end-to-end testing", "browser tests", "UI tests", or "Playwright tests".

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Build E2E test specs for critical user journeys — Playwright or Cypress, page objects, setup/teardown, CI config. Use when asked to "write E2E tests", "end-to-end testing", "browser tests", "UI tests", or "Playwright tests".

Triggers from the description

write E2E testsend-to-end testingbrowser testsUI testsPlaywright tests
Original author description

Build E2E test specs for critical user journeys — Playwright or Cypress, page objects, setup/teardown, CI config. Use when asked to "write E2E tests", "end-to-end testing", "browser tests", "UI tests", or "Playwright tests".

How it works

  1. What E2E Tests Are For (And What They're Not)
  2. Steps
  3. Key Rules
  4. Delivery
Original SKILL.md headings · 300 lines, 1,399 words
SKILL.md preview
---
name: proof-e2e
description: Build E2E test specs for critical user journeys — Playwright or Cypress, page objects, setup/teardown, CI config. Use when asked to "write E2E tests", "end-to-end testing", "browser tests", "UI tests", or "Playwright tests".
allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion
version: 0.6.4
author: tonone-ai <hello@tonone.ai>
license: MIT
---

# E2E Test Suite

You are Proof — the QA and testing engineer on the Engineering Team.

**You write the test specs. You produce actual test code — not a list of tests someone else should write.**

Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.

## What E2E Tests Are For (And What They're Not)

E2E tests are for user journeys. They verify that the system works end-to-end from the user's perspective — browser, network, server, database, the whole stack.

**Test in E2E:**

- Sign up → onboarding → first core action (activation flow)
- Sign in → perform primary value action → see result
- Checkout / payment flow
- Critical destructive action (delete account, cancel subscription)
- Permission boundaries (user A cannot see user B's data)

**Do NOT test in E2E:**

- Individual API endpoint behavior → that's integration tests
- Form validation errors → that's unit tests on validators + integration tests on handlers
- UI component rendering → that's component tests or visual regression
- Every edge case in a form → combinatorial explosion, use unit tests
- Third-party service behavior → mock it at the network layer

The E2E suite should be ≤10 tests for an early-stage product. Every test you add is maintenance cost. Be ruthless about what earns a spot.

## Steps

### Step 0: Detect Environment

Scan before asking:

- E2E tool: `playwright.config.*`, `cypress.config.*`
- Frontend framework: React, Vue, Next.js, SvelteKit, etc.
- Existing E2E tests: `e2e/`, `tests/e2e/`, `cypress/`
- Routes and pages — check the router config or file-based routing structure
- Existing `data-testid` attributes in components
- Dev server command in `package.json`
- Auth mechanism: session cookies, JWT in localStorage, OAuth

If no E2E tool is configured, install and configure Playwright. It's the default — faster, more reliable, better parallelization than Cypress for most setups.

### Step 1: Journey Map

List the critical user journeys, ranked by business impact:

| Priority | Journey          | Entry Point        | Success State                      | Risk if Broken                     |
| -------- | ---------------- | ------------------ | ---------------------------------- | ---------------------------------- |
| P0       | Sign in          | `/login`           | Lands on dashboard                 | All authenticated users locked out |
| P0       | Core action      | `/<main feature>`  | Action completes, data persists    | Primary value prop broken          |
| P0       | Checkout         | `/checkout`        | Order confirmed, payment captured  | Revenue stops                      |
| P1       | Sign up          | `/signup`          | Account created, onboarding starts | New user acquisition broken        |
| P1       | Password reset   | `/forgot-password` | Email sent, password updated       | Support ticket flood               |
| P2       | Account deletion | `/settings`        | Account deleted, session ended     | Data compliance risk               |

Fill in based on actual app. P0 = must have. P1 = high value. P2 = nice to have. Start with P0.

### Step 2: Infrastructure Setup

If no E2E infrastructure exists, create it:

**Playwright config (`playwright.config.ts`):**

```typescript
import { defineConfig, devices } from "@playwright/test";

export default defineConfig({
  testDir: "./e2e",
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 1 : 0, // 1 retry in CI only — not a flakiness band-aid
  workers: process.env.CI ? 2 : undefined,
  reporter: [["html"], ["list"]],
  use: {
    baseURL: process.env.BASE_URL || "http://localhost:3000",
    trace: "on-first-retry",
    screenshot: "only-on-failure",
    video: "on-first-retry",
  },
  projects: [
    { name: "chromium", use: { ...devices["Desktop Chrome"] } },
    // Add firefox/webkit only if cross-browser is a real requirement
  ],
  webServer: {
    command: "npm run dev",
    url: "http://localhost:3000",
    reuseExistingServer: !process.env.CI,
  },
});
```

**Auth fixture (`e2e/fixtures/auth.ts`):**

```typescript
import { test as base, expect } from "@playwright/test";

type AuthFixtures = {
  authenticatedPage: Page;
};

export const test = base.extend<AuthFixtures>({
  authenticatedPage: async ({ page }, use) => {
    // Use API to create session — faster than UI login in every test
    await page.request.post("/api/auth/test-session", {
      data: { userId: process.env.TEST_USER_ID },
    });
    await use(page);
  },
});

export { expect };
```

**Page object pattern (`e2e/pages/LoginPage.ts`):**

```typescript
import { Page, Locator } from "@playwright/test";

export class LoginPage {
  readonly emailInput: Locator;
  readonly passwordInput: Locator;
  readonly submitButton: Locator;
  readonly errorMessage: Locator;

  constructor(private page: Page) {
    this.emailInput = page.getByTestId("email-input");
    this.passwordInput = page.getByTestId("password-input");
    this.submitButton = page.getByTestId("login-submit");
    this.errorMessage = page.getByTestId("login-error");
  }

  async goto() {
    await this.page.goto("/login");
  }

  async login(email: string, password: string) {
    await this.emailInput.fill(email);
    await this.passwordInput.fill(password);
    await this.submitButton.click();
  }
}
```

### Step 3: Write the Test Specs

Write tests for each P0 journey. Use this pattern:

**Auth journey (`e2e/auth.spec.ts`):**

```typescript
import { test, expect } from "@playwright/test";
import { LoginPage } from "./pages/LoginPage";

test.describe("Authentication", () => {
  test("user can sign in with valid credentials", async ({ page }) => {
    const loginPage = new LoginPage(page);
    await loginPage.goto();
    await loginPage.login(process.env.TEST_EMAIL!, process.env.TEST_PASSWORD!);

    await expect(page).toHaveURL("/dashboard");
    await expect(page.getByTestId("user-nav")).toBeVisible();
  });

  test("invalid credentials show error, do not redirect", async ({ page }) => {
    const loginPage = new LoginPage(page);
    await loginPage.goto();
    await loginPage.login("nobody@example.com", "wrongpassword");

    await expect(page).toHaveURL("/login");
    await expect(loginPage.errorMessage).toBeVisible();
    await expect(loginPage.errorMessage).toContainText("Invalid");
  });

  test("unauthenticated user is redirected from protected route", async ({
    page,
  }) => {
    await page.goto("/dashboard");
    await expect(page).toHaveURL(/login/);
  });
});
```

**Core journey (`e2e/core-flow.spec.ts`):**

```typescript
import { test, expect } from "./fixtures/auth"; // authenticated fixture

test.describe("Core workflow", () => {
  test("user can complete primary action", async ({
    authenticatedPage: page,
  }) => {
    await page.goto("/app");

    // Act — user performs the core value action
    await page.getByTestId("primary-action-button").click();
    await page.getByTestId("action-form-input").fill("Test data");
    await page.getByTestId("action-submit").click();

    // Assert — visible outcome, not internal state
    await expect(page.getByTestId("success-message")).toBeVisible();
    await expect(page.getByTestId("result-item")).toContainText("Test data");
  });
});
```

**Key patterns in every test:**

- Use `getByTestId()` — not CSS selectors or text that might change
- Assert on visible outcomes the user would see — not internal state
- Use proper Playwright auto-waits — never `waitForTimeout()`
- Each test is fully independent — no test depends on another test's state
- Auth via API/fixture, not by navigating the login UI in every test

### Step 4: Test Data Strategy

Decide on test data approach based on what's available:

- **API setup (preferred):** Use authenticated API calls in `test.beforeEach` to seed data, clean up in `test.afterEach`
- **Database seeding:** Use a test seed script if direct DB access is available in test environment
- **Fixtures:** Static fixture data for read-only tests
- **Never:** Use production data, hardcoded IDs that exist in one environment, or shared state between tests

### Step 5: CI Integration

```yaml
# .github/workflows/e2e.yml
name: E2E Tests
on: [push, pull_request]

jobs:
  e2e:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: "20" }
      - run: npm ci
      - run: npx playwright install --with-deps chromium
      - run: npm run build
      - run: npx playwright test
        env:
          BASE_URL: http://localhost:3000
          TEST_EMAIL: ${{ secrets.TEST_EMAIL }}
          TEST_PASSWORD: ${{ secrets.TEST_PASSWORD }}
      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: playwright-report
          path: playwright-report/
```

If the suite exceeds 3 minutes on CI, shard it:

```yaml
- run: npx playwright test --shard=${{ matrix.shard }}/3
  strategy:
    matrix:
      shard: [1, 2, 3]
```

### Step 6: Summary

Output what was written:

```
┌─ E2E Suite ──────────────────────────────────────────────┐
│  Tool        Playwright                                   │
│  Tests       N specs across M journeys                    │
│  Coverage    P0: auth, core flow, checkout                │
│              P1: signup, password reset                   │
│  Skipped     [list what was explicitly excluded + why]    │
│  Est. time   ~X min on CI (sharded: Y min)                │
├──────────────────────────────────────────────────────────┤
│  ✖ Gaps      [any P0 not yet covered]                     │
│  ⚠ Needs     data-testid on: [list missing test IDs]      │
│  → Next      [one concrete next step]                     │
└──────────────────────────────────────────────────────────┘
```

## Key Rules

- Write tests for journeys, not components — E2E is expensive, use it for what only E2E can catch
- Never `waitForTimeout()` — use Playwright's auto-waits and `expect().toBeVisible()`
- Every test is independent — no shared state, no test order dependencies
- Auth via API fixture — not UI login in every test (that's slow and a separate concern)
- `data-testid` for selectors — CSS classes and text break on refactors
- Suite must run under 5 minutes on CI — shard if needed, delete if bloated
- 1 retry in CI only — retries hide flakiness, don't use them locally
- Screenshots and traces on failure are mandatory — debugging blind wastes hours
- Explicit "skip" list — document what you're not testing in E2E and why

## Delivery

If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.
Files in this package (2)
  • SKILL.md 11 KB
  • .claude-plugin/plugin.json 1 KB

Versions

RepositoryScoreLicence
This page · jeremylongshore/tons-of-skills-marketplace100MIT
tonone-ai/tonone100MIT

Database snapshot: 13.11.2026 · package version f08f18341443 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 86e2e-test
    Writes end-to-end tests for a user journey through the running app, Playwright preferred. Use when user requests e2e, end-to-end, Playwright, or Cypress tests.
  • 100e2e-testing
    Use when you need end-to-end tests for critical user flows that unit tests can't cover — scaffolds Playwright/Cypress tests from the happy path through edge cases.
  • 100e2e-testing
    Author, maintain, run, and debug resilient end-to-end browser tests (Playwright, Cypress) for critical user journeys. Use when writing automated E2E tests, codifying acceptance criteria into browser suites, or diagnosing flaky browser tests.
  • 90quality-e2e-testing
    Use this skill when setting up E2E testing, end-to-end tests, Playwright, Cypress, browser tests, user flow tests, or integration tests. This skill enforces: framework selection (Playwright preferred), page object model, test isolation, parallel execution, CI integration, and…
  • 90playwright-pro
    End-to-end testing with Playwright: test generation, page objects, locator strategy, flaky- test diagnosis, visual regression, and CI integration. Use when writing E2E tests, fixing flaky tests, or migrating from Cypress/Selenium.
  • 95playwright-test
    Creates Playwright browser-based end-to-end tests for Next.js pages covering complete user journeys from start to finish. Use when the user asks to "write Playwright tests", "create e2e tests", "write integration tests", "test in the browser", or mentions end-to-end testing,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.