Skip to content
Skills Library
Programming · Testing

webapp-testing

/webapp-testing

Test local web applications with Playwright. Use when asked to verify frontend functionality, debug UI behavior, capture browser screenshots, or inspect browser logs. Pure-methodology skill: teaches the reconnaissance-then-action pattern and decision tree for static vs dynamic apps, with no bundled scripts. The agent writes native Playwright code or uses browser MCP tools instead.

Licence
MIT
Last repository change
12.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
2
Deprecation

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

Test local web applications with Playwright. Use when asked to verify frontend functionality, debug UI behavior, capture browser screenshots, or inspect browser logs. Pure-methodology skill: teaches the reconnaissance-then-action pattern and decision tree for static vs dynamic apps, with no bundled scripts. The agent writes native Playwright code or uses browser MCP tools instead.

Original author description

Test local web applications with Playwright. Use when asked to verify frontend functionality, debug UI behavior, capture browser screenshots, or inspect browser logs. Pure-methodology skill: teaches the reconnaissance-then-action pattern and decision tree for static vs dynamic apps, with no bundled scripts. The agent writes native Playwright code or uses browser MCP tools instead.

How it works

  1. Decision Tree: Choosing Your Approach
  2. Two execution paths
  3. Reconnaissance-Then-Action Pattern
  4. Common Pitfall
  5. Best Practices
  6. What was removed from the upstream skill
Original SKILL.md headings · 106 lines, 590 words
SKILL.md preview
---
name: webapp-testing
description: "Test local web applications with Playwright. Use when asked to verify frontend functionality, debug UI behavior, capture browser screenshots, or inspect browser logs. Pure-methodology skill: teaches the reconnaissance-then-action pattern and decision tree for static vs dynamic apps, with no bundled scripts. The agent writes native Playwright code or uses browser MCP tools instead."
---

# Web Application Testing

Test local web applications by writing native Python Playwright scripts, or by using the browser MCP tools available in VS Code Copilot Chat (open_browser_page, click_element, read_page, screenshot_page, type_in_page).

This skill teaches the **reconnaissance-then-action** pattern and the **static vs dynamic decision tree**. It does not bundle any helper scripts — the agent writes Playwright code directly or uses the browser MCP tools.

## Decision Tree: Choosing Your Approach

```mermaid
flowchart TD
    A[User task] --> B{Is it static HTML?}
    B -- Yes --> C[Read HTML file directly<br/>to identify selectors]
    C --> D{Success?}
    D -- Yes --> E[Write Playwright script<br/>using selectors]
    D -- Fails/Incomplete --> F[Treat as dynamic]
    B -- No, dynamic webapp --> G{Is server already running?}
    G -- No --> H[Tell user to start server<br/>or use MCP browser tools]
    H --> I[Reconnaissance-then-action]
    G -- Yes --> I
    I --> J[1. Navigate and wait for networkidle]
    J --> K[2. Take screenshot or inspect DOM]
    K --> L[3. Identify selectors from rendered state]
    L --> M[4. Execute actions with discovered selectors]
```

## Two execution paths

### Path A: Native Playwright (Python)

Write a self-contained Playwright script. The agent manages server lifecycle itself — it does NOT shell out to a bundled helper. If a dev server needs to start, the user starts it in a separate terminal, or the agent uses the run_in_terminal tool.

**Single server example** (user starts `npm run dev` in a terminal first):

```python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto('http://localhost:5173')
    page.wait_for_load_state('networkidle')  # CRITICAL: wait for JS to execute
    # ... your automation logic
    browser.close()
```

**Static HTML example** (no server needed):

```python
from playwright.sync_api import sync_playwright
from pathlib import Path

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto(f'file://{Path("index.html").resolve()}')
    page.wait_for_load_state('networkidle')
    # ... your automation logic
    browser.close()
```

### Path B: Browser MCP tools (VS Code Copilot)

If the browser MCP tools are available (open_browser_page, click_element, read_page, screenshot_page, type_in_page), prefer them for interactive inspection — they require no script file and give live feedback.

```
1. open_browser_page → http://localhost:5173
2. read_page → get accessibility snapshot
3. screenshot_page → capture current state
4. click_element / type_in_page → interact
5. read_page → verify result
```

## Reconnaissance-Then-Action Pattern

1. **Inspect rendered DOM** (after waiting for networkidle):
   ```python
   page.screenshot(path='/tmp/inspect.png', full_page=True)
   content = page.content()
   page.locator('button').all()
   ```

2. **Identify selectors** from inspection results

3. **Execute actions** using discovered selectors

## Common Pitfall

**Don't** inspect the DOM before waiting for `networkidle` on dynamic apps.
**Do** wait for `page.wait_for_load_state('networkidle')` before inspection.

## Best Practices

- Use `sync_playwright()` for synchronous scripts
- Always close the browser when done
- Use descriptive selectors: `text=`, `role=`, CSS selectors, or IDs
- Add appropriate waits: `page.wait_for_selector()` or `page.wait_for_timeout()`
- If a dev server is needed, start it in a separate terminal or via run_in_terminal — do not bundle server management into the test script

## What was removed from the upstream skill

The original `webapp-testing` skill (JZKK720/oz-skills) bundled `scripts/with_server.py` to manage server lifecycle. SkillSpector blocked it at `scripts/with_server.py:69` for HIGH TM1 — tool parameter abuse (`shell=True`, which allows arbitrary command injection through user-provided `--server` arguments).

This port **removes all bundled scripts**. The agent writes native Playwright code directly or uses the browser MCP tools. Server lifecycle is the user's responsibility (start `npm run dev` in a terminal) or the agent's (via run_in_terminal), never a bundled helper that shells out with user input.

The methodology — decision tree, reconnaissance-then-action, static vs dynamic handling, common pitfalls — is preserved verbatim. Only the unsafe script execution path was removed.

Versions

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

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

  • 100testing-webapps
    Use when testing local web applications using Playwright. Triggers include requests to verify frontend functionality, debug UI behavior, capture browser screenshots, view browser logs, or test any web application interactively. Write native Python Playwright scripts for all web…
  • 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.
  • 100playwright-automation
    Browser automation and testing with Playwright. Use when testing web applications, automating browser tasks, taking screenshots, or validating UI behavior.
  • 100web-debug
    Python Playwright testing of local web apps. Use when verifying frontend functionality, debugging UI behavior, capturing browser screenshots, or viewing browser console logs.
  • 100web-debug
    You MUST use this when interacting with or testing local web applications with Playwright - verifying frontend functionality, debugging UI behavior, capturing browser screenshots, or viewing browser console logs.
  • 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/.

Feedback and reports

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