Using Skills · GitHub Copilot Best Practices

Key insight: Skills are the bridge between your context packs and consistent, high-quality outputs. Rather than re-explaining how you want something done every session, a Skill encodes that knowledge once and reuses it automatically.

What is a Skill?

A Skill is a plain text (Markdown) file stored in a specific location that OpenCode can load on demand. When you invoke a Skill, the agent reads those instructions and follows them as it works through your task.

Think of it like a standing operating procedure (SOP) written for the AI. Instead of saying "please follow our standard format for release notes, use this template, pull in these details, and check it against this checklist" — you write that once as a Skill, and from then on you just say "use the release notes skill".

Skills can contain:

Step-by-step instructions for how to approach a task
Format requirements or output templates
Rules and constraints the agent must follow
Pointers to context files to read
Examples of good outputs

When to create a Skill

You don't need a Skill for every task — they're most valuable when:

You find yourself repeating the same detailed instructions session after session
A task has a specific process, format, or set of rules it must follow every time
Multiple people on your team need to produce consistent outputs from similar inputs
You want to codify tribal knowledge — the "how we do things here" — so it's available to anyone using OpenCode

Common examples: meeting summary templates, release note formats, stakeholder update drafts, weekly status drafts, ticket-creation patterns. Anything you do regularly with a recognisable shape can become a Skill.

Where Skills live

You don't need to worry about where OpenCode saves Skills — it handles that automatically. Just ask it to create one and it will put it in the right place.

Tip: If you're storing your work in a GitHub repository (recommended), Skills get saved there too — which means the whole team can use the same Skills and any improvements flow to everyone automatically.

How to create a Skill

Just ask OpenCode to write one. You don't need to create files or folders manually. Something like:

From everything you know about how I like to write release notes, create a Skill that captures that process.

OpenCode will write the Skill file and save it in the right place. You can then refine it by telling it what to change, just like editing any other document in a session.

The more context OpenCode has about your process before you ask — past examples, templates, instructions you've given it — the better the Skill it writes will be.

Combining Skills with context packs

Skills tell OpenCode how to do something. Context packs tell it what to know. Together they're much more powerful than either alone.

For example: a "meeting summary" Skill tells OpenCode your preferred format and what to extract. But if you also load the meeting transcript as context, it applies your format to the actual meeting. That combination — structured process + relevant content — is where you get output that doesn't need much editing before it's usable.

Sharing Skills with your team

If your Skills are stored in a shared GitHub repository, anyone who clones or syncs that repo gets access to the same Skills. This is the best way to ensure consistency across the team — one person improves a Skill, everyone benefits.

You can also store Skills in a shared folder structure and document them on a page like this one so people know what's available.