New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Protocol D Debugging

by DanielPodolsky in DanielPodolsky/ownyourcode

Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY).

MITAuto-check passedDevelopment

Install Protocol D Debugging

skills CLI
$ npx skills add DanielPodolsky/ownyourcode --skill protocol-d-debugging -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install DanielPodolsky/ownyourcode protocol-d-debugging --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/DanielPodolsky/ownyourcode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/fundamentals/debugging .claude/skills/protocol-d-debugging && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
protocol-d-debugging
GitHub stars
290
Token cost
~2.8k tokens
SKILL.md length
753 words
Files
1
Skills in repo
19
Repo updated
First seen
Licence
MIT

At a glance

Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY).

  • Works in 10 steps: READ the Error → ISOLATE the Problem → Check the DOCS → …
  • Junior says stuck
  • SKILL.md covers When to Apply, The Protocol D Framework, Step-by-Step Guide and Common Bug Categories, plus 8 more sections
  • Calls claude

What it does

Protocol D Debugging is an agent skill from DanielPodolsky/ownyourcode. Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY). Use when junior says "stuck", "not working", "broken", "bug", "error", "crashed", "failing", "can't figure out", or expresses frustration. Do NOT use for general questions.

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Debugging. The repository describes itself as: Claude Code workflow for AI-mentored development. Work efficiently with Spec-Driven Development and the 6 Gates. Built to fight cognitive offloading — for developers using AI to… The licence is MIT.

When your agent uses it

  • Junior says stuck
  • Cant figure out
  • Expresses frustration
  • General questions

Example prompts

  • “not working”
  • “broken”
  • “crashed”
  • “/protocol-d-debugging”

Requirements

  • Node.js

Workflow steps

10 steps, taken from the step headings in SKILL.md.

  1. READ the Error
  2. ISOLATE the Problem
  3. Check the DOCS
  4. HYPOTHESIZE
  5. VERIFY
  6. Type Errors
  7. Async Errors
  8. Reference Errors
  9. Network Errors
  10. State Errors (React)

What it can do on your machine

Read from SKILL.md and the folder at commit bd1f17c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • claude

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Protocol D Debugging loads about 2.8k tokens when it runs. Until then it costs about 71 tokens; SKILL.md has 753 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~71
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from DanielPodolsky/ownyourcode at commit bd1f17c, republished under its MIT licence (© DanielPodolsky). 753 words, ~2,758 tokens.

Download SKILL.mdSave it as .claude/skills/protocol-d-debugging/SKILL.md (or your agent's skills folder).
name
protocol-d-debugging
description
Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY). Use when junior says "stuck", "not working", "broken", "bug", "error", "crashed", "failing", "can't figure out", or expresses frustration. Do NOT use for general questions.
argument-hint
[error message or problem description]

Protocol D: Systematic Debugging

"Debugging is not guessing. It's a systematic elimination of possibilities."

When to Apply

Activate this skill when:

  • Junior says "it's not working" or "I'm stuck"
  • Junior encounters an error they don't understand
  • Junior has been spinning on the same problem
  • Junior is frustrated and can't find the bug
  • Junior asks "why isn't this working?"

The Protocol D Framework

┌─────────────────────────────────────────────────────────────────┐
│                      PROTOCOL D                                  │
│              Systematic Debugging Flow                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  STEP 1: READ                                                    │
│  ────────────────────────────────────────────────                │
│  "Read the error message OUT LOUD. What is it actually saying?"  │
│                                                                  │
│  - Don't skim. Read every word.                                  │
│  - What file? What line? What type of error?                     │
│  - Is there a stack trace? Follow it.                            │
│                                                                  │
│                         ↓                                        │
│                                                                  │
│  STEP 2: ISOLATE                                                 │
│  ────────────────────────────────────────────────                │
│  "Where EXACTLY is the failure? Can you point to the line?"      │
│                                                                  │
│  - Frontend or Backend?                                          │
│  - Which function? Which line?                                   │
│  - Add console.log/print statements to narrow down               │
│  - Binary search: comment out half, does it still fail?          │
│                                                                  │
│                         ↓                                        │
│                                                                  │
│  STEP 3: DOCS                                                    │
│  ────────────────────────────────────────────────                │
│  "What does the official documentation say about this?"          │
│                                                                  │
│  - Google the EXACT error message                                │
│  - Check official docs for the function/API                      │
│  - Read the types/signatures carefully                           │
│  - Are you using it correctly?                                   │
│                                                                  │
│                         ↓                                        │
│                                                                  │
│  STEP 4: HYPOTHESIZE                                             │
│  ────────────────────────────────────────────────                │
│  "What do YOU think the problem is? Form a hypothesis."          │
│                                                                  │
│  - Based on the error and your investigation                     │
│  - What's your best guess?                                       │
│  - What would need to be true for your code to work?             │
│  - What assumption might be wrong?                               │
│                                                                  │
│                         ↓                                        │
│                                                                  │
│  STEP 5: VERIFY                                                  │
│  ────────────────────────────────────────────────                │
│  "Test your hypothesis. Did it work? Why or why not?"            │
│                                                                  │
│  - Make ONE change at a time                                     │
│  - Did it fix it? Great, explain WHY                             │
│  - Didn't fix it? What did you learn? New hypothesis.            │
│  - Loop until resolved                                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Step-by-Step Guide

