Skip to content
Skills Library
Programming · Testing

webapp-testing

/webapp-testing

Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.

Repository
dotclaude ↗
Licence
MIT
Last repository change
25.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 25.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

Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.

Original author description

Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.

How it works

  1. Step 1: Check for Playwright and a running app
  2. Step 2: Identify what to verify
  3. Step 3: Write the Playwright script
  4. Step 4: Interaction patterns
  5. Step 5: Run and report
  6. Common failure patterns to check
Original SKILL.md headings · 153 lines, 770 words
SKILL.md preview
---
name: webapp-testing
description: Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.
---

Test the application in a real browser rather than claiming it works from a code read alone. A passing type-check or unit test does not mean the page renders, the form submits, or the network request succeeds. Run the app, drive it with Playwright, and report what actually happened.

## Step 1: Check for Playwright and a running app

```bash
# Check if Playwright is installed
npx playwright --version 2>/dev/null || echo "not installed"

# Check if there is an existing Playwright config
ls playwright.config.ts playwright.config.js 2>/dev/null
```

If Playwright is not installed, install it:

```bash
npm install --save-dev @playwright/test
npx playwright install chromium
```

Check whether the dev server is already running. If not, start it before writing tests. Use the project's start script - check `package.json` for the correct command (`npm run dev`, `npm start`, etc.). The server must be running for Playwright to connect.

## Step 2: Identify what to verify

Before writing any test, state the scenario in plain terms:

- What page or URL does the scenario start from?
- What actions does the user take? (navigate, click, type, submit, wait)
- What is the expected outcome? (page title changes, element appears, URL changes, form resets, API call completes)
- Are there any states to verify along the way? (loading indicator, validation message, success confirmation)

If the user has not specified a scenario, default to: navigate to the app's root, confirm it loads without console errors, and take a screenshot.

## Step 3: Write the Playwright script

Write a focused script that tests the specified scenario. Keep each script to one scenario.

```typescript
import { chromium } from "@playwright/test";

const browser = await chromium.launch({ headless: true });
const context = await browser.newContext({
  viewport: { width: 1280, height: 720 },
});
const page = await context.newPage();

// Collect console errors throughout the session
const consoleErrors: string[] = [];
page.on("console", (msg) => {
  if (msg.type() === "error") consoleErrors.push(msg.text());
});

// Collect failed network requests
const networkErrors: string[] = [];
page.on("requestfailed", (request) => {
  networkErrors.push(`${request.method()} ${request.url()} - ${request.failure()?.errorText}`);
});

try {
  // Navigate and wait for the page to be ready
  await page.goto("http://localhost:3000", { waitUntil: "networkidle" });

  // Take a screenshot of the initial state
  await page.screenshot({ path: "screenshot-initial.png", fullPage: true });

  // Example: verify a heading is present
  const heading = await page.locator("h1").first().textContent();
  console.log(`Page heading: ${heading}`);

  // Example: fill and submit a form
  // await page.fill('[name="email"]', 'test@example.com');
  // await page.fill('[name="password"]', 'test-password');
  // await page.click('[type="submit"]');
  // await page.waitForURL('**/dashboard');

  // Take a final screenshot
  await page.screenshot({ path: "screenshot-final.png", fullPage: true });

  console.log("Console errors:", consoleErrors.length === 0 ? "none" : consoleErrors);
  console.log("Network errors:", networkErrors.length === 0 ? "none" : networkErrors);
} finally {
  await browser.close();
}
```

Adapt the script to the actual scenario. Replace the example interactions with the specific steps needed.

## Step 4: Interaction patterns

Use these patterns for common UI actions:

**Waiting correctly:**
```typescript
// Wait for a specific element to appear (not arbitrary sleep)
await page.waitForSelector(".success-message", { state: "visible" });

// Wait for navigation
await page.waitForURL("**/dashboard");

// Wait for a network request to complete
await page.waitForResponse((resp) => resp.url().includes("/api/login") && resp.status() === 200);
```

**Forms:**
```typescript
await page.fill('[name="email"]', "user@example.com");
await page.selectOption("select#country", "US");
await page.check('[name="terms"]');
await page.click('[type="submit"]');
```

**Responsive layout:**
```typescript
// Mobile viewport
await page.setViewportSize({ width: 375, height: 812 });
await page.screenshot({ path: "screenshot-mobile.png" });

// Tablet
await page.setViewportSize({ width: 768, height: 1024 });
await page.screenshot({ path: "screenshot-tablet.png" });
```

**Checking visibility and content:**
```typescript
const isVisible = await page.locator(".error-banner").isVisible();
const text = await page.locator(".status-message").textContent();
const count = await page.locator(".list-item").count();
```

## Step 5: Run and report

```bash
npx ts-node test-scenario.ts
# or if using @playwright/test:
npx playwright test
```

Report the outcome as:

**Passed:** what was verified (page loaded, form submitted, URL changed, specific elements present), the screenshot paths, and the console/network error counts.

**Failed:** the exact step that failed, the error message, what the page looked like at failure (screenshot path), any console errors collected, and any failed network requests.

Do not report "the test ran" as success. Report what was actually observed: the page title, the presence or absence of specific elements, whether the expected URL was reached, and whether any console errors fired.

## Common failure patterns to check

- **Hydration errors:** React/Next.js console errors starting with "Hydration failed" or "Text content did not match"
- **Missing environment variables:** `undefined` values appearing in rendered output where a URL or key should be
- **Network failures:** API calls returning 401, 404, or 500 visible in the network error list
- **Layout breaking at mobile widths:** elements overlapping or overflowing at 375px
- **Form validation not triggering:** submit button reachable without filling required fields

Versions

RepositoryScoreLicence
This page · khaledsaeed18/dotclaude100MIT
Navinspire-ia/navin100AGPL-3.0
Reprograme/redevkit100MIT
wrongstack/wrongstack100MIT
baysao/dot.agents100Apache-2.0
patriotai/ai-lab100MIT
alebgl77/claude-inc100MIT
jeffersonvalente/cardume100MIT
JZKK720/cubecloud-skills-bundle-kit100MIT

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 6a20f5c80401 (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

  • 100playwright
    Run browser-based E2E tests, capture screenshots, and validate user flows using Playwright with visible Chrome. Use this skill when testing a web UI end-to-end, capturing screenshots for visual review, checking responsive layouts, or auditing accessibility in a real browser.…
  • 100e2e-playwright-testing
    End-to-end testing with Playwright for web applications. Use when writing E2E tests, browser automation, form submission testing, or user flow testing. Triggers on "playwright", "e2e test", "browser test", "end-to-end", "form flow testing", or test files in tests/e2e/.
  • 95memstack-development-webapp-testing
    Use when the user says 'write browser tests', 'test this page', 'playwright test', 'e2e test', 'end to end test', 'browser test', 'test the UI', or needs Playwright-based browser testing for a web application. Do NOT use for unit tests, API tests, or non-browser testing.
  • 90browser-verification
    Verify frontend changes in a real browser, including layout, console errors, responsive states, network failures, screenshots, and interactions. Use after local or deployed web UI changes, visual fixes, forms, navigation, asset updates, canvas or 3D work, or whenever browser…
  • 100browser-verification
    Use when a completed task changed UI-affecting files and browser verification is needed during /work. Checks visual elements, interactions, and console errors in a real browser via Playwright. Not a standalone skill.
  • 100webapp-visual-testing
    Use when a browser-facing UI needs visual verification, a layout bug or visual regression is reported, accessibility of an interactive component needs checking, or a browser workflow must be exercised end-to-end.

Feedback and reports

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