Collaborative code review: you narrate, Claude tracks, challenges your ideas, then we generate a friendly GitHub review together

This skill should be used when the user asks to "set up code quality", "configure git hooks", "add pre-commit hooks", "set up lint-staged", "add pre-push checks", "initialize code quality", or when starting a new project that needs quality gates.

Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

Checks a change against the BROADER codebase beyond the diff — missed propagation (a renamed or changed entity not updated everywhere), stale references, inconsistent patterns, logic duplicated instead of reusing existing helpers, and docs/types/configs that drift from the change. Replicates the senior reviewer who holds the whole repo in their head. Use this whenever you implement or review a change, especially one touching a shared entity used across files. Auto-activates during /hv:build-feature and /hv:review-pr.

Use Codex CLI for AI-powered code review. Triggers on "codex review", "review with codex", "code review pr", or when user wants AI code review before PR/merge.

Compliance review and testing: evaluate your application against HIPAA, SOC 2, PCI-DSS, and GDPR technical requirements with browser-based validation and YAML regression tests for continuous compliance.

Debug SwiftUI application issues systematically. This skill helps diagnose and resolve SwiftUI-specific problems including view update failures, state management issues with @State/@Binding/@ObservedObject, NavigationStack problems, memory leaks from retain cycles, preview crashes, Combine publisher issues, and animation glitches. Provides Xcode debugger techniques, Instruments profiling, and LLDB commands for iOS/macOS development.

Isolate root causes through structured evidence gathering, pattern analysis, hypothesis testing (max 3 at a time, highest confidence first), and fix validation with a reproducing test before implementation. Use when any verification step fails, tests break, or debugging a reported bug. This skill MUST be consulted because symptom-fixing creates new bugs, and unbounded hypothesis testing causes tunnel vision; root cause must be proven before any fix attempt.

Docs strategy — audience map, Diátaxis (tutorial / how-to / reference / explanation), IA, docs-as-code, review + maintenance with owners + staleness alerts, findability, localization + a11y, metrics.

Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs, improve confidence, and enable fast deployment. Use when implementing E2E tests, debugging flaky tests, or establishing testing standards.

EliteForge skill authoring specification for creating or modifying eliteforge-* skills. Use when users create a new EliteForge skill, modify an existing EliteForge skill, review skill structure, add or change skill environment variables or output path rules, or need to validate SKILL.md/frontmatter/agents metadata with skill-creator.

Identify and refactor Elixir anti-patterns. Use when reviewing Elixir code for smells, refactoring problematic patterns, or improving code quality.

Comprehensive Go testing patterns including table-driven tests, mocking, integration testing, benchmarks, and test organization.

Performance optimization techniques for GPUI including rendering optimization, layout performance, memory management, and profiling strategies. Use when user needs to optimize GPUI application performance or debug performance issues.

Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

Use when about to ask the user a factual question, propose a solution, diagnose an error, or choose between approaches. Triggers on: 'Do you have X installed?', 'What version?', 'Is X configured?', 'We should...', 'The fix is...', 'Options: 1...', 'Based on my understanding...', 'I believe X supports...'. Before deciding anything, spin up parallel subagents to WebSearch for current docs, community solutions, framework best practices, and GitHub issues. Your memory is stale — verify everything.

Autonomous end-to-end workflow — implement, test, review, fix, and capture learnings in one shot

Revenue advisor — scans the Obsidian vault for work history and active projects, diagnoses the revenue system, and surfaces monetization opportunities the user can't see from inside their own perspective. Make sure to use this skill whenever the user says "/money", "how can I make more money", "review my revenue", "what should I charge", "help me monetize", "find opportunities", or asks about income, pricing, or business strategy. Goes beyond the vault — diagnoses structure first, then surfaces opportunities.

This skill should be used when the user asks to "debug notebook", "inspect notebook outputs", "find notebook error", "read traceback from ipynb", "why did notebook fail", or needs to understand runtime errors in executed Jupyter notebooks from any source (marimo, jupytext, papermill).

