10 OpenCode Skills Worth Installing in 2026

OpenCode is model-agnostic by design. It runs any LLM through any provider, which is why the community around it has grown fast since Anthropic blocked third-party tools from using Claude subscriptions in early 2026. But the model is only half of what makes an agent useful. The other half is context and workflow, and that is what skills provide.

OpenCode implements the Agent Skills open standard natively. It exposes a skill tool to the model that lists every installed skill by name and description at startup, then loads the full instructions only when the model decides a skill applies. That progressive loading is what makes it possible to have dozens of skills installed without eating context on unrelated work. It is also what makes a skill written for Claude Code or Codex work in OpenCode without any modification, because OpenCode reads Claude-compatible and agent-standard directories alongside its own.

These are the best OpenCode skills I would install first. Ten skills that cover the real gaps in what a coding agent can do out of the box: live web access, session handoff, codebase understanding, plan pressure-testing, multi-agent orchestration, output compression, and SaaS integrations.

OpenCode skills are directories containing a SKILL.md file and optional supporting scripts or reference files. The SKILL.md file opens with YAML frontmatter (required fields: name and description) followed by markdown instructions the agent reads when the skill activates.

What makes OpenCode's implementation distinct is the native skill tool. At session start, OpenCode reads every installed skill and exposes its name and description to the model through a tool definition. When you give the agent a task, it inspects the list, calls skill({ name: "..." }) on any that match, and only then loads the full instruction body. Skills that never get called never enter the context.

OpenCode looks for skills in six directory locations:

Note that the global OpenCode path is ~/.config/opencode/skills/, not ~/.opencode/skills/. Several third-party guides get this wrong. The official docs are the source of truth.

Because skills are markdown, they work with whatever provider OpenCode is pointed at: Anthropic Claude, OpenAI, Google Gemini, xAI, Moonshot's Kimi, GLM, DeepSeek, Qwen, or local models via Ollama. (For a head-to-head coding benchmark of the latest GLM and Kimi models, see GLM-5.2 vs. Kimi K2.7 Code.) A few skills that originated in the Claude Code ecosystem lean on Claude-specific features (particularly the Task tool for subagents) and may need adaptation on other providers. I flag those below.

OpenCode also has a separate plugin system: JavaScript or TypeScript modules that hook into runtime events (session lifecycle, tool execution, chat messages) rather than instructing the agent. Some tools, like Obra Superpowers, ship both a skill collection and a plugin. Skills teach the agent what to do; plugins change how OpenCode behaves.

Permissions are OpenCode-specific and worth knowing about. In opencode.json, you can allow, deny, or gate individual skills:

{
  "permission": {
    "skill": {
      "*": "allow",
      "internal-*": "deny",
      "experimental-*": "ask"
    }
  }
}

Skills marked deny are hidden from the agent entirely. Per-agent overrides let different agents in the same project see different skill sets. If you want a specific agent to skip skills altogether, set tools: { skill: false } on that agent.

For a deeper walkthrough of how the Agent Skills spec came together and grew to over 40,000 published skills, read Firecrawl's Agent Skills Explained.

After installing and testing a lot of them, the skills that actually earn their spot share a pattern.

Signs a skill is worth installing:

• A specific trigger description. Bad: "helps with web tasks." Good: "Use when the user asks to scrape a URL, search the web, crawl a documentation site, or extract structured data from a webpage." OpenCode's native skill tool pattern-matches against the description at every turn. Vague descriptions produce vague activation.
• Deterministic work runs in scripts. Parsing, validation, and sorting belong in bundled scripts, not in the model. Skills that offload the mechanical parts to code are cheaper and more reliable.
• Lean SKILL.md, deep reference files. The main body should be short. Push edge cases into companion files that only load when needed.
• One skill, one job. Skills that try to cover five workflows trigger at the wrong times and confuse the routing.

Signs a skill will cause problems:

• A bloated SKILL.md that loads on every adjacent task and burns context regardless of relevance.
• Undocumented network calls inside bundled scripts. Read the SKILL.md and every script before installing from unfamiliar authors.
• No examples. If you cannot infer the use case from the description and body, neither can the model.

Here are the ten I actually keep installed.

An agent is only as smart as the context it has. The Firecrawl skill gives OpenCode live web context: search, scrape, crawl, map, and browser interaction.

