Define and generate mock objects for external dependencies using `package:mockito` and `build_runner`. Use when unit testing classes that depend on complex external services like APIs or databases.

Deep root cause analysis with fix proposal. Use when the user says "/schovi:debug", "debug this issue", "find the root cause", or "investigate this bug", with a Jira ID, GitHub issue/PR, Datadog URL, error description, or stack trace file. Returns problem summary, root cause, fix proposal, testing strategy, and rollout plan.

This skill should be used when the user asks to "create an isolated worktree", "set up worktree for feature", "create a feature branch worktree", or needs workspace isolation with automatic dependency setup and test verification.

DHH-style code review. Reviews Ruby, Rails, and JavaScript code for convention violations, framework contamination, and unnecessary complexity.

Use when facing 3+ independent failures that can be investigated without shared state or dependencies - dispatches multiple Claude agents to investigate and fix independent problems concurrently

Builds end-to-end browser tests for critical user flows using Playwright or Cypress. Includes selector strategies, test data management, page objects, and visual regression testing. Use for "E2E testing", "browser tests", "Playwright", or "Cypress tests".

Write or run automated tests for Encore.ts code with `encore test` and vitest/jest. Covers isolated per-test databases, calling handlers directly, and `describe`/`it`/`expect`.

PR creation workflow for Engram following the issue-first enforcement system. Trigger: When creating a pull request, opening a PR, or preparing changes for review.

Use when you have a written implementation plan to execute in a separate session with review checkpoints.

Diagnose and fix Flutter layout constraint violations (RenderFlex overflow, unbounded height/width, ParentData misuse). Use when encountering layout exceptions, yellow-black overflow stripes, or red error screens.

Setup and manage git hooks for pre-commit, pre-push automation (lint, test, format)

Setup and manage git hooks for pre-commit, pre-push automation (lint, test, format)

This skill should be used when generating financial reports, encountering German financial terms, or when the user asks to "update glossary", "add term to glossary", "maintain glossary", "explain German financial term", "what does [term] mean", "define [German financial term]", or "financial vocabulary". Manages automatic glossary maintenance for German financial terminology in Obsidian.

WHEN: User wants to improve test coverage, find untested code, generate test stubs, or asks "what tests am I missing?" or "how do I improve coverage?" for a Go project. WHEN NOT: When running existing tests, debugging test failures, or benchmarking.

Reviews, updates, and sets goals at quarterly, monthly, or weekly level in the Obsidian vault. Make sure to use this skill whenever the user says "review my goals", "OKR check-in", "quarterly review", "am I on track", "update my goals", "set monthly goals", or runs /goals. Works across all three goal levels — choose based on the argument or ask if unclear.

Reviews LangGraph code for bugs, anti-patterns, and improvements. Use when reviewing code that uses StateGraph, nodes, edges, checkpointing, or other LangGraph features. Catches common mistakes in state management, graph structure, and async patterns.

Test-driven development for Laravel with PHPUnit and Pest, factories, database testing, fakes, and coverage targets.

Updates an existing OpenCode command to match current platform best practices, fixes deprecated patterns, and validates the result. Use when user says "update opencode command", "fix opencode command", "migrate command to opencode", or wants to modernize an existing OpenCode command file.

Updates an existing OpenCode skill to match current platform best practices, fixes deprecated patterns, and validates the result. Use when user says "update opencode skill", "fix opencode skill", "migrate skill to opencode", or wants to modernize an existing OpenCode SKILL.md file.

Transform outside-of-diff review files into properly formatted issue files for a given PR. Use when converting review files from ai-docs/reviews-pr-<PR>/outside/ into issue format in ai-docs/reviews-pr-<PR>/issues/. Automatically determines starting issue number and preserves all metadata (file path, date, status) from original review files. Don't use for inline-diff review files, non-PR review artifacts, or creating GitHub issues directly.

Run and configure oxlint — the high-performance JavaScript/TypeScript linter built on the Oxc compiler stack. Use this skill whenever working in a project that has oxlint installed (check for `oxlint` in package.json devDependencies or an `.oxlintrc.json` / `oxlint.config.ts` config file). This includes when you need to lint code after making changes, fix linting errors, configure oxlint rules/plugins, set up or modify `.oxlintrc.json`, or migrate from ESLint.

Use when facing 3+ independent failures that can be investigated without shared state or dependencies - dispatches multiple Claude agents to investigate and fix independent problems concurrently

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies. Also use when multiple test files fail with different root causes, multiple subsystems are broken independently, or you want agents to work concurrently on separate problem domains. If tasks touch different files and don't share state, this skill applies.

Use when executing decomposed plans with parallel batches - dispatches up to 2 fresh subagents per batch with code review between batches, enabling fast parallel iteration with quality gates

Validate and fix parallel prompts for required sections

Request peer review with proper context and preparation. Structures review requests with clear description of changes and testing status.

Systematic performance profiling and optimization. Use when performance issues are reported or suspected. Measure first, optimize second. Applies Pareto principle — find the 20% of code causing 80% of slowness, fix that, not the rest.

Analyze pipeline health — prioritize deals, flag risks, get a weekly action plan

When the user wants to validate product-market fit, measure PMF, or plan before scaling. Also use when the user mentions "PMF," "product-market fit," "product market fit," "Sean Ellis test," "very disappointed," "vitamin vs painkiller," "PMF validation," "premature scaling," or "validate before scale." For GTM after validation, use gtm-strategy.

This skill should be used when the user asks to "address the review", "discuss PR feedback", "plan fixes for the review", "create a plan to fix PR issues", or wants to brainstorm solutions for review findings. Use after a PR review has been posted to fetch the review comment and guide the user through creating an action plan using the brainstorming workflow.

Comprehensive codebase health analysis. Use when reviewing code quality, identifying technical debt, checking dependencies, or assessing project structure.

Implement code changes from reconciled project PRDs, ADRs, traceability matrices, executable acceptance scenarios, or a project-specs-reconciliation implementation handoff. Use after project-specs-reconciliation has created or updated the governing specs, or when the user explicitly says the specs are already reconciled. This skill owns the spec-to-test-to-code workflow and composes with language-specific TDD, BDD, and red-green-refactor skills without replacing their framework-specific guidance.

Introduces property-based testing with proptest, helping users find edge cases automatically by testing invariants and properties. Activates when users test algorithms or data structures.

Testing pyramid, quality metrics, and technical debt management strategies. PROACTIVELY activate for: (1) Designing testing strategy, (2) Evaluating code quality metrics, (3) Managing technical debt, (4) Analyzing test coverage approaches, (5) Calculating complexity. Triggers: "testing strategy", "testing pyramid", "quality metrics", "technical debt", "cyclomatic complexity", "maintainability", "coverage principles"

Generate a quarterly GitHub contributions review — monthly + per-repo breakdown and synthesized accomplishment narrative. Use when asked for "quarterly review", "Q1/Q2/Q3/Q4 review", "what did I ship this quarter", or "summarize my contributions". Works across personal repos and a specified org.

Process and resolve CodeRabbit automated PR review comments. Use when the user says "check rabbit review", "handle coderabbit comments", "resolve rabbit feedback", or mentions CodeRabbit PR comments. Also use after PR creation when CodeRabbit has left automated review comments.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Review the current conversation and capture valuable knowledge — best practices, coding conventions, architecture decisions, workflows, and user feedback — into persistent memory (AGENTS.md) or reusable skills. Use when the user says: (1) remember this, (2) save what we learned, (3) update memory, (4) capture learnings.

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Review recent changes for correctness, regressions, and relevant domain-specific quality criteria

Interactively review plausibly AI-generated bug reports (from Detail, Copilot, or humans using AI) filed as GitHub issues. Use when the user says things like "let's review bug reports," "review issues," "review AI issues," or points at a specific machine-generated-looking issue.

Review a contract against your organization's negotiation playbook — flag deviations, generate redlines, provide business impact analysis

Comprehensive PM resume review and tailoring against 10 best practices including XYZ+S formula, keyword optimization, job-specific tailoring, and structure. Use when reviewing a PM resume, preparing for job applications, or improving resume impact.

Analyzes feedback logs to identify patterns and suggest improvements to review skills. Use when you have accumulated feedback data and want to improve review accuracy.

Run a reviewer validation check on a PR at PCI. Validates the author's AI review, runs an independent code quality pass, and identifies missed issues.

Use when using ru for multi-repo commits, sync, GitHub review, or maintenance automation.

Test web applications with screen readers including VoiceOver, NVDA, and JAWS. Use when validating screen reader compatibility, debugging accessibility issues, or ensuring assistive technology support.

Analyze and resolve Sentry comments on GitHub Pull Requests. Use this when asked to review or fix issues identified by Sentry in PR comments. Can review specific PRs by number or automatically find recent PRs with Sentry feedback.

