DWARF debug format skill for understanding debug information. Use when inspecting DWARF sections with dwarfdump, working with split DWARF (.dwo files), setting up debuginfod for remote symbol resolution, or understanding how DWARF interacts with LTO and symbol stripping. Activates on queries about DWARF, .debug_info, .debug_line, dwarfdump, split DWARF, .dwo files, debuginfod, or debug info stripping.

Review QA test and capture element screenshots to enrich documentation

Use when there is a written implementation plan to execute in a separate session with review checkpoints

Scoped debugging methodology for when a test or build fails during execution/stabilization. Use to diagnose the failing check without scope-creeping — read the full error, reproduce in isolation, hypothesize before changing, localize, fix the root cause not the symptom, and guard with a regression test.

Diagnose and fix bugs with root-cause analysis and verification. Use when you have a concrete issue report, failing behavior, runtime error, or test regression that should be resolved safely. Stop and escalate to brainstorm when scope or risk grows.

Fix knip "Unused exports" violations. Handles all violation categories: test-only exports (extract to new file), dead barrel re-exports (remove from index.ts), and internally-only-used exports (un-export). Use when `npm run knip` reports unused exports.

Diagnoses and fixes flaky tests by identifying root causes (timing issues, shared state, randomness, network dependencies) and provides stabilization strategies. Use for "flaky tests", "test stability", "intermittent failures", or "test debugging".

This skill should be used when the user asks to "migrate to V13", "upgrade to Foundry V13", "update module for V13", "fix V13 compatibility", "convert to ESM", "use DataModel", or mentions V13-specific patterns like hook signature changes, actor.system vs actor.data.data, or Application V2. Provides comprehensive Foundry VTT V13 development patterns and migration guidance.

Fetch GitHub issues, select candidates, spawn background fix agents, open PRs, and optionally process PR review comments.

Operate GitHub repositories, workflows, and PRs efficiently. Use for Actions optimization, PR hygiene, repo maintenance, and team collaboration patterns.

Review GitHub pull requests with detailed, multi-perspective code analysis using parallel subagents. Use this skill whenever the user wants to review a PR, asks for code review on a pull request, mentions "review PR", "check this PR", "look at pull request", or references a PR number or GitHub PR URL. Also trigger when the user wants feedback on code changes, wants to approve or request changes on a PR, or asks to review someone's contribution.

Use when asked to review a plan, challenge a proposal, run a CEO review, poke holes in an approach, think bigger about scope, or decide whether to expand or reduce the plan.

Validate a business idea before investing time or money. Use whenever a solopreneur has a raw idea and needs a structured process to stress-test it against reality — covering problem definition, demand evidence, competitive context, customer discovery, riskiest-assumption testing, and a scored go/no-go decision. Trigger on phrases like "validate my idea", "is this worth building", "should I pursue this", "test my business idea", "does this idea have legs".

Turn rough ideas into clear work orders before planning or building. Use when request is vague like "add a button", "make it better", "fix the thing". Triggers on ambiguous or underspecified requests. Produces a brief with scope, acceptance criteria, and stop conditions.

This skill should be used for configuring devloop project settings via .devloop/local.md, git workflow preferences, commit settings, review options

Prepare PRs for review by cleaning noisy history, improving PR descriptions, and adding reviewer guidance without changing code behavior. Use for "make this easy to review", "tidy this PR", "clean up commits", or "annotate the diff".

Operate the Moltrade trading bot (config, backtest, test-mode runs, Nostr signal broadcast, exchange adapters, strategy integration) in OpenClaw.

Delegate coding to OpenCode CLI (features, PR review).

Create user personas through interactive dialogue. Generates personas from a business case or guided questioning, with iterative review. Also supports updating existing personas.

Develop and contribute to the PinchTab project. Use when working on PinchTab source code, adding features, fixing bugs, running tests, or preparing PRs. Triggers on "work on pinchtab", "pinchtab development", "contribute to pinchtab", "fix pinchtab bug", "add pinchtab feature".

Use this skill whenever the user wants to address, respond to, work through, or handle GitHub PR review comments — including code review feedback, reviewer suggestions, bot comments, or requested changes — even if they don't say "address". Handles the full end-to-end workflow: fetch threads, plan fixes, commit, push, and reply. Requires `gh` CLI.

Review GitHub pull requests with structured analysis and gh CLI integration. Use when asked to "review a PR", "check my PRs", "review pull request", or help with code review workflows.