OpenCode ships with no live web access. Whatever the model was trained on is what it knows, which means recent docs, library changelogs, and live pages are invisible by default. The Firecrawl skill fixes that by teaching OpenCode how to install and use the Firecrawl CLI on its own. After one install command, OpenCode has a complete web data toolkit it can reach for autonomously.

The Firecrawl CLI is built specifically for AI agents. Results write to files rather than dumping into the context window, JavaScript rendering is handled automatically, and the commands map cleanly to how an agent thinks about web tasks. Search to find sources, scrape to read them, crawl to index a whole site, map to discover URLs, interact to control a live browser session.

Install:

npx -y firecrawl-cli@latest init --all --browser

The --all flag detects OpenCode alongside every other AI coding agent on your machine and installs the skill to each. The --browser flag opens browser authentication so you can connect your API key without copying it manually. Get a free API key at firecrawl.dev/app/api-keys. For a broader tour of the eight major AI coding agents in 2026, including which support Firecrawl out of the box, see the sourced comparison.

Commands OpenCode gets access to:

• firecrawl search: Live web search with full-page content, not just snippets or a cached index (see the best web search MCP servers comparison for how Firecrawl compares to Tavily and Exa)
• firecrawl scrape: Clean markdown from any page, including JavaScript-heavy sites
• firecrawl crawl: Recursively follow links across an entire site
• firecrawl map: Discover all URLs on a domain
• firecrawl interact: Scrape a page then interact with it via natural language prompts or Playwright code, with a live view stream you can watch or control

Example:

"Scrape the Prisma docs changelog and summarize what changed in the last 30 days"
"Search for the top three competitors to our product and extract their pricing pages into a comparison table"
"Crawl the OpenCode docs and find every page that mentions the plugin system"

Honest take: Firecrawl is the primitive I install first on any coding agent, OpenCode included. The reason is architectural: unlike Composio (which handles SaaS APIs) or Cloudflare's skill (which teaches product knowledge), Firecrawl gives OpenCode access to the open web. That is the one thing no LLM provider ships natively. Every other skill that depends on live information (documentation lookups, competitor research, changelog watching) sits on top of it.

Cons: You can try the endpoints without an API key, but ongoing use needs one and consumes credits on heavy usage. The free tier of 1,000 credits per month covers substantial testing, but production research workflows may need a paid plan.

Firecrawl is used by 1.25M+ developers across 150,000+ companies and has served 5B+ requests to date. Builders keep coming back because the whole workflow (search, scrape, crawl, interact) lives in a single install on the real web.

Full documentation and CLI reference at docs.firecrawl.dev/cli. Also worth reading: the deeper look at why default agent web search falls short and the Claude Agent SDK with Firecrawl guide.

Hardik Pandya's stop-slop skill teaches the agent to detect and remove common AI writing tells from any prose it generates.

Anyone who has asked a coding agent to draft a README, a commit message, or documentation knows the pattern: throat-clearing openers, business jargon, em dashes everywhere, and the "Not X. But Y." rhetorical rhythm that shows up in every AI-generated draft. The stop-slop skill, currently at 13.4k stars, is a SKILL.md plus three companion reference files (phrases.md, structures.md, examples.md) that give the agent a specific taxonomy of what to strip and a 1-10 scoring rubric across five dimensions (Directness, Rhythm, Trust, Authenticity, Density). The skill revises anything scoring below 35 out of 50.

This is not a code skill. It is an Encoded Preference skill for writing tasks: docs, blog posts, changelogs, marketing copy, anything where the agent generates prose you will actually ship.

Install:

mkdir -p ~/.agents/skills
git clone https://github.com/hardikpandya/stop-slop.git ~/.agents/skills/stop-slop

For an OpenCode-native install, drop into ~/.config/opencode/skills/stop-slop instead. Both paths work because OpenCode reads six recognized skill directories.

What the skill actually catches:

• Throat-clearing openers like "Here's what I find interesting..."
• Emphasis crutches, all adverbs, vague declaratives
• Structural cliches: binary contrasts ("Not X. But Y."), dramatic fragmentation, rhetorical setups, narrator-from-a-distance voice, passive voice
• Em dashes, Wh-sentence starters, staccato fragmentation
• Business jargon and lazy extremes

Example:

"Draft the README for this repo and run stop-slop on it before showing me"
"Rewrite this changelog entry, then apply stop-slop"
"Score this landing page copy with stop-slop and revise anything under 35"