Identifies customers with disputed or charged-back orders and tags their customer record for proactive review on future orders.

Review code in two passes: spec compliance then quality — use for thorough PR or feature reviews

Execute a batch of backlog tickets in parallel. Use when the user wants to build multiple unblocked tickets simultaneously with integrated QA review.

Use this skill when the user asks to review formatting, naming conventions, language idioms, lint/style consistency, or import organization. It checks style against project conventions and distinguishes auto-fixable issues from manual fixes.

Test-driven development workflow for feature work and bug fixes. Use when the user asks for TDD, red-green-refactor, test-first implementation, regression-first bug fixes, or vertical-slice delivery.

Use only when the user explicitly asks for TDD, a failing test, or a regression test, OR when the bug has an obvious cheap local test target. Skip when the test path is unclear, expensive, integration-heavy, or not requested.

Pre-refactor safety checklist. Verifies test coverage exists before AI modifies existing code. Use before asking AI to refactor anything.

Test-Driven Development (TDD) workflow for ultrawork tasks with approach: "tdd". Enforces RED-GREEN-REFACTOR cycle with gate hooks and evidence requirements. Required knowledge for worker agents implementing TDD tasks.

Reviews test coverage and suggests missing test cases for error paths, edge cases, and business logic. Activates when users write tests or implement new features.

Write tests with TDD following structured patterns. Ensures consistent AAA structure, proper coverage targets, and framework-specific conventions. Without this skill, tests lack consistent naming, miss coverage targets, and skip anti-pattern checks.

SLASH COMMAND ONLY - Do NOT invoke automatically. Only runs via /test-gh-skills command. Executes Python test orchestrator for 80 tests across 6 skill groups.

Detects and removes duplicate transactions across overlapping bank, credit-card, and brokerage statement imports using a stable composite key (account_id, date ±1d, amount_cents, description_normalized). Emits a list of new transactions to commit, a list of suppressed duplicates with their reasons, and a list of suspicious near-duplicates that need human review. Use when ingesting financial statements that may overlap prior drops, merging multiple export sources for the same account, or when user mentions duplicate transactions, deduping a transaction file, or reconciling overlapping statements.

Systematic error analysis on real AI traces. Read traces, judge pass/fail, let failure categories emerge from data, compute failure rates, decide what to fix. Use when you have 50+ test cases or are seeing production failures. Do NOT use when you have fewer than 20 test cases (use /start-evals first).

Verify a competitive programming or LeetCode solution for correctness, edge cases, and performance. Use when asked to "verify my solution", "check my code", "is this solution correct", "test my solution", "review my competitive programming answer", "validate my algorithm", or any solution verification request.

Draft scientific research manuscripts from research data. Use when user wants to write a research paper, has a project folder with papers, data, figures, and a GitHub repository link. Orchestrates context-ingestion, scoping, literature-review, code-analyzer, results-interpreter, synthesis, and assembler sub-skills.

Stress-test the plan through adversarial review and edge case analysis. Use when: (1) After PLAN phase in 5D-SDD workflow, (2) User wants to 'validate,' 'review,' or 'check' a plan, (3) Before committing significant resources to implementation, (4) Plan exists but hasn't been challenged. This phase catches plan-level errors before they become code-level errors.

Multi-layer verification of implementation against spec and intent. Use when: (1) After BUILD phase in 5D-SDD workflow, (2) Implementation is complete and needs validation, (3) User asks to 'test,' 'verify,' or 'check' the implementation, (4) Before considering a feature done. This phase catches errors at multiple levels and routes fixes appropriately.

Receive and act on code review feedback with technical rigor, not performative agreement or blind implementation

Set up or reorganize project documentation using intent-based structure (BUILD/FIX/UNDERSTAND/LOOKUP)

Add an integration test for a specific tool in an existing collection. Creates a test file following the collection's established patterns. Use when adding tests for new or modified tools, or re-creating deleted tests.

Determine whether an app is ready to submit, then drive the current App Store release flow with asc, including validation, staging, review submission, first-time availability, subscriptions, IAP, Game Center, and App Privacy checks.

Determine whether an app is ready to submit, then drive the current App Store release flow with asc, including validation, staging, review submission, first-time availability, subscriptions, IAP, Game Center, and App Privacy checks.

Creates and manages Biome GritQL custom lint rules to enforce coding patterns. Use when creating linter rules, enforcing code conventions, preventing anti-patterns, or when the user mentions Biome, GritQL, custom lint rules, or AST-based linting.