Step 1: READ the Error

Never say: "There's an error" Always say: "The error says [exact message] on line [X] in file [Y]"

Claude asks:
"Read the error message out loud. What EXACTLY does it say?"
"What file and line number?"
"What TYPE of error is it? (TypeError, SyntaxError, NetworkError, etc.)"
Step 2: ISOLATE the Problem

Goal: Narrow down from "it doesn't work" to "line 42 is the problem"

Claude asks:
"Is this a frontend error or backend error?"
"At what point does it break? Does it even reach this function?"
"What's the last thing that worked correctly?"
"Can you add a console.log before and after to see where it dies?"

Binary Search Debugging:

typescript
// Comment out half the code
// Does it still fail?
// YES → bug is in remaining half
// NO → bug is in commented half
// Repeat until you find the exact line
Step 3: Check the DOCS

Goal: Verify you're using the API/function correctly

Claude asks:
"What does the documentation say about this function?"
"What parameters does it expect?"
"What does it return? Are you handling that correctly?"
"Are there any common pitfalls mentioned in the docs?"

Search Strategy:

  1. Copy the EXACT error message into Google
  2. Add the framework name (e.g., "React", "Node.js")
  3. Look for Stack Overflow answers with high votes
  4. Check GitHub issues for the library
Step 4: HYPOTHESIZE

Goal: Form a testable theory before changing code randomly

Claude asks:
"Based on what you've found, what do YOU think is wrong?"
"What would need to be true for your code to work?"
"What assumption might be incorrect?"
"If you had to bet, where's the bug?"

Common Hypotheses:

  • "I think the data isn't in the format I expected"
  • "I think the function is being called before the data loads"
  • "I think I'm missing a dependency"
  • "I think there's a typo in the variable name"
Step 5: VERIFY

Goal: Test ONE thing at a time

Claude asks:
"Okay, test that hypothesis. Make ONE change."
"Did it fix the problem?"
"If yes, explain WHY that fixed it."
"If no, what did you learn? What's your new hypothesis?"

The Rule of One:

  • Change ONE thing
  • Test it
  • If it didn't work, UNDO it before trying the next thing
  • Random changes = random results

Common Bug Categories

1. Type Errors
"Cannot read property 'X' of undefined"

Translation: You're trying to access .X on something that's undefined Debug: Log the variable right before. Is it what you expect?

2. Async Errors
"Promise { <pending> }" or unexpected undefined

Translation: You're not waiting for an async operation Debug: Did you await? Is the function async?

3. Reference Errors
"X is not defined"

Translation: Variable doesn't exist in this scope Debug: Where is it defined? Can this scope see it?

4. Network Errors
"Failed to fetch" or CORS errors

Translation: The request didn't succeed Debug: Check Network tab. What status code? What response?

5. State Errors (React)
Component not updating, stale data

Translation: State isn't being set correctly Debug: Log before and after setState. Is it actually changing?

Socratic Questions for Debugging

Instead of giving answers, ask:

  1. "What did you expect to happen?"
  2. "What actually happened?"
  3. "What's the difference between expected and actual?"
  4. "What changed since it last worked?"
  5. "If you remove this line, what happens?"
  6. "What would a senior engineer check first?"

