Skip to main content

​
What are Skills?

Skills are SKILL.md files you commit to your repositories that teach Devin how to test your application end-to-end — how to start services, run the app locally, verify changes in the browser, and validate that everything works before opening a PR. 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.

​
Why Skills Matter

Without skills, Devin has to figure out how to run and test your app from scratch every session. With skills, Devin knows exactly how to:
  • Start your local dev environment — which services to run, which ports to use, how to seed test data
  • Verify changes in the browser — which pages to check, what “correct” looks like, what breakage to flag
  • Run the right test suites — which commands to execute, what passing output looks like

​
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 and test your application.

​
Quick Example

A skill that tells Devin how to test a Next.js app: 
---
name: test-before-pr
description: Run the local dev server and verify pages before opening any PR that touches frontend code.
---

## Setup

1. Install dependencies: `npm install`
2. Start the database: `docker-compose up -d postgres`
3. Run migrations: `npx prisma migrate dev`
4. Start the dev server: `npm run dev`
5. Wait for "Ready on http://localhost:3000"

## Verify

1. Read the git diff to identify which pages changed
2. Open each affected page in the browser
3. Check for: console errors, layout issues, broken links
4. Screenshot each page at desktop (1280px) and mobile (375px) widths

## Before Opening the PR

1. Run `npm run lint` and fix any issues
2. Run `npm test` and confirm all tests pass
3. Include screenshots in the PR description

​
Skill Discovery

Devin discovers skills from two sources, merged together at the start of every session:
  1. Indexed repos — Devin’s backend indexes SKILL.md files across all repositories connected to your organization. These are available immediately when a session starts, before any repos are cloned.
  2. Cloned repos — As repositories are cloned onto the session’s machine, Devin scans them for SKILL.md files on disk. Disk-scanned skills update or override any matching indexed skill from the same repo, ensuring Devin always uses the latest version on the branch being worked on.
When a repo clone completes mid-session, Devin automatically re-scans that repo so newly added or modified skills are picked up without restarting.

​
Supported Skill File Locations

Devin searches for SKILL.md files in all of the following directories:
  • .agents/skills/<skill-name>/SKILL.md (recommended)
  • .github/skills/<skill-name>/SKILL.md
  • .claude/skills/<skill-name>/SKILL.md
  • .cursor/skills/<skill-name>/SKILL.md
  • .codex/skills/<skill-name>/SKILL.md
  • .cognition/skills/<skill-name>/SKILL.md
All six 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:
FieldPurpose
nameIdentifies the skill. Falls back to the parent directory name if omitted.
descriptionShort summary shown in the skill list so Devin (and you) know what the skill does.
allowed-toolsRestricts which tools Devin can use while the skill is active.
Devin also supports these additional frontmatter fields beyond the standard spec:
FieldPurpose
argument-hintHint text shown alongside the skill name describing expected arguments.
triggersControls who can invoke the skill — ["user", "model"] by default. Set to ["user"] to prevent Devin from auto-activating it.
Everything after the frontmatter is the skill body — the step-by-step instructions Devin is prompted to follow when the skill is invoked. See the Agent Skills specification for the full file format reference. In addition to the standard spec, Devin supports two kinds of dynamic content in the skill body that are processed at invocation time:
  • $ARGUMENTS — replaced with the full arguments string passed when the skill is invoked (e.g. via @skills:deploy staging prod). You can also access individual arguments by index: $ARGUMENTS[0] or $0 for the first, $ARGUMENTS[1] or $1 for the second, etc. Arguments are split by whitespace.
  • !`command` — the command is executed in the repo root and replaced with its stdout, letting skills include dynamic values like branch names or port numbers.
For example, a deploy skill might use arguments like this: 
---
name: deploy
description: Deploy the app to a target environment.
argument-hint: <environment>
---

1. Check out the `$ARGUMENTS` branch
2. Run `./scripts/deploy.sh $0`
3. Verify the deployment at `https://$0.example.com`
Invoking with @skills:deploy staging would substitute staging for $ARGUMENTS and $0.

​
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 injects its body into its current context as a system-level instruction. This means Devin actively follows the skill’s steps for the remainder of the task — it’s not just a reference, it directly guides Devin’s behavior. 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: 
Fix the login bug on the /auth page @skills:test-before-pr
You can also pass arguments: 
@skills:deploy staging
The arguments are substituted into the skill body wherever $ARGUMENTS, $ARGUMENTS[0], $1, etc. appear.

​
One active skill at a time

Devin can only have one skill active at a time. Invoking a new skill replaces the previous one. When active, Devin is prompted to follow the skill’s steps in order and complete each one before moving on.

​
Searching and listing

Devin can search for skills by keyword or directory if it needs to find the right one mid-session. You can also ask Devin to list available skills or reload them after you’ve pushed changes to a skill file.

​
Limitations

  • Global / org-level skills — Today, skills live inside repositories. For org-wide skills, you can create a dedicated “skills” repo as a workaround. We’re exploring first-class support for org-level skills that apply across all repos.
  • Composing multiple skills — Currently only one skill can be active at a time. We’re working on support for chaining and composing workflows.

​
Learn More

  • Agent Skills specification — the open standard for SKILL.md file format, frontmatter fields, and directory structure
  • Knowledge — for contextual tips and facts (not step-by-step procedures)
  • Playbooks — for reusable prompt templates attached to sessions