This skill should be used when the user asks to "review this PR", "check the pull request", "review PR

Execute and generate pytest tests for Python projects with fixtures, parametrization, and mocking support

This skill should be used when classifying issues, findings, or code review problems with severity levels. Triggers on requests like "classify severity", "what is P1/P2/P3", "determine issue priority".

Invoke IMMEDIATELY via python script when user requests refactoring analysis, technical debt review, or code quality improvement. Do NOT explore first - the script orchestrates exploration.

Requirements clarification for TDD. Use BEFORE RED phase to understand WHAT to test. Asks targeted questions to uncover ambiguities, edge cases, and acceptance criteria.

Resolve issues on all your open PRs in parallel. Use when user says "fix all my open PRs", "resolve issues on all my PRs", "address comments on all my pull requests", "batch fix my PRs", or "make all my PRs merge-ready".

Respond to review comments on a PR after evaluation and fixes

Receive and process code review feedback effectively. Applies suggestions, addresses comments, and iterates on implementation improvements.

Use before code review - determine if change is minor (review new code only) or major (review impacted code too)

Unflinching academic reviewer. Verifies references via Zotero, identifies errors, assigns confidence ratings, and produces actionable review reports.

Systematic code review skill for providing constructive feedback

Use when "scikit-learn", "sklearn", "machine learning", "classification", "regression", "clustering", or asking about "train test split", "cross validation", "hyperparameter tuning", "ML pipeline", "random forest", "SVM", "preprocessing"

Set up a repository for effective use with OpenHands. Creates AGENTS.md, setup and pre-commit scripts, and a PR review workflow. Designed to run automatically with minimal user intervention. Use when a user wants to configure their repo for OpenHands.

Set up the OpenHands automated PR review workflow in a GitHub repository. Creates the workflow file and asks the user for configuration preferences. Use when a user wants AI code review on their pull requests.

Shopify integration - currently under maintenance. Contact [email protected] for assistance.

Tags orders flagged as high-risk for manual review and optionally places fulfillment holds to prevent shipping.

Test and iterate on a skill using parallel eval runs. Spawns with-skill and baseline runs, grades results, and helps improve the skill based on feedback. Use when testing skill quality or iterating on skill improvements.