Honest take: This is the skill I reach for most on documentation tasks. The score-then-revise pattern is smarter than a simple "make it less AI-sounding" prompt because it gives the agent a concrete rubric to hit. Reading the flagged reference files is also educational: you start noticing the same patterns in your own writing.

Cons: Not designed for code output, only prose. And the rubric is opinionated. If your team writing style already leans heavy on em dashes or dramatic contrasts, the skill will fight you. Fork it and tune the reference files before turning it loose on marketing copy.

Repo: github.com/hardikpandya/stop-slop. Author writeup: hvpandya.com/stop-slop.

Matt Pocock's handoff skill compresses your current OpenCode session into a structured markdown document so you can continue the work in a fresh session, or pass it to a different agent entirely.

The problem it solves is context drift. As discussed on HN, sessions nearing compaction limits do not just slow down, they get worse at their job. After roughly 120k tokens, attention relationships strain and response quality degrades. /handoff gives you a clean exit before you hit that wall: a document containing the purpose of the next session, relevant context from the current one, suggested skills to invoke, and pointers to existing artifacts, without duplicating file content.

The pattern that makes this genuinely powerful is cross-agent: plan in Claude Code (or use /grill-me there), generate a handoff doc, then hand it to OpenCode running any model of your choice for the actual implementation. Or split a large task across parallel OpenCode worktrees with the same handoff seeding each one.

Install:

npx skills@latest add mattpocock/skills

The installer prompts you to pick which skills to install and which agents to install them to; select handoff and OpenCode. Matt's collection sits at 158k GitHub stars and is one of the largest skills repositories in the ecosystem.

Example:

"Create a handoff for this session before I run out of context"
"Handoff, I want to continue this in a new OpenCode session"
"Generate a handoff doc so I can delegate the implementation to a worktree running Qwen"

Honest take: The handoff document is more purposeful than a /compact summary because you control what the next session needs to know. It works especially well in OpenCode because you can hand off to a session running a completely different model, matching model cost and capability to the specific task at hand.

Cons: The generated document goes to your OS temp directory by default, so commit it if you want a permanent record. Most useful when you are deliberately splitting work across sessions or agents; less necessary for single-threaded sessions.

Full reference at aihero.dev/skills-handoff.

Matt Pocock's grill-me skill interviews you relentlessly about every aspect of a plan until you reach shared understanding, before OpenCode writes any code.

Grill-me went viral on X earlier this year because it fixes the most common failure mode in agentic coding: the agent charging ahead with wrong assumptions before you had a chance to correct them. The instruction in the SKILL.md is direct: "Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer." If a question can be answered by reading the codebase, OpenCode reads it and moves on rather than asking you.

This is a design review tool. Use it before you write code, not after. The questions surface implicit assumptions, dependency chains between decisions, and gaps in your plan that feel obvious until you try to articulate them.

Install:

npx skills add https://github.com/mattpocock/skills --skill grill-me

Example:

"Grill me on this feature spec before I start building"
"Run grill-me on my plan for the auth refactor"
"Walk me through every decision in this architecture before I commit to it"

Honest take: Grill-me is where I would start if I were new to OpenCode. It forces the model to think about the plan before generating code, which changes the ratio of code you have to throw away later. The recommended-answer pattern also keeps things moving. You are not stuck at each question with no direction, you are reacting to a proposed answer.

Cons: Requires an actual plan or design to stress-test. "I want to build X" is too vague to grill effectively. Prepare a written spec or description before invoking the skill. The session is open-ended by design, not a checklist with a fixed number of questions.

Repo: github.com/mattpocock/skills.

Superpowers is the most complete agentic development framework available as an OpenCode-compatible skill set.

Obra's Superpowers is currently the highest-starred skills repository on GitHub (247k stars, 21.9k forks). It ships two things: a plugin that injects a bootstrap into every session (the "1% rule": if there is even a 1% chance a skill applies, use it), and a set of composable skills that structure the full software development lifecycle. Brainstorming, git worktree setup, implementation planning, subagent-driven execution, test-driven development, systematic debugging, verification before completion, and finishing a development branch.

OpenCode is a first-class target for Superpowers. There is a dedicated .opencode/ directory in the repository with harness-specific install instructions and documentation at docs/README.opencode.md.

Install (OpenCode-specific):

Paste this as a prompt to OpenCode:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

OpenCode will fetch the install doc and run through the setup itself. Alternatively, add the plugin declaratively in opencode.json:

{
  "plugin": ["superpowers@git+https://github.com/obra/superpowers.git"]
}

Key skills in the collection:

• brainstorming: Socratic design refinement before any code
• using-git-worktrees: isolated workspace per feature, with a clean baseline check
• writing-plans: breaks work into 2-5 minute tasks with exact file paths and verification steps
• subagent-driven-development: dispatches fresh subagents per task with two-stage review (spec compliance, then code quality)
• test-driven-development: enforces red-green-refactor discipline
• systematic-debugging: a four-phase root-cause process
• verification-before-completion: ensures the fix actually works before marking a task done

Example:

"Brainstorm the approach for adding real-time collaboration to this note app"
"Write a plan for the auth refactor, then execute it"
"Debug this failing test using systematic-debugging"

Honest take: Superpowers is heavy. The bootstrap runs in every session, and the opinionated methodology (TDD, YAGNI, DRY) will not fit every workflow. But if your project has clear requirements and you want systematic execution instead of exploratory prototyping, it is the closest thing available to a full agentic engineering harness dropped into your existing tool. The subagent-driven approach also matches OpenCode's model flexibility well: you can route subagents to cheaper models and keep frontier models for design review.

Cons: Ambient token cost from the bootstrap in every session. Requires the plugin system (separate install path from most other skills). Telemetry ships on by default; disable with SUPERPOWERS_DISABLE_TELEMETRY=1.

Repo: github.com/obra/superpowers. Original release writeup: blog.fsck.com/2025/10/09/superpowers.

Understand-Anything turns any codebase into an interactive knowledge graph that OpenCode can query, tour, and diff against your changes.

Understand-Anything is a multi-agent skill collection (71k stars) that runs a pipeline of specialized agents (project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, domain-analyzer) to produce a full knowledge graph of your project. Every file, function, class, and dependency becomes a node with plain-English summaries. Then a dashboard exposes fuzzy and semantic search, color-coded architectural layers, and guided tours.

The skill combines Tree-sitter (deterministic structure extraction) with LLM analysis (semantic summaries) so the graph is grounded in the actual code, not just what the model remembers about your repo.

Install (OpenCode-specific):

curl -fsSL https://raw.githubusercontent.com/Egonex-AI/Understand-Anything/main/install.sh | bash -s opencode

Restart OpenCode after install. Windows PowerShell: iwr -useb https://raw.githubusercontent.com/Egonex-AI/Understand-Anything/main/install.ps1 | iex. Update with ./install.sh --update, uninstall with ./install.sh --uninstall opencode.

Commands OpenCode gets:

• /understand: scans the project and builds .understand-anything/knowledge-graph.json, incremental on subsequent runs
• /understand-dashboard: opens an interactive web dashboard with color-coded architectural layers and search
• /understand-chat: ask natural-language questions about the codebase
• /understand-diff: see which parts of the system your changes affect before committing
• /understand-domain: extract business domains, flows, and process steps
• /understand-knowledge: analyze wiki-style knowledge bases (the Karpathy LLM-wiki pattern)

Example:

"Run /understand on this monorepo and open the dashboard"
"Which modules depend on the payment service?"
"Show me the domain flow for user signup"

Honest take: The first /understand run on a large codebase eats a substantial number of tokens because it has to analyze every file. Subsequent runs are incremental and cheap. This makes Understand-Anything a great fit for OpenCode specifically because you can point the first-time analysis at a local model via Ollama or a cheap open model, and switch to a frontier model for the interactive queries later.

Cons: First-run cost is real. If your project is over 100k lines and you are on a paid API, budget accordingly. Requires restart after install to register the commands.

Repo: github.com/Egonex-AI/Understand-Anything.

Julius Brussee's Caveman skill cuts OpenCode output tokens by an average of 65% by stripping narration, filler, and pleasantries while keeping every technical fact and code block byte-for-byte intact.

The concept: when OpenCode explains a React re-render bug normally, it says something like "The reason your component is re-rendering is likely because you're creating a new object reference on each render cycle. I'd recommend using useMemo to memoize the object." (69 tokens). In caveman mode: "New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo." (19 tokens). Same fix. 75% fewer words.

A March 2026 paper found that constraining large models to brief responses actually improved accuracy by 26 points on certain benchmarks. Caveman does not make the model dumber; it makes its output smaller while keeping its reasoning the same size.

Install: