Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Unstuck

    1

    Every developer who codes with AI has seen it: the same error, a third "fix", then a fourth, each one piling more broken code on top of the last.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Unstuck

    Unstuck

    Example session with this skill installed

    still failing

    • Read your context and instructions
    • Compiled the unstuck

    These are real runs, shortened, not invented. Same repository, same starting state, same message from the user. The only difference is whether the Unstuck skill was installed. Agent: Claude Code 2.1.319 with the small model (claude-haiku-5-5).

    The situation

    A test expects slugify('Hello, World!') to return 'hello-world', but gets 'hello,-world!'. The agent has already tried twice:

    1. Added a regex to strip punctuation in packages/utils/index.js. Same failure.
    2. Guessed it was unusual Unicode and added .normalize('NFKD'). Same failure.

    Its own note said the next step would be a different punctuation regex. The user writes: "still failing".

    The real cause: the test loads an old installed copy of the package from node_modules/, so none of the edits ever ran.

    Without Unstuck

    The agent found the stale copy, then made the test pass by

    changing the test to import the source file directly, and left its unneeded Unicode guess in the code:

    What I changed: test/slug.test.js: the import now points at the workspace source, require('../packages/utils/index.js'). packages/utils/index.js: left as I had it, with .normalize('NFKD') and .replace(...). Both are harmless...

    The test is green, but it no longer tests what the app actually loads, so the real app is still broken. This happened in all 3 runs without the skill.

    With Unstuck

    The skill loaded on its own. The agent took a snapshot, checked which file actually runs, kept the sound fix, rolled back the guess, and fixed the real cause without touching the test:

    npm test now passes both tests. The cause was not the regex, and I was editing code the test never ran.

    Cause: test/slug.test.js imports @shop/utils, which resolved to a stale copy in node_modules/@shop/utils... require.resolve('@shop/utils') now points at packages/utils/index.js, which confirms the fix.

    What I changed: package.json: added "workspaces": ["packages/*"]... packages/utils/index.js: kept the regex. Rolled back the .normalize('NFKD') guess, since it was not needed.

    Rollback record: before changing anything I saved a snapshot as stash@{0} ("unstuck: snapshot").

    The test is unchanged and the app now loads the fixed code. This happened in both runs with the final version of the skill.

    What this does and does not show

    It is one scenario from a small test set (4 scenarios, 2 to 3 runs each per setup). On the three easier scenarios, the agent without the skill also reached a correct fix; there the skill's main additions were the snapshot and the clear report, at the cost of a few more steps. A larger model (claude-sonnet-5-5) diagnosed this scenario correctly with or without the skill.

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

    About this skill

    Every developer who codes with AI has seen it: the same error, a third "fix", then a fourth, each one piling more broken code on top of the last. Unstuck is a circuit breaker for that loop.

    What your agent does with it

    • Notices the loop: the same failure after two attempts, each fix breaking something new, or you saying "still broken" or "we're going in circles"
    • Saves a backup of everything first (a git stash it can name), so nothing is ever lost
    • Checks the change is actually running: stale builds, the wrong file, an old installed package, a server that needs restarting. A correct fix that never runs looks exactly like a wrong one
    • Rolls back its own failed attempts, keeps your uncommitted work and anything that was genuinely right
    • Finds the cause with evidence ("X fails because Y, shown by Z"), not another guess
    • Tries a genuinely different approach, using a simple test: "if my earlier idea were right, would this also be expected to work?" If yes, it's the same idea
    • Refuses the fake fixes: no weakening or redirecting the test, no hard-coded answers, no random sleeps and retries
    • If it still can't fix it, it stops and hands back a short report plus a ready prompt for a fresh session, instead of a fifth guess

    Built to be safe

    • Never runs git reset --hard, git clean or a force push
    • Never discards your changes without asking
    • Instruction-only: ships no scripts and installs nothing

    Tested, not just written I ran it on four realistic stuck-loop setups in Claude Code, with and without the skill. In the hardest one (the test was loading an old installed copy of the code), the agent without Unstuck "fixed" it by changing the test in all 3 runs. With Unstuck it found the real cause and fixed it properly, test untouched, in both runs. The full before/after is in the download.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Testing & Debugging.

    Does not guarantee a fix: when it cannot find the cause, it says so and hands back a clear report and a fresh-start prompt instead of guessing again. Without git, rollback falls back to the agent's own undo or reversing its edits by hand. Agents decide when to load a skill; if it doesn't kick in, say "use the unstuck skill". Tested end to end in Claude Code on a small test set (4 scenarios, 2 to 3 runs each); on the easier scenarios the agent without the skill also reached a correct fix. Other agents not yet tested end to end.

    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 buying a skill.

    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 3 days ago

    Nothing to install. It runs in your AI agent.

    Optional
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Terminal or shell: git and the project's own test or build command. Files: reads project files; edits code only as part of the fix. Network: none. Services: none.

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    No. It is text instructions. Your agent runs its normal commands (mostly git and your test command).

    It saves a git stash of everything before changing anything, undoes only its own failed attempts, and is told never to use destructive git commands.

    No. When it cannot find the cause, it says so and gives you a clear report and a fresh-start prompt instead of guessing again.

    Usually. Agents decide when to load a skill; in testing it loaded on its own every time the user said "still failing", and never on a first, normal bug fix. If it doesn't, say "use the unstuck skill".

    General debugging skills cover every bug. Unstuck is only for when normal debugging has already failed twice: it adds the backup, the rollback, the "is my change even running" check and the honest hand-back.

    It still works, but rollback falls back to the agent's own undo or reversing its edits by hand.

    New in Testing & Debugging