Thomashighbaugh
111 verified skills111 total stars
agent-format-enforcer
Enforce the <Agent_Prompt> XML wrapper convention across all agent definition files. Scan, validate, and auto-fix non-compliant agents.
development1
config-sync
Synchronize opencode.jsonc with the latest OpenCode config schema from Context7. Checks schema, detects drift, and updates config to remain compliant.
development1
joc-teams
CLI-team runtime for opencode, codex, or gemini workers in tmux panes when you need process-based parallel execution
tools1
omc-plan
Strategic planning with optional interview workflow
tools1
naming-cheatsheet
Apply language-agnostic naming conventions using the A/HC/LC pattern. Use when naming variables, functions, or reviewing code for naming consistency.
development1
joc-doctor
Diagnose and fix OpenCode JOC installation issues for self-managed global file installations
development1
icon-generator
Generate web UI/UX icon assets (favicon.ico, apple-touch-icon, PWA icons) and optionally Unreal Engine packaging icons from a single source SVG/PNG.
development1
graph-thinking
Apply graph-based thinking to visualize complex relationships and solve problems non-linearly. Use when mapping dependencies, analyzing systems, exploring interconnected concepts, or designing architectures.
testing1
github-ops
GitHub operations via gh CLI for pull requests/PRs, GitHub code search, and drafting exact gh commands. Always use instead of WebFetch for github.com.
tools1
orchestrate-router
Natural language intent router — takes amorphous user requests and routes to the correct /orchestrate, /ideation, or /harvest-context subcommand
tools1
typescript-interface-vs-type
Guidance on when to use `interface` vs `type` in TypeScript. Use when reviewing TypeScript code, choosing between interface and type alias, or evaluating type system usage.
development1
file-organizer
Intelligently organizes files and folders by understanding context, finding duplicates, suggesting better structures, and automating cleanup tasks.
tools1
idea-refine
Refines ideas iteratively through structured divergent and convergent thinking. Use to transform raw ideas into actionable concepts.
tools1
opencode-configure
Manage all OpenCode configuration surfaces — opencode.jsonc, agents, skills, commands, tools, plugins, rules, MCP, and project-scoped .opencode/ config. Use when adding, modifying, validating, or inspecting any part of the config stack.
tools1
planning-and-task-breakdown
Break work into ordered tasks with explicit acceptance criteria. Use when you have requirements and need to break them into implementable units.
testing1
hubs-doctor
Diagnose and fix OpenCode Hubs installation issues for self-managed global file installations
development1
vectorize-context
Manual vector DB for semantic search over .opencode/context/ — triggered via /harvest-context search
development1
dependency-updater
Smart dependency management for any language. Auto-detects project type, applies safe updates automatically, prompts for major versions, diagnoses and fixes dependency issues.
data-ai1
deliberate-practice
Apply deliberate practice principles for rapid skill acquisition and expert-level performance. Use when learning new skills, plateauing in development, designing training routines, or seeking to accelerate expertise acquisition.
development1
deepinit
Deep codebase initialization with hierarchical AGENTS.md documentation
development1
overhaul
Analyze an existing project across multiple dimensions and produce a prioritized implementation plan for targeted refinement
tools1
compact
Compact session context — save work artifacts to state and update CHANGELOG with recent changes. Use when session context is full or before switching tasks.
documentation1
tree-of-thoughts
Explore multiple solution branches in parallel, evaluate each, and recommend the best path. Use when the user explicitly invokes /ideation tree-of-thoughts or asks for "tree of thought" / "branching exploration".
testing1
self-consistency
Run multiple independent reasoning passes and find consensus. Use when the decision is critically important, the stakes are high, or the user explicitly requests "run it multiple times" / "check consistency" / "self-consistency".
testing1
opro
Optimization by PROmpting — generate candidate prompt variations, test each against a benchmark, and report the best performer. Use when the user invokes /ideation opro or asks for "prompt optimization" / "OPRO".
testing1
mcp-setup
Configure popular MCP servers for enhanced agent capabilities
tools1
conventional-commit
Structure commit messages following the Conventional Commits specification. Use when drafting commit messages before coding or reviewing commit message quality.
testing1
project-config-composer
Auto-generate a minimal per-project .opencode/ configuration from a stack fingerprint + recommendations. Creates opencode.jsonc, project agents, rules, and instructions that reference global resources. Used by /init-project provision.
development1
agent-md-refactor
Refactor bloated AGENTS.md, or similar agent instruction files to follow progressive disclosure principles. Splits monolithic files into organized, linked documentation.
development1
ask
Process-first advisor routing for multi-model consultation via ask commands, with artifact capture and no raw CLI assembly
tools1
autoresearch-agent
Delegate autoresearch tasks to a headless OpenCode sub-agent process. Use when the current agent needs to run any autoresearch command as an autonomous background or foreground subprocess.
development1
ccg
Multi-model orchestration via ask commands for alternative perspectives, then synthesis
data-ai1
changelog-generator
Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes.
development1
skills/configure-notifications
--- name: configure-notifications description: Configure notification integrations (Telegram, Discord, Slack) via natural language level: 2 triggers: - "configure notifications" - "setup notifications" - "configure telegram" - "setup telegram" - "telegram bot" - "configure discord" - "setup discord" - "discord webhook" - "configure slack" - "setup slack" - "slack webhook" level: 2 --- # Configure Notifications Set up OMC notification integrations so you're alerted when se
development1
crafting-effective-readmes
Use when writing or improving README files. Provides templates and guidance matched to your audience and project type.
documentation1
design-system-starter
Create and evolve design systems with design tokens, component architecture, accessibility guidelines, and documentation templates. Ensures consistent, scalable, and accessible UI across products.
documentation1
joc-reference
OAS agent catalog, available tools, team pipeline routing, commit protocol, and skills registry. Auto-loads when delegating to agents, using OAS tools, orchestrating teams, making commits, or invoking skills.
tools1
learner
Extract a learned skill from the current conversation
tools1
professional-communication
Guide technical communication for software developers. Covers email structure, team messaging etiquette, meeting agendas, and adapting messages for technical vs non-technical audiences. Use when drafting professional messages, preparing meeting communications, or improving written communication.
development1
skill-creator
Guide for creating effective skills. Use when users want to create a new skill or update an existing skill that extends capabilities with specialized knowledge, workflows, or tool integrations.
tools1
ralplan
Consensus planning entrypoint that auto-gates vague ralph/autopilot/team requests before execution
tools1
remember
Review reusable project knowledge and decide what belongs in project memory, notepad, or durable docs
testing1
trace
Evidence-driven tracing lane that orchestrates competing tracer hypotheses in OpenCode built-in team mode
development1
visual-verdict
Structured visual QA verdict for screenshot-to-reference comparisons
testing1
web-to-markdown
Use ONLY when the user explicitly says: 'use the skill web-to-markdown ...' (or 'use a skill web-to-markdown ...'). Converts webpage URLs to clean Markdown by calling the local web2md CLI (Puppeteer + Readability), suitable for JS-rendered pages.
tools1
joc-setup
Install or refresh OpenCode JOC — delegates to /init-project for the full workflow
development1
mui
Material-UI v7 component library patterns including sx prop styling, theme integration, responsive design, and MUI-specific hooks. Use when working with MUI components, styling with sx prop, theme customization, or MUI utilities.
development1
ai-slop-cleaner
Clean AI-generated code slop with a regression-safe, deletion-first workflow and optional reviewer-only mode
development1
deep-dive
2-stage pipeline: trace (causal investigation) -> deep-interview (requirements crystallization) with 3-point injection
devops1
hud
Configure HUD display options (layout, presets, display elements)
tools1
hubs-setup
Install or refresh OpenCode Hubs — delegates to /init-project for the full workflow
development1
release
Automated release workflow for OpenCode Hubs
development1
humanizer
Remove signs of AI-generated writing from text. Use when editing or reviewing text to make it sound more natural and human-written. Based on Wikipedia's comprehensive "Signs of AI writing" guide.
documentation1
skills/hive-methodology
--- name: hive-methodology description: Agent Hive methodology — 7 principles for structured multi-agent coordination: Plan→Approve→Execute, context persistence, batched parallelism, worktree isolation, good enough wins, tests define done, iron laws level: 2 --- # Agent Hive Methodology > **Stop vibing. Start hiving.** Plan first. Execute with trust. Context persists. Inspired by [hung319/agent-hive](https://github.com/hung319/agent-hive)'s PHILOSOPHY.md — a multi-agent orchestration framewor
development1
document-processor
Convert documents (PDF, EPUB, HTML, DOCX, MD) to clean Markdown using pandoc and pdftotext for ingestion into project context
development1
commands
Manage OpenCode skills - list, add, remove, edit, search, create, update, package, validate, sync, setup, scan
development1
cancel
Cancel any active OMC mode (autopilot, ralph, ultrawork, ultraqa, swarm, ultrapilot, pipeline, team)
development1
opencode-plugin-creator
Guide for creating OpenCode plugins — hook plugins (.ts), npm plugins, and TUI plugins (.tsx). Use when building, updating, or packaging OpenCode plugins.
tools1
external-context
Invoke parallel document-specialist agents for external web searches and documentation lookup
development1
react-key-prop
Guidance on React key prop best practices for stable keys and reconciliation. Use when reviewing React components, rendering lists, or troubleshooting key-related rendering bugs.
development1
deep-interview
Socratic deep interview with mathematical ambiguity gating before autonomous execution
tools1
harden
Composable robustness — safeTask (error+deviation tracking), circuitBreaker (halt on failure rate), verificationGate (block downstream until verified)
development1
sciomc
Orchestrate parallel scientist agents for comprehensive analysis with AUTO mode
testing1
skillify
Turn a repeatable workflow from the current session into a reusable OMC skill draft
tools1
self-improve
Autonomous evolutionary code improvement engine with tournament selection
development1
brownfield
Feature addition to existing codebase — analyze system, identify integration points, validate strategy before implementation
development1
ultraqa
QA cycling workflow - test, verify, fix, repeat until goal met
tools1
ultrawork
Parallel execution engine for high-throughput task completion
tools1
verify
Verify that a change really works before you claim completion
testing1
skills/pipeline
--- name: pipeline description: Declarative multi-stage pipeline — Stage 1: lint → Stage 2: test → Stage 3: build → Stage 4: deploy, each stage gates the next --- # Pipeline Declarative multi-stage pipeline with hard gates between stages. Each stage must pass before the next begins. Stages are: lint → test → build → deploy. Failed stages produce actionable diagnostics, not silent failures. ## When to Use - You need a reliable, repeatable delivery pipeline - Changes must pass quality gates be
development1
project-session-manager
Worktree-first dev environment manager for issues, PRs, and features with optional tmux sessions
development1
autopilot
Full autonomous execution from idea to working code
development1
team
N coordinated agents on shared task list using OpenCode native teams
development1
plan-execute
Classic plan-then-execute — architect builds complete plan, executor implements step by step
development1
skills/pair
--- name: pair description: Pair programming — two agents on one task: Driver writes code, Navigator reviews in real-time, catching mistakes early --- # Pair Programming Two agents collaborate on one task: the **Driver** writes code while the **Navigator** reviews in real-time, catching mistakes early. Roles are clearly separated — the Driver focuses on implementation, the Navigator on quality, correctness, and strategic direction. ## When to Use - Complex implementation that benefits from r
development1
debug
Diagnose the current OMC session or repo state using logs, traces, state, and focused reproduction
development1
writer-memory
Agentic memory system for writers - track characters, relationships, scenes, and themes
documentation1
vibe-code
Conversational rapid prototyping — describe app in natural language, generate full-stack, iterate with feedback through conversational rounds
development1
hubs-reference
OAS agent catalog, available tools, team pipeline routing, commit protocol, and skills registry. Auto-loads when delegating to agents, using OAS tools, orchestrating teams, making commits, or invoking skills.
tools1
privacy-scan
Dynamically scan files and content for secrets, PII, API keys, tokens, credentials, and privacy-compromising content before committing to version control or saving as durable context. Used by init-project and harvest-context hubs.
development1
hubs-teams
CLI-team runtime for opencode, codex, or gemini workers in tmux panes when you need process-based parallel execution
tools1
llm-cache
Semantic LLM response cache — caches and retrieves LLM responses for semantically similar prompts using vector similarity
data-ai1
adr-skill
Create and maintain Architecture Decision Records (ADRs) optimized for agentic coding workflows. Use when you need to propose, write, update, accept/reject, deprecate, or supersede an ADR; consult existing ADRs before implementing changes; or enforce ADR conventions. This skill uses structured interviewing to capture intent before drafting, and validates output against an agent-readiness checklist.
testing1
grilling
Interview the user relentlessly about every aspect of a plan or design until reaching shared understanding. Use when the user wants to stress-test a plan before building, when plans seem vague or incomplete, when dependencies between decisions need resolution, or when the user says "grill me" or "stress-test this." Walks down each branch of the design tree one question at a time, providing recommended answers.
development1
opencode-config-workflow
Workflow and methodology for API-efficient OpenCode configuration management (global + per-project). Use when modifying opencode.jsonc, creating agents/skills/commands/rules, deciding global vs project placement, validating schema compliance, or minimizing LLM turns for config tasks. Complements `opencode-configure` (surface details) and `customize-opencode` (schema shapes) by providing the decision framework and API-cost-minimization strategy.
development1
opencode-agent-creator
Create specialized OpenCode agents with proper configuration for primary agents and subagents. Use when creating reusable agent profiles.
development1
opencode-command-creator
Create custom OpenCode commands with proper structure, trigger descriptions, arguments, and configuration. Use when the user wants reusable slash/command workflows in OpenCode, needs `.opencode/commands/*.md` or `opencode.jsonc` entries, wants command templates with `$ARGUMENTS`, or needs to override/extend built-in commands safely.
development1
subagent-driven-development
Execute implementation plans by dispatching independent subagents per task with automated review gates. Use when executing implementation plans with independent tasks, when you need per-task subagents for isolated context, or when you want spec compliance + code quality review after each task. CRITICAL for Hub-to-Hub handoffs between /ideation and /orchestrate — ensures plans survive context switches.
development1
find-tools
Discover, vet, and generate project-relevant OpenCode tools by searching registries (GitHub, npm) and local template catalog. Used by /init-project setup/refresh to provision project-specific tools alongside skills and agents.
tools1
readme-updater
Update README files to reflect current codebase state — scans agents, skills, tools, rules, commands, archetypes, and plugins; preserves existing tone, links, and structure; produces SEO-optimized, technically proficient documentation. Use when the user says "update the readme" or via /project readme.
tools1
systematic-debugging
Structured debugging methodology that mandates root cause investigation before attempting any fixes. Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. ESPECIALLY when under time pressure, when "just one quick fix" seems obvious, when you've already tried multiple fixes, or when you don't fully understand the issue. Do NOT skip when the issue seems simple — simple bugs have root causes too.
development1
ralph
Self-referential loop until task completion with configurable verification reviewer
tools1
find-skills
Discover, vet, and install agent skills by searching across every major skill registry (skills.sh, clawhub.ai, GitHub) simultaneously, presenting top results with security scanning. Use when setting up a project (/init-project), when the user asks "how do I do X", "find a skill for X", or when you need to extend agent capabilities. Searches all major registries at once instead of trusting a single site's rankings.
development1
skills/ideation
# Ideation Unified entry point for all planning and research methods. Each subcommand is a hardfork into a specific methodology with shared lifecycle behavior. ## When to Use - Starting a new feature, project, or task and need to plan before building - Researching a topic before committing to an approach - Refining a vague idea into an actionable plan - Deep-dive code quality analysis before starting a refactor - Analyzing module boundaries and planning modularity improvements - Designing arc
development1
skills/orchestrate
# Orchestrate Unified entry point for all execution and orchestration patterns. Each subcommand invokes a specific execution methodology with shared lifecycle behavior. ## When to Use - You have an approved plan (from `/ideation` or elsewhere) and need to execute it - You want a specific execution pattern for a task - Multi-agent execution with progress tracking and checkpoints - Resume interrupted work from a prior orchestration session ## No-Argument Behavior When invoked without argument
testing1
skills/init-project
# Init Project Unified project initialization hub with subcommand routing. Detects, scaffolds, documents, and refines an OpenCode Hubs project. Works for both first-time setup and iterative re-runs. ## When to Use - First time setting up Hubs in a project - Adding Hubs to an existing codebase - Refreshing config after major changes (refactors, new deps, team growth) - Re-running to capture new context and refine docs - Replacing `/hubs-setup`, `/deepinit`, or `/init-project-config` ## No-Arg
development1
tool-creator
Create valid, type-safe TypeScript tools for OpenCode — generates correct boilerplate, typed interfaces, and handler stubs. Use when building new tools for global config or per-project .opencode/tools/.
tools1
provision
Analyze a codebase and auto-generate project-specific agents, skills, tools, and rules into .opencode/. Project wrappers inject deep project context into subagents for dramatically more effective AI assistance.
tools1
stack-recommender
Maps a stack fingerprint (from @stack-detector or direct input) to recommended global OpenCode resources — skills, agents, rules, commands, archetypes. Used by /init-project setup and refresh to provision per-project configs.
development1
skills/harvest-context
# Harvest Context Unified entry point for extracting, generating, and managing project context. Each subcommand captures a different type of knowledge artifact, with a shared pattern of scanning existing state, checking for overlaps, and saving to the right location. ## When to Use - After a productive session, extract what you learned - After orchestration, capture decisions and patterns - When the codebase needs documentation (AGENTS.md hierarchy) - When session knowledge should become a re
development1
skills/project
# Project Unified entry point for project operations. Each subcommand delegates to an existing command, skill, or agent, with shared behavior for argument parsing and state awareness. ## When to Use - Creating tests for an agent - Committing, staging, or managing git operations - Creating or managing pull requests - Reviewing code quality, security, and architecture - Analyzing or optimizing code - Refactoring, simplifying, and modernizing code - Cleaning up AI-generated code slop - Generatin
development1
rule-generator
Generate project-specific OpenCode rules from a conventions fingerprint — converts detected coding patterns into .opencode/rules/*.md files with BAD/GOOD examples, tags, and auto-registration
development1
wiki
LLM Wiki compliance layer — index, log, frontmatter, and cross-references for .opencode/context/ (Karpathy model)
development1
find-agents
Discover, vet, and install AI agents by searching across agent registries and GitHub. Use when setting up a project (/init-project), when the user asks "find an agent for X", or when you need to extend agent capabilities with specialized subagents. Searches multiple sources simultaneously instead of trusting a single registry.
development1
context7-docs
Fetch official library docs via Context7 MCP for Tailwind CSS, React, Next.js, Vue, MCP, OpenCode, or any npm library. Always use before external web search.
tools1
find-rules
Discover, vet, and generate project-relevant OpenCode rules by searching registries (GitHub, skills.sh) and local template catalog. Used by /init-project setup/refresh to provision project-specific rules alongside skills and agents.
development1
improve-codebase-architecture
Analyze codebases for architectural friction and propose module-deepening refactors as testability improvements. Use when the codebase feels hard to change, tests are brittle, or modules seem shallow. Applies John Ousterhout's deep module principle — small interfaces hiding large implementations for better testability and AI navigability.
development1
redesign-existing-projects
Audit and upgrade existing websites and apps to premium design standards without breaking functionality. Use when redesigning an existing UI — identifies generic AI patterns (overused gradients, Lucide icons, centered card columns) and applies high-end alternatives. Works with any CSS framework.
development1
tag-resources
Scan, validate, and auto-tag global OpenCode resources (skills, agents, rules, archetypes) for resource_tags filtering. Used by /init-project, config maintenance, and by stack-recommender for accurate mapping.
development1
swarm
Architect-led swarm of 11 specialized agents with gated QA pipeline. Use when you need parallel execution with quality gates between batches
testing1
skills/tdd
--- name: tdd description: Test-driven development loop — red-green-refactor: write failing test, make it pass, refactor, repeat until all features covered --- # TDD Test-driven development following the red-green-refactor loop. Write a failing test first, make it pass with minimal implementation, then refactor for quality. Repeat until all features are covered. ## When to Use - Building new features where correctness is critical - Fixing bugs — write a test that reproduces the bug first, th
development1