Cluster a GitHub issue backlog by root cause into a small set of plan-master issues, redirect children with a standardized comment, and bundle architectural-fix PRs that close clusters atomically. Use when an issue tracker has accumulated dozens of reports that share underlying defects, when asked to triage / consolidate / cluster / dedupe issues, when asked to build a plan series or roadmap from open issues, or when routing a new incoming bug into an existing plan.

Scores a candidate paper against a keyword watchlist and a relevance-criteria document, returning KEEP/DROP/REVIEW with a one-line rationale and a 0-100 relevance score. Combines keyword-match strength, criteria-fit, and a historical-context check (was this paper or its preprint already covered in a recent digest). Domain-neutral - usable for any literature-scan workflow. Use after fetching candidate papers from bioRxiv, medRxiv, or PubMed and before clustering or synthesis. Trigger keywords - paper relevance, filter papers, keep or drop, score papers, relevance rationale.

List PRs awaiting your review, checkout the branch, run linter, and generate a structured code review document.

Use when asked to review a PR with Codex and save, document, post, or update the review results. This skill owns PR comment/cache state, invokes codex-review-pass for the six-subagent review bundle, and publishes one canonical review comment through .pr-review-cache/pr-#.json.

Expert in code quality, formatting, linting, and quality gates workflow. Use when user needs to setup quality tools, fix linting errors, configure Biome/Prettier, setup pre-commit hooks, or run quality checks. Examples - "setup code quality", "fix lint errors", "configure Biome", "setup Husky", "run quality checks", "format code", "type check errors".

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear, technically questionable, or comes from multiple reviewers

Resolves merge conflicts during rebases, merges, and cherry-picks — reads both sides, understands intent from git history, auto-resolves clear-cut cases, and asks about ambiguous ones. Also handles end-to-end rebase workflows (fetch, rebase onto target, resolve, continue). Use when the user says "rebase onto main", "resolve conflicts", "fix these conflicts", "merge main in", "finish this rebase", or when a rebase/merge/cherry-pick has stopped due to conflicts.

Use when the user wants to address, process, or work through GitHub PR review comments. Trigger on phrases like "address PR comments", "work through review comments", "process PR feedback", "apply reviewer suggestions", or "/review-pr-comments <number>".

Review feature spec files with 3 focused agents — spec quality (business+correctness+ambiguity), completeness (missing scenarios+safety+testability), and buildability (compatibility+blockers+traceability). Sequential by default.

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes - four-phase framework (root cause investigation, pattern analysis, hypothesis testing, implementation) that ensures understanding before attempting solutions

Use when implementing features or fixes - test-driven development with RED-GREEN-REFACTOR cycle and full code coverage requirement

Generate protocol/interface test suites that any implementation must pass. Define the contract once, test every implementation. Use when designing protocols or swapping implementations.

Generate test fixture factories for your models. Builder pattern and static factories for zero-boilerplate test data. Use when tests need sample data setup.

Strict RED-GREEN-REFACTOR enforcement with no exceptions. Use when implementing features or fixing bugs. No production code without a failing test first.

Skill validation framework PLUS daily test-suite health and regression intelligence. Validates skill conformance (frontmatter, manifest coverage, resolver coverage). Runs the project test suite in tiered phases (unit / evals / integration / system health), classifies failures, and produces a regression-aware report.

Generate testing documentation from Linear issues and git commits. Use when the user requests test instructions, testing summary, or QA handover documentation for a completed feature or bug fix.

Upgrade Cairo smart contracts using OpenZeppelin's UpgradeableComponent on Starknet. Use when users need to: (1) make Cairo contracts upgradeable via replace_class_syscall, (2) integrate the OpenZeppelin UpgradeableComponent, (3) understand Starknet's class-based upgrade model vs EVM proxy patterns, (4) ensure storage compatibility across upgrades, (5) guard upgrade functions with access control, or (6) test upgrade paths for Cairo contracts.

Evaluate yoga teaching readiness through scenarios, knowledge probes, and guided learning exercises. Use when a teacher wants to test their understanding or prepare for a class.

This skill should be used when the user asks to "refactor code", "rename function", "extract method", "reduce complexity", "migrate code", "code migration", "modernize code", "split class", "move code", or mentions code restructuring and refactoring operations.

Safe refactoring workflow for replacing old types with new type-safe implementations through integration-test-first, file-by-file migration with incremental verification