Post-restart smoke tests + auto-fix for gbrain and OpenClaw environments. Tests critical services, auto-fixes known issues, extensible via user-defined test scripts in ~/.gbrain/smoke-tests.d/*.sh.

Run the SPARC Refinement and Completion phases — review code, improve test coverage, validate against specification, and generate documentation

Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.

Erzwingt striktes Test-Driven Development mit Red-Green-Refactor Zyklus. Blockiert Code-Generierung ohne vorherige Tests. Dokumentiert 13 ungueltige Rationalisierungen. Aktivieren bei neuen Features, Bug Fixes, Refactoring.

Become a wise, incredibly effective teacher who verifies the human deeply understands the work done in the current session — the problem, the solution, and the broader impact — before the session ends. Use whenever the user asks to be taught or walked through what happened ("teach me this session", "make sure I understand what we did", "explain these changes to me", "quiz me on this", "what did we actually change?"), before they review or commit work they didn't write line-by-line themselves, or any time they signal they want mastery rather than a summary — even if they don't say the word "teach".

Review changed code for reuse, quality, and efficiency using a team of persistent named reviewers. This skill should be used when the user says "team review", "review with team", or wants parallel code review with persistent team members for follow-up questions. Similar to /subagent-review but reviewers persist after review.

Creates factories and builders for generating consistent, composable test data with realistic values and relationship handling. Use for "test factories", "test data builders", "fixture factories", or "test data generation".

Apply TDD methodology with Red-Green-Refactor cycle. Use when implementing features, fixing bugs, or when user says "TDD", "test first", "test-driven". Ensures code quality through disciplined test-first development.

Use this skill when generating tests with AI assistance. Activate when the user wants to create unit tests, integration tests, generate test cases, improve test coverage, write tests for existing code, or set up testing patterns for their project.

Testing strategies for OCaml libraries. Use when discussing tests, alcotest, eio mocks, test structure, or test-driven development in OCaml projects.

You need to trace how a system would fail or behave at a scale you can't cheaply test or measure. Use to imagine the scenario and walk the consequence chain step by step.

About to add a feature/layer/process to fix a problem. First ask what to remove instead — subtraction is often more robust than addition. Use for simplification and complexity reduction.

Rapidly triage an incoming NDA — classify as standard approval, counsel review, or full legal review

Weekly bounded maintenance loop across ingestion, hygiene, compaction, lifecycle management, and concepts

Test smart contracts comprehensively using Hardhat and Foundry with unit tests, integration tests, and mainnet forking. Use when testing Solidity contracts, setting up blockchain test suites, or validating DeFi protocols.

Test smart contracts comprehensively using Hardhat and Foundry with unit tests, integration tests, and mainnet forking. Use when testing Solidity contracts, setting up blockchain test suites, or validating DeFi protocols.

This snippet should be used when following Test-Driven Development (TDD) methodology with the Red-Green-Refactor-Commit cycle for all implementation tasks.

Use when you need to find the source code location of installed plugins, explore plugin structure, access reference materials in plugins, or debug plugin issues. Provides step-by-step guidance to trace installed plugins back to their local repository locations by reading ~/.claude/plugins/installed_plugins.json and navigating to the installPath. Useful for finding skills, commands, reference docs, or understanding plugin implementation.

Use this skill when the user wants to "create PR", "update PR", "merge PR", "PR template", "auto-fill PR", "request review", or manage pull request lifecycle. Generates PR descriptions from commits/issues with intelligent defaults.

Analyze session replay patterns across experiment variants to understand user behavior differences. Use when the user wants to see how users interact with different experiment variants, identify usability issues, compare behavior patterns between control and test groups, or get qualitative insights to complement quantitative experiment results.

Test and preview monitoring configurations before enabling. Handles "dry-run threshold", "preview alerts", "test this rule", "what would fire".

Run tests, linters, type checkers, and builds with AI-powered analysis. Use this INSTEAD OF running test/lint/build commands directly via Bash. Wraps any command (pytest, jest, go test, make test, npm test, make lint, mypy, tsc, eslint, golangci-lint, cargo clippy, make typecheck, make build, etc.) to produce clean summarized output, keeping conversation context small. When a test or lint fails, ATR analyzes the full output and returns actionable failure insights.

Debug B2C Commerce server-side scripts using the b2c CLI. Use this skill whenever the user needs to set breakpoints, step through code, inspect variables, evaluate expressions, or investigate runtime behavior on a B2C Commerce instance. Also use when the user wants to understand what a script is doing at runtime, capture state at a specific line, or drive the debugger from a headless script — even if they just say "debug this controller" or "what's the value of basket at line 42".

Batch-fix all open bugs in parallel, iterate on PR reviews until clean, then squash-merge each PR sequentially. Extends bug-blitz with automated review cycles and merge. Fetches bug-type tasks from Transit, creates worktrees, spawns parallel fix agents, runs /pr-review-fixer in a loop until no blockers/critical/major issues remain, then merges PRs one by one with squash-and-merge.

Generate end to end automated tests for existing features. Use when the user says "create qa automated tests for [feature]"

Generates a structured Bug Fix Brief (BFB) to document issue corrections. Includes root cause analysis, repro steps, fix options, and fix checklist. Use when user asks to create a BFB, document a bug fix, or generate a bug correction document.

Technical debt expert specializing in identifying, quantifying, and prioritizing technical debt in software projects. Use when auditing a codebase for technical debt or planning remediation.

Commit changes, push to remote, and create a pull request. Use for completing features or fixes ready for review.

Set up the Discord channel — save the bot token and review access policy. Use when the user pastes a Discord bot token, asks to configure Discord, asks "how do I set this up" or "who can reach me," or wants to check channel status.

Defines ROI-based coverage targets with critical path identification, layer-specific targets, and explicit "don't test this" guidelines. Use for "test coverage", "coverage strategy", "test priorities", or "coverage targets".

Create a pull request with Conventional Commits formatting, a templated body, and local verification. Use when the user asks to create a PR, open a PR, submit changes for review, or put code up for review.

Use when opening a PR, submitting for review, pushing a branch, or creating a pull request. Pushes and creates GitHub PRs with auto-assignment and description.

Extract large inline test modules into adjacent test files while preserving the same effective visibility, helper access, and coverage shape. Use when the user wants implementation files slimmed down without accidentally turning private unit tests into weaker integration tests.

Write and organize unit tests for functions, methods, and classes using `package:test`. Use when creating new logic or fixing bugs to ensure code remains correct and regression-free.

Write unit tests with mocking and coverage analysis for pure Dart projects and CLI apps. Use when testing business logic, generating mocks with Mockito or mocktail, or measuring test coverage.

Uses static analysis diagnostics and custom handling patterns for null safety, dynamic lists, contravariance overrides, and unrecoverable errors.

Core concepts and best practices for `package:test`. Covers `test`, `group`, lifecycle methods (`setUp`, `tearDown`), and configuration (`dart_test.yaml`).

Generates deterministic seed data for development and testing with factory functions, realistic fixtures, and database reset scripts. Use for "data seeding", "test fixtures", "database seeding", or "mock data generation".

Systematic 4-phase debugging methodology for complex, intermittent, or mysterious issues. Use when investigating bugs, race conditions, or unexplained failures.

Core skill for safe refactoring - enforces test-first approach and atomic changes

Review avec auto-fix automatique - Mode AUTO (Phase 7)

Review qualité complète - PHPStan + Elegant Objects + code review (Phase 6)

Prove and counter-prove a statement using parallel agents to eliminate confirmation bias. Use when someone says "dialectic", "prove/disprove", "stress test this claim", "is this really true", "argue both sides", or when a statement needs objective analysis from opposing viewpoints.

Update user-facing documentation when code changes. Use when asked to update docs, review docs, handle documentation changes, run scheduled documentation tasks, or analyze recent commits for documentation needs.

Control terminal TUIs and web/Electron apps for testing, demos, QA, and computer-use tasks. Use when you need to automate a CLI, drive a browser, record a demo, or capture proof artifacts.

Use when implementing end-to-end tests, using Playwright or Cypress, testing user journeys, debugging flaky tests, or asking about "E2E testing", "Playwright", "Cypress", "browser testing", "visual regression", "test automation"

This skill should be used when the user asks to "implement a feature in Elixir", "refactor this module", "should I use a GenServer here?", "how should I structure this?", "use the pipe operator", "add error handling", "make this concurrent", or mentions protocols, behaviours, pattern matching, with statements, comprehensions, structs, or coming from an OOP background. Contains paradigm-shifting insights.

Review existing Encore Go code for best practices and common anti-patterns.

Strunk & White grammar review using the 11 elementary rules from "Elements of Style" Chapter I. Use when checking mechanics, punctuation, and grammatical correctness.

Scaffold PoC projects, test workflows against eval criteria. Use for /eval, "test this workflow". NOT for scoring (/eval-score) or improving (/autoimprove).

Use when performing a blank-slate codebase review -- orchestrates the scout, file sampling, fan-out decision, reviewer dispatch, and output formatting pipeline

Files a GitHub issue on this repo to tell Brent about anything worth his attention — confusion, something that didn't work, an idea or wish, or a new way the user phrased a request. Brent is a collaborator on this private repo and uses these issues to fix and improve the tools. Use this whenever the user sounds confused or frustrated, says something is broken or didn't work as expected, wishes something worked differently, or asks to tell Brent something — even if they never say "feedback" or "issue". Also invoked by blake-os:git-ops to log a request it could not cleanly route.

Use when completing work on a feature branch, preparing to merge, or cleaning up after development is done. Triggers: branch work is complete, user says "merge", "create PR", "finish branch", "done with this branch", ready for code review.

Stops execution and fixes root cause when commands, builds, scripts, or tools fail unexpectedly. Triggers on workaround language: 'directly', 'instead', 'alternatively', 'skip', 'fall back', 'work around', 'isn't working', 'broken', 'manually'. Activates on any unexpected non-zero exit code or process failure.

Define testing strategy, test pyramid, and pattern-based conventions (Golden Variants, State Matrix, Interaction Contracts). Use when establishing test architecture or choosing the right testing approach for a Flutter project.

Create diverse synthetic test inputs using dimension-based tuple generation. Use when bootstrapping an eval dataset, when real user data is sparse, or when stress-testing specific failure hypotheses. Do NOT use when you already have 100+ representative real traces (use stratified sampling instead).

Resolve a GitHub issue end-to-end using the gh CLI. Checks for blocking sub-issues/dependencies, self-assigns, investigates the codebase, makes changes, reviews code, and commits. Use when asked to resolve, fix, or work on a GitHub issue.