Copilot Edits e Agent Mode: Editing Multi-File e Sviluppo Autonomo nell'IDE
Jusqu'à présent, nous avons exploré Copilot en tant qu'assistant de suggestion en ligne et en tant qu'agent. travailleur indépendant travaillant sur GitHub. Il existe cependant un territoire intermédiaire extrêmement puissant : Modifications du copilote e Mode Agent, qui apportent les capacités édition multi-fichiers et exécution autonome directement dans votre IDE. Au lieu d'éditer un fichier à la fois, vous pouvez décrire une modification qui affecte plusieurs fichiers et laisser que Copilot coordonne tous les changements de manière cohérente.
Dans cet article, nous explorerons en détail les modes d'édition avancés disponibles : Mode édition pour l'édition guidée de plusieurs fichiers, Mode Agent pour exécution autonome avec auto-guérison, Mode Planification pour planifier d'abord de l'action, e Suggestions de modifications suivantes (NES) pour un flux d'édition prédictif et fluide.
Vue d'Ensemble de la Série
| # | Article | Focus |
|---|---|---|
| 1 | Foundation e Mindset | Setup e mentalità |
| 2 | Concept et exigences | De l'idée au MVP |
| 3 | Architecture back-end | API e database |
| 4 | Structure frontale | UI e componenti |
| 5 | Prompt Engineering | Prompt e Agenti MCP |
| 6 | Testing e Qualità | Unit, integration, E2E |
| 7 | Documentation | README, API docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evoluzione | Scalabilità e manutenzione |
| 10 | Coding Agent | Sviluppo autonomo |
| 11 | Code Review Automatica | Review AI-powered |
| 12 | Sei qui → Edits e Agent Mode | Editing multi-file |
| 13 | GitHub Spark | Micro-app AI-native |
| 14 | Copilot Spaces | Contesto condiviso |
| 15 | Modelli AI | Multi-model e selezione |
| 16 | Personalizzazione | Custom instructions |
| 17 | Enterprise | Adozione organizzativa |
| 18 | Estensioni | Copilot Extensions |
| 19 | Sicurezza | Security e compliance |
Modes d'édition du copilote
Copilot propose plusieurs modes d'interaction dans l'IDE, chacun conçu pour un niveau différent d’autonomie et de complexité. Comprendre les différences est essentiel de choisir le mode adapté à chaque situation.
Comparaison des modes d'édition
| Modalità | Autonomia | Scope | IDE Supportati | Caso d'Uso |
|---|---|---|---|---|
| Inline Suggestions | Minima | Riga/blocco corrente | Tutti | Completamento codice in tempo reale |
| Edit Mode | Media | File specificati | VS Code, Visual Studio, JetBrains | Modifications coordonnées sur plusieurs fichiers sélectionnés |
| Agent Mode | Alta | Projet entier | VS Code, Visual Studio, JetBrains | Tâches autonomes avec auto-guérison |
| Plan Mode | Controllata | Projet entier | VS Code, JetBrains, Eclipse, Xcode | Planification avant exécution |
| Coding Agent | Massima | Référentiel complet | GitHub (cloud) | Task completamente autonomi (PR) |
Copilot Edits: Editing Multi-File
Modifications du copilote c'est la modalité qui permet de décrire un changement de langage naturel et l'appliquer à plusieurs fichiers à la fois. Contrairement aux suggestions en ligne qui fonctionnent dans un contexte immédiat, les modifications prennent prend en compte la relation entre les fichiers sélectionnés et génère des modifications cohérentes.
Flux de travail des modifications copilotes
- Sélectionnez les fichiers : Ajouter les fichiers qui doivent être modifiés au contexte Copilot
- Décrivez le changement : Expliquez en langage naturel ce que vous souhaitez réaliser
- Examiner les modifications : Copilot affiche un diff pour chaque fichier avec les modifications proposées
- Répéter: Si les modifications ne sont pas parfaites, affinez la demande
- Appliquer: Acceptez les changements que vous jugez corrects, rejetez les autres
Comment accéder aux modifications du copilote
Activation dans différents IDE
| IDE | Shortcut | Menu | Note |
|---|---|---|---|
| VS Code | Ctrl+Shift+I (Win/Linux) / Cmd+Shift+I (Mac) |
View > Copilot Edits | Panneau dédié dans la barre latérale |
| Visual Studio | Ctrl+Shift+. |
Edit > Copilot Edits | Intégré au panneau Copilot Chat |
| JetBrains | Ctrl+Shift+I |
Tools > Copilot > Edits | IntelliJ IDEA, WebStorm, PyCharm, etc. |
Exemple Pratique: Refactoring Multi-File
Imaginons que nous souhaitions extraire la logique de validation d'un contrôleur dans un middleware dédié, mettant à jour simultanément le contrôleur, les routes et les tests.
// File: src/controllers/user.controller.ts (PRIMA)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';
export class UserController {{ '{' }}
constructor(private userService: UserService) {{ '{' }}}
async createUser(req: Request, res: Response) {{ '{' }}
// Validazione inline nel controller
const {{ '{' }} email, name, password } = req.body;
if (!email || !email.includes('@')) {{ '{' }}
return res.status(400).json({{ '{' }} error: 'Invalid email' });
}
if (!name || name.length < 2) {{ '{' }}
return res.status(400).json({{ '{' }} error: 'Name too short' });
}
if (!password || password.length < 8) {{ '{' }}
return res.status(400).json({{ '{' }} error: 'Password too short' });
}
const user = await this.userService.create({{ '{' }} email, name, password });
res.status(201).json(user);
}
async updateUser(req: Request, res: Response) {{ '{' }}
const {{ '{' }} id } = req.params;
const {{ '{' }} email, name } = req.body;
if (email && !email.includes('@')) {{ '{' }}
return res.status(400).json({{ '{' }} error: 'Invalid email' });
}
if (name && name.length < 2) {{ '{' }}
return res.status(400).json({{ '{' }} error: 'Name too short' });
}
const user = await this.userService.update(id, {{ '{' }} email, name });
res.json(user);
}
}Estrai tutta la logica di validazione dal UserController in un
middleware dedicato. Crea:
1. Un file src/middleware/validation.middleware.ts con funzioni
di validazione riutilizzabili usando class-validator
2. Un file src/dto/user.dto.ts con le classi DTO per CreateUser e UpdateUser
3. Aggiorna il controller per rimuovere la validazione inline
4. Aggiorna src/routes/user.routes.ts per usare il middleware di validazione
5. Aggiorna i test in tests/controllers/user.controller.test.tsCopilot Edits analyse les 5 fichiers et génère des modifications coordonnées. Voyons le résultat pour chaque fichier.
// File: src/dto/user.dto.ts (GENERATO da Copilot Edits)
import {{ '{' }} IsEmail, IsString, MinLength, IsOptional } from 'class-validator';
export class CreateUserDto {{ '{' }}
@IsEmail({{ '{' }}}, {{ '{' }} message: 'Invalid email format' })
email: string;
@IsString()
@MinLength(2, {{ '{' }} message: 'Name must be at least 2 characters' })
name: string;
@IsString()
@MinLength(8, {{ '{' }} message: 'Password must be at least 8 characters' })
password: string;
}
export class UpdateUserDto {{ '{' }}
@IsOptional()
@IsEmail({{ '{' }}}, {{ '{' }} message: 'Invalid email format' })
email?: string;
@IsOptional()
@IsString()
@MinLength(2, {{ '{' }} message: 'Name must be at least 2 characters' })
name?: string;
}// File: src/middleware/validation.middleware.ts (GENERATO)
import {{ '{' }} Request, Response, NextFunction } from 'express';
import {{ '{' }} validate } from 'class-validator';
import {{ '{' }} plainToInstance } from 'class-transformer';
export function validateBody(dtoClass: any) {{ '{' }}
return async (req: Request, res: Response, next: NextFunction) => {{ '{' }}
const dtoInstance = plainToInstance(dtoClass, req.body);
const errors = await validate(dtoInstance, {{ '{' }}
whitelist: true,
forbidNonWhitelisted: true
});
if (errors.length > 0) {{ '{' }}
const messages = errors.flatMap(err =>
Object.values(err.constraints || {{ '{' }}})
);
return res.status(400).json({{ '{' }}
error: 'Validation failed',
details: messages
});
}
req.body = dtoInstance;
next();
};
}// File: src/controllers/user.controller.ts (DOPO - senza validazione)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';
export class UserController {{ '{' }}
constructor(private userService: UserService) {{ '{' }}}
async createUser(req: Request, res: Response) {{ '{' }}
// La validazione è gestita dal middleware
const {{ '{' }} email, name, password } = req.body;
const user = await this.userService.create({{ '{' }} email, name, password });
res.status(201).json(user);
}
async updateUser(req: Request, res: Response) {{ '{' }}
const {{ '{' }} id } = req.params;
const {{ '{' }} email, name } = req.body;
const user = await this.userService.update(id, {{ '{' }} email, name });
res.json(user);
}
}Edit Mode vs Agent Mode
La différence fondamentale entre le mode Édition et le mode Agent réside dans le niveau d'autonomie et dans les types d’actions que Copilot peut effectuer.
Differenze Operative
| Aspetto | Edit Mode | Agent Mode |
|---|---|---|
| Fichiers de travail | Uniquement les fichiers explicitement sélectionnés | Trova e modifica file autonomamente |
| Creazione file | Ne crée pas de nouveaux fichiers | Il peut créer de nouveaux fichiers et dossiers |
| Esecuzione comandi | N'exécute pas les commandes du terminal | Peut exécuter des commandes (npm, build, test) |
| Auto-correzione | Nécessite un retour manuel | Rileva errori e si auto-corregge |
| Contesto | File selezionati + file aperti | Intero workspace + terminal output |
| Conferma utente | Demande pour chaque changement | Requis uniquement pour les commandes de terminal |
| Velocità | Plus rapide (moins de contexte) | Plus lent (analyse approfondie) |
| Rischio | Faible (portée limitée) | Moyen (actions plus autonomes) |
Mode Agent : développement autonome dans l'EDI
Mode Agent est le mode le plus avancé de Copilot dans l'EDI. Contrairement au mode édition, l'agent peut parcourir le système de fichiers, créer des fichiers, exécuter des commandes dans le terminal et, surtout, auto-correction quand quelque chose ne va pas.
Self-Healing: Auto-Correzione Intelligente
La caractéristique la plus distinctive du mode Agent est la auto-guérison. Lorsque l'agent génère du code générateur d'erreurs (compilation, linting, test), il analyse le message d'erreur vous-même et essayez de corriger le problème en répétant le boucle jusqu'à ce que le succès ou la limite d'itération soit atteinte.
Cycle d'auto-guérison
- Génération: L'agent écrit du code en fonction de la demande
- Vérifier: Exécute la build ou les tests pour vérifier l'exactitude
- Analyse des erreurs : S'il y a une erreur, il lit le message d'erreur complet
- Diagnostic: Identifiez la cause (type manquant, importation incorrecte, syntaxe)
- Correction: Appliquez le correctif et revenez à l'étape 2
- Succès ou escalade : Si après N itérations il échoue, il demande de l'aide à l'utilisateur
Types d'erreurs traitées
Erreurs gérées de manière autonome par le mode Agent
| Type d'erreur | Exemple | Corriger la stratégie | Success Rate |
|---|---|---|---|
| Erreurs de type TypeScript | Property 'x' does not exist on type 'Y' |
Ajoute une propriété ou corrige un type | Élevé (90 %+) |
| Import mancanti | Cannot find module '../services/user' |
Ajoute l'importation correcte ou crée le fichier | Élevé (95 %+) |
| Erreurs de syntaxe | Unexpected token, expected ';' |
Corrige la syntaxe | Élevé (95 %+) |
| Dipendenze mancanti | Cannot find package 'lodash' |
Esegue npm install |
Élevé (90 %+) |
| Test falliti | Expected 42 but received undefined |
Analyser le test et corriger l'implémentation | Moyen (60-70%) |
| Errori runtime | TypeError: Cannot read property of undefined |
Ajoute des vérifications nulles ou corrige la logique | Moyen (50-70%) |
| Erreurs de configuration | Invalid configuration option 'x' |
Corrige le fichier de configuration | Moyen (60-80%) |
| Errori logici complessi | Résultat incorrect sans message clair | Potrebbe necessitare aiuto umano | Faible (30-40%) |
Comment activer et configurer le mode agent
// .vscode/settings.json
{{ '{' }}
// Abilita Agent Mode (abilitato di default nelle versioni recenti)
"github.copilot.chat.agent.enabled": true,
// Configura quali comandi l'agente può eseguire senza conferma
"github.copilot.chat.agent.autoApprove": {{ '{' }}
// Comandi che non richiedono conferma
"allowedCommands": [
"npm test",
"npm run lint",
"npm run build",
"npx tsc --noEmit"
],
// Comandi che richiedono sempre conferma
"blockedCommands": [
"rm",
"git push",
"npm publish",
"docker"
]
},
// Limite di iterazioni per il self-healing
"github.copilot.chat.agent.maxIterations": 5,
// File e cartelle che l'agente non può modificare
"github.copilot.chat.agent.protectedPaths": [
".env",
".env.*",
"secrets/",
"*.key",
"*.pem"
]
}Garde-corps de sécurité
Le mode Agent comprend des garde-corps conçus pour empêcher les actions potentiellement dangereuses. Il est crucial de les configurer correctement, notamment dans les environnements de production.
Protections actives par défaut
- Confirmation requise pour chaque commande du terminal
- Impossible d'accéder aux fichiers
.env - Impossible d'exécuter
git pushsans confirmation - Il ne modifie pas les fichiers de configuration du système
- Limite d'itérations pour éviter les boucles infinies
- Impossible d'installer les dépendances sans confirmation
Protezioni Personalizzabili
- Liste des commandes auto-approuvées
- Liste des commandes bloquées
- Itinéraires protégés (non modifiables)
- Nombre maximum d'itérations
- Délai d'attente pour une seule opération
- Notifications pour les opérations sensibles
Mode Plan : Planifier avant l'action
Mode Planification est un mode qui ajoute une étape de planification avant exécution. Au lieu de commencer immédiatement à éditer des fichiers, Copilot analyse la demande, pose des questions de clarification si nécessaire et construit un plan d'exécution détaillé que vous pouvez d'abord approuver, modifier ou rejeter que n'importe quel code est touché.
Comment activer le mode Plan
Attivazione in Diversi IDE
| IDE | Metodo | Détail |
|---|---|---|
| VS Code | Shift+Tab dans le chat Copilot |
Basculer entre le mode agent et le mode plan |
| JetBrains | Icône « Plan » dans la barre d'outils Copilot Chat | Disponible dans tous les IDE JetBrains |
| Eclipse | Menu Copilot > Plan Mode | Intégré au panneau Copilot |
| Xcode | Menu Copilot > Plan Mode | Supporto nativo |
Workflow del Plan Mode
- Demande: Décrire la tâche en langage naturel
- Analyses : Copilot analyse la base de code et identifie les fichiers pertinents
- Questions (facultatif) : Si la demande est ambiguë, posez des questions de clarification
- Piano: Genera un piano strutturato con:
- Fichiers à créer, modifier ou supprimer
- Ordre des opérations
- Dépendances entre les changements
- Commandes à exécuter
- Revoir: Vous révisez le plan et pouvez le modifier
- Exécution: Après approbation, le plan est exécuté étape par étape
Quand utiliser le mode Plan
Scénarios idéaux pour le mode Plan
| Scenario | Pourquoi le mode Planification | Alternativa |
|---|---|---|
| Refactoring complesso | Vous souhaitez vérifier que le plan touche tous les fichiers nécessaires | Agent Mode potrebbe saltare file |
| Nuova feature multi-componente | Vous souhaitez valider l’architecture avant mise en œuvre | Edit Mode richiederebbe troppo lavoro manuale |
| Migration de bibliothèque | Vous souhaitez voir la liste complète des fichiers concernés | Agent Mode potrebbe dimenticare file |
| Tâches avec des exigences ambiguës | Les questions de clarification évitent un travail inutile | Agent Mode potrebbe assumere e sbagliare |
| Codice critico | Vous voulez un contrôle total sur chaque changement | Aucun : le mode Plan est le meilleur choix |
Exemple pratique : mode Plan pour un élément complexe
Aggiungi un sistema di notifiche in-app al progetto.
Requisiti:
- Modello Notification con titolo, messaggio, tipo, letto/non letto
- Service per CRUD notifiche
- Controller con endpoint REST
- Componente Angular con icona campanella e badge contatore
- WebSocket per aggiornamenti real-time
- Test per service e controller# Piano di Implementazione: Sistema Notifiche
## Domande Chiarificatrici
1. Vuoi persistere le notifiche su database o solo in memoria?
-> Risposta: Database (PostgreSQL con Prisma)
2. Le notifiche devono essere per utente specifico o broadcast?
-> Risposta: Per utente, con possibilità di broadcast
3. Quale libreria WebSocket preferisci?
-> Risposta: Socket.io (gia presente nelle dipendenze)
## File da Creare (5)
1. src/models/notification.model.ts - Schema Prisma e tipi
2. src/services/notification.service.ts - Business logic
3. src/controllers/notification.controller.ts - Endpoint REST
4. src/gateways/notification.gateway.ts - WebSocket gateway
5. frontend/src/app/components/notification-bell/ - Componente Angular
## File da Modificare (4)
1. prisma/schema.prisma - Aggiungere modello Notification
2. src/routes/index.ts - Registrare route notifiche
3. src/app.ts - Registrare WebSocket gateway
4. frontend/src/app/app.component.ts - Aggiungere notification-bell
## Comandi da Eseguire (3)
1. npx prisma migrate dev --name add-notifications
2. npm test -- --testPathPattern=notification
3. npm run build
## Ordine di Esecuzione
Phase 1: Backend (modello, service, controller)
Phase 2: WebSocket (gateway, eventi)
Phase 3: Frontend (componente, integrazione)
Phase 4: Test e verifica
## Stima: ~45 minuti di esecuzione agentNext Edit Suggestions (NES)
Suggestions de modifications suivantes c'est une fonctionnalité qui prédit le séquence de changements ce que vous ferez probablement après une opération initiale. Au lieu de simplement suggérer l'achèvement de la ligne actuelle, NES l'analyse le schéma de votre changement et anticipez les domaines dans lesquels vous devrez intervenir ensuite.
Comment fonctionne la NES
Le mécanisme est intuitif : effectuez une modification à un moment donné du code, et Copilot identifie automatiquement les autres endroits du fichier (ou du projet) qui doivent être mis à jour en conséquence. Un indicateur visuel apparaît dans la gouttière de l'éditeur, montrant où les suggestions d’édition sont disponibles.
Interaction avec la NES
| Azione | Shortcut | Effetto |
|---|---|---|
| Navigare al prossimo suggerimento | Tab |
Le curseur se déplace vers le point d'édition suivant |
| Acceptez la suggestion | Tab (quand sur le pourboire) |
Le changement est appliqué |
| Rejeter la suggestion | Esc |
L'indice disparaît |
| Vedere tutti i suggerimenti | Icônes dans la gouttière de l'éditeur | Des indicateurs visuels montrent toutes les positions |
Cas d'utilisation de la NES
Scénarios où NES excelle
| Scenario | Modifica Iniziale | Suggerimenti NES |
|---|---|---|
| Rinomina variabile | Rinomini userData in userProfile |
Suggère une mise à jour à tous les points où la variable est utilisée |
| Aggiunta parametro | Ajouter un paramètre options à une fonction |
Il suggère de mettre à jour tous les appelants et le JSDoc |
| Cambio tipo | Changer le type de retour de string a UserResponse |
Suggerisce aggiornamenti nei consumatori del valore |
| Aggiunta campo | Ajouter un champ avatar à l'interface User |
Propose des mises à jour dans les usines, des tests, une cartographie |
| Cambio pattern | Convertir un rappel en async/wait | Suggère la conversion vers tous les modèles similaires dans le fichier |
| Aggiunta import | Vous utilisez un nouveau type dans le fichier | Suggerisce l'import statement corretto |
Exemple : Renommer avec NES
Supposons que nous renommons une variable data in userProfile
dans un fichier avec 15 occurrences. Sans NES, vous devrez rechercher et remplacer manuellement ou
utilisez la refactorisation IDE. Avec NES, le processus devient transparent.
// Step 1: Rinomini la prima occorrenza
const userProfile = await fetchUserData(userId);
// ^^^^^^^^^^^ modifica manuale
// Step 2: NES mostra indicatori nel gutter su tutte le altre occorrenze
// Linea 15: [NES] data.name -> userProfile.name
// Linea 23: [NES] data.email -> userProfile.email
// Linea 31: [NES] return data; -> return userProfile;
// Linea 45: [NES] if (data) -> if (userProfile)
// Step 3: Premi Tab per navigare al primo suggerimento
// Step 4: Premi Tab per accettare
// Step 5: Ripeti fino a completare tutte le occorrenze
// Risultato: tutte le 15 occorrenze aggiornate con pochi TabIndicateurs dans la gouttière
NES utilise des indicateurs visuels dans la gouttière de l'éditeur (la colonne à gauche des chiffres ligne) pour indiquer où les suggestions sont disponibles. Dans VS Code, les indicateurs ils incluent également une coloration syntaxique dans l'info-bulle pour faciliter la révision visuelle du changement proposé.
Avantages de la NES
- Édition 3 à 5 fois plus rapide pour les modifications répétitives
- Réduit les erreurs de renommage partiel
- Cela fonctionne également entre fichiers
- Comprend le contexte sémantique
- Ne nécessite pas d'expression régulière ou de recherche-remplacement
- Il prédit également des changements non évidents
Limites de la NES
- Uniquement disponible dans VS Code (pour l'instant)
- Cela peut suggérer des changements indésirables
- Il ne trouve pas toujours toutes les correspondances
- La qualité dépend de la clarté du motif
- Il ne gère pas les refactorisations complexes
- Nécessite une attention particulière lors de l'examen des suggestions
Editing Symbol-Aware
Pour des langues comme C++ e C#, Copilot a intégré une compréhension au niveau du compilateur qui va au-delà de la simple correspondance de modèles textuel. LE'édition sensible aux symboles analyse les symboles, les types et les dépendances entre les fichiers, permettant des opérations de refactoring sémantiquement correctes à l'échelle du projet.
Comment ça marche
Contrairement à l'édition de texte traditionnelle, l'édition basée sur les symboles utilise Informations sur le protocole Language Server (LSP) à inclure :
- Déclarations : Où un symbole est défini
- Références : Où un symbole est utilisé
- Types : Le type de chaque symbole et ses relations
- Portées : La visibilité de chaque symbole
- Dépendances : Quels fichiers dépendent d'un symbole
Prise en charge des langages sensibles aux symboles
| Linguaggio | IDE | Niveau d'assistance | Opérations prises en charge |
|---|---|---|---|
| C++ | Visual Studio 2026 | Complet | Rinomina, cambio firma, estrai metodo, sposta tipo |
| C# | Visual Studio 2026 | Complet | Rinomina, cambio firma, estrai interfaccia, genera implementazione |
| TypeScript | VS Code | Parziale (via LSP) | Renommer avec NES, mettre à jour l'importation |
| Java | JetBrains | Parziale | Rinomina, aggiornamento riferimenti |
| Python | VS Code / JetBrains | Base | Renommer avec des suggestions contextuelles |
Exemple : changement de signature de méthode en C#
// PRIMA: Metodo originale in UserService.cs
public async Task<User> GetUserById(int id)
{{ '{' }}
return await _repository.FindAsync(id);
}
// MODIFICA: Aggiungi parametro 'includeOrders' alla firma
public async Task<User> GetUserById(int id, bool includeOrders = false)
{{ '{' }}
var user = await _repository.FindAsync(id);
if (includeOrders)
{{ '{' }}
user.Orders = await _orderRepository.FindByUserIdAsync(id);
}
return user;
}
// SYMBOL-AWARE: Copilot identifica TUTTI i 23 chiamanti nel progetto
// e suggerisce aggiornamenti per ciascuno:
// File: UserController.cs (linea 45)
// PRIMA: var user = await _userService.GetUserById(id);
// DOPO: var user = await _userService.GetUserById(id, false);
// File: OrderController.cs (linea 78)
// PRIMA: var user = await _userService.GetUserById(userId);
// DOPO: var user = await _userService.GetUserById(userId, true);
// File: UserServiceTests.cs (linea 112)
// PRIMA: var result = await service.GetUserById(1);
// DOPO: var result = await service.GetUserById(1, false);
// ... e cosi via per tutti i 23 riferimentiEsempi Pratici Avanzati
Voyons quelques scénarios réels où les différents modes d'édition sont combinés pour résoudre des problèmes complexes.
Exemple 1 : Ajouter une fonctionnalité avec le mode Agent
Aggiungi paginazione a tutti gli endpoint che restituiscono liste.
Requisiti:
- Query params: page (default 1), limit (default 20, max 100)
- Risposta: {{ '{' }} data: T[], meta: {{ '{' }} page, limit, total, totalPages } }
- Endpoint coinvolti: GET /users, GET /orders, GET /products
- Aggiorna i test esistenti per verificare la paginazione
- Aggiorna la documentazione OpenAPI
Pattern da seguire: vedi src/utils/pagination.ts (se esiste) o crealoLe mode Agent analyse la base de code, trouve les 3 points de terminaison, crée l'utilitaire de pagination, modifier les contrôleurs et les services, mettre à jour les tests et la documentation. Si un essai échoue pendant le processus, l'agent analyse l'erreur et s'auto-corrige.
Exemple 2 : Utiliser le mode Plan pour la migration
Migra il progetto da Moment.js a Day.js.
Contesto:
- Moment.js e usato in 15 file
- Usiamo i plugin: timezone, relative-time, duration
- I test usano mock di Moment.js
- Il formato delle date in DB e ISO 8601
Requisiti:
- Sostituire tutti gli import di moment con dayjs
- Configurare i plugin equivalenti
- Aggiornare i format string se necessario
- Aggiornare tutti i test
- Rimuovere moment dalle dipendenze
- Verificare che il build compili senza errori# Piano di Migrazione: Moment.js -> Day.js
## Analisi Impatto
File impattati: 15
Test impattati: 8
Plugin da sostituire: 3
## Phase 1: Setup (5 min)
1. npm install dayjs
2. Creare src/utils/dayjs-config.ts con plugin
## Phase 2: Migrazione File (20 min)
File da modificare (ordine per dipendenze):
1. src/utils/date-helpers.ts (utility condiviso)
2. src/services/report.service.ts
3. src/services/scheduling.service.ts
4. src/controllers/report.controller.ts
... (altri 11 file)
## Phase 3: Test (10 min)
1. Aggiornare mock in tests/setup.ts
2. Aggiornare assertion nei test
3. Eseguire test suite completa
## Phase 4: Cleanup (5 min)
1. npm uninstall moment @types/moment
2. Verificare build
3. Verificare bundle size (atteso: -200KB)
## Rischi Identificati
- Il plugin timezone di Day.js ha API diversa
- Alcuni format string sono diversi
- I mock nei test potrebbero richiedere refactoringMeilleures pratiques pour les modes d'édition
Guide de sélection des modes
| Situazione | Modalità Consigliata | Motivazione |
|---|---|---|
| Remplir une seule fonction | Inline Suggestions | Veloce, contesto immediato sufficiente |
| Modificare 2-3 file correlati | Edit Mode | Controllo sui file, modifica coordinata |
| Implémenter une fonctionnalité complète | Agent Mode | Crea file, esegue comandi, si auto-corregge |
| Refactoring critique avec de nombreux fichiers | Plan Mode | Plan vérifiable avant exécution |
| Rinomina e aggiornamenti ripetitivi | NES | Prédictif, rapide, Tab pour naviguer |
| Changement de signature de méthode dans un grand projet | Symbol-Aware + NES | Comprensione semantica cross-file |
| Tâche non urgente, base de code inconnue | Plan Mode + Agent Mode | Planifiez d’abord, puis exécutez sous supervision |
Troubleshooting e Problemi Comuni
Les modes d'édition avancés peuvent présenter des problèmes dans certains paramètres situations. Voici comment diagnostiquer et résoudre les problèmes les plus courants.
Problemi Comuni e Soluzioni
| Problème | Causa | Solution |
|---|---|---|
| Le mode agent ne trouve pas les fichiers pertinents | Structure non conventionnelle ou fichiers cachés | Spécifiez les chemins de fichiers dans l'invite |
| Self-healing loop infinito | Erreur structurelle que le correctif ne résout pas | Arrêtez, résolvez manuellement le problème de base |
| Edit Mode modifica troppo | Prompt troppo ampio | Soyez précis sur ce qu'il faut changer et ce qu'il ne faut PAS toucher |
| NES n'apparaît pas | Extension obsolète ou fonctionnalité désactivée | Aggiorna l'estensione, verifica settings |
| Plan Mode genera piano incompleto | Contexte insuffisant ou projet trop gros | Ajouter plus de contexte ou limiter la portée |
| Comandi terminal falliscono | Environnement non configuré ou dépendances manquantes | Vérifiez d'abord que le projet se compile manuellement |
| Modifications incohérentes entre les fichiers | L'agent perd le contexte entre les changements | Divisez-vous en tâches plus petites ou utilisez le mode Plan |
Quand arrêter l'agent
Panneaux d'avertissement
- Plus de 3 itérations sur la même erreur
- Les changements aggravent le problème
- L'agent modifie les fichiers non pertinents
- Le code généré n'a aucun sens logique
- Des dépendances inutiles sont ajoutées
- Les tests réussissent mais la logique est fausse
Azioni Correttive
- Presse
Ctrl+Carrêter - USA
git diffpour voir tous les changements - Tu fais
git stashogit checkoutrestaurer - Reformulez la demande avec plus de contexte
- Divisez la tâche en sous-tâches
- Passez en mode Plan pour plus de contrôle
Résumé et prochaines étapes
Les modes d'édition avancés de Copilot transforment notre façon de travailler dans notre IDE. Des suggestions en ligne à l'édition coordonnée de plusieurs fichiers, à partir d'un agent autonome de l'auto-guérison à la planification avant l'action, chaque modalité a sa place dans la boîte à outils du développeur moderne.
Punti Chiave
- Mode édition pour des changements coordonnés sur des fichiers spécifiques : vous choisissez les fichiers, Copilot génère les changements cohérents.
- Mode Agent pour des tâches autonomes avec auto-réparation : l'agent explore le projet, exécute des commandes et s'auto-répare.
- Mode Planification pour un contrôle total : planifiez d’abord, exécutez plus tard. Idéal pour les tâches complexes et le code critique.
- Suggestions de modifications suivantes pour une édition fluide : Tab pour naviguer, Tab pour accepter. Renommez et mettez à jour des mises à jour répétitives en quelques secondes.
- Édition prenant en compte les symboles pour la refactorisation sémantique : compréhension au niveau du compilateur de C++ et C# dans Visual Studio.
Progression de la série
| # | Article | État |
|---|---|---|
| 1 | Foundation e Mindset | Terminé |
| 2 | Concept et exigences | Terminé |
| 3 | Architecture back-end | Terminé |
| 4 | Structure frontale | Terminé |
| 5 | Prompt Engineering | Terminé |
| 6 | Testing e Qualità | Terminé |
| 7 | Documentation | Terminé |
| 8 | Deploy e DevOps | Terminé |
| 9 | Evoluzione | Terminé |
| 10 | Coding Agent | Terminé |
| 11 | Code Review Automatica | Terminé |
| 12 | Copilot Edits e Agent Mode | Terminé |
| 13 | GitHub Spark | Prossimo |
| 14 | Copilot Spaces | In arrivo |
| 15 | Modelli AI | In arrivo |
| 16 | Personalizzazione | In arrivo |
| 17 | Enterprise | In arrivo |
| 18 | Estensioni | In arrivo |
| 19 | Sicurezza | In arrivo |
Dans le prochain article, nous explorerons GitHub Spark, la plateforme pour créer des micro-applications IA natives directement depuis le navigateur en utilisant le langage naturel, sans avoir besoin d’écrire du code ou de configurer l’infrastructure.