Copilot Edits e Agent Mode: Editing Multi-File e Sviluppo Autonomo nell'IDE
Hasta ahora hemos explorado Copilot como asistente de sugerencias en línea y como agente. autónomo que trabaja en GitHub. Sin embargo, existe un territorio intermedio extremadamente poderoso: Ediciones de copiloto e Modo agente, que aportan las capacidades edición de varios archivos y ejecución independiente directamente en su IDE. En lugar de editar un archivo a la vez, puede describir un cambio que afecta a varios archivos y dejar que Copilot coordine todos los cambios de manera consistente.
En este artículo exploraremos en detalle los modos de edición avanzados disponibles: Modo de edición para la edición guiada de varios archivos, Modo agente para ejecución autónoma con autocuración, Modo de planificación para planificar primero de la acción, e Siguiente sugerencias de edición (NES) para un flujo de edición predictivo y fluido.
Vista General de la Serie
| # | Artículo | Enfoque |
|---|---|---|
| 1 | Foundation e Mindset | Setup e mentalità |
| 2 | Concepto y requisitos | De idea a MVP |
| 3 | Arquitectura de back-end | API e database |
| 4 | Estructura frontal | UI e componenti |
| 5 | Prompt Engineering | Prompt e Agenti MCP |
| 6 | Testing e Qualità | Unit, integration, E2E |
| 7 | Documentación | 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 |
Modos de edición de Copilot
Copilot ofrece varios modos de interacción en el IDE, cada uno diseñado para un nivel diferente de autonomía y complejidad. Comprender las diferencias es Es esencial elegir el modo adecuado para cada situación.
Comparación de modos de edición
| 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 | Cambios coordinados en múltiples archivos seleccionados |
| Agent Mode | Alta | Todo el proyecto | VS Code, Visual Studio, JetBrains | Tareas autónomas con autocuración. |
| Plan Mode | Controllata | Todo el proyecto | VS Code, JetBrains, Eclipse, Xcode | Planificación antes de la ejecución |
| Coding Agent | Massima | repositorio completo | GitHub (cloud) | Task completamente autonomi (PR) |
Copilot Edits: Editing Multi-File
Ediciones de copiloto es la modalidad que permite describir un cambio en el lenguaje natural y aplicarlo a varios archivos a la vez. A diferencia de las sugerencias en línea que operan en el contexto inmediato, Edits toma tiene en cuenta la relación entre los archivos seleccionados y genera cambios consistentes.
Flujo de trabajo de ediciones de Copilot
- Seleccionar archivos: Agregue los archivos que deben editarse al contexto de Copilot
- Describe el cambio: Explica en lenguaje natural lo que quieres conseguir.
- Revisar cambios: Copilot muestra una diferencia para cada archivo con los cambios propuestos
- Iterar: Si los cambios no son perfectos, refine la solicitud.
- Aplicar: Acepta los cambios que creas correctos, rechaza los demás.
Cómo acceder a las ediciones de Copilot
Activación en diferentes IDE
| IDE | Shortcut | Menu | Note |
|---|---|---|---|
| VS Code | Ctrl+Shift+I (Win/Linux) / Cmd+Shift+I (Mac) |
View > Copilot Edits | Panel dedicado en la barra lateral |
| Visual Studio | Ctrl+Shift+. |
Edit > Copilot Edits | Integrado en el panel de Copilot Chat |
| JetBrains | Ctrl+Shift+I |
Tools > Copilot > Edits | IntelliJ IDEA, WebStorm, PyCharm, etc. |
Ejemplo Práctico: Refactoring Multi-File
Imaginemos que queremos extraer la lógica de validación de un controlador a un middleware dedicado, actualizando simultáneamente el controlador, rutas y pruebas.
// 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 analiza los 5 archivos y genera ediciones coordinadas. veamos el resultado para cada archivo.
// 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 diferencia fundamental entre el Modo Edición y el Modo Agente radica en el nivel de autonomía. y en los tipos de acciones que Copilot puede realizar.
Differenze Operative
| Aspetto | Edit Mode | Agent Mode |
|---|---|---|
| Archivos de trabajo | Sólo archivos seleccionados explícitamente | Trova e modifica file autonomamente |
| Creazione file | No crea nuevos archivos | Puede crear nuevos archivos y carpetas. |
| Esecuzione comandi | No ejecuta comandos de terminal | Puede ejecutar comandos (npm, build, test) |
| Auto-correzione | Requiere retroalimentación manual | Rileva errori e si auto-corregge |
| Contesto | File selezionati + file aperti | Intero workspace + terminal output |
| Conferma utente | Solicitud de cada cambio | Requerido solo para comandos de terminal |
| Velocità | Más rápido (menos contexto) | Más lento (análisis en profundidad) |
| Rischio | Bajo (alcance limitado) | Medio (acciones más autónomas) |
Modo Agente: Desarrollo Autónomo en el IDE
Modo agente es el modo más avanzado de Copilot en el IDE. A diferencia del modo de edición, el agente puede explorar el sistema de archivos, crear archivos, ejecutar comandos en la terminal y, lo más importante, autocorregirse cuando algo sale mal.
Self-Healing: Auto-Correzione Intelligente
La característica más distintiva del Modo Agente es la autosanación. Cuando el agente genera código que produce errores (compilación, linting, prueba), analiza el mensaje de error usted mismo e intente corregir el problema repitiendo el bucle hasta que se alcance el éxito o el límite de iteración.
Ciclo de autocuración
- Generación: El agente escribe código según la solicitud.
- Verificar: Ejecuta la compilación o prueba para verificar la corrección.
- Análisis de errores: Si hay un error, lee el mensaje de error completo.
- Diagnóstico: Identifique la causa (tipo faltante, importación incorrecta, sintaxis)
- Corrección: Aplique la solución y regrese al paso 2.
- Éxito o escalada: Si después de N iteraciones falla, pide ayuda al usuario
Tipos de errores manejados
Errores que el modo agente gestiona de forma autónoma
| Tipo de error | Ejemplo | Arreglar estrategia | Success Rate |
|---|---|---|---|
| Errores de tipo TypeScript | Property 'x' does not exist on type 'Y' |
Agrega propiedad o corrige el tipo | Alto (90%+) |
| Import mancanti | Cannot find module '../services/user' |
Agrega la importación correcta o crea el archivo. | Alto (95%+) |
| Errores de sintaxis | Unexpected token, expected ';' |
Corrige la sintaxis | Alto (95%+) |
| Dipendenze mancanti | Cannot find package 'lodash' |
Esegue npm install |
Alto (90%+) |
| Test falliti | Expected 42 but received undefined |
Analizar la prueba y arreglar la implementación. | Medio (60-70%) |
| Errori runtime | TypeError: Cannot read property of undefined |
Agrega controles nulos o corrige la lógica. | Medio (50-70%) |
| Errores de configuración | Invalid configuration option 'x' |
Corrige el archivo de configuración. | Medio (60-80%) |
| Errori logici complessi | Resultado incorrecto sin mensaje claro | Potrebbe necessitare aiuto umano | Bajo (30-40%) |
Cómo habilitar y configurar el modo agente
// .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"
]
}Barandilla de seguridad
El Modo Agente incluye barreras diseñadas para evitar acciones potencialmente peligrosas. Es crucial configurarlos correctamente, especialmente en entornos de producción.
Protecciones activas predeterminadas
- Se requiere confirmación para cada comando de terminal
- No puedo acceder a los archivos
.env - No se puede ejecutar
git pushsin confirmación - No modifica los archivos de configuración del sistema.
- Límite de iteraciones para evitar bucles infinitos.
- No se pueden instalar dependencias sin confirmación
Protezioni Personalizzabili
- Lista de comandos autoaprobados
- Lista de comandos bloqueados
- Rutas protegidas (no editables)
- Número máximo de iteraciones
- Tiempo de espera para una sola operación
- Notificaciones de operaciones sensibles
Modo de planificación: planificación antes de la acción
Modo de planificación es un modo que añade un paso de planificación antes de la ejecución. En lugar de comenzar a editar archivos inmediatamente, Copilot analiza la solicitud, hace preguntas aclaratorias si es necesario y construye un plan de ejecución detallado que puede aprobar, modificar o rechazar primero que se toque cualquier código.
Cómo activar el modo de plan
Attivazione in Diversi IDE
| IDE | Metodo | Detalle |
|---|---|---|
| VS Code | Shift+Tab en el chat del copiloto |
Alternar entre el modo de agente y el modo de plan |
| JetBrains | Icono "Plan" en la barra de herramientas de Copilot Chat | Disponible en todos los IDE de JetBrains |
| Eclipse | Menu Copilot > Plan Mode | Integrado en el panel Copilot |
| Xcode | Menu Copilot > Plan Mode | Supporto nativo |
Workflow del Plan Mode
- Pedido: Describir la tarea en lenguaje natural.
- Análisis: Copilot analiza el código base e identifica archivos relevantes
- Preguntas (opcional): Si la solicitud es ambigua, haga preguntas aclaratorias.
- Piano: Genera un piano strutturato con:
- Archivos para crear, editar o eliminar
- Orden de operaciones
- Dependencias entre cambios
- Comandos a ejecutar
- Revisar: Revisas el plan y puedes modificarlo
- Ejecución: Después de la aprobación, el plan se ejecuta paso a paso.
Cuándo utilizar el modo Plan
Escenarios ideales para el modo Plan
| Scenario | Por qué el modo Planificar | Alternativa |
|---|---|---|
| Refactoring complesso | Quieres verificar que el plan toca todos los archivos necesarios | Agent Mode potrebbe saltare file |
| Nuova feature multi-componente | Quiere validar la arquitectura antes de la implementación. | Edit Mode richiederebbe troppo lavoro manuale |
| Migración de biblioteca | Quieres ver la lista completa de archivos afectados | Agent Mode potrebbe dimenticare file |
| Tareas con requisitos ambiguos. | Las preguntas aclaratorias evitan trabajos innecesarios | Agent Mode potrebbe assumere e sbagliare |
| Codice critico | Quieres control total sobre cada cambio | Ninguno: el modo Plan es la mejor opción |
Ejemplo práctico: modo de planificación para funciones complejas
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)
Siguiente Editar sugerencias es una característica que predice el secuencia de cambios lo que probablemente harás después de una operación inicial. En lugar de limitarse a sugerir la finalización de la línea actual, NES la analiza el patrón de su cambio y anticipe dónde necesitará intervenir a continuación.
Cómo funciona NES
El mecanismo es intuitivo: haz un cambio en un punto del código y Copilot identifica automáticamente otros lugares en el archivo (o proyecto) que deben ser actualizado en consecuencia. Aparece un indicador visual en el margen del editor, mostrando dónde están disponibles las sugerencias de edición.
Interacción con NES
| Azione | Shortcut | Effetto |
|---|---|---|
| Navigare al prossimo suggerimento | Tab |
El cursor se mueve al siguiente punto de edición. |
| Acepta la sugerencia | Tab (cuando está en la punta) |
El cambio se aplica |
| Rechazar la sugerencia | Esc |
La pista desaparece |
| Vedere tutti i suggerimenti | Iconos en el canal del editor | Los indicadores visuales muestran todas las posiciones. |
Casos de uso de NES
Escenarios donde NES sobresale
| Scenario | Modifica Iniziale | Suggerimenti NES |
|---|---|---|
| Rinomina variabile | Rinomini userData in userProfile |
Sugiere actualizar en todos los puntos donde se utiliza la variable. |
| Aggiunta parametro | Agregar un parámetro options a una función |
Sugiere actualizar todas las personas que llaman y el JSDoc. |
| Cambio tipo | Cambiar el tipo de devolución de string a UserResponse |
Suggerisce aggiornamenti nei consumatori del valore |
| Aggiunta campo | Agregar un campo avatar a la interfaz User |
Sugiere actualizaciones en fábricas, pruebas, mapeo. |
| Cambio pattern | Convertir una devolución de llamada a async/await | Sugiere la conversión a todos los patrones similares en el archivo. |
| Aggiunta import | Usas un nuevo tipo en el archivo. | Suggerisce l'import statement corretto |
Ejemplo: cambiar el nombre con NES
Supongamos que cambiamos el nombre de una variable. data in userProfile
en un archivo con 15 ocurrencias. Sin NES, tendrías que buscar y reemplazar manualmente o
Utilice la refactorización IDE. Con NES, el proceso se vuelve fluido.
// 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 TabIndicadores en la cuneta
NES utiliza indicadores visuales en el margen del editor (la columna a la izquierda de los números línea) para mostrar dónde están disponibles las sugerencias. En VS Code, los indicadores También incluyen resaltado de sintaxis en la información sobre herramientas para facilitar la revisión visual. del cambio propuesto.
Ventajas de NES
- Edición de 3 a 5 veces más rápida para ediciones repetitivas
- Reduce los errores de cambio de nombre parcial
- También funciona entre archivos.
- Entiende el contexto semántico.
- No requiere expresiones regulares ni buscar-reemplazar
- También predice cambios no obvios.
Limitaciones de NES
- Sólo disponible en VS Code (por ahora)
- Puede sugerir cambios no deseados.
- No siempre encuentra todas las coincidencias.
- La calidad depende de la claridad del patrón.
- No maneja refactorizaciones complejas.
- Requiere atención al revisar sugerencias.
Editing Symbol-Aware
Para idiomas como C++ e C#, Copilot ha integrado una comprensión a nivel de compilador que va más allá de la simple coincidencia de patrones textual. EL'edición con reconocimiento de símbolos analiza símbolos, tipos y dependencias entre archivos, lo que permite operaciones de refactorización semánticamente correctas a escala del proyecto.
Cómo funciona
A diferencia de la edición tradicional basada en texto, la edición con reconocimiento de símbolos utiliza La información del protocolo de servidor de idiomas (LSP) debe incluir:
- Declaraciones: Donde se define un símbolo
- Referencias: Donde se utiliza un símbolo
- Tipos: El tipo de cada símbolo y sus relaciones.
- Alcances: La visibilidad de cada símbolo.
- Dependencias: ¿Qué archivos dependen de un símbolo?
Soporte de lenguaje basado en símbolos
| Linguaggio | IDE | Nivel de soporte | Operaciones soportadas |
|---|---|---|---|
| C++ | Visual Studio 2026 | Completo | Rinomina, cambio firma, estrai metodo, sposta tipo |
| C# | Visual Studio 2026 | Completo | Rinomina, cambio firma, estrai interfaccia, genera implementazione |
| TypeScript | VS Code | Parziale (via LSP) | Cambiar nombre con NES, actualizar importación |
| Java | JetBrains | Parziale | Rinomina, aggiornamento riferimenti |
| Python | VS Code / JetBrains | Base | Cambiar nombre con sugerencias contextuales |
Ejemplo: cambio de firma de método 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
Veamos algunos escenarios reales donde se combinan los diferentes modos de edición. para resolver problemas complejos.
Ejemplo 1: agregar una función con el modo agente
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 crealoEl modo agente analiza el código base, encuentra los 3 puntos finales, crea la utilidad de paginación, modificar controladores y servicios, actualizar pruebas y documentación. si una prueba falla durante el proceso, el agente analiza el error y lo autocorrige.
Ejemplo 2: utilizar el modo Plan para la migración
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 refactoringMejores prácticas para modos de edición
Guía de selección de modo
| Situazione | Modalità Consigliata | Motivazione |
|---|---|---|
| Completa una sola función | Inline Suggestions | Veloce, contesto immediato sufficiente |
| Modificare 2-3 file correlati | Edit Mode | Controllo sui file, modifica coordinata |
| Implementar una característica completa | Agent Mode | Crea file, esegue comandi, si auto-corregge |
| Refactorización crítica con muchos archivos. | Plan Mode | Plan verificable antes de la ejecución. |
| Rinomina e aggiornamenti ripetitivi | NES | Predictivo, rápido, Tab para navegar |
| Cambio de firma de método en proyecto grande. | Symbol-Aware + NES | Comprensione semantica cross-file |
| Tarea no urgente, base de código desconocida | Plan Mode + Agent Mode | Planificar primero y luego ejecutar con supervisión |
Troubleshooting e Problemi Comuni
Los modos de edición avanzados pueden presentar problemas en ciertas configuraciones situaciones. A continuación se explica cómo diagnosticar y solucionar los problemas más comunes.
Problemi Comuni e Soluzioni
| Problema | Causa | Solución |
|---|---|---|
| El modo agente no encuentra archivos relevantes | Estructura no convencional o archivos ocultos | Especifique rutas de archivos en el mensaje |
| Self-healing loop infinito | Error estructural que la solución no resuelve | Detener, solucionar manualmente el problema básico |
| Edit Mode modifica troppo | Prompt troppo ampio | Sea específico sobre qué cambiar y qué NO tocar |
| NES no aparece | Extensión desactualizada o función deshabilitada | Aggiorna l'estensione, verifica settings |
| Plan Mode genera piano incompleto | Contexto insuficiente o proyecto demasiado grande | Agregue más contexto o limite el alcance |
| Comandi terminal falliscono | Entorno no configurado o dependencias faltantes | Comprueba que el proyecto se compila manualmente primero. |
| Cambios inconsistentes entre archivos. | El agente pierde contexto entre cambios. | Divida las tareas en tareas más pequeñas o utilice el modo Planificar |
Cuándo detener al agente
Señales de advertencia
- Más de 3 iteraciones sobre el mismo error.
- Los cambios empeoran el problema
- El agente modifica archivos irrelevantes.
- El código generado no tiene sentido lógico.
- Se agregan dependencias innecesarias.
- Las pruebas pasan pero la lógica es incorrecta.
Azioni Correttive
- Prensa
Ctrl+Cparar - EE.UU
git diffpara ver todos los cambios - Tú haces
git stashogit checkoutrestaurar - Reformule la solicitud con más contexto
- Dividir la tarea en subtareas
- Cambie al modo Plan para tener más control
Resumen y próximos pasos
Los modos de edición avanzados de Copilot transforman nuestra forma de trabajar en nuestro IDE. Desde sugerencias en línea hasta edición coordinada de múltiples archivos, desde un agente autónomo desde la autocuración hasta la planificación antes de la acción, cada modalidad tiene su lugar en el conjunto de herramientas del desarrollador moderno.
Punti Chiave
- Modo de edición para cambios coordinados en archivos específicos: usted elige los archivos, Copilot genera los cambios consistentes.
- Modo agente para tareas autónomas con autocuración: el agente explora el proyecto, ejecuta comandos y se autocura.
- Modo de planificación para un control total: planifique primero, ejecute después. Ideal para tareas complejas y código crítico.
- Siguiente Editar sugerencias para una edición fluida: Tabulador para navegar, Tabulador para aceptar. Cambiar nombre y actualizaciones repetitivas en segundos.
- Edición consciente de símbolos para refactorización semántica: comprensión a nivel de compilador de C++ y C# en Visual Studio.
Progreso de la serie
| # | Artículo | Estado |
|---|---|---|
| 1 | Foundation e Mindset | Completado |
| 2 | Concepto y requisitos | Completado |
| 3 | Arquitectura de back-end | Completado |
| 4 | Estructura frontal | Completado |
| 5 | Prompt Engineering | Completado |
| 6 | Testing e Qualità | Completado |
| 7 | Documentación | Completado |
| 8 | Deploy e DevOps | Completado |
| 9 | Evoluzione | Completado |
| 10 | Coding Agent | Completado |
| 11 | Code Review Automatica | Completado |
| 12 | Copilot Edits e Agent Mode | Completado |
| 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 |
En el próximo artículo exploraremos Chispa de GitHub, la plataforma para cree microaplicaciones nativas de IA directamente desde el navegador usando el lenguaje natural, sin necesidad de escribir código ni configurar infraestructura.