Les Skills sont des fichiers SKILL.md que vous validez dans vos dépôts et qui indiquent à Devin comment tester votre application de bout en bout : comment démarrer les services, exécuter l’application en local, vérifier les changements dans le navigateur et confirmer que tout fonctionne avant d’ouvrir une PR. Ils suivent le standard ouvert Agent Skills, de sorte que les mêmes fichiers de Skills fonctionnent avec plusieurs outils d’IA pour le code.
Placez les fichiers de Skills à l’emplacement .agents/skills/<skill-name>/SKILL.md dans votre dépôt. Devin les découvre automatiquement dans tous vos dépôts connectés. Consultez la spécification Agent Skills pour la référence complète du format de fichier.
Pourquoi les Skills sont importants
Sans Skills, Devin doit comprendre comment exécuter et tester votre application à partir de zéro à chaque session. Avec des Skills, Devin sait exactement comment :
- Démarrer votre environnement de développement local — quels services lancer, quels ports utiliser, comment préremplir les données de test
- Vérifier les modifications dans le navigateur — quelles pages vérifier, à quoi ressemble un état « correct », quels dysfonctionnements signaler
- Exécuter les bonnes suites de tests — quelles commandes lancer, à quoi doit ressembler une sortie réussie
Devin suggère automatiquement des compétences
Devin peut automatiquement vous suggérer des compétences. Après que Devin a testé votre application ou qu’il a appris quelque chose de nouveau sur votre configuration au cours d’une session, il vous proposera de créer ou de mettre à jour une compétence pour capitaliser ces connaissances. Vous verrez une suggestion dans l’historique de votre session avec :
- Un résumé de ce qui a été appris (par exemple « comment démarrer le backend avec Docker »)
- Le contenu proposé du fichier
SKILL.md
- Un bouton « Create PR » pour créer une pull request (PR) et valider la compétence dans votre dépôt
Avec le temps, Devin constitue dans votre dépôt une bibliothèque de compétences sur la façon d’exécuter et de tester votre application.
Un skill qui indique à Devin comment tester une application Next.js :
---
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
Découverte des compétences
Devin découvre des compétences à partir de deux sources, mises en commun au début de chaque session :
- Dépôts indexés — le backend de Devin indexe les fichiers
SKILL.md dans tous les dépôts connectés à votre organisation. Ceux-ci sont disponibles immédiatement au démarrage d’une session, avant que des dépôts ne soient clonés.
- Dépôts clonés — au fur et à mesure que les dépôts sont clonés sur la machine associée à la session, Devin les analyse à la recherche de fichiers
SKILL.md présents sur le disque. Les compétences détectées sur le disque mettent à jour ou remplacent toute compétence indexée correspondante provenant du même dépôt, garantissant que Devin utilise toujours la dernière version sur la branche en cours de travail.
Lorsqu’un clonage de dépôt se termine en cours de session, Devin réanalyse automatiquement ce dépôt afin que les compétences nouvellement ajoutées ou modifiées soient prises en compte sans avoir besoin de redémarrer la session.
Emplacements pris en charge pour les fichiers de compétences
Devin recherche les fichiers SKILL.md dans tous les répertoires suivants :
.agents/skills/<skill-name>/SKILL.md (recommandé)
.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
.windsurf/skills/<skill-name>/SKILL.md
Tous les six chemins sont analysés dans chaque dépôt.
Ce que Devin charge depuis un fichier de skill
Lorsqu’un skill est découvert, Devin analyse le frontmatter YAML (le bloc --- en haut) et en extrait :
| Champ | Rôle |
|---|
name | Identifie le skill. Revient au nom du répertoire parent s’il est omis. |
description | Brève description affichée dans la liste des skills pour que Devin (et vous) sachiez ce que fait le skill. |
allowed-tools | Restreint les outils que Devin peut utiliser tant que le skill est actif. |
Devin prend également en charge ces champs de frontmatter supplémentaires au-delà de la spécification standard :
| Champ | Rôle |
|---|
argument-hint | Texte d’aide affiché à côté du nom du skill décrivant les arguments attendus. |
triggers | Contrôle qui peut invoquer le skill — ["user", "model"] par défaut. Définissez ["user"] pour empêcher Devin de l’activer automatiquement. |
Tout ce qui se trouve après le frontmatter constitue le corps du skill — les instructions étape par étape que Devin doit suivre lorsque le skill est invoqué.
Consultez la spécification Agent Skills pour la référence complète du format de fichier.
En plus de la spécification standard, Devin prend en charge deux types de contenu dynamique dans le corps du skill, traités au moment de l’invocation :
$ARGUMENTS — remplacé par la chaîne complète d’arguments passée lorsque le skill est invoqué (par exemple via @skills:deploy staging prod). Vous pouvez aussi accéder individuellement aux arguments par index : $ARGUMENTS[0] ou $0 pour le premier, $ARGUMENTS[1] ou $1 pour le second, etc. Les arguments sont séparés par des espaces.
!`command` — la commande est exécutée à la racine du dépôt et remplacée par son stdout, ce qui permet aux skills d’inclure des valeurs dynamiques comme des noms de branches ou des numéros de port.
Par exemple, un skill de déploiement pourrait utiliser des arguments de cette façon :
---
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`
Appeler la commande @skills:deploy staging remplacerait $ARGUMENTS et $0 par staging.
Au début de chaque session, Devin a accès à une liste de tous les skills disponibles (nom + description). Lorsqu’un skill est invoqué, Devin lit le fichier SKILL.md complet et injecte son contenu dans son contexte actuel en tant qu’instruction système. Cela signifie que Devin suit activement les étapes du skill pour le reste de la tâche — ce n’est pas qu’une simple référence, cela guide directement le comportement de Devin.
Devin peut utiliser les skills de plusieurs façons :
Lorsque Devin détermine qu’une compétence est pertinente pour la tâche en cours, il l’invoque automatiquement. Par exemple, si vous demandez à Devin de corriger un bug dans du code front-end et qu’il existe une compétence test-before-pr, Devin l’activera avant d’ouvrir la PR. Définissez triggers: ["user"] dans le frontmatter pour empêcher l’invocation automatique pour les compétences que vous ne souhaitez déclencher qu’explicitement.
Indiquer une compétence dans votre prompt
Vous pouvez demander à Devin d’utiliser une compétence spécifique en ajoutant @skills:skill-name à votre message :
Fix the login bug on the /auth page @skills:test-before-pr
Vous pouvez également passer des arguments :
Les arguments sont remplacés dans le corps de la skill à chaque endroit où apparaissent $ARGUMENTS, $ARGUMENTS[0], $1, etc.
Une seule compétence active à la fois
Devin ne peut avoir qu’une seule compétence active à la fois. Appeler une nouvelle compétence remplace la précédente. Lorsqu’une compétence est active, Devin doit suivre ses étapes dans l’ordre et terminer chacune d’elles avant de passer à la suivante.
Devin peut rechercher des skills par mot-clé ou par répertoire lorsqu’il doit en trouver un en cours de session. Vous pouvez également demander à Devin d’afficher la liste des skills disponibles ou de les recharger après avoir poussé des modifications dans un fichier de skill.
- Compétences globales / au niveau de l’organisation — À l’heure actuelle, les compétences sont définies à l’intérieur des dépôts. Pour des compétences valables à l’échelle de l’organisation, vous pouvez créer un dépôt dédié « skills » comme solution de contournement. Nous étudions une prise en charge native des compétences au niveau de l’organisation, applicables à tous les dépôts.
- Composer plusieurs compétences — Actuellement, une seule compétence peut être active à la fois. Nous travaillons sur la prise en charge de l’enchaînement et de la composition de workflows.
Les skills et les playbooks donnent tous deux à Devin des instructions réutilisables, mais ils fonctionnent différemment :
| Skills | Playbooks |
|---|
| Où ils résident | Dans votre dépôt sous forme de fichiers SKILL.md — versionnés aux côtés de votre code | Dans l’application web Devin — gérés via l’interface utilisateur |
| Comment ils sont déclenchés | Devin les découvre et les invoque automatiquement, ou vous les référencez avec @skills:name dans n’importe quel prompt | Rattachés manuellement à une session au moment où vous la démarrez |
| Portée | Limitée à un dépôt — Devin sélectionne les bons skills en fonction des dépôts pertinents pour la tâche | À l’échelle de l’organisation — n’importe quel membre de l’équipe peut rattacher n’importe quel playbook à n’importe quelle session |
| Suggestion automatique | Devin suggère de nouveaux skills après avoir testé votre application ou appris quelque chose de nouveau | Créés manuellement par les membres de l’équipe |
| Idéal pour | Procédures de test, configuration de développement local, listes de contrôle de déploiement, workflows spécifiques à un dépôt | Modèles de prompts réutilisables, modèles de tâches multi-dépôts, guides d’onboarding |
Lequel dois-je utiliser ? Si vos instructions sont liées à un dépôt spécifique — comment l’exécuter, le tester ou le déployer — utilisez un skill. Si vos instructions sont des prompts génériques qui s’appliquent à plusieurs dépôts ou équipes, les playbooks fonctionnent aujourd’hui, mais nous prévoyons de tout consolider dans les skills à l’avenir. Les skills sont le concept de base le plus puissant : ils sont versionnés, découverts automatiquement et prennent en charge du contenu dynamique comme les arguments et l’exécution de commandes shell. Avec le temps, nous ajouterons directement aux skills les fonctionnalités qui rendent les playbooks utiles (comme la portée au niveau de l’organisation et la gestion via l’interface).
Si vous avez déjà des playbooks qui fonctionnent bien, rien ne presse pour migrer — ils continueront à fonctionner. Mais pour de nouvelles instructions, nous recommandons de commencer par des skills.
- Agent Skills specification — le standard ouvert pour le format de fichier
SKILL.md, les champs de frontmatter et la structure des répertoires
- Knowledge — pour des conseils contextuels et des informations factuelles (pas des procédures détaillées étape par étape)
- Playbooks — pour des modèles de prompts réutilisables, associés aux sessions