opencode-power-pack bundles eleven Claude Code skills as an OpenCode plugin
under one config line, with each skill also exposed as a slash command.
Skills (by category):
Review
code-review multi-agent PR review with cross-check pass and
concrete reproduction scenarios
security-review OWASP-bucketed three-stage filtering with mandatory
PoC per finding
Feature dev
feature-dev seven-phase guided workflow
code-explorer deep codebase analysis sub-task
code-architect decisive architecture blueprint sub-task
code-reviewer two-pass adversarial review sub-task
Design
frontend-design distinctive, production-grade UI generation
Authoring
mcp-builder build high-quality MCP servers (Python or TypeScript)
skill-creator author new SKILL.md files
Project memory
agents-md-improver audit and update AGENTS.md / CLAUDE.md
agents-md-revise capture session learnings into the rules file
Architecture:
- .opencode/plugins/opencode-power-pack.js auto-registers skills/ via
config.skills.paths.push() (live config singleton modification, pattern
adapted from obra/superpowers).
- skills/<name>/SKILL.md hold the workflows the model executes.
- commands/<name>.md ship physical slash command files that inline the
full SKILL.md content, so the model receives the actual workflow as
its prompt rather than a meta-instruction. Symlinked into
~/.config/opencode/commands/ during install.
Almost all skill content is ported or translated from upstream Anthropic
projects (claude-code/plugins, skills, claude-code-security-review,
claude-plugins-official). The plugin loader pattern is adapted from
obra/superpowers. See README.md -> Acknowledgments for per-skill
attribution; each SKILL.md frontmatter also carries a license field
naming its specific upstream.
4.4 KiB
description
| description |
|---|
| Guide a feature implementation through a structured seven-phase workflow with deep codebase understanding, clarifying questions, parallel architecture design, and quality review. Use this skill when t |
Feature Development
Help a developer implement a new feature systematically. Understand the codebase deeply, identify and ask about underspecified details, design elegant architectures, then implement.
Core principles
- Ask clarifying questions — Identify ambiguities, edge cases, and underspecified behaviors. Ask specific, concrete questions rather than making assumptions. Wait for user answers before proceeding.
- Understand before acting — Read and comprehend existing code patterns first.
- Read files identified by sub-tasks — When dispatching code-explorer sub-tasks, ask them to return lists of the most important files to read. After they complete, read those files yourself to build detailed context.
- Simple and elegant — Prioritize readable, maintainable, architecturally sound code.
- Track progress — Use a todo list throughout.
Phase 1: Discovery
Goal: Understand what needs to be built.
- Create a todo list covering all seven phases.
- If the feature is unclear, ask the user:
- What problem are they solving?
- What should the feature do?
- Any constraints or requirements?
- Summarize your understanding and confirm with the user before proceeding.
Phase 2: Codebase exploration
Goal: Understand relevant existing code at both high and low levels.
- Dispatch 2–3
code-explorersub-tasks in parallel. Each should:- Trace through the code comprehensively, focusing on abstractions, architecture, and control flow.
- Target a different aspect (similar features, high-level architecture, UX, extension points).
- Return a list of 5–10 key files to read.
- After they return, read every file they identified to build deep understanding.
- Present a comprehensive summary of findings and patterns to the user.
Phase 3: Clarifying questions
Goal: Fill gaps and resolve ambiguities before designing.
This is one of the most important phases. Do not skip.
- Review the codebase findings and the original feature request.
- Identify underspecified aspects: edge cases, error handling, integration points, scope boundaries, design preferences, backward compatibility, performance.
- Present all questions to the user as a clear, organized list.
- Wait for answers before moving to architecture.
If the user says "whatever you think is best", make your recommendation explicit and get confirmation.
Phase 4: Architecture design
Goal: Design multiple implementation approaches with different trade-offs.
- Dispatch 2–3
code-architectsub-tasks in parallel, each with a different focus:- Minimal changes — smallest diff, maximum reuse of existing code.
- Clean architecture — maintainability, elegant abstractions.
- Pragmatic balance — speed plus quality.
- Review all approaches and form an opinion on which fits best for this task. Consider scope (small fix vs. large feature), urgency, complexity, and team context.
- Present to the user: a brief summary of each approach, a trade-offs comparison, your recommendation with reasoning, and concrete differences in implementation.
- Ask the user which approach they prefer.
Phase 5: Implementation
Goal: Build the feature.
Do not start without explicit user approval.
- Wait for approval.
- Re-read all relevant files identified earlier.
- Implement following the chosen architecture.
- Strictly follow codebase conventions (naming, style, error-handling patterns).
- Update todos as you progress.
Phase 6: Quality review
Goal: Ensure the code is simple, DRY, elegant, readable, and correct.
- Dispatch 3
code-reviewersub-tasks in parallel, each with a different focus:- Simplicity / DRY / elegance
- Bugs / functional correctness
- Project conventions and abstractions
- Consolidate findings and rank issues by severity.
- Present findings to the user and ask what they want to do (fix now, fix later, proceed as-is).
- Address issues based on their decision.
Phase 7: Summary
Goal: Document what was accomplished.
- Mark all todos complete.
- Summarize:
- What was built
- Key decisions made
- Files modified
- Suggested next steps
User arguments: $ARGUMENTS