# Configuration et personnalisation (/fr/docs/verdent-for-vscode/configuration/settings)
> Personnaliser Verdent pour l'adapter à votre flux de travail
Verdent for VS Code offre de nombreuses options de configuration pour s'adapter à votre flux de travail de développement, à vos préférences de codage et aux standards de votre équipe. Configurez les paramètres via l'interface de paramètres native de VS Code, personnalisez les raccourcis clavier, et créez des règles et des sous-agents pour un comportement spécialisé.
### Ce que vous allez apprendre [#ce-que-vous-allez-apprendre]
* Configurer les paramètres de l'extension VS Code pour Verdent
* Personnaliser les raccourcis clavier pour un flux de travail efficace
* Créer et gérer des règles pour un comportement d'agent personnalisé
* Créer des sous-agents personnalisés pour des tâches spécialisées
### Prérequis [#prérequis]
* Verdent for VS Code installé et authentifié
* Accès aux paramètres de VS Code (`Cmd+,` ou `Ctrl+,`)
* Compréhension de base du JSON pour les fichiers de règles (facultatif)
***
## Paramètres de l'extension VS Code [#paramètres-de-lextension-vs-code]
Les paramètres de Verdent for VS Code sont accessibles à plusieurs endroits selon le type et la portée de la configuration.
### Accéder aux paramètres [#accéder-aux-paramètres]
**Paramètres de l'extension (natifs de VS Code) :**
1. Ouvrez les paramètres de VS Code : `Cmd+,` (macOS) ou `Ctrl+,` (Windows/Linux)
2. Recherchez « Verdent » dans la barre de recherche des paramètres
3. Modifiez les paramètres de l'extension (par exemple, `verdent.enableCheckpoints`)
**Paramètres spécifiques à Verdent :**
Sélectionnez le bouton **Settings** dans la barre supérieure de Verdent pour accéder à :
* **Rules** - règles utilisateur, règles de projet, règles de plan
* **Serveurs MCP** - configurations du Model Context Protocol
* **Subagents** - gestion des sous-agents personnalisés
**Contrôles dans le chat :**
De nombreux paramètres peuvent être activés directement depuis la zone de saisie en bas du panneau Verdent :
* **Switch Permission** - Manual Accept, Auto-Run, Plan, Skip Permissions
* **Switch Mode** - modes Agent, Plan, Chat
* **Switch/Customize AI Model** - préréglages Performance, Balance, Efficiency
* **Think Hard Mode** - budget de réflexion maximal pour un raisonnement complexe
* **Add Context** - joindre des fichiers via des mentions @
* **Add Images or Files** - inclure des captures d'écran ou des documents
* **Add Subagent** - déléguer à des sous-agents spécialisés
Les changements de paramètres prennent effet immédiatement, sans nécessiter le redémarrage de VS Code.
***
## Paramètres d'extension disponibles [#paramètres-dextension-disponibles]
Verdent for VS Code propose **2 paramètres d'extension essentiels** qui peuvent être configurés via l'interface de paramètres de VS Code :
| Paramètre | Type | Valeur par défaut | Description |
| --------------------------- | --------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `verdent.enableCheckpoints` | `boolean` | `true` | Permet à l'extension d'enregistrer des points de contrôle de l'espace de travail au fil des tâches en utilisant Git. Peut affecter les performances sur les espaces de travail volumineux. |
| `verdent.enableProxy` | `boolean` | `true` | Active la prise en charge du proxy pour les connexions réseau. Nécessaire pour les utilisateurs derrière un pare-feu ou un serveur proxy d'entreprise. |
Voici l'ensemble des paramètres de l'extension VS Code pour Verdent. Les options de configuration supplémentaires (Rules, Subagents, serveurs MCP) sont gérées via le menu Settings de Verdent dans la barre supérieure de l'extension.
***
## Référence des contrôles de la zone de saisie [#référence-des-contrôles-de-la-zone-de-saisie]
La zone de saisie en bas du panneau Verdent donne un accès rapide aux contrôles de configuration :
| Contrôle | Fonction | Options |
| ----------------------------- | ------------------------------------------------------------ | -------------------------------------------------------------------- |
| **Add Context** | Joindre des fichiers via des mentions @ | @nomdefichier, @nomdedossier |
| **Add Images or Files** | Inclure des captures d'écran ou des documents | Charger des images, des PDF, des fichiers texte |
| **Add Subagent** | Déléguer à des agents spécialisés | @Verifier, @Explorer, @Code-reviewer, sous-agents personnalisés |
| **Switch Mode** | Changer de mode d'exécution | Agent Mode, Plan Mode, Chat Mode |
| **Switch/Customize AI Model** | Sélectionner un préréglage de modèle ou un modèle spécifique | Performance (coût 1 à 2x), Balance (coût 1x), Efficiency (coût 0,3x) |
| **Think Hard Mode** | Activer un raisonnement étendu | Activer/désactiver pour les problèmes complexes |
| **Switch Permission** | Changer de niveau de permission | Manual Accept (par défaut), Auto-Run, Plan, Skip Permissions |
### Modes de permission [#modes-de-permission]
* Chaque opération nécessite une validation
* Visibilité et contrôle complets
* Idéal pour l'apprentissage, les bases de code inconnues, le code de production
* Les commandes nécessitent une validation, les opérations sur les fichiers sont automatiques
* Moins de demandes de permission
* Idéal pour les projets de confiance, le prototypage rapide
* Analyse et planification en lecture seule uniquement
* Aucune modification de code pendant la planification
* Idéal pour les changements complexes, les décisions d'architecture
* Autonomie complète sans demande de validation
* Exécution la plus rapide mais risque le plus élevé
* Idéal pour les environnements automatisés, l'intégration/déploiement continus (CI/CD)
### Préréglages de modèle [#préréglages-de-modèle]
* **Coût :** référence 1x
* **Modèles :** Claude-4.5-sonnet
* **Idéal pour :** le développement général, le codage quotidien, l'implémentation de fonctionnalités
* **Coût :** 1 à 2x la référence Balance
* **Modèles :** Claude-4.5-sonnet-1m (contexte de 1 million de tokens)
* **Idéal pour :** l'architecture complexe, les grandes bases de code, les tâches dépassant 200 000 tokens
* **Coût :** 3,2 fois plus efficace que Sonnet (70 % d'économie de crédits)
* **Modèles :** Claude-4.5-haiku
* **Idéal pour :** les corrections rapides, les tâches simples, les opérations courantes
***
## Personnalisation des raccourcis clavier [#personnalisation-des-raccourcis-clavier]
### Raccourcis par défaut [#raccourcis-par-défaut]
**Raccourci principal :**
* **macOS :** `Cmd+L` - ouvrir/donner le focus au panneau Verdent
* **Windows/Linux :** `Ctrl+L` - ouvrir/donner le focus au panneau Verdent
* Commande : `verdent.addToChat`
* Fonctionne depuis la palette de commandes et le contexte de l'éditeur
Il s'agit du raccourci essentiel pour accéder rapidement à Verdent depuis n'importe où dans VS Code sans interrompre votre flux de codage.
**Commandes supplémentaires :**
Disponibles via la palette de commandes (les raccourcis par défaut peuvent être personnalisés) :
* `verdent.addFeedBack` - donner un retour
* `verdent.addTerminalOutputToChat` - ajouter la sortie du terminal à Verdent
* `verdent.addToChatBySearch` - ajouter à Verdent par recherche
* `verdent.centerButtonClicked` - centre utilisateur
* `verdent.historyButtonClicked` - historique du projet
* `verdent.mcpButtonClicked` - ajouter un serveur MCP
* `verdent.openInNewTabByParams` - ouvrir dans un nouvel onglet
* `verdent.plusButtonClicked` - nouvelle session
* `verdent.rulesButtonClicked` - paramètres des règles
* `verdent.SettingClicked` - menu des paramètres
* `verdent.subagentButtonClicked` - ajouter un sous-agent
### Personnaliser les raccourcis [#personnaliser-les-raccourcis]
Tous les raccourcis clavier de Verdent peuvent être personnalisés à l'aide du système standard de raccourcis clavier de VS Code.
Recommandé pour la plupart des utilisateurs - interface visuelle pour gérer les raccourcis.
Appuyez sur `Cmd+K Cmd+S` (macOS) ou `Ctrl+K Ctrl+S` (Windows/Linux)
Saisissez « Verdent » dans le champ de recherche pour filtrer les commandes Verdent
Sélectionnez l'icône crayon à côté de n'importe quelle commande, appuyez sur la combinaison de touches souhaitée, puis appuyez sur Entrée pour enregistrer
Pour les utilisateurs avancés - configuration JSON directe, compatible avec le contrôle de version.
Appuyez sur `Cmd+Shift+P` (macOS) ou `Ctrl+Shift+P` (Windows/Linux)
Saisissez « Preferences: Open Keyboard Shortcuts (JSON) » et sélectionnez-le
```json macOS
{
"key": "cmd+shift+v",
"command": "verdent.addToChat"
}
```
```json Windows/Linux
{
"key": "ctrl+shift+v",
"command": "verdent.addToChat"
}
```
**Portée de la personnalisation :**
* Toutes les commandes Verdent peuvent être reconfigurées
* Plusieurs raccourcis peuvent être associés à la même commande
* Les raccourcis par défaut peuvent être supprimés
* Les changements sont synchronisés entre les machines grâce à la synchronisation des paramètres de VS Code
### Raccourcis spécifiques à la plateforme [#raccourcis-spécifiques-à-la-plateforme]
Verdent respecte les conventions de clavier spécifiques à chaque plateforme de VS Code :
| Plateforme | Modèle de touche de modification |
| ----------------- | ------------------------------------------------------------------------------ |
| **macOS** | `Cmd` pour les raccourcis principaux, `Option` pour les raccourcis alternatifs |
| **Windows/Linux** | `Ctrl` pour les raccourcis principaux, `Alt` pour les raccourcis alternatifs |
**Modèles courants :**
* Paramètres : `Cmd+,` (macOS) vs `Ctrl+,` (Windows/Linux)
* Palette de commandes : `Cmd+Shift+P` (macOS) vs `Ctrl+Shift+P` (Windows/Linux)
* Raccourcis clavier : `Cmd+K Cmd+S` (macOS) vs `Ctrl+K Ctrl+S` (Windows/Linux)
***
## Instructions personnalisées et personas [#instructions-personnalisées-et-personas]
Verdent for VS Code prend en charge deux systèmes pour personnaliser le comportement de l'IA : les **règles** pour les préférences et les consignes, et les **sous-agents** pour des personas de tâches spécialisées.
### Système de règles [#système-de-règles]
Les règles définissent la manière dont Verdent se comporte et répond pendant les sessions de codage. Elles sont stockées dans des fichiers Markdown et appliquées en continu tout au long des conversations.
#### Trois types de règles [#trois-types-de-règles]
**1. Règles utilisateur (VERDENT.md) :**
* **Emplacement :** `~/.verdent/` (répertoire de configuration global)
* **Portée :** appliquées à toutes les conversations, dans tous les projets
* **Objectif :** préférences de codage personnelles, style de communication, standards de documentation
**2. Règles de projet (AGENTS.md) :**
* **Emplacement :** répertoire racine du projet ou espace de travail
* **Portée :** appliquées uniquement au projet en cours
* **Contrôle de version :** peuvent être versionnées via Git pour des standards partagés au sein de l'équipe
* **Objectif :** standards de codage spécifiques au projet, modèles d'architecture, exigences de test
**3. Règles de plan (plan\_rules.md) :**
* **Emplacement :** `~/.verdent/` (répertoire de configuration global)
* **Portée :** appliquées lors de l'utilisation de Plan Mode dans tous les projets
* **Objectif :** personnaliser le contenu, le format et le niveau de détail des plans
#### Créer et modifier des règles [#créer-et-modifier-des-règles]
Sélectionnez le bouton **Settings** dans la barre supérieure de Verdent, puis sélectionnez **Rules** dans le menu déroulant
Sélectionnez **User Rules**, **Project Rules** ou **Plan Rules** selon vos besoins
Les fichiers de règles s'ouvrent dans l'éditeur VS Code. Utilisez le formatage Markdown pour rédiger des instructions claires et directives
Enregistrez le fichier. Les règles s'appliquent immédiatement aux sessions actuelles et futures - aucun redémarrage nécessaire
**Exemple de règles utilisateur :**
```markdown
# Code Style Preferences
- Always use functional React components with hooks
- Prefer TypeScript over JavaScript
- Add JSDoc comments for all exported functions
- Provide explanations before showing code
```
**Exemple de règles de projet :**
```markdown
## Testing instructions
- Run `pnpm turbo run test --filter ` to run all checks
- Fix test and type errors until suite is green
- Add or update tests for code changes
## PR instructions
- Title format: []
- Always run `pnpm lint` and `pnpm test` before committing
```
#### Stockage et application des règles [#stockage-et-application-des-règles]
| Type de règle | Emplacement | Portée | Contrôle de version |
| ------------------ | -------------------------- | ---------------------------- | ------------------------------------------------------ |
| Règles utilisateur | `~/.verdent/VERDENT.md` | Tous les projets | Personnel, non partagé |
| Règles de projet | `<project>/AGENTS.md` | Projet en cours | Peuvent être versionnées pour la cohérence de l'équipe |
| Règles de plan | `~/.verdent/plan_rules.md` | Tous les projets (Plan Mode) | Personnel, non partagé |
**Ordre de priorité de la configuration :**
En cas de conflit entre les règles, Verdent applique l'ordre de priorité suivant :
1. **Règles de projet (AGENTS.md)** - priorité la plus élevée (spécifique au projet)
2. **Règles utilisateur (VERDENT.md)** - préférences globales de l'utilisateur
3. **Comportement par défaut** - valeurs par défaut intégrées de Verdent
<Tip>
Versionnez AGENTS.md pour partager les standards de codage spécifiques au projet avec toute votre équipe. L'espace de travail de chaque membre de l'équipe suit automatiquement les règles du projet tout en conservant des préférences individuelles via VERDENT.md.
</Tip>
***
## Sous-agents [#sous-agents]
Les sous-agents sont des agents IA spécialisés disposant de prompts système personnalisés et de fenêtres de contexte isolées pour traiter des tâches spécifiques.
### Sous-agents intégrés [#sous-agents-intégrés]
Verdent inclut trois sous-agents par défaut disponibles immédiatement, sans configuration :
<Tabs>
<Tab title="@Verifier">
* Vérifications de code rapides
* Validation rapide sans revue complète
* À utiliser pour : les contrôles de cohérence rapides, la validation de syntaxe, les vérifications avant commit
</Tab>
<Tab title="@Explorer">
* Exploration et navigation rapides dans la base de code
* Trouve rapidement des fichiers et répond aux questions sur la base de code
* À utiliser pour : explorer des bases de code inconnues, trouver des composants, comprendre la structure
</Tab>
<Tab title="@Code-reviewer">
* Évaluation instantanée de la qualité du code
* Identifie les problèmes de sécurité, de maintenabilité et de performance
* À utiliser pour : les revues avant commit, les audits de sécurité, l'optimisation des performances
</Tab>
</Tabs>
### Créer des sous-agents personnalisés [#créer-des-sous-agents-personnalisés]
<Steps>
<Step title="Accéder aux paramètres des sous-agents">
Sélectionnez **Settings** → **Subagents** dans la barre supérieure de Verdent
</Step>
<Step title="Créer un nouveau sous-agent">
Créez un nouveau sous-agent ou accédez à `~/.verdent/subagents/` et créez un fichier Markdown avec un en-tête YAML
</Step>
<Step title="Définir le comportement du sous-agent">
Rédigez un prompt système qui établit la personnalité, le style d'interprétation et l'approche du sous-agent face aux tâches
</Step>
<Step title="Spécifier la politique d'invocation">
Définissez dans quels cas le sous-agent doit être utilisé (invocation stricte ou flexible)
</Step>
</Steps>
**Format de fichier de sous-agent :**
```markdown
---
name: security-reviewer
description: Security-focused code review specialist
---
# System Prompt
You are a security-focused code reviewer. When analyzing code:
- Prioritize security vulnerabilities (SQL injection, XSS, auth flaws)
- Use skeptical, critical tone - assume code is vulnerable until proven otherwise
- Provide specific remediation steps with code examples
- Reference OWASP Top 10 and security best practices
- Never approve code with unresolved security issues
Invocation policy (strict): Only run security-reviewer if user explicitly requests it.
When to use the security-reviewer agent:
- User requests security review of authentication/authorization logic
- User asks to audit code for vulnerabilities
- User needs security assessment before deployment
When NOT to use:
- General code review without security focus
- Opening or reading files without analysis
```
### Gérer les sous-agents [#gérer-les-sous-agents]
Accédez à **Settings → Subagents** pour :
* **Modifier :** ajuster les prompts système, les autorisations d'outils, les configurations
* **Copier :** dupliquer des sous-agents pour créer des variantes ou des modèles
* **Supprimer :** retirer les sous-agents inutilisés
* **Activer/désactiver :** basculer la disponibilité sans suppression
### Utiliser les sous-agents [#utiliser-les-sous-agents]
**Sous-agents intégrés :**
* Référencez-les avec des mentions @ : `@Verifier`, `@Explorer`, `@Code-reviewer`
* Invoqués automatiquement lorsque des types de tâches appropriés sont détectés
**Sous-agents personnalisés :**
* Sélectionnez le bouton **Add Subagent** dans la zone de saisie
* Choisissez dans le menu déroulant
* L'agent principal délègue automatiquement les tâches appropriées
### Sous-agents vs règles [#sous-agents-vs-règles]
| Aspect | Règles | Sous-agents |
| ------------------------ | --------------------------------------- | ----------------------------------------------- |
| **Moment d'application** | En continu, à chaque réponse | À la demande, pour des tâches spécifiques |
| **Contexte** | Fenêtre de contexte principale partagée | Contexte isolé et distinct |
| **Comportement** | Préférences et consignes | Personas comportementaux spécifiques à la tâche |
| **Invocation** | Toujours active | Délégation automatique ou manuelle |
| **Objectif** | Définir CE QUE vous préférez | Définir QUI traite les tâches et COMMENT |
**Exemple de flux de travail :**
1. **Règle utilisateur :** « Générer des tests unitaires pour toutes les nouvelles fonctions »
2. **Agent principal :** détecte le besoin de génération de tests
3. **Délègue au sous-agent générateur de tests :** approche de test approfondie et spécialisée
4. **Sous-agent :** génère une suite de tests complète avec un contexte isolé
5. **Agent principal :** reçoit les résultats et poursuit sans pollution du contexte
<Tip>
Partagez des sous-agents avec les membres de votre équipe en utilisant le bouton **Copy** dans Settings → Subagents, ou en partageant directement les fichiers Markdown des sous-agents depuis `~/.verdent/subagents/`.
</Tip>
***
## FAQ (questions fréquentes) [#faq-questions-fréquentes]
<Accordion title="Quand les changements de configuration prennent-ils effet ?">
La plupart des paramètres de Verdent s'appliquent immédiatement, sans nécessiter de redémarrage :
* **Modes de permission :** basculement instantané via la zone de saisie
* **Préréglages de modèle :** s'appliquent à la prochaine requête
* **Fichiers de règles :** s'appliquent aux nouvelles conversations (l'enregistrement déclenche le rechargement)
* **Sous-agents :** disponibles immédiatement après leur création
* **Raccourcis clavier :** s'appliquent après l'enregistrement dans VS Code
**Exception :** les paramètres de l'extension VS Code (comme `verdent.enableCheckpoints`) prennent effet immédiatement, mais peuvent nécessiter la réouverture des fichiers ou des sessions pour une application complète.
</Accordion>
<Accordion title="Quelle est la différence entre les règles et les sous-agents ?">
Les **règles** définissent CE QUE vous préférez de manière globale :
* Application continue à toutes les conversations
* Standards de codage, style de communication, préférences
* Stockées dans des fichiers Markdown (VERDENT.md, AGENTS.md, plan\_rules.md)
* Toujours actives en arrière-plan
Les **sous-agents** définissent QUI traite des tâches spécifiques et COMMENT :
* Invocation à la demande pour des types de tâches spécifiques
* Personas comportementaux spécialisés avec prompts système personnalisés
* Fenêtres de contexte isolées (ne polluent pas le contexte principal)
* Délégués automatiquement ou manuellement via des mentions @
**Exemple :** une règle indique « Générer des tests unitaires pour les nouvelles fonctions ». Un sous-agent générateur de tests se charge de la création réelle des tests avec une méthodologie de test approfondie.
</Accordion>
<Accordion title="Puis-je utiliser plusieurs modes de permission en même temps ?">
Non, les modes de permission sont mutuellement exclusifs - vous ne pouvez en utiliser qu'UN à la fois :
* **Manual Accept** - par défaut, contrôle maximal
* **Auto-Run** - simplifié pour les projets de confiance
* **Plan** - mode de planification en lecture seule
* **Skip Permissions** - autonomie complète
Vous pouvez changer de mode instantanément via le bouton **Switch Permission** dans la zone de saisie. La plupart des utilisateurs alternent entre les modes selon le contexte de la tâche (par exemple, Plan Mode pour les fonctionnalités complexes, Auto-Run pour les corrections rapides).
</Accordion>
<Accordion title="Comment choisir le bon préréglage de modèle pour ma tâche ?">
Adaptez le préréglage de modèle à la complexité de la tâche et au budget :
**Utilisez Efficiency (3,2 fois plus efficace que Sonnet) :**
* Corrections de bugs rapides et génération de code simple
* Opérations courantes et tâches à haute fréquence
* Lorsque la vitesse compte plus que la profondeur
**Utilisez Balance (référence 1x) - par défaut :**
* Développement général et codage quotidien
* Implémentation de fonctionnalités et revues de code
* Performance équilibrée pour la plupart des scénarios
**Utilisez Performance (efficacité 0,5x, coût 2x) :**
* Décisions d'architecture complexes
* Grandes bases de code nécessitant un contexte étendu (200 000+ tokens)
* Débogage et refactorisation sophistiqués
**Astuce :** la plupart des utilisateurs conservent Balance par défaut et ne passent à Performance qu'en cas de limite de contexte atteinte ou de besoin de raisonnement approfondi.
</Accordion>
***
## Voir aussi [#voir-aussi]
<CardGroup cols="2">
<Card title="Flux de travail basés sur la planification" icon="sitemap" href="/docs/verdent-for-vscode/configuration/plan-workflows">
Configurer la planification des tâches assistée par IA et les flux de validation
</Card>
<Card title="Optimisation de la configuration" icon="sliders" href="/docs/verdent-for-vscode/configuration/tuning">
Ajuster les paramètres pour optimiser la vitesse, le coût et les performances
</Card>
</CardGroup>