Red Flags (When Junior is Guessing)

Bad SignBetter Approach
"I'll just try this" (random change)"What's your hypothesis? Why do you think this will help?"
"I don't know, maybe it's X?""Let's verify. How would you test if it's X?"
"I changed 5 things and now it works""Undo 4 of them. Which ONE fixed it?"
"ChatGPT said to do this""What does the actual documentation say?"
Show full SKILL.md (293 more words)Show less

The Rubber Duck Technique

If junior is really stuck:

"Explain to me, line by line, what this code is supposed to do.
Start from the beginning. Pretend I know nothing."

Often, just explaining the code reveals the bug.

Red Lines (Never Cross)

Never Do ThisWhy
Write the fix for themCreates dependency, not debugging skills
Skip straight to the answerSkips the learning moment
Provide more than 8 lines of exampleExamples should show pattern, not solution
Let junior make random changesEncourages guessing over systematic thinking
Solve before they've tried Protocol DRobs them of the growth opportunity

When to Escalate

Claude provides direct debugging help when:

  1. Junior has followed all 5 steps
  2. Junior has a clear hypothesis but it didn't work
  3. It's genuinely a tricky edge case
  4. The error message is genuinely cryptic

Even then, EXPLAIN the fix: "The bug was X because Y. In the future, watch for Z."

The 8-Line Rule still applies — if you must show code, show the PATTERN (max 8 lines), not their exact solution.

Military Frame (For Daniel)

Debugging StepMilitary Equivalent
READIntel gathering - know your enemy
ISOLATERecon - locate the hostile
DOCSCheck the manual - know your equipment
HYPOTHESIZEBattle plan - form the attack strategy
VERIFYExecute and assess - did the plan work?

Interview Connection

Debugging skills are HIGHLY valued in interviews:

"Tell me about a difficult bug you solved."

STAR Format:

  • Situation: "I encountered [error type] in [system]"
  • Task: "I needed to [fix X] without breaking [Y]"
  • Action: "I systematically isolated the bug by [Protocol D steps]"
  • Result: "Found it was [root cause], fixed it by [solution], learned [lesson]"

Success Metrics

Protocol D worked if:

  1. Junior found the bug themselves
  2. Junior can explain WHY it was a bug
  3. Junior knows how to PREVENT this bug in the future
  4. Junior's debugging speed improves over time

© DanielPodolsky, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/fundamentals/debugging of DanielPodolsky/ownyourcode.

Open the folder on GitHubat commit bd1f17c

Compare with similar skills

Protocol D Debugging next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Protocol D Debugging compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Protocol D Debugging this skillDanielPodolsky/ownyourcode290—~2.8kAutomated safety check: PassMIT
Trellis Session Insightmindfold-ai/Trellis15k4 repos~1.7kAutomated safety check: PassAGPL-3.0
Native Data FetchingCherryHQ/cherry-studio-app4k6 repos~2.9kAutomated safety check: NotesMIT
Aoti Debugpytorch/pytorch104k1 repos~1.7kAutomated safety check: PassCustom licence
Herdr Throwaway Reproductionherdrdev/herdr43k—~2.4kAutomated safety check: PassApache-2.0
Systematic Debuggingultralisp/ultralisp25851 repos~2.4kAutomated safety check: PassNone

Similar skills

  • Trellis Session Insight

    mindfold-ai/Trellis

    Reach into past AI conversation history through the trellis mem CLI.

    15k GitHub starsUsed in 4 repos~1.7k tokens
    DevelopmentAuto-check passed

  • Native Data Fetching

    CherryHQ/cherry-studio-app

    A skill your agent uses when implementing or debugging ANY network request, API call, or data fetching.

    4k GitHub starsUsed in 6 repos~2.9k tokens
    DevelopmentAuto-check: notes

  • Aoti Debug

    pytorch/pytorch

    Debug AOTInductor (AOTI) errors and crashes. An agent skill from pytorch/pytorch.

    104k GitHub starsUsed in 1 repo~1.7k tokens
    DevelopmentAuto-check passed

  • Herdr Throwaway Reproduction

    herdrdev/herdr

    Runs a disposable, uniquely named Herdr session inside an existing one so runtime, pane, terminal or API bugs can be reproduced without touching the main session.

    43k GitHub stars~2.4k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Systematic Debugging

    ultralisp/ultralisp

    A skill your agent uses when encountering any bug, test failure, or unexpected behavior, before proposing fixes

    258 GitHub starsUsed in 51 repos~2.4k tokens
    DevelopmentAuto-check passed

  • OpenLogi macOS Permissions Triage

    AprilNEA/OpenLogi

    Decides whether an OpenLogi device problem on macOS is a privacy-permission (TCC) problem, using agent log lines, and says which identity needs which grant.

    23k GitHub stars~2.5k tokensUpdated 4 days ago
    DevelopmentAuto-check: notes

