Skip to main content
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

Using Superpowers

The foundation: invoke relevant skills BEFORE any response or action.

Brainstorming

Turn ideas into fully-formed designs through collaborative dialogue before writing any code.

Test-Driven Development

Write failing tests first, then implement minimal code to pass. No exceptions.

Systematic Debugging

Find root causes before attempting fixes. Stop guessing, start investigating.

Writing Plans

Create comprehensive, bite-sized implementation plans with exact file paths and commands.

Executing Plans

Execute written plans in batches with review checkpoints for architect feedback.

Subagent-Driven Development

Dispatch fresh subagents per task with two-stage review for fast, high-quality iteration.

Using Git Worktrees

Create isolated development workspaces for parallel feature development.

Requesting Code Review

Dispatch code-reviewer subagent to analyze changes against requirements.

Receiving Code Review

Handle review feedback with technical rigor and know when to push back.

Finishing a Development Branch

Complete work systematically: verify, decide (merge/PR/keep/discard), cleanup.

Verification Before Completion

Never claim completion without verification. Evidence over claims.

Dispatching Parallel Agents

Launch multiple agents to work on independent problems concurrently.

Writing Skills

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-<feature>-design.md for designs
  • docs/plans/YYYY-MM-DD-<feature>.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:
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

1

Start with Brainstorming

When building anything new, start with the Brainstorming skill to explore requirements and create a design.
2

Learn TDD

Understand the Test-Driven Development workflow - it’s used throughout all implementation.
3

Master Debugging

Study 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.

Build docs developers (and LLMs) love

Get started for freeTalk to us