Structural editor that proposes cuts, reorganization, and simplification while preserving comprehension. Use when user requests structural review or editorial review of structure

QA a web or app feature from a ticket, URL, acceptance criteria, or plain-language description, then generate reusable browse flows for regression coverage. Uses the `browse` skill for the actual browser or simulator interaction and keeps the QA loop focused on scenarios, evidence, and report quality.

Generate, update, review, delete, and transform business cases in four formats (one-pager, lean canvas, short-form, full). Interviews the user to fill gaps when input is insufficient.

Resolve ambiguities interactively with tracked changes. Works with scope, code review, and other skills.

You are a technical debt expert specializing in identifying, quantifying, and prioritizing technical debt in software projects. Analyze the codebase to uncover debt, assess its impact, and create acti

Reviews code changes for quality issues. Use when user says "review my changes", "review the diff", "review my code", "check for issues", "sanity check", or asks to find holes, gaps, or simplification opportunities.

Comprehensive code review with parallel specialized agents

Provides practical guidance for conducting thorough code reviews that identify issues early, promote knowledge sharing, and deliver constructive feedback. This skill should be used when reviewing pull requests, establishing team review standards, or mentoring developers on effective review practices.

Structured disagreement protocols that expose weaknesses, test assumptions, and generate alternatives. Use when stress-testing proposals, playing devil's advocate, challenging architectural decisions, or auditing assumptions before finalizing plans.

Use when the user asks to create, open, or submit a GitHub pull request, says "make a PR", "open a PR", or wants to commit, push, and turn the current branch into a PR. For mobile/CommCare repos with JIRA-prefixed tickets and RELEASES.md QA notes, prefer create-mobile-pr instead.

Create or edit Python routines for market analysis, monitoring, and data visualization. Use when the user asks to create, modify, or fix a routine in the routines/ folder.

Generates a single standardized submission-style CTF writeup for competition handoff and organizer review. Use after solving a CTF challenge to document the solution steps, tools used, and lessons learned in a structured format.

Uses get_runtime_errors and lsp to fetch an active stack trace, locate the failing line, apply a fix, and verify resolution via hot_reload.

Define and generate mock objects for external dependencies using `package:mockito` and the `build_runner` code generation lifecycle for unit testing classes.

Migrate test suites from legacy `package:matcher` (using `expect()`) to the modern, fluent, and highly descriptive assertions of `package:checks`.

Execute `dart analyze` to identify warnings and errors, and use `dart fix --apply` to automatically resolve mechanical lint issues. Use during development to ensure code quality and before committing changes.

QA an analysis before sharing with stakeholders — methodology checks, accuracy verification, and bias detection. Use when reviewing an analysis for errors, checking for survivorship bias, validating aggregation logic, or preparing documentation for reproducibility.

Investigate production issues by querying Datadog logs, metrics, and APM traces, then correlating findings with the codebase. Use this skill whenever the user mentions production errors, Datadog, observability, log investigation, latency spikes, error rate increases, 500s, trace IDs, monitor alerts, or wants to debug any service issue in a deployed environment.

Colony diagnostic pipeline -- 6-phase targeted bug repair with parallel investigation, competitive solution ranking, and adversarial review

Research-aligned self-consistency for debugging. Spawns independent solver agents that each explore and debug the problem from scratch. Uses majority voting. Based on "Self-Consistency Improves Chain of Thought Reasoning" (Wang et al., 2022). Use for critical bugs, algorithms, or when other approaches have failed.

Debugging optimized builds skill for diagnosing issues in release code. Use when debugging RelWithDebInfo builds, using -Og for debuggable optimization, working with split-DWARF, applying GDB scheduler-locking, reading inlined frames, or understanding "value optimized out" messages. Activates on queries about debugging optimized code, RelWithDebInfo, -Og, inlined functions in GDB, value optimized out, GDB with -O2, or debugging release builds.

Comprehensive DAG failure diagnosis and root cause analysis. Use for complex debugging requests requiring deep investigation like "diagnose and fix the pipeline", "full root cause analysis", "why is this failing and how to prevent it". For simple debugging ("why did dag fail", "show logs"), the airflow entrypoint skill handles it directly. This skill provides structured investigation and prevention recommendations.

Test harness creation skill - creates characterization tests to preserve behavior during refactoring

Review and validate implementation quality — catch workarounds, simulated data, incomplete implementations, and shortcuts. Use when checking if a feature is genuinely working end-to-end.