hive.quality-monitor
Periodically self-assess output quality to catch degradation before the judge does.
hive.task-decomposition
Decompose complex tasks into explicit subtasks before diving in.
ai-review-validator
Autonomously validate and execute AI Review suggestions from PR comments. Use when users provide AI Review comments (from GitHub Copilot, CodeRabbit, etc.) that suggest code changes, API migrations, or fixes. The skill verifies suggestions against official docs, tests compilation, calculates confidence scores, and auto-applies changes when verified. Triggers on phrases like "verify this AI Review", "apply this suggestion", "validate AI Review comment", or when users paste AI Review URLs/content.
archive-and-cleanup-vibe-docs
>
codex-plan-reviewer
Cross-model adversarial review loop for markdown plans. Use this skill whenever the user asks to review, validate, or stress-test a markdown plan file using Codex (OpenAI). Triggers on phrases like "review this plan with codex", "let codex check the plan", "adversarial review", "cross-model review", "codex audit", "validate plan", or when the user has a markdown plan and wants a second opinion from a different AI model. Also trigger when the user says "plan review loop", "codex review loop", or references having Codex critique a plan before execution.
project-onboarding
Rapidly understand unfamiliar codebases through structured analysis. Use when the user needs to understand a new project, especially poorly documented or non-standard code. Triggers include "help me understand this project", "analyze this codebase", "onboard me to [project]", "what does this project do", or when the user provides a project path for exploration. Particularly effective for legacy code, hack projects, and codebases lacking documentation.
justfile
Use when writing Justfiles to understand the latest syntax, features, and best practices
obra-writing-plans
Use when the user asks for a plan, roadmap, or step-by-step breakdown for a multi-step task in VS Code Copilot Agent mode.
obra-writing-skills
Use when creating new skills, editing existing skills, or verifying skills work before deployment
investigation-mode
DEPRECATED: See systematic-debugging for current implementation.
minimalist-surgical-development
Use when editing an existing codebase and the goal is minimal, standard, and non-invasive changes - prioritizes simplest solution, standard libraries first, and surgical modification without unsolicited refactors
obra-brainstorming
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
obra-dispatching-parallel-agents
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
obra-executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints
obra-finishing-a-development-branch
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
obra-receiving-code-review
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
obra-requesting-code-review
Use when completing tasks, implementing major features, or before merging to verify work meets requirements
obra-subagent-driven-development
Use when executing implementation plans with independent tasks in the current session
obra-systematic-debugging
Use when errors are unclear, flaky, or regressions occur; apply a disciplined debugging loop in VS Code Copilot Agent mode.
obra-test-driven-development
Use when implementing new behavior or fixing bugs via tests-first (TDD) in VS Code Copilot Agent mode.
obra-using-git-worktrees
Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
obra-using-superpowers
Use when working in VS Code Copilot Agent mode and you want the Superpowers workflow (plans, verification, debugging, TDD) applied consistently.
obra-verification-before-completion
Use before finalizing answers or PRs: confirm requirements met, run checks, and avoid “looks good” without evidence in VS Code Copilot Agent mode.
root-cause-tracing
Use when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior
systematic-debugging
Use when errors are unclear, flaky, or regressions occur; apply a disciplined debugging loop in VS Code Copilot Agent mode.
task-direction-approval
Use when considering switching libraries/tools, changing architecture, or replacing automation with manual workarounds - explains root cause, offers 2-3 options with trade-offs, and requests explicit user choice
uncertainty-verification
Use when providing exact commands, flags, config keys, file paths, API details, standards, or version-specific behavior - enforces verification via official docs (Context7/web fetch), explicit citations, and bans assumption-based specifics
verification-before-completion
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
pfp-animate
Generate animated videos from static profile pictures using AI. Use when users want to animate images, create PFP videos, make meme videos, or turn portraits into short clips. Supports video with generated audio, lip-sync to existing audio, and precise keyframe control.
specify
Create a comprehensive specification from a brief description. Manages specification workflow including directory creation, README tracking, and phase transitions.
analyze
Discover and document business rules, technical patterns, and system interfaces through iterative analysis
brainstorm
You MUST use this before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements, and design before implementation.
constitution
Create or update a project constitution with governance rules. Uses discovery-based approach to generate project-specific rules.
debug
Systematically diagnose and resolve bugs through conversational investigation and root cause analysis
document
Generate and maintain documentation for code, APIs, and project components
implement
Executes the implementation plan from a specification. Loops through plan phases, delegates tasks to specialists, updates phase status on completion. Supports resuming from partially-completed plans.
refactor
Refactor, simplify, or clean up code for improved maintainability without changing business logic
review
Multi-agent code review with specialized perspectives (security, performance, patterns, simplification, tests)
specify-meta
Scaffold, status-check, and manage specification directories. Handles auto-incrementing IDs, README tracking, phase transitions, and decision logging in .start/specs/. Falls back to docs/specs/ for legacy specs. Used by both specify and implement workflows.
specify-plan
Create and validate implementation plans (PLAN). Use when planning implementation phases, defining tasks, sequencing work, analyzing dependencies, or working on plan files in .start/specs/. Generates per-phase files (plan/README.md + plan/phase-N.md) for progressive disclosure. Includes TDD phase structure and specification compliance gates.
specify-requirements
Create and validate product requirements documents (PRD). Use when writing requirements, defining user stories, specifying acceptance criteria, analyzing user needs, or working on requirements.md files in .start/specs/. Includes validation checklist, iterative cycle pattern, and multi-angle review process.
specify-solution
Create and validate solution design documents (SDD). Use when designing architecture, defining interfaces, documenting technical decisions, analyzing system components, or working on solution.md files in .start/specs/. Includes validation checklist, consistency verification, and overlap detection.
test
Use when completing implementation, fixing bugs, refactoring code, or any time you need to verify the test suite passes. Also use when tests fail and you hear "pre-existing" or "not my changes" — enforces strict code ownership. Ensures MECE coverage (no overlap, no gaps) and that ALL test categories including E2E are executed.
validate
Validate specifications, implementations, constitution compliance, or understanding. Includes spec quality checks, drift detection, and constitution enforcement.
writing-skills
Use when creating new skills, editing existing skills, auditing skill quality, converting skills to markdown conventions, or verifying skills before deployment. Triggers include skill authoring requests, skill review needs, or "the skill doesn't work" complaints.
feature-prioritization
RICE, MoSCoW, Kano, and value-effort prioritization frameworks with scoring methodologies and decision documentation. Use when prioritizing features, evaluating competing initiatives, creating roadmaps, or making build vs defer decisions.
pattern-detection
Identify existing codebase patterns (naming conventions, architectural patterns, testing patterns) to maintain consistency. Use when generating code, reviewing changes, or understanding established practices.
project-discovery
Unified codebase discovery across structure navigation, tech-stack detection, and documentation extraction. Use when onboarding to a project, locating implementation paths, identifying frameworks/tooling, or validating docs against code reality.
requirements-elicitation
Requirement gathering techniques, stakeholder analysis, user story patterns, and specification validation. Use when clarifying vague requirements, resolving conflicting needs, documenting specifications, or validating requirements with stakeholders.
user-research
User research and insight synthesis for interviews, usability testing, personas, journey mapping, and actionable product/design recommendations. Use when planning studies, collecting evidence, synthesizing patterns, or converting findings into prioritized decisions.
Page 422 of 1446 · 72294 results