Deep Amazon review analysis for competitive intelligence and product improvement. Extract sentiment patterns, recurring complaints, feature requests, and competitive insights from customer feedback. Turn reviews into actionable product development and marketing strategies. Use when the user asks about review analysis, customer feedback, product complaints, sentiment analysis, or what customers think about products.

Use when the user wants to run XCUITests, parse test results, view test failures, or export test attachments.

Use when troubleshooting Bknd issues, debugging errors, fixing common problems, or diagnosing why something isn't working. Covers CLI debug commands, error codes, logging, common issues and solutions.

Discover available agents, skills, quality commands (lint, test, typecheck), tech stack, verification capabilities, and LSP code intelligence features via parallel environment scanning. Use when starting implementation, creating PRs, reviewing PRs, or addressing feedback. This skill MUST be consulted because assuming tools exist causes runtime failures, and assuming they do not causes missing capabilities.

Guide to migrating an existing Capacitor iOS app from CocoaPods to Swift Package Manager (SPM). Use this skill when users want Capacitor 8-style SPM projects, need to run or recover from spm-migration-assistant, replace Podfile/Pods/App.xcworkspace with CapApp-SPM, add debug.xcconfig, verify plugin SPM support, or remove CocoaPods from an app project.

Code quality standards for implementing and reviewing code. Use this whenever you write or change code, review a PR or diff, or someone asks to "review code", "check quality", "improve", or "refactor". Auto-activates during /hv:build-feature implementation and /hv:review-pr so that quality is judged the same way it was built. Covers readability, naming, error handling, dead code, abstraction, tests, and matching existing style.

Generate weekly code-review digest docs from PR review comments for any GitHub repo, capturing themes, repeated issues, and concrete takeaways.

Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

Navigate privacy regulations (GDPR, CCPA), review DPAs, and handle data subject requests. Use when reviewing data processing agreements, responding to data subject access or deletion requests, assessing cross-border data transfer requirements, or evaluating privacy compliance.

Use after implementing features - 7-criteria code review with MANDATORY artifact posting to GitHub issue; blocks PR creation until complete

End-to-end open source contribution workflow: from scanning issues to submitting PRs. Use this skill whenever the user wants to contribute to an open source project, find issues to fix, submit a pull request, fork a repo to contribute, fix a GitHub issue, or mentions 'open source contribution'. Also trigger when they provide a GitHub repo URL and ask about contributing, say things like 'help me submit a PR', 'find good first issues', 'I want to contribute to X', or mention fixing bugs in someone else's project.

Quality gate via second model. Spawn a different AI model to review work before committing. Includes refusal routing: if one model refuses, switch silently to the next. Extended in v0.25.1 with structured review-mode gating (when to invoke vs not) and a Codex code-review handoff for the diff-review case.

Detects data integrity issues including orphaned records, broken foreign key relationships, constraint violations, and provides automated fix migrations. Use for "data integrity", "orphaned records", "broken relationships", or "data quality".

Structured root-cause analysis — reproduce, hypothesize, test, verify, fix, and capture learnings

Expert-level Deno knowledge for code review, debugging, and best practice enforcement. Use when reviewing Deno code or answering advanced Deno questions.

Multi-pass AI workflow for shipping high-quality code. Use when the user is about to finalize a change, wants a standards review, or asks to ship/workflow/review their code. Covers plan review, self-review, standards pass, documentation, and PR creation.

Reference data for .NET test framework detection patterns, assertion APIs, skip annotations, setup/teardown methods, and common test smell indicators across MSTest, xUnit, NUnit, and TUnit. Loaded by test analysis skills (test-anti-patterns) as framework-specific lookup tables.

Master emerging technologies including blockchain, cybersecurity, QA testing, and specialized tech roles. Stay ahead with cutting-edge technologies.

This skill should be used when the user asks about "factories", "FactoryBot", "factory_bot", "traits", "sequences", "build vs create", "transient attributes", "associations in factories", or needs guidance on test data generation in RSpec.

Fetch unresolved review comments from a PR and evaluate with receive-feedback skill

