> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/obra/superpowers/llms.txt > Use this file to discover all available pages before exploring further. # Skills Library Overview > Learn how to use specialized skills to guide OpenCode through complex workflows The Skills Library is a collection of specialized workflows that help OpenCode handle complex software engineering tasks systematically. Each skill provides detailed guidance on a specific aspect of development, from brainstorming new features to debugging production issues. ## How Skills Work Skills are loaded dynamically when OpenCode detects that a task matches a specific pattern. You can also invoke skills explicitly when you know which workflow you need. Skills contain detailed instructions, checklists, and process flows that guide OpenCode through proven workflows. They ensure consistency and quality across all development tasks. ### Automatic Activation OpenCode automatically loads relevant skills based on the task context: * **Brainstorming** loads when you describe a feature or component to build * **Test-Driven Development** loads when implementing features or fixing bugs * **Systematic Debugging** loads when encountering errors or unexpected behavior * **Writing Plans** loads when you have specifications that need implementation plans ### Manual Invocation You can explicitly request a skill by name: ``` "Use the systematic-debugging skill to investigate this test failure" "Load the test-driven-development skill" ``` ## Available Skills The foundation: invoke relevant skills BEFORE any response or action. Turn ideas into fully-formed designs through collaborative dialogue before writing any code. Write failing tests first, then implement minimal code to pass. No exceptions. Find root causes before attempting fixes. Stop guessing, start investigating. Create comprehensive, bite-sized implementation plans with exact file paths and commands. Execute written plans in batches with review checkpoints for architect feedback. Dispatch fresh subagents per task with two-stage review for fast, high-quality iteration. Create isolated development workspaces for parallel feature development. Dispatch code-reviewer subagent to analyze changes against requirements. Handle review feedback with technical rigor and know when to push back. Complete work systematically: verify, decide (merge/PR/keep/discard), cleanup. Never claim completion without verification. Evidence over claims. Launch multiple agents to work on independent problems concurrently. Create and test new skills using TDD methodology applied to documentation. ## Core Principles All skills in the library follow these fundamental principles: ### 1. Process Over Instinct Skills provide systematic workflows that prevent common pitfalls. Following the process consistently produces better results than ad-hoc approaches. ### 2. Verification at Every Step Each skill emphasizes verification: * Tests must fail before implementation * Changes must be tested before marking complete * Root causes must be found before proposing fixes ### 3. Incremental Progress Skills break complex tasks into small, manageable steps: * One test at a time * One fix at a time * Frequent commits * Regular checkpoints ### 4. Documentation as Code Designs, plans, and decisions are documented in markdown files alongside code: * `docs/plans/YYYY-MM-DD--design.md` for designs * `docs/plans/YYYY-MM-DD-.md` for implementation plans * Version controlled with git ## Skill Categories ### Design & Planning Skills that help turn ideas into actionable plans: * **Brainstorming**: Explore requirements and create designs * **Writing Plans**: Transform designs into detailed implementation tasks ### Development Skills for writing and testing code: * **Test-Driven Development**: Red-green-refactor cycle * **Executing Plans**: Batch execution with checkpoints * **Subagent-Driven Development**: Parallel task execution with reviews ### Problem Solving Skills for investigating and fixing issues: * **Systematic Debugging**: Root cause analysis before fixes ## Workflow Integration Skills are designed to work together in natural workflows: ```mermaid theme={null} graph LR A[Brainstorming] --> B[Writing Plans] B --> C{Execution Choice} C -->|Same Session| D[Subagent-Driven Development] C -->|Parallel Session| E[Executing Plans] D --> F[TDD per Task] E --> F F --> G{Bug Found?} G -->|Yes| H[Systematic Debugging] H --> F G -->|No| I[Complete] ``` Skills explicitly declare when to invoke other skills, creating a guided workflow from idea to implementation. ## Anti-Patterns Skills also document common anti-patterns to avoid: * **"Too simple for a design"** - Every project needs design, even simple ones * **"Tests after implementation"** - Tests written after prove nothing * **"Quick fix now, investigate later"** - Root cause analysis always comes first * **"Skip verification, I'll test manually"** - Automated tests are systematic and repeatable ## Next Steps When building anything new, start with the [Brainstorming](/skills/brainstorming) skill to explore requirements and create a design. Understand the [Test-Driven Development](/skills/test-driven-development) workflow - it's used throughout all implementation. Study [Systematic Debugging](/skills/systematic-debugging) before you need it - it'll save hours when issues arise. ## Best Practices ### Trust the Process Skills encode hard-won lessons from real projects. When a skill says something is mandatory, it's preventing a category of bugs you haven't seen yet. ### Follow the Checklists Each skill includes checklists for a reason. Complete every item before moving forward. ### Recognize Red Flags Skills list "red flags" - thoughts that indicate you're about to skip a critical step. When you catch yourself thinking "just this once," stop and follow the process. ### Use Skills Together Skills reference each other explicitly. When a skill says "invoke X next," do so. The transitions are designed to maintain quality. Violating the letter of skill rules means violating the spirit. "I understand the principle but..." leads to the same bugs the skills prevent.