Loading...
Loading...
Found 87 Skills
Code-verification session with the rubber duck — user explains code just written, finds edge cases, fixes planted bugs. Use after implementing a feature, or when they say "duck verify", "재확인해줘". Not for plan review (/duck-plan) or PR review (/duck-review).
Systematic debugging methodology with root cause analysis. Phases: investigate, hypothesize, validate, verify. Capabilities: backward call stack tracing, multi-layer validation, verification protocols, symptom analysis, regression prevention. Actions: debug, investigate, trace, analyze, validate, verify bugs. Keywords: debugging, root cause, bug fix, stack trace, error investigation, test failure, exception handling, breakpoint, logging, reproduce, isolate, regression, call stack, symptom vs cause, hypothesis testing, validation, verification protocol. Use when: encountering bugs, analyzing test failures, tracing unexpected behavior, investigating performance issues, preventing regressions, validating fixes before completion claims.
Generates before/after verification pairs for loom plans. Proves a stage actually changed system behavior by capturing state before and after implementation. Use for delta-proof verification — proving new commands, endpoints, modules, or bug fixes work by comparing system state.
This skill should be used when fixing bugs, implementing features, debugging issues, or making code changes. Ensures understanding of code flow before implementation by: (1) Tracing execution path with specific file:line references, (2) Creating lightweight text diagrams showing class.method() flows, (3) Verifying understanding with user. Prevents wasted effort from assumptions or guessing. Triggers when users request: bug fixes, feature implementations, refactoring, TDD cycles, debugging, code analysis.
Diagnose and fix errors with Codex delegation. Traces error to root cause, researches approach, delegates fix, verifies. Use when: bug reports, error messages, stack traces, test failures.
Hard-bug DIAGNOSIS + FIX: reproduce the failure, name the cause, write a regression test, apply the minimal fix. Use whenever the user reports a bug, failure, flaky test, perf regression, error, or visible misbehaviour whose cause is not yet known — even if they only paste a symptom, stack trace, or failing test output, or say "why is X broken", "it stopped working", "it got slower", "this looks wrong". Do NOT start debugging inline without this skill: if your next step would be forming hypotheses about an unexplained failure, invoke /pasteurize first. Do NOT use for review-only diffs (/age), feature design (/mold), fixes where the cause is already known (/cook), or when the user opted out of writes (/culture).
Streamlines bug fixing by creating a GitHub issue first, then a feature branch for implementing and thoroughly testing the solution before merging.
Automated visual QA testing using Playwright — navigate web apps like a real user, capture screenshots, find bugs, and fix them.
Phase 2 of the issue process — Read the issue report + read the code, identify the true root cause and assess the repair risk, and finally provide the user with 2-3 repair plan options for them to decide. This phase is **not about starting to modify code** — after analysis, show the conclusion to the user first, and only proceed to Phase 3 after the user confirms the plan. The prerequisite dependency easysdd-issue-report has been completed. Trigger scenarios: The user says "analyze this bug", "find the root cause", "locate the issue", and the {slug}-report.md already exists in the issue directory.
Use when asked to debug, fix a bug, investigate an error, or do root cause analysis, and when users report errors, stack traces, unexpected behavior, or say something stopped working.
Use when fixing, editing, changing, or debugging existing TypeScript code and keeping changes small and proportional to what was touched.
Comet Preset Path: Bug fix / Hotfix. Skip brainstorming, go directly through open → build → verify → archive. Applicable for behavior fixes and scenarios that do not involve new capability design.