Bulk-fix cslint warnings in a C# codebase. Use when the user says 'fix cslint', 'fix lint warnings', 'fix cs lint', 'fix linter issues', 'clean up cslint', 'fix cslint warnings', 'run cslint and fix', 'fix all lint errors', 'fix C# lint', 'bulk fix lint', 'fix all cslint', 'fix formatting warnings', 'fix style warnings', 'fix naming violations', 'fix code style', or any variation of wanting to fix cslint diagnostics across a C# repo. Not for non-C# linters. Accepts an optional path argument (defaults to current directory).

Generate DETAILED reports with metrics, health checks, or epic-specific analysis. More comprehensive than quick status overview. USE THIS SKILL WHEN: - User asks for "metrics" or "statistics" or "performance report" - User asks for "health check" or "workflow health" or "compliance check" - User asks for "epic report" or "epic status for X" - User asks for "detailed report" or "comprehensive report" - User asks "how are we performing" or "what's our throughput" - User asks about "cycle times" or "demotion rates" - User wants analysis, not just current state REPORT TYPES: - metrics: Throughput, cycle times, first-pass rates, demotion rates - health: Compliance status, stale threads, violation history, memory bank status - epic: Single epic details with thread history, progress, decisions DO NOT USE THIS SKILL WHEN: - User just wants QUICK status overview (use ghe-status) - User wants to CLAIM an issue (use ghe-claim) - User wants to POST a checkpoint (use ghe-checkpoint) - User wants to TRANSITION phases (use ghe-transition) KEY DIFFERENCE FROM ghe-status: - ghe-status = quick overview, current state, what's active - ghe-report = detailed analysis, metrics, trends, health assessment EXAMPLES: <example> Context: User wants performance metrics user: "Show me the workflow metrics" assistant: "I'll use ghe-report with type 'metrics' for detailed performance analysis" </example> <example> Context: User wants to check workflow compliance user: "Run a health check on the workflow" assistant: "I'll use ghe-report with type 'health' to assess workflow compliance" </example> <example> Context: User wants details on specific epic user: "Give me a report on the jwt-auth epic" assistant: "I'll use ghe-report with type 'epic' for jwt-auth" </example> <example> Context: User asks about performance trends user: "What's our first-pass review rate?" assistant: "I'll use ghe-report with type 'metrics' to get performance statistics" </example>

Use this when the user wants to review Hacker News top 30 stories, select software or AI related items, and automatically publish a Chinese thread of at least 3 posts to x.com or Twitter from an already logged-in browser session.

Investigate production incidents using Datadog. Use when user says "what's causing this alert", "investigate production incident", "root cause analysis for production error", "debug production issue", "what caused this outage", "analyze production logs", "triage production error", "why is the service down", "production is throwing errors", or "help me understand this incident". Always use this skill when diagnosing production issues, on-call alerts, or service degradations that require querying logs, metrics, or traces.

Deliver a tracked GitHub issue end-to-end in the Recoupable house style — documentation-driven (OpenAPI/contract first), then test-driven (red→green) implementation that matches the docs, verified against the live preview deployment, with results posted to the PR. Use when the user says "implement this issue", "build out issue

Assess and classify legal risks using a severity-by-likelihood framework with escalation criteria. Use when evaluating contract risk, assessing deal exposure, classifying issues by severity, or determining whether a matter needs senior counsel or outside legal review.

Displays the roster of architecture team members with their specialties and expertise areas. Use when the user asks "Who's on the architecture team?", "List architecture members", "Show me the architects", "What specialists are available?", "Who can I ask for reviews?", or wants to discover available experts. Do NOT use for requesting reviews (use specialist-review or architecture-review) or checking documentation status (use architecture-status).

Work safely with endpoint versions — preview a draft in the playground, roll back to an older version, update settings on one version without bumping query history, deactivate a specific version. Use when the user asks "how do I roll back my endpoint", "preview my changes before publishing", "I want to fix v5 without bumping the version", or anything involving the version history. Calls out today's limitations honestly: there is no pointer flip; "rollback" means forking the old query into a new top version.

Guides users on creating mock implementations for testing with traits, providing test doubles, and avoiding tight coupling to test infrastructure. Activates when users need to test code with external dependencies.

Review milestones and project progress — diff materials table against repo state, surface gaps, check for orphaned work items, and propose next actions.

