Don't be Dumb!

    1

    A recovery and reality-check skill that stops AI coding agents from going in circles and forces evidence-based debugging.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Don't be Dumb!

    Example session with this skill installed

    don't be dumb. you've tried changing the auth middleware three times and the 401 error is still there. zoom out.

    • Read your context and instructions
    • Compiled the don t be

    DON'T BE DUMB CHECK

    Status: POSSIBLE REASONING LOOP

    Original goal: Resolve 401 Unauthorized errors on the /api/v1/profile endpoint.
    Last known good: Commit 7d2f3a (before the Passport.js upgrade).
    Current failure: All authenticated requests return 401 despite valid Bearer tokens.

    Facts

    • middleware/auth.ts was modified in the last 3 turns.
    • GET /api/v1/profile returns 401 in curl tests.
    • Passport strategy JWT is initialized in app.ts.

    Assumptions

    • The issue is inside the middleware logic.
    • The environment variables for JWT_SECRET are correctly loaded.

    Evidence for current hypothesis: Middleware logs show "Authentication failed" string.
    Evidence against: The same middleware works for /api/v1/health.
    What changed: Passport.js was updated from v0.4 to v0.6, which changed the session default.

    Possible explanations

    1. Passport v0.6 requires explicit session: false which is missing in the new config.
    2. The JWT secret in the .env file is being shadowed by a shell export.
    3. The client is sending a malformed header that the new version parses differently.

    Best next diagnostic: cat .env and check process.env.JWT_SECRET via a temporary log in app.ts.
    Why: If the secret is mismatched, no amount of middleware refactoring will fix the 401.

    Do not change code yet.

    Next steps

    1. Run the suggested diagnostic to verify the secret.
    2. Check the Passport.js migration guide specifically for session handling changes.
    3. If the secret is valid, perform a git diff 7d2f3a middleware/auth.ts to see what was deleted.

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

    About this skill

    Coding agents often fall into reasoning tunnels, digging deeper into speculative fixes while ignoring the root cause. This leads to broken builds, regressed code, and wasted tokens. This skill provides a structured recovery layer to halt speculative edits and force a reality check based on evidence rather than assumptions.

    What it does

    • Stops speculative loops by halting multi-variable edits and workarounds when progress stalls.
    • Establishes Last-Known-Good states by auditing git history, logs, and user confirmations to find the boundary of failure.
    • Audits evidence by strictly separating established facts from unproven assumptions and citing sources.
    • Challenges hypotheses via internal self-questioning to detect confirmation bias or symptom-fixing.
    • Plans minimal diagnostics by identifying the smallest action needed to prove or falsify the current direction.

    How it works

    1. Trigger the skill manually with don't be dumb or allow the agent to auto-activate when it detects repeated failed attempts.
    2. Reconstruct the original task and constraints to strip away accidental scope creep.
    3. Analyze the gap between the last working state and the first failure to isolate the actual change that caused the regression.
    4. Execute a diagnostic plan that prioritizes gathering evidence over modifying code.

    Frameworks & tools

    This skill is platform-agnostic and works with any environment where the agent has access to git, test runners, and terminal output. It is designed for use in Claude Code, Cursor, and other agentic IDE environments.

    Why this beats prompting it yourself

    Manual prompting often fails once the agent is already in a reasoning loop because the context is saturated with its own incorrect assumptions. This skill provides a rigid, phase-based framework that forces the agent to move out of its own context and treat its previous actions as untrusted data.

    Use cases

    • Recovering when an agent keeps "fixing" the same file but the test still fails.
    • Identifying why a previously working feature suddenly broke after a series of complex refactors.
    • Breaking out of a loop where the agent keeps suggesting the same library update or config change.

    Known limitations

    Does not perform automated rollbacks without explicit permission. Requires access to local history or git to establish a credible last-known-good state.

    Requires git or command history for state reconstruction. Cannot force a fix, only a diagnostic reassessment. Will not perform destructive actions or rollbacks without user consent.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    GitHub
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Allowed Hosts

    raw.githubusercontent.com
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill is designed to stop agents from spiraling into 'speculative loops' where they repeatedly apply broken fixes. It forces the agent to stop editing, audit recent changes against git history, and gather hard evidence before attempting another code change.

    It is platform-agnostic and works with any agentic environment that has access to a terminal and version control, including Claude Code, Cursor, Windsurf, and custom CLI agents. It relies on standard tools like git and test runners rather than specific IDE APIs.

    Setup is straightforward: you add the skill to your agent's toolset or system prompt instructions. Once installed, it can be triggered manually with a simple command or set to auto-activate when the agent detects a series of failed test runs.

    No, for safety reasons the skill identifies the 'Last-Known-Good' state but will not force a git reset or delete code without your explicit confirmation. It provides the diagnostic path, but you maintain final control over the codebase.

    You receive the full skill integration package, including the structured recovery framework, activation triggers, and a guide for optimal configuration across different LLM providers. Purchasers also get access to logic updates as new 'looping' behaviors are identified in modern models.

    While simple prompts can be ignored once a model is stuck in a reasoning tunnel, this skill uses a phase-based architecture that forces the agent to treat its own recent history as 'untrusted data,' effectively resetting its logic gates without losing the project context.

    New in Testing & Debugging