Les compétences transforment la façon dont les développeurs collaborent avec l'IA en convertissant des flux de travail répétitifs en fonctionnalités réutilisables et structurées. En tant qu'éditeur de code IA de référence, Cursor est souvent l'outil privilégié pour mettre en œuvre ces compétences, mais leur configuration suppose de maîtriser la structure des fichiers, la gestion du contexte et la conception des prompts. Ce guide explique comment créer et configurer des compétences Cursor, présente des exemples utiles et montre comment bâtir des compétences personnalisées avec l'IA pour transformer les bonnes pratiques en « automatismes » réutilisables.
Comment créer et utiliser des compétences dans Cursor ?
Pour exploiter concrètement les compétences Cursor, commencez par comprendre comment les configurer au sein de la structure de votre projet. Une fois cette configuration en place, vous pouvez facilement créer, organiser et utiliser des compétences pour automatiser vos flux de développement. Suivez ces étapes pour créer et utiliser des compétences dans Cursor.
Étape 1 : créer un dossier .cursor
Rendez-vous d'abord à la racine de votre projet et créez un dossier nommé .cursor. Ce dossier stocke les fichiers de configuration propres à Cursor ainsi que les paramètres au niveau du projet.
Étape 2 : ajouter un répertoire skills
Créez ensuite un dossier skills à l'intérieur du dossier .cursor. Ce répertoire contiendra toutes vos compétences personnalisées.
Étape 3 : créer un dossier pour chaque compétence
Chaque compétence doit disposer de son propre dossier au sein du répertoire skills. Par exemple :
api-creation-skilldocumentation-creatorcode-review-assistant
Répartir les compétences dans des dossiers distincts évite les conflits et simplifie les mises à jour à mesure que votre bibliothèque de compétences s'étoffe
Étape 4 : ajouter un fichier SKILL.md
Dans chaque dossier de compétence, créez un fichier nommé SKILL.``md. Ce fichier constitue le format standard utilisé pour définir le fonctionnement de la compétence et le moment où Cursor doit l'appliquer.
Étape 5 : définir la structure de base
Une fois le fichier créé, ajoutez les sections essentielles qui décrivent la compétence.
Un fichier SKILL.md type doit comporter :
Titre : le nom de la compétence.
Description : précise quand la compétence doit être utilisée.
Instructions : les consignes détaillées que Cursor suit lors de l'exécution des tâches.
Une structure claire aide Cursor à comprendre la finalité de la compétence et à produire des résultats plus cohérents.
Étape 6 : ajouter des améliorations facultatives (si nécessaire)
Après avoir défini les éléments de base, vous pouvez enrichir la compétence en ajoutant des sections supplémentaires telles que :
Modèles
Exemples
Remarques
Règles de validation
Exigences relatives aux résultats
Étape 7 : utiliser la compétence dans Cursor
Une fois la compétence configurée, ouvrez Cursor Chat avec Ctrl + I. Tapez / pour afficher les compétences disponibles, choisissez celle que vous souhaitez utiliser, puis décrivez votre tâche. Cursor charge automatiquement les instructions de la compétence sélectionnée et les applique à la tâche.
Étape 8 : laisser Cursor exécuter le flux de travail
L'IA suivra les règles de votre compétence, posera des questions de clarification si besoin et générera des résultats structurés, comme des API ou de la documentation.
Les compétences personnalisées peuvent transformer en profondeur la façon dont les développeurs travaillent avec Cursor. En convertissant les prompts les plus fréquents en flux de travail réutilisables, les équipes gagnent du temps, préservent la cohérence et fluidifient les tâches de développement complexes.
| Compétence | Objectif |
|---|---|
| canvas | Créer ou modifier des fichiers .canvas.tsx, ouvrir un Canvas visuel (graphiques, tableaux, panneaux d'analyse, etc.) en parallèle du chat |
| sdk | Utiliser le SDK Cursor (@cursor/sdk/ cursor-sdk) pour appeler Agent dans les scripts, les pipelines CI et les automatisations |
| babysit | Maintenir une PR prête à fusionner : traiter les commentaires, résoudre les conflits, corriger la CI |
| statusline | Configurer une barre d'état CLI personnalisée (statusLine dans ~/.cursor/cli-config.json) |
| split-to-prs | Répartir les modifications en cours en plusieurs petites PR faciles à relire |
| update-cursor-settings | Modifier les paramètres de l'IDE (settings.json : thème, police, mise en forme, etc.) |
| update-cli-config | Modifier la configuration CLI (~/.cursor/cli-config.json : autorisations, mode d'approbation, vim, etc.) |
| shell | Traiter la commande /shell, exécuter le texte qui suit comme une commande shell littérale |
| migrate-to-skills | Migrer .cursor/rules/.mdc et .cursor/commands/.md vers le format Skills |
| create-subagent | Créer un sous-agent personnalisé (sous-agent IA dédié) |
| create-rule | Créer des Cursor Rules (.cursor/rules/, AGENTS.md, etc.) |
| create-hook | Créer des Cursor Hooks (hooks.json, exécuter une logique personnalisée avant ou après les événements de l'Agent) |
| create-skill | Créer une nouvelle Agent Skill (définir la structure et les spécifications du SKILL.md) |
Compétences externes compatibles avec Cursor
| Compétence | Description | Lien GitHub |
|---|---|---|
| best-of-n-solving | Expérimenter plusieurs approches d'un problème complexe en parallèle, dans des worktrees git isolés, puis retenir la meilleure solution. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/best-of-n-solving/SKILL.md |
| parallel-exploring | Explorer rapidement une vaste base de code en lançant plusieurs sous-agents en lecture seule qui examinent simultanément différentes zones. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/parallel-exploring/SKILL.md |
| adding-e2e-tests | Mettre en place Playwright avec sa configuration, des tests d'exemple, des page objects et l'intégration CI. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-e2e-tests/SKILL.md |
| adding-auth | Ajouter la connexion OAuth, la gestion des sessions et des routes protégées avec Auth.js (NextAuth). | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-auth/SKILL.md |
| adding-stripe | Intégrer le paiement Stripe, les abonnements, les webhooks et le portail client. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-stripe/SKILL.md |
| adding-docker | Conteneuriser n'importe quelle application avec un Dockerfile multi-étapes, docker-compose et .dockerignore. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-docker/SKILL.md |
| adding-analytics | Ajouter le suivi des événements PostHog, les pages vues, les feature flags et le replay de session à n'importe quelle application web. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-analytics/SKILL.md |
| adding-error-tracking | Ajouter le rapport de plantage Sentry, le suivi des performances et les source maps. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/adding-error-tracking/SKILL.md |
| auditing-security | Audit de sécurité systématique vérifiant les vulnérabilités du Top 10 de l'OWASP, l'exposition de secrets et les schémas non sécurisés. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/auditing-security/SKILL.md |
| profiling-performance | Profiler les performances CPU d'une application en cours d'exécution à l'aide du profileur de navigateur de Cursor afin de capturer les piles d'appels et d'identifier les fonctions lentes. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/profiling-performance/SKILL.md |
| converting-css-to-tailwind | Convertir des feuilles de style CSS classiques en classes utilitaires Tailwind — sélecteurs, media queries, pseudo-classes, animations et valeurs arbitraires. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/converting-css-to-tailwind/SKILL.md |
| generating-images | Générer ou modifier des images (icônes, logos, illustrations d'en-tête de blog, images OG, illustrations, maquettes) avec OpenAI gpt-image-2. Prend en charge le texte vers image, l'image vers image, l'inpainting masqué et les traitements par lots en parallèle. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/generating-images/SKILL.md |
| api-smoke-testing | Repérer les routes API dans la base de code, solliciter chaque endpoint et signaler ceux qui renvoient des erreurs. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/api-smoke-testing/SKILL.md |
| creating-pr | Créer des pull requests soignées et prêtes à la relecture, avec des titres conventionnels, des descriptions structurées et des issues liées. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/creating-pr/SKILL.md |
| babysitting-pr | Surveiller une PR ouverte pour détecter les échecs CI, les commentaires de relecture et les conflits de fusion, puis les corriger automatiquement afin de la maintenir prête à fusionner. | https://github.com/spencerpauly/awesome-cursor-skills/blob/main/resources/babysitting-pr/SKILL.md |
Astuce bonus : créer facilement vos compétences personnelles avec Kimi
La fonction de conversion de documents en compétences de Kimi vous permet de transformer des documents, du code ou des modèles existants en compétences IA réutilisables. Au lieu de se contenter de lire ou de résumer vos fichiers, elle extrait directement des flux de travail structurés de votre contenu et les convertit en actions automatisées. Vous réutilisez ainsi facilement les processus issus de vos fichiers Office ou de vos documents internes, et automatisez les tâches répétitives sans avoir à reconstruire vos flux de travail de zéro.
Comment convertir des documents en compétences ?
Si vous disposez déjà de procédures (SOP), de modèles, de rapports ou de fichiers structurés, vous pouvez les convertir directement en compétence dans Kimi. Voici comment procéder.
Étape 1 : accéder à l'outil de conversion de documents en compétences
Rendez-vous sur kimi.com pour commencer. Cliquez sur le bouton « + » (créer), puis accédez à « Skills » et sélectionnez l'option « Document to skills ».
Étape 2 : importer des fichiers Office
Importez vos fichiers existants : documents Word, PDF, feuilles Excel ou présentations. Une fois l'import terminé, expliquez clairement ce que vous souhaitez que Kimi extraie, reproduise ou convertisse en compétence réutilisable. Kimi traite alors le fichier, repère les schémas clés et extrait automatiquement la structure du flux de travail sous-jacent.
Étape 3 : créer et utiliser vos compétences
Cliquez sur « Create skill » pour lancer la génération. Kimi analyse votre document et le convertit en une compétence structurée et réutilisable ; l'opération peut prendre quelques minutes selon la taille et la complexité du fichier.
Une fois la génération terminée, vous pouvez ouvrir la compétence pour l'utiliser directement. Vous avez également la possibilité de la modifier, d'en copier le contenu ou de la télécharger sous forme de fichier .md pour la réutiliser ou la partager.
Principales fonctionnalités de l'outil de conversion de documents en compétences de Kimi
Maintenant que vous savez comment transformer des documents en compétences réutilisables, il est important d'examiner ce qui rend cette fonctionnalité si puissante.
Transformer vos documents en un système de compétences et de connaissances réutilisable
Kimi convertit des documents tels que des procédures (SOP), des manuels et des directives en compétences structurées. Ces compétences capturent flux de travail, règles et savoir-faire métier dans un format réutilisable. Au lieu de rester de simples fichiers statiques, vos documents deviennent des instructions IA directement exploitables. Vous pouvez ainsi réutiliser la même expertise sur de nombreuses tâches.
Combiner compétences personnalisées et compétences existantes pour de meilleurs résultats
Kimi vous permet d'utiliser plusieurs compétences ensemble, qu'il s'agisse de vos compétences personnalisées ou de celles intégrées. En combinant différentes compétences au sein d'un même flux de travail, vous obtenez des résultats davantage conformes à vos attentes et aux exigences de la tâche. Cette approche flexible facilite l'adaptation des compétences à différents scénarios et améliore la qualité globale des résultats.
Conclusion
Les compétences simplifient la gestion des tâches de développement en regroupant les instructions dans des flux de travail réutilisables, directement au sein de l'éditeur. Elles garantissent la cohérence des résultats et réduisent le recours aux prompts manuels répétés pendant le développement. Les développeurs appliquent ainsi la même logique structurée à différents projets, gagnant en efficacité et en organisation. Pour une mise en place encore plus rapide, des outils comme Kimi convertissent vos documents existants en compétences réutilisables, rendant l'automatisation des flux de travail plus simple et plus évolutive.