Review a completed implementation branch against its spec and acceptance criteria — catch gaps, shortcuts, and quality issues before merge.

Read, stream, and analyze Apple unified logs (OSLog) for iOS/macOS apps. Auto-detects subsystem from Logger usage or bundle identifier. Supports live log show, real-time streaming, and .logarchive analysis with full predicate reference. Use when the user asks to check app logs, stream console output, debug with OSLog, or analyze .logarchive files on iOS/macOS.

Activate when managing PM2 services for Playwright test reports, trace viewers, or other test artifacts. Includes starting/stopping services, generating dynamic workspace URLs (Coder/VS Code), and viewing service logs.

Write the canonical engineering record of a fixed bug — root cause, mechanism, fix, validation, and how it slipped through. Use after a debug session lands a validated fix, before closing the bug.

Triage unresolved PR review comments, produce a severity-ordered fix plan, then resolve or fix each issue with subagents. Use when addressing PR feedback before merge.

MUST be used when creating pull requests. Handles context gathering, title generation (conventional commit format), body formatting, and PR creation via GitHub CLI. Creates PRs as drafts by default. Triggers on: 'create PR', 'open PR', 'ready for review', 'push for PR', 'send for review'.

Interactive quarterly business review covering performance, development, finance, and well-being. Use when user mentions "quarterly review", "quarter review", "Q1/Q2/Q3/Q4 review", "review past quarter", or wants to assess quarterly performance and plan next steps.

Code review workflow. Use this skill whenever the user says "review", "code review", "review this PR", "review my changes", or otherwise wants a code review.

Comprehensive iOS/SwiftUI code review with optional parallel agents

Write professional, empathetic responses to App Store reviews that build trust and turn critics into fans. Use when responding to negative reviews, drafting templates for common review types, or improving review management strategy.

Comprehensive BubbleTea TUI code review for terminal applications. Use when reviewing charmbracelet/bubbletea, lipgloss, bubbles, or Wish SSH code; optionally reviews each area concurrently.

Use when encountering any bug, test failure, unexpected behavior, or error message — before proposing any fixes. Also use when you see tracebacks, exceptions, "not working" complaints, build failures, performance problems, or integration issues. If you're tempted to "just try changing X and see if it works", this skill applies. Systematic root cause investigation always comes before fix attempts.

Review recently changed files for code reuse, quality, and efficiency issues, then fix them. Use when simplifying code, removing complexity, improving readability, or after making changes.

This skill should be used when the user asks about "shared examples", "shared contexts", "spec structure", "test organization", "describe blocks", "RSpec tagging", "spec file layout", or needs guidance on organizing and structuring RSpec test suites.

Change the status of an ADR or spec (e.g., proposed to accepted, draft to review). Use when the user says "accept ADR", "approve the spec", "mark as accepted", or wants to update decision status.

Red-green-refactor scaffold for building new features with TDD. Write failing tests first, then implement to pass. Use when building new features test-first.

No-nonsense test executor that reports failures without attempting fixes

Test pyramid approach with unit, integration, and load tests. DI enables testability. Use vitest-mock-extended for typed mocks.

Generates comprehensive unit tests with AAA pattern (Arrange-Act-Assert), edge cases, error scenarios, and coverage analysis. Creates test files matching source structure with complete test suites. Use for "unit testing", "test generation", "Jest tests", or "test coverage".

Verification loop to ensure tasks are fully completed before moving on - implements feedback cycle from QA back to Development until all issues are resolved

Systematically add test coverage for all local code changes using specialized review and development agents. Add tests for uncommitted changes (including untracked files), or if everything is commited, then will cover latest commit.

Systematically debug issues with reproduction steps, error analysis, hypothesis testing, and root cause fixes. Use when investigating bugs, analyzing production incidents, or troubleshooting unexpected behavior.

This skill should be used when the user asks to "analyze test coverage", "find untested code", "check coverage gaps", "improve test coverage", "identify missing tests", "measure code coverage", "test quality analysis", or mentions testing strategies and coverage metrics.

Write the test first, watch it fail, write minimal code to pass

Never test mock behavior. Never add test-only methods to production classes. Understand dependencies before mocking.