Skip to main content

What are Skills?

Skills are SKILL.md files, committed to your repositories or written on the Customize page, that teach Devin reusable procedures — any repeatable workflow you want Devin to follow consistently. Testing your app before opening a PR, deploying to an environment, investigating a codebase, scaffolding a new service — if you can write it as step-by-step instructions, you can turn it into a skill. They follow the open Agent Skills standard, so the same skill files work across multiple AI coding tools. Place skill files at .agents/skills/<skill-name>/SKILL.md in your repository. Devin automatically discovers them across all your connected repositories. See the Agent Skills specification for the full file format reference.
Skills don’t have to live in a repository. Skills in plugins can be installed at the personal, organization, or enterprise scope and are available in every session in that scope, alongside repository skills.

Why Skills Matter

Without skills, Devin has to figure out workflows from scratch every session. With skills, you define a procedure once and Devin follows it reliably every time. Skills are useful whenever you have a workflow that:
  • Should be done the same way every time — testing checklists, deployment steps, review procedures
  • Requires repo-specific knowledge — which services to start, what ports to use, which commands to run
  • Benefits from dynamic context — pulling in git diffs, branch names, or environment info at invocation time

Devin Suggests Skills Automatically

Devin can automatically suggest skills for you. After Devin tests your application or learns something new about your setup during a session, it will suggest creating or updating a skill to capture that knowledge. You’ll see a suggestion in your session timeline with:
  • A summary of what was learned (e.g. “how to start the backend with Docker”)
  • The proposed SKILL.md file contents
  • A “Create PR” button to commit the skill to your repo
Over time, Devin builds up a library of skills in your repo about how to run, test, and deploy your application. A skill can also carry a dynamic workflow script, so a multi-agent orchestration you ran once becomes reusable.

Examples

Testing before opening a PR

A skill that tells Devin how to verify a Next.js app before creating a pull request:

Deploying to an environment

A skill that deploys the app using arguments for the target environment:
Invoking with @skills:deploy staging substitutes staging for $ARGUMENTS and $1. The triggers: ["user"] field ensures Devin only runs this skill when you explicitly ask for it — it won’t auto-activate.

Investigating a part of the codebase

A skill for guided code exploration that pre-approves read-only tools:
The allowed-tools field lets Devin use the listed tools without asking for permission while the skill is active. Other tools remain available but go through the normal permission prompt. To block a tool outright, use permissions: { deny: [...] } (see below).

Creating a Skill in the web app

You don’t need a repository to write a skill. On the Customize page, open the Skills tab, pick the scope — Personal (only you), Organization, or Enterprise (every organization in your enterprise) — and click Create skill. You get an editor for the skill’s SKILL.md; save it and it is available in every new session in that scope. Edit it from the same place later; each save keeps a version history. Devin ships its own built-in skills (for example implement, plan, triage, review) in the System Skills plugin, which is installed for everyone. A skill’s name is how you call it everywhere: @skills:<name> in the prompt box, in Slack, or in an API prompt. Jira and Linear labels, schedules, and automations pick a skill the same way.

Writing a good skill

A skill works best when it reads like instructions to a new teammate:
  • Procedure: one step per line, written imperatively, covering setup, the task itself, and delivery. Each step has an action verb (write, run, open) and the steps together cover the whole task without overlapping.
  • Specifications: what must be true when Devin is done, so Devin can check its own work.
  • Advice: preferences and corrections that apply to the whole task; advice for one step goes under that step.
  • Forbidden actions: anything Devin must never do.
  • Required from user: tokens, links, or decisions Devin can’t get on its own.
Specific commands, flags, and strings are fair game, often the difference between a skill that works and one that doesn’t. Don’t over-specify the rest: too much detail reduces Devin’s ability to solve problems along the way. Run two sessions in parallel with a new skill to find its gaps quickly, and when Devin needs help mid-session, add what you told it to the skill so the next session doesn’t. You can also ask Devin to create or improve a skill from past sessions.

Skill Discovery

Devin discovers skills from two sources:
  1. Repositories — As each repository is cloned onto the session’s machine, Devin scans it for SKILL.md files on disk, so Devin always sees the version on the branch being worked on. A repo cloned mid-session is scanned when its clone completes, without restarting the session.
  2. Plugins — Skills shipped by plugins installed for your organization are available as soon as the session starts, before any repo is cloned.

Supported Skill File Locations

Devin searches for SKILL.md files in all of the following directories:
  • .agents/skills/<skill-name>/SKILL.md (recommended)
  • .devin/skills/<skill-name>/SKILL.md
  • .github/skills/<skill-name>/SKILL.md
  • .claude/skills/<skill-name>/SKILL.md
  • .cognition/skills/<skill-name>/SKILL.md
  • .windsurf/skills/<skill-name>/SKILL.md
  • .cursor/skills/<skill-name>/SKILL.md
  • .codex/skills/<skill-name>/SKILL.md
  • .codeium/skills/<skill-name>/SKILL.md
  • .kiro/skills/<skill-name>/SKILL.md
All ten paths are scanned in every repo.

What Devin Loads from a Skill File

When a skill is discovered, Devin parses the YAML frontmatter (the --- block at the top) and extracts: Devin also supports these additional frontmatter fields beyond the standard spec: Everything after the frontmatter is the skill body — the instructions Devin reads when the skill is invoked. See the Agent Skills specification for the full file format reference.

How Devin Uses Skills

At the start of every session, Devin sees a list of all available skills (name + description). When a skill is invoked, Devin reads the full SKILL.md file and adds its body to its conversation context, where it stays for the rest of the session — it’s not just a reference, it directly guides Devin’s behavior. Invoking a skill whose body is already in context doesn’t add it again. Devin can use skills in several ways:

Automatic invocation

When Devin determines a skill is relevant to the current task, it invokes it automatically. For example, if you ask Devin to fix a bug in frontend code and there’s a test-before-pr skill, Devin will activate it before opening the PR. Set triggers: ["user"] in the frontmatter to prevent auto-invocation for skills you only want triggered explicitly.

Mention a skill in your prompt

You can tell Devin to use a specific skill by including @skills:skill-name in your message:
You can also pass arguments:
The arguments are substituted into the skill body wherever placeholders appear: $ARGUMENTS is replaced with the full argument string, and $1 through $9 with the individual whitespace-separated arguments (missing ones become empty). If the skill body contains no placeholders, the arguments are appended to the end of the skill content instead. $0, $10 and beyond, and other dollar expressions like $HOME are left as-is.

Using several skills together

Invoking a skill doesn’t replace the previous one. Each invocation adds that skill’s body to Devin’s context, so mentioning two skills in one prompt (or invoking a second skill later) leaves the first in place and Devin follows both. Each skill’s allowed-tools and permissions take effect when it is invoked and stay in effect afterwards.

Searching and listing

Devin can list the available skills, or search a project directory or the active plugins for more, if it needs to find the right one mid-session.

Skills vs. Playbooks

Use skills for all new work. Playbooks are moving to Skills: when your account moves, each playbook becomes a skill with the same instructions, the Playbooks pages become read-only, and the Playbooks API reads and writes the skill. New accounts will start with Skills and have no Playbooks, from October 24, 2026. See Playbooks are moving to Skills.

Skills vs. Memory

Skills are procedures you write deliberately. Memory is what Devin learns about your preferences and projects as you work, saved automatically and personal to you.

Learn More