opencode-improved

name

opencode-improved

description

Analyze external resources (GitHub repos, documentation, articles) and suggest improvements to OpenCode configuration. Use for discovering new patterns, comparing implementations, and enhancing existing skills, commands, and agents. Use proactively when user says "improve based on", "learn from", "compare to", "what can I learn from", or provides a link to analyze. Examples: - user: "What can I learn from this repo?" → analyze and suggest concrete improvements - user: "Improve my agents based on this article" → extract patterns, propose updates - user: "/improve https://github.com/example/config" → compare and recommend enhancements

Analyze external resources and suggest actionable improvements to OpenCode configuration.

This skill enables systematic improvement by:

1. Analyzing external resources (repos, docs, articles)
2. Extracting relevant patterns and techniques
3. Comparing against current configuration
4. Suggesting concrete, actionable improvements

Phase 1: Resource Acquisition

1. Identify resource type:

   • GitHub repository → Fetch relevant config files
   • Documentation URL → Extract key concepts
   • Article/blog → Identify patterns and recommendations

2. Fetch content:

   • For GitHub: Look for opencode.json, .opencode/, AGENTS.md
   • For docs: Extract configuration examples
   • For articles: Identify actionable recommendations

Phase 2: Pattern Extraction

MUST extract patterns in these categories:

Category	Look For
Agents	New archetypes, permission patterns, tool configs
Skills	Organization patterns, reference structures
Commands	Workflow shortcuts, argument patterns
Config	Provider setups, MCP configurations, permissions

Phase 3: Gap Analysis

MUST compare extracted patterns against:

1. Existing .opencode/ structure
2. Current opencode.json configuration
3. Defined agents, skills, and commands

Phase 4: Recommendations

MUST generate recommendations with:

• Priority: High / Medium / Low
• Effort: Minimal / Moderate / Significant
• Impact: Description of benefit
• Implementation: Concrete steps or code

Output Format

## Analysis Summary

**Source**: [URL or repo name]
**Type**: [Repository | Documentation | Article]
**Relevance Score**: [High | Medium | Low]

## Key Findings

### Finding 1: [Title]

**Pattern**: [What they do]
**Current State**: [What you have]
**Gap**: [What's missing]

### Finding 2: [Title]
...

## Recommendations

### 1. [Recommendation Title] (Priority: High, Effort: Minimal)

**Impact**: [What this improves]

**Implementation**:
\`\`\`jsonc
// Code or configuration example
\`\`\`

### 2. [Recommendation Title] (Priority: Medium, Effort: Moderate)
...

## Not Applicable

These patterns from the source don't apply because:
- [Pattern]: [Reason it doesn't fit]

Evaluation Criteria

Worth Adopting

• SHOULD solve a problem you currently have
• SHOULD improve developer experience
• SHOULD reduce repetitive configuration
• MUST follow OpenCode best practices
• MUST be compatible with existing setup

Skip If

• Over-engineered for your use case
• Conflicts with existing patterns
• Requires major restructuring for minimal benefit
• Outdated or deprecated approaches
• Not applicable to your workflow

Opinionated Guidance

This skill is intentionally opinionated:

• Honesty over politeness: If nothing is useful, say so
• Quality over quantity: Fewer good suggestions > many mediocre ones
• Practicality over theory: Focus on actionable improvements
• Compatibility matters: MUST NOT suggest breaking changes

Response Templates

When useful patterns found:

"I found 3 patterns worth adopting and 2 that don't fit your setup. Here's what I recommend..."

When nothing applicable:

"After analyzing [resource], I don't see improvements that would benefit your current setup. The patterns there are [too basic / too specialized / incompatible] because [reason]."

When partially useful:

"One pattern from [resource] could help: [description]. The rest is either already covered or not applicable."

Integration with Slash Command

This skill works with the /improve command:

---
description: Analyze a resource and suggest OpenCode improvements
---

Analyze the following resource and suggest improvements to my OpenCode configuration:

$ARGUMENTS

Use the opencode-improved skill. Be opinionated and honest about what's useful.

Best Practices

MUST

• Fetch and analyze the actual content, not guess
• Compare against current configuration specifically
• Provide implementation examples, not just suggestions
• Be honest when nothing is useful
• Prioritize by impact and effort

MUST NOT

• Suggest changes without understanding current setup
• Recommend patterns that conflict with existing config
• Be vague ("consider improving") - be specific
• Force-fit patterns that don't apply
• Overwhelm with too many suggestions