More from DanielPodolsky/ownyourcode

All 19 skills in this repo

  • Accessibility Fundamentals

    DanielPodolsky/ownyourcode

    Reviews accessibility including WCAG, ARIA, keyboard navigation.

    290 GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed

  • Backend Fundamentals

    DanielPodolsky/ownyourcode

    Reviews API design, REST conventions, and backend architecture.

    290 GitHub starsUsed in 1 repo~1.1k tokens
    Auto-check passed

  • Database Fundamentals

    DanielPodolsky/ownyourcode

    Reviews schema design, SQL queries, ORM patterns. An agent skill from DanielPodolsky/ownyourcode.

    290 GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed

  • Documentation Fundamentals

    DanielPodolsky/ownyourcode

    Guides documentation standards including READMEs, JSDoc, and code comments.

    290 GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed

  • Error Handling Fundamentals

    DanielPodolsky/ownyourcode

    Guides error handling for async operations and API calls. An agent skill from DanielPodolsky/ownyourcode.

    290 GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed

  • Frontend Fundamentals

    DanielPodolsky/ownyourcode

    Reviews React/Vue component architecture, state, and hooks. An agent skill from DanielPodolsky/ownyourcode.

    290 GitHub starsUsed in 1 repo~874 tokens
    Auto-check passed

Categories

Questions about Protocol D Debugging

What does Protocol D Debugging do?

Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY). Protocol D Debugging is an agent skill from DanielPodolsky/ownyourcode. Guides systematic debugging through Protocol D (READ, ISOLATE, DOCS, HYPOTHESIZE, VERIFY).

When should I use Protocol D Debugging?

Protocol D Debugging fits situations like: junior says stuck; cant figure out; expresses frustration; general questions.

How do I install Protocol D Debugging in Claude Code?

Run `npx skills add DanielPodolsky/ownyourcode --skill protocol-d-debugging -a claude-code`. Or copy the skill folder (.claude/skills/fundamentals/debugging in DanielPodolsky/ownyourcode) into .claude/skills/protocol-d-debugging in your project. Claude Code loads it when a task matches its description.

How do I install Protocol D Debugging in Codex?

Run `npx skills add DanielPodolsky/ownyourcode --skill protocol-d-debugging -a codex`. Or copy the skill folder (.claude/skills/fundamentals/debugging in DanielPodolsky/ownyourcode) into .agents/skills/protocol-d-debugging in your project. Codex loads it when a task matches its description.

Can I use Protocol D Debugging in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add DanielPodolsky/ownyourcode --skill protocol-d-debugging -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/protocol-d-debugging, .gemini/skills/protocol-d-debugging, .github/skills/protocol-d-debugging and .opencode/skills/protocol-d-debugging in your project.

What does Protocol D Debugging need to run?

Going by SKILL.md and its folder, Protocol D Debugging needs the command-line tools its instructions call (claude). Our summary lists: Node.js.

Does Protocol D Debugging access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Protocol D Debugging safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Protocol D Debugging use?

Protocol D Debugging is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Protocol D Debugging use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Protocol D Debugging?

Skills that share tags, products or a category with Protocol D Debugging: Trellis Session Insight (mindfold-ai/Trellis, 15k stars), Native Data Fetching (CherryHQ/cherry-studio-app, 4k stars), Aoti Debug (pytorch/pytorch, 104k stars) and Herdr Throwaway Reproduction (herdrdev/herdr, 43k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Protocol D Debugging?

DanielPodolsky (a GitHub user) maintains it in DanielPodolsky/ownyourcode, which has 290 GitHub stars. The repository holds 19 skills in this directory. The repository was last updated on June 27, 2026.

Source: DanielPodolsky/ownyourcode on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.