More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Deep Skills

    1

    Coding agents fail in two expensive ways: they build the wrong thing because a requirement was misread, and they break unrelated code because nobody mapped the blast radius.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    deep-skills

    deep-skills

    Example session with this skill installed

    /deep-feature on a small ticket: add a search box and a status filter to an issue list, keep both in the URL so links can be shared and the back button works, and show an empty state with a way to reset. The app is a small demo made for this example.

    • Read your context and instructions
    • Compiled the deep-

    Result, from the published run, step by step:

    1. deep-plan found what the ticket left open and asked 4 questions, plus 5 stated defaults. For example, a plain lower-case search misses "İstanbul" when you type "istanbul", so it asked how strictly letters should match. Then it stopped for a go.

    2. Implementation followed the plan's 6 steps, each with a check.

    3. deep-test found no bugs, took the unit tests from 17 to 21, and broke the code on purpose 14 ways; the tests caught all 14.

    4. deep-ui-test ran 26 scenarios at 8 viewport sizes in a real browser and found a bug: on a slow connection, whatever you typed before the script loaded was wiped.

    5. deep-ux tried 6 tasks as a first-time user and made 7 ranked suggestions, prototyped live. The user picked 6.

    6. deep-review ran its own pass and an independent reviewer, over two rounds, and found 4 more bugs: the list stopped updating after Safari's limit on URL changes, a refused URL change was never retried, going back two pages showed the wrong status, and focus was lost on back/forward. It also disproved one earlier "pass" from deep-test.

    7. deep-ship stopped for a second go, then committed and opened the PR.

    Final state: 22 unit tests and 34 e2e runs passing (17 tests on desktop and phone). The user answered 20 questions, most with "all recommended", and gave the 2 go's.

    Not verified, and it says so: Firefox, real Safari and iOS (Playwright WebKit only), a real phone keyboard, arrow keys on the status control in Chrome on Windows or Linux, and back/forward-cache restores.

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

    About this skill

    Coding agents fail in two expensive ways: they build the wrong thing because a requirement was misread, and they break unrelated code because nobody mapped the blast radius. deep-skills puts a process around the agent that catches both.

    What's in the pack

    • deep-feature conducts the whole flow from a ticket, skips what doesn't apply, and stops at both gates.
    • deep-plan reads the material, maps the code, sweeps edge cases, plans tests and asks every open question with a recommended answer. It implements nothing until you say go.
    • deep-test finds the edge cases that can really happen, audits the unit tests, and checks that tests fail when the behaviour breaks.
    • deep-ui-test turns requirements into a scenario matrix and runs it in a real browser across states, viewports and locales.
    • deep-ux walks the changed screens as a first-time user and returns ranked suggestions. It changes nothing until you pick.
    • deep-review reviews the branch against the plan twice: its own pass and an independent reviewer.
    • deep-ship commits only what belongs to the work, pushes safely and opens a reviewer-facing PR.
    • deep-pr-comments checks each review comment against the code, fixes the valid ones and drafts replies.

    How it works

    Every step reads and writes one work doc, so a new or compacted session continues where the last one stopped. Claims about current behaviour point at a file and line, or are labelled as assumptions. Your repo's own rules win over the skills.

    Where it stops

    It never implements or ships without your explicit go. It's a heavy process on purpose: skip it for a one-line fix or a quick experiment.

    • Heavy by design: it costs real agent time and usage. Skip it for small fixes.
    • deep-ui-test and deep-ux need a web UI and a browser tool.
    • deep-ship and deep-pr-comments support GitHub and GitLab.
    • Built and used with Claude Code as locally installed skills. Loading it through Agensi's MCP connection, and deep-feature's steps running as subagents that way, is untested.

    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 today

    Requires

    GitHub
    Gitlab
    git
    GitHub CLI (gh) or GitLab CLI (glab)
    Browser automation: Claude in Chrome or Playwright
    Node.js
    prettier
    eslint
    tsc
    jest
    vitest
    playwright
    cypress

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Network Access

    Allowed Hosts

    api.github.com
    gitlab.com

    Reads and edits project files and runs the project's own commands (tests, lint, typecheck). Uses git, and gh or glab to push and open PRs (deep-ship) and read review comments (deep-pr-comments). deep-ui-test and deep-ux drive a browser against your local app. It never ships or implements without your explicit go.

    Listedtoday

    What's inside

    Frequently Asked Questions

    No. Each skill works alone. deep-review is a good first try on a branch you already have: with no plan or ticket, it rebuilds the intent from the commits and says so.

    No. deep-plan and deep-feature wait for an explicit go before implementing, and deep-feature waits again before shipping. Invoking deep-ship by itself counts as that go.

    Yes. It reads CLAUDE.md, AGENTS.md, CONTRIBUTING.md and the docs index first, and where they differ from the skill, your repo wins.

    The docs link has one full run: the ticket, the work doc, screenshots and code.

    New in Agents & Orchestration