> ## Documentation Index > Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt > Use this file to discover all available pages before exploring further. # Skills > Enseignez à Devin des procédures réutilisables en validant des fichiers SKILL.md dans vos dépôts
## Que sont les Skills ?
Les Skills sont des fichiers `SKILL.md` que vous validez dans vos dépôts et qui enseignent à Devin des **procédures réutilisables** : tout workflow répétable que vous souhaitez voir Devin suivre de manière cohérente. Tester votre application avant d’ouvrir une PR, déployer vers un environnement, analyser une base de code, générer l’ossature d’un nouveau service — si vous pouvez l’écrire sous forme d’instructions étape par étape, vous pouvez en faire une Skill. Ils suivent le standard ouvert [Agent Skills](https://agentskills.io/specification), 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.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](https://agentskills.io/specification) pour la référence complète du format de fichier.
## Pourquoi les Skills sont importantes
Sans Skills, Devin doit repartir de zéro à chaque session pour reconstituer les workflows. Avec les Skills, vous définissez une procédure une seule fois, et Devin l’applique de façon fiable à chaque fois. Les Skills sont utiles dès que vous avez un workflow qui : * **Doit être exécuté de la même manière à chaque fois** — check-lists de test, étapes de déploiement, procédures de revue * **Nécessite des connaissances propres au dépôt** — quels services démarrer, quels ports utiliser, quelles commandes exécuter * **Bénéficie d’un contexte dynamique** — récupération des diffs Git, des noms de branche ou des informations d’environnement au moment de l’exécution
## Devin suggère automatiquement des skills
Devin peut automatiquement vous suggérer des skills. Après que Devin a testé votre application ou appris quelque chose de nouveau sur votre configuration au cours d’une session, il vous proposera de créer ou de mettre à jour un skill pour capturer ces connaissances. Vous verrez une suggestion dans la chronologie 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 valider le skill dans votre dépôt Au fil du temps, Devin constitue dans votre dépôt une bibliothèque de skills sur la façon d’exécuter, de tester et de déployer votre application.
## Exemples
### Vérification avant d’ouvrir une PR
Un skill qui indique à Devin comment vérifier une application Next.js avant de créer une demande de fusion : ```markdown theme={null} --- 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éploiement dans un environnement
Un skill qui déploie l’application à l’aide d’arguments pour l’environnement cible, avec injection dynamique de contenu : ```markdown theme={null} --- name: deploy description: Deploy the app to a target environment and run smoke tests. argument-hint: triggers: ["user"] --- ## Deploy 1. Make sure you are on the correct branch for this deploy 2. Run `./scripts/deploy.sh $0` 3. Wait for the deploy script to complete successfully ## Verify 1. Curl `https://$0.example.com/health` and confirm a 200 response 2. Run the smoke test suite: `npm run test:smoke -- --env=$0` 3. Report the deployment URL and test results ## Current context - Branch: !`git branch --show-current` - Last commit: !`git log --oneline -1` ``` L’invoquer avec `@skills:deploy staging` remplace `$ARGUMENTS` et `$0` par `staging`, et les blocs `` !`command` `` insèrent des informations Git en temps réel. Le champ `triggers: ["user"]` garantit que Devin n’exécute ce skill que lorsque vous le demandez explicitement — il ne s’activera pas automatiquement.
### Explorer une partie de la base de code
Un skill d’exploration guidée du code qui limite Devin à des outils en lecture seule : ```markdown theme={null} --- name: investigate description: Research a part of the codebase and produce a written summary with file references. allowed-tools: Read, Grep, ListDir argument-hint: --- ## Research 1. Search the codebase for files related to: $ARGUMENTS 2. Read the most relevant files thoroughly 3. Trace the call chain and data flow ## Summarize 1. Write a summary of how $ARGUMENTS works 2. Include specific file paths and line numbers for every claim 3. Note any concerns, edge cases, or areas that need attention ``` Le champ `allowed-tools` limite Devin à des opérations en lecture seule — aucune modification, aucune commande shell. C’est utile pour les tâches d’exploration où vous souhaitez une analyse sans effets de bord.
## Découverte des compétences
Devin découvre des compétences à partir de **deux sources**, mises en commun au début de chaque session : 1. **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. 2. **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 skill
Devin recherche les fichiers `SKILL.md` dans tous les répertoires suivants : * `.agents/skills//SKILL.md` **(recommandé)** * `.devin/skills//SKILL.md` * `.github/skills//SKILL.md` * `.claude/skills//SKILL.md` * `.cursor/skills//SKILL.md` * `.codex/skills//SKILL.md` * `.cognition/skills//SKILL.md` * `.windsurf/skills//SKILL.md` Les huit 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](https://agentskills.io/specification) pour la référence complète du format de fichier.
## Comment Devin utilise les skills
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 :
### Invocation automatique
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 : ``` @skills:deploy staging ``` 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.
### Recherche et affichage
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.
## Limites
* **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.
## Skills vs. Playbooks
Les skills et les [playbooks](/fr/product-guides/creating-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, schémas de tâches multi-dépôts, guides d'intégration | **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, utilisez un playbook.
## En savoir plus
* [Agent Skills specification](https://agentskills.io/specification) — le standard ouvert pour le format de fichier `SKILL.md`, les champs de frontmatter et la structure des répertoires * [Knowledge](/fr/product-guides/knowledge) — pour des conseils contextuels et des informations factuelles (pas des procédures détaillées étape par étape) * [Playbooks](/fr/product-guides/creating-playbooks) — pour des modèles de prompts réutilisables, associés aux sessions