More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Socratic Duck

    1

    A Socratic debugging tutor that guides you to find your own bugs through progressive hints without ever providing the fix.

    Free

    Security scanned
    Socratic Duck

    Socratic Duck

    Example session with this skill installed

    Use socratic-duck. My second call to add_to_cart remembers the first one's item and I don't get why.

    def add_to_cart(item, cart=[]):
        cart.append(item)
        return cart
    
    alice = add_to_cart("laptop")
    bob = add_to_cart("headphones")
    print(bob)  # expected ['headphones'], got ['laptop', 'headphones']
    
    • Read your context and instructions
    • Compiled the socratic duck

    Duck: Quack. Before we touch the code: you called the function twice and never passed a cart. How many separate lists did you expect to exist at the end, and how many do you think actually exist?

    You: I expected two. Maybe there's only one? I don't know why.

    Duck: Good thing to question. Look at the function's first line, the part in the parentheses. When does Python evaluate what's written there: every time the function runs, or at some other moment?

    You: Not sure. Maybe when the function is defined?

    Duck: Don't take my word for it, test it. Print id(cart) inside the function and call it three times. What do you notice about the ids?

    You: Same id every time. So the default list is created once when the def runs, and every call without an argument shares it.

    Duck: That's the cause, and you worked it out yourself. Solved.

    Case file

    Root cause: A default argument is evaluated once, when the function is defined, so every call that skips the argument shares the same list.

    • Lesson: Be suspicious of mutable objects as default parameter values.
    • Flashcard: When is a default argument evaluated in Python? Once, at function definition time.

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

    About this skill

    Socratic Duck is a debugging tutor for your coding agent. You paste an error, a traceback or some code that isn't behaving, and instead of a patch you get questions. The first one is always about what you expected to happen versus what actually happened. If you're still stuck after a couple of replies, the questions get more specific: first a region of the code, then the concept behind it, then the exact line.

    It never writes the fix and never tells you what's wrong. When you work out the cause and say it back, it confirms that and gives you a short case file with the root cause in your own words, a one-line lesson and a flashcard.

    Who it's for: people learning to code, students prepping for exams or interviews, and teachers who want a tool that won't hand out answers.

    How to use it: tell your agent something like "use socratic-duck, my loop skips the first item". If your agent can read files or images, you can point it at a file or an error screenshot.

    There's a patience habit too. Beg it for the answer and it gets grumpier and moves up a hint level. That part is partly for fun, but it does discourage blind guessing.

    What it won't do: edit your files, run your code or fix anything for you. If you just want the answer, use your normal assistant.

    I originally built Socratic Duck as a web app on Gemma 4, and it won Best Use of Gemma 4 at an MLH hackathon. This skill is the tutoring part, packaged so it works in any agent. The full app is on GitHub: github.com/pythonperfec/socratic-duck

    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.

    • The "never reveal the fix" rule is enforced by instructions and a self-check, not a separate checker. With pressure or a weaker model it can occasionally slip. The full app adds a second-model check; a skill can't.
    • It won't write, apply or confirm fixes. For the answer, use a normal assistant.
    • Works best on a single bug in a snippet or small file, not whole repos.
    • Question quality depends on the model behind your agent. Small models may ask vaguer questions.
    • Reads files only; never edits them. Screenshots need an agent with image support.
    • Tested mainly on Python and JavaScript. [Confirm this is true.]

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    • Free with an Agensi account

    Permissions

    Write Files
    Browser

    File Scopes

    **/*.py
    **/*.js
    **/*.ts
    **/*.jsx
    **/*.tsx
    Listed8 days ago

    What's inside

    Frequently Asked Questions

    No, the Socratic Duck is programmed with strict guardrails that prevent it from providing code blocks, diffs, or direct fixes, ensuring you develop the problem-solving skills to fix it yourself.

    The skill is entirely language-agnostic; it can analyze logic, syntax, and stack traces for any programming language, from Python and JavaScript to C++ and Rust.

    Upon purchase, you receive the full Socratic Duck skill configuration, including its progressive hinting logic, the learning reinforcement module, and any future version updates.

    Simply import the skill into your preferred AI agent platform, provide a code snippet or error message, and the agent will immediately begin the guided questioning process.

    Standard LLMs are designed to be 'helpful' by fixing code automatically, whereas this skill is specialized to withhold the answer and guide your cognitive process through a structured four-level hinting ladder.

    Once you've identified the bug, the agent generates a 'Case File' that includes a summarized lesson and a custom flashcard to help you internalize the fix and prevent the same error in the future.

    New in Testing & Debugging

    Free