Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    explore first e2e

    1

    Verify UI flows through manual exploration, human confirmation, and proven Playwright automation.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    explore first e2e

    explore first e2e

    Example session with this skill installed

    Add E2E tests for the profile feature of this project. Start the site with POPUP=dismiss PORT=4331 node app/server.mjs. There is no login.

    • Read your context and instructions
    • Compiled the explore first e2e

    Real run on a small demo site with planted bugs, translated and condensed.

    I walked the profile feature as a user and

    stopped at the confirmation step without writing any tests. Writing them now would turn behavior like "bio disappears after reload" and "the server returns 500 but the screen says Saved" into expected results.

    How I explored: local site, Playwright with Edge, real clicks and typing only. 12 scenarios at desktop (1280×800) and phone (375×812) sizes.

    Needs your decision

    IDObservedSuggested expectationPlease confirmLevel
    S3Fill in bio and save: shows "Saved" (POST 200). After reload the bio is blank, and GET always returns an empty bio. The nickname is keptBio stays after reloadShould bio persist like the nickname?P0
    S4Nickname with an emoji: POST returns 500 bad_charset, the console shows an error, the screen still says "Saved", and nothing is storedShow an error, not "Saved"Should a failure show an error? Should emoji be supported?P1
    S5The popup appears on every load and covers the page (.overlay intercepts pointer events). Esc and clicking the backdrop don't close it; only "Got it" doesDoesn't reappear once closed, though reminding every time may be intendedEvery time, or only once?P2
    S6Blank, spaces-only, and space-padded nicknames all show "Saved" and are stored as typedReject blanks, trim spacesCan a nickname be blank?P2
    S7A 300-character nickname saves with no warningUndecidedIs there a length limit?P2
    S8One shared profile for the whole site. A stale tab that saves overwrites what another tab just savedAcceptable if it's a single-user demoIs last-save-wins acceptable?P2

    Looks fine

    These become tests as suggested unless you object.

    • S1: the popup covers the profile page, and the form works after "Got it".
    • S2: a saved nickname survives a reload.
    • S9: special characters and HTML in nicknames are saved as typed.
    • S10: phone size behaves the same as desktop.

    E2E not recommended

    • S11: double-clicking Save sends 2 POSTs with the same result.
    • S12: character, length, and blank rules belong in API tests.

    Status

    • Scenarios: 0 confirmed, 12 waiting for you
    • Tests: none added yet
    • Scan: HIGH 0, MEDIUM 0; the decision record has 12 undecided rows
    • Not reached: other popup modes, slow or lost network, other browsers

    Your turn

    Reply per scenario with S1 ok, S3 bug, S5 change: only once, S7 skip, or S6 unsure, or say "go with your suggestions".

    Next, I'll write the confirmed scenarios as @core Playwright tests and mark confirmed bugs with test.fail(). I'll then temporarily break the product to prove each test goes red, and wire them into CI.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Traditional E2E testing often fails because scripts are written to match the code rather than the user experience. This leads to "false greens" where tests pass despite UI overlays blocking buttons, state resets on navigation, or API failures masked as success. This skill enforces a strict verification lifecycle: manual exploration, human confirmation of expected behavior, and automated breakage testing.

    What it does

    • User-centric exploration walks through application flows as a human would to identify real-world failure points.
    • Human-in-the-loop confirmation separates observed behavior from expected results to prevent bugs from becoming "features."
    • Playwright script generation creates stable, scenario-based automation for confirmed behaviors.
    • Failure proofing runs automated mutations to verify that tests actually turn red when the product breaks.
    • CI/CD integration audit ensures tests are wired into the deployment pipeline and not just sitting idle in the repository.

    How it works

    1. Explore the entry points and main flows using a browser tool or ariaSnapshot to record actual vs. expected behavior.
    2. Report findings using the decision record format and wait for the user to categorize each scenario (bug, ok, skip, or unsure).
    3. Script the confirmed scenarios in Playwright, following the exact user path and asserting visible UI results.
    4. Prove test reliability by temporarily breaking the source code and confirming the test suite catches the fault.

    Frameworks & tools

    This skill is built for Playwright and Node.js environments. It utilizes custom scripts for scanning fake tests and verifying breakage, and works with standard CI/CD workflows (GitHub Actions, GitLab CI).

    Why this beats prompting it yourself

    Generic prompts often result in tests that assert what the code currently does, missing UI-specific blockers or race conditions. This skill forces a "red-first" mentality, ensuring every test added has been proven to fail under pressure and verified by a human before it ever hits the main branch.

    Use cases

    • Regression testing after a core UI screen or navigation flow has changed.
    • Auditing test suites to identify "duplicate" or "fake" tests that never actually run in CI.
    • New feature verification to establish a baseline of core flows before shipping.
    • Root cause analysis when production breaks despite all existing tests passing.

    Known limitations

    Does not support pure backend logic with no UI components. Requires a local or test environment with valid test accounts. Folder paths on Windows must be managed via mklink if they exceed 260 characters.

    Requires a local or test environment; don't explore production. Not for pure backend logic without UI. Waits for human confirmation before writing tests, so it won't deliver a finished suite unattended. The scanner reads JS/TS only and is a static screen. CI templates have not been run on GitHub Actions. Tested in Claude Code only. Windows paths over 260 characters need mklink. Credentials must be provided by the user.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 15 days ago

    Requires

    Node.js
    playwright

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Read Files
    Write Files
    Environment Variables

    Terminal: runs the bundled Node scripts, your dev server, and Playwright. Read/Write Files: reads the project, writes reports to specs/ and tests, and during failure checks temporarily edits product files you name, then restores them byte for byte. Browser: operates your app as a user. Network: reaches only the local or test site being tested; the bundled scripts make no outbound calls of their own. Environment Variables: scripts pass your environment to your test command and do not collect it; keep test credentials there.

    Listed15 days ago

    What's inside

    Frequently Asked Questions

    AI-generated scripts often come straight from the source code, so they can pass while users are stuck. This skill adds two checks. Before writing tests, the agent operates your app and asks you to confirm the expected behavior, so a current bug doesn't become the expected result. After writing them, a bundled script temporarily breaks the product code, checks the test fails for the right reason, and restores the file byte for byte. A bundled scanner also flags patterns that can hide failures. This reduces false greens but can't guarantee a test suite is complete.

    It's built for Playwright and needs Node.js for its helper scripts (tested on Node v24 and Playwright 1.64). The scanner reads JS and TS test files and checks CI wiring in GitHub Actions workflows only. The included GitHub Actions templates have not been run on GitHub yet, so check the first run yourself. Other test frameworks or CI systems would need adapting. Tested in Claude Code only.

    No. A local environment works and is preferred; a test environment is fine too. The skill avoids exploring production, and treats any site sharing a database with other projects as production. You only need test accounts if your app has a login.

    You get the skill folder: the main SKILL.md workflow, a README, four reference guides (exploration checklist, Playwright script rules, red-test triage and test audits, CI setup), a full example report, and two templates (exploration report, core-flow list). It also includes two dependency-free Node scripts: one scans for tests that don't verify behavior and for CI wiring problems, and one temporarily breaks product code to prove a test can fail, then restores it. Playwright itself is not included; install it in your project.

    Yes. It targets web apps that Playwright can open in a browser and that you can run locally or in a test environment. It isn't meant for pure backend logic with no UI, where unit or API tests fit better, or for prototypes whose UI changes daily. Canvas apps and games need extra care because canvas content isn't visible to accessibility tools, so assertions rely on on-page text, saved data, or the API. Native mobile and desktop apps aren't covered. Apps with a login need test accounts from you.

    New in Testing & Debugging