Copilot Edits e Agent Mode: Edição Multi-Arquivo e Desenvolvimento Autônomo na IDE
Até agora, exploramos o Copilot como assistente de sugestões em linha e como agente autônomo trabalhando no GitHub. No entanto, existe um território intermediário extremamente poderoso: Edições do copiloto e Modo Agente, que trazem as capacidades edição de vários arquivos e execução autônoma diretamente em seu IDE. Em vez de editar um arquivo por vez, você pode descrever uma alteração que afeta vários arquivos e deixar que o Copilot coordene todas as mudanças de forma consistente.
Neste artigo exploraremos em detalhes os modos de edição avançados disponíveis: Modo de edição para edição guiada de vários arquivos, Modo Agente para execução autônoma com autocura, Modo de planejamento para planejar primeiro da ação, e. Próximas sugestões de edição (NES) para um fluxo de edição preditivo e fluido.
Visão geral da série
| # | Artigo | Foco |
|---|---|---|
| 1 | Fundamentos e Mindset | Setup e mentalidade |
| 2 | Ideação e Requisitos | Da ideia ao MVP |
| 3 | Arquitetura Backend | API e banco de dados |
| 4 | Estrutura Frontend | UI e componentes |
| 5 | Prompt Engineering | Prompts e Agentes MCP |
| 6 | Testes e Qualidade | Unitários, Integração, E2E |
| 7 | Documentação | README, API Docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evolução | Escalabilidade e manutenção |
| 10 | Coding Agent | Desenvolvimento autônomo |
| 11 | Code Review Automático | Reviews com IA |
| 12 | Você está aqui → Edits e Agent Mode | Edição multi-arquivo |
| 13 | GitHub Spark | Micro-apps nativas de IA |
| 14 | Copilot Spaces | Contexto compartilhado |
| 15 | Modelos de IA | Multi-model e seleção |
| 16 | Personalização | Instruções personalizadas |
| 17 | Enterprise | Adoção organizacional |
| 18 | Extensions | Copilot Extensions |
| 19 | Segurança | Segurança e compliance |
Modos de edição do Copilot
O Copilot oferece vários modos de interação no IDE, cada um projetado para um nível diferente de autonomia e complexidade. Compreender as diferenças é essencial escolher o modo certo para cada situação.
Comparação de modos de edição
| 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 | Mudanças coordenadas em vários arquivos selecionados |
| Agent Mode | Alta | Projeto inteiro | VS Code, Visual Studio, JetBrains | Tarefas autônomas com autocura |
| Plan Mode | Controllata | Projeto inteiro | VS Code, JetBrains, Eclipse, Xcode | Planejar antes da execução |
| Coding Agent | Massima | Repositório completo | GitHub (cloud) | Task completamente autonomi (PR) |
Copilot Edits: Editing Multi-File
Edições do copiloto é a modalidade que permite descrever uma mudança na linguagem natural e aplique-a a vários arquivos de uma vez. Ao contrário das sugestões in-line que operam no contexto imediato, as edições levam leva em consideração o relacionamento entre os arquivos selecionados e gera alterações consistentes.
Fluxo de trabalho de edições do Copilot
- Selecione os arquivos: Adicione os arquivos que precisam ser editados ao contexto do Copilot
- Descreva a mudança: Explique em linguagem natural o que você deseja alcançar
- Revise as alterações: O Copilot exibe uma comparação para cada arquivo com as alterações propostas
- Iterar: Se as alterações não forem perfeitas, refine a solicitação
- Aplicar: Aceite as mudanças que você acha corretas, rejeite as outras
Como acessar as edições do Copilot
Ativação em diferentes IDEs
| IDE | Shortcut | Menu | Note |
|---|---|---|---|
| VS Code | Ctrl+Shift+I (Win/Linux) / Cmd+Shift+I (Mac) |
View > Copilot Edits | Painel dedicado na barra lateral |
| Visual Studio | Ctrl+Shift+. |
Edit > Copilot Edits | Integrado ao painel Copilot Chat |
| JetBrains | Ctrl+Shift+I |
Tools > Copilot > Edits | IntelliJ IDEA, WebStorm, PyCharm, etc. |
Exemplo prático: refatoração de vários arquivos
Vamos imaginar que queremos extrair a lógica de validação de um controlador para um middleware dedicado, atualizando simultaneamente o controlador, rotas e testes.
// 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.tsO Copilot Edits analisa os 5 arquivos e gera edições coordenadas. Vamos ver o resultado para cada arquivo.
// 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
A diferença fundamental entre o Modo de Edição e o Modo Agente está no nível de autonomia e nos tipos de ações que o Copilot pode realizar.
Differenze Operative
| Aspetto | Edit Mode | Agent Mode |
|---|---|---|
| Arquivos de trabalho | Somente arquivos explicitamente selecionados | Trova e modifica file autonomamente |
| Creazione file | Não cria novos arquivos | Pode criar novos arquivos e pastas |
| Esecuzione comandi | Não executa comandos de terminal | Pode executar comandos (npm, build, test) |
| Auto-correzione | Requer feedback manual | Rileva errori e si auto-corregge |
| Contesto | File selezionati + file aperti | Intero workspace + terminal output |
| Conferma utente | Solicitação para cada mudança | Necessário apenas para comandos de terminal |
| Velocità | Mais rápido (menos contexto) | Mais lento (análise aprofundada) |
| Rischio | Baixo (escopo limitado) | Médio (ações mais autônomas) |
Modo Agente: Desenvolvimento Autônomo no IDE
Modo Agente é o modo mais avançado do Copilot no IDE. Ao contrário do Modo de Edição, o agente pode navegar no sistema de arquivos, crie arquivos, execute comandos no terminal e, o mais importante, autocorreção quando algo dá errado.
Self-Healing: Auto-Correzione Intelligente
A característica mais distintiva do Modo Agente é o autocura. Quando o agente gera código que produz erros (compilação, linting, teste), ele analisa você mesmo a mensagem de erro e tente corrigir o problema repetindo o loop até que o sucesso ou o limite de iteração seja atingido.
Ciclo de autocura
- Geração: O agente escreve o código com base na solicitação
- Verificar: Executa a compilação ou testes para verificar a correção
- Análise de erros: Se houver um erro, ele lê a mensagem de erro completa
- Diagnóstico: Identifique a causa (tipo ausente, importação incorreta, sintaxe)
- Correção: Aplique a correção e retorne à etapa 2
- Sucesso ou escalada: Se após N iterações falhar, ele pede ajuda ao usuário
Tipos de erros tratados
Erros que o modo agente gerencia de forma autônoma
| Tipo de erro | Exemplo | Estratégia de correção | Success Rate |
|---|---|---|---|
| Erros de tipo TypeScript | Property 'x' does not exist on type 'Y' |
Adiciona propriedade ou corrige tipo | Alto (90% +) |
| Import mancanti | Cannot find module '../services/user' |
Adiciona a importação correta ou cria o arquivo | Alto (95% +) |
| Erros de sintaxe | Unexpected token, expected ';' |
Corrige a sintaxe | Alto (95% +) |
| Dipendenze mancanti | Cannot find package 'lodash' |
Esegue npm install |
Alto (90% +) |
| Test falliti | Expected 42 but received undefined |
Analise o teste e corrija a implementação | Médio (60-70%) |
| Errori runtime | TypeError: Cannot read property of undefined |
Adiciona verificações nulas ou corrige a lógica | Médio (50-70%) |
| Erros de configuração | Invalid configuration option 'x' |
Corrige o arquivo de configuração | Médio (60-80%) |
| Errori logici complessi | Resultado incorreto sem mensagem clara | Potrebbe necessitare aiuto umano | Baixo (30-40%) |
Como ativar e configurar o 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"
]
}Guarda-corpo de segurança
O Modo Agente inclui grades de proteção projetadas para evitar ações potencialmente perigosas. É crucial configurá-los corretamente, principalmente em ambientes de produção.
Proteções ativas padrão
- Confirmação necessária para cada comando do terminal
- Não é possível acessar os arquivos
.env - Não é possível executar
git pushsem confirmação - Não modifica arquivos de configuração do sistema
- Limite de iterações para evitar loops infinitos
- Não é possível instalar dependências sem confirmação
Protezioni Personalizzabili
- Lista de comandos autoaprovados
- Lista de comandos bloqueados
- Rotas protegidas (não editáveis)
- Número máximo de iterações
- Tempo limite para operação única
- Notificações para operações confidenciais
Modo de planejamento: planejamento antes da ação
Modo de planejamento é um modo que adiciona uma etapa de planejamento antes da execução. Em vez de começar imediatamente a editar arquivos, O Copilot analisa a solicitação, faz perguntas esclarecedoras se necessário e constrói um plano de execução detalhado que você pode aprovar, modificar ou rejeitar primeiro que qualquer código seja tocado.
Como ativar o modo de plano
Attivazione in Diversi IDE
| IDE | Metodo | Detalhe |
|---|---|---|
| VS Code | Shift+Tab no bate-papo do Copilot |
Alternar entre Modo Agente e Modo Plano |
| JetBrains | Ícone "Plano" na barra de ferramentas do Copilot Chat | Disponível em todos os IDEs JetBrains |
| Eclipse | Menu Copilot > Plan Mode | Integrado ao painel Copilot |
| Xcode | Menu Copilot > Plan Mode | Supporto nativo |
Workflow del Plan Mode
- Solicitar: Descreva a tarefa em linguagem natural
- Análises: O Copilot analisa a base de código e identifica arquivos relevantes
- Perguntas (opcional): Se a solicitação for ambígua, faça perguntas esclarecedoras
- Piano: Genera un piano strutturato con:
- Arquivos para criar, editar ou excluir
- Ordem das operações
- Dependências entre mudanças
- Comandos para executar
- Análise: Você revisa o plano e pode modificá-lo
- Execução: Após a aprovação, o plano é executado passo a passo
Quando usar o modo de planejamento
Cenários ideais para o modo de planejamento
| Scenario | Por que o modo de planejamento | Alternativa |
|---|---|---|
| Refactoring complesso | Você deseja verificar se o plano abrange todos os arquivos necessários | Agent Mode potrebbe saltare file |
| Nuova feature multi-componente | Você deseja validar a arquitetura antes da implementação | Edit Mode richiederebbe troppo lavoro manuale |
| Migração de biblioteca | Você deseja ver a lista completa de arquivos afetados | Agent Mode potrebbe dimenticare file |
| Tarefas com requisitos ambíguos | Esclarecer dúvidas evita trabalho desnecessário | Agent Mode potrebbe assumere e sbagliare |
| Codice critico | Você deseja controle total sobre cada mudança | Nenhum: o Modo Plano é a melhor escolha |
Exemplo prático: modo de planejamento para recursos complexos
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)
Próximas sugestões de edição é um recurso que prevê o sequência de mudanças o que você provavelmente fará após uma operação inicial. Em vez de apenas sugerir conclusão da linha atual, NES analisa o padrão de sua mudança e antecipe onde você precisará intervir em seguida.
Como funciona o NES
O mecanismo é intuitivo: faça uma alteração em um ponto do código e o Copilot identifica automaticamente outros locais no arquivo (ou projeto) que precisam ser atualizado em conformidade. Um indicador visual aparece na medianiz do editor, mostrando onde sugestões de edição estão disponíveis.
Interação com NES
| Azione | Shortcut | Effetto |
|---|---|---|
| Navigare al prossimo suggerimento | Tab |
O cursor se move para o próximo ponto de edição |
| Aceite a sugestão | Tab (quando na ponta) |
A mudança é aplicada |
| Rejeite a sugestão | Esc |
A dica desaparece |
| Vedere tutti i suggerimenti | Ícones na sarjeta do editor | Indicadores visuais mostram todas as posições |
Casos de uso de NES
Cenários onde o NES se destaca
| Scenario | Modifica Iniziale | Suggerimenti NES |
|---|---|---|
| Rinomina variabile | Rinomini userData in userProfile |
Sugere atualização em todos os pontos onde a variável é usada |
| Aggiunta parametro | Adicione um parâmetro options para uma função |
Sugere atualizar todos os chamadores e o JSDoc |
| Cambio tipo | Alterar o tipo de retorno de string a UserResponse |
Suggerisce aggiornamenti nei consumatori del valore |
| Aggiunta campo | Adicionar um campo avatar para a interface User |
Sugere atualizações em fábricas, testes, mapeamento |
| Cambio pattern | Converter um retorno de chamada em assíncrono/aguardar | Sugere conversão para todos os padrões semelhantes no arquivo |
| Aggiunta import | Você usa um novo tipo no arquivo | Suggerisce l'import statement corretto |
Exemplo: Renomear com NES
Suponha que renomeamos uma variável data in userProfile
em um arquivo com 15 ocorrências. Sem o NES, você teria que procurar e substituir manualmente ou
use refatoração IDE. Com o NES, o processo se torna perfeito.
// 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 na sarjeta
O NES usa indicadores visuais na medianiz do editor (a coluna à esquerda dos números linha) para mostrar onde sugestões estão disponíveis. No Código VS, os indicadores eles também incluem destaque de sintaxe na dica de ferramenta para facilitar a revisão visual da mudança proposta.
Vantagens do NES
- Edição 3 a 5x mais rápida para edições repetitivas
- Reduz erros parciais de renomeação
- Também funciona em arquivos cruzados
- Compreende o contexto semântico
- Não requer regex ou localizar-substituir
- Também prevê mudanças não óbvias
Limitações do NES
- Disponível apenas no VS Code (por enquanto)
- Pode sugerir alterações indesejadas
- Nem sempre encontra todas as correspondências
- A qualidade depende da clareza do padrão
- Não lida com refatorações complexas
- Requer atenção ao revisar sugestões
Editing Symbol-Aware
Para idiomas como C++ e C#, o Copilot integrou uma compreensão em nível de compilador que vai além da simples correspondência de padrões textual. O'edição com reconhecimento de símbolos analisa símbolos, tipos e dependências entre arquivos, permitindo operações de refatoração semanticamente corretas na escala do projeto.
Como funciona
Ao contrário da edição tradicional baseada em texto, a edição com reconhecimento de símbolos usa Informações do Protocolo de Servidor de Linguagem (LSP) que devem incluir:
- Declarações: Onde um símbolo é definido
- Referências: Onde um símbolo é usado
- Tipos: O tipo de cada símbolo e suas relações
- Escopos: A visibilidade de cada símbolo
- Dependências: Quais arquivos dependem de um símbolo
Suporte a linguagem com reconhecimento de símbolos
| Linguaggio | IDE | Nível de suporte | Operações Suportadas |
|---|---|---|---|
| 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) | Renomear com NES, atualizar importação |
| Java | JetBrains | Parziale | Rinomina, aggiornamento riferimenti |
| Python | VS Code / JetBrains | Base | Renomear com sugestões contextuais |
Exemplo: alteração de assinatura de método em 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
Vamos ver alguns cenários reais onde os diferentes modos de edição são combinados para resolver problemas complexos.
Exemplo 1: Adicionar um recurso com 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 crealoO Modo Agente analisa a base de código, encontra os 3 endpoints, cria o utilitário de paginação, modificar controladores e serviços, atualizar testes e documentação. Se um teste falha durante o processo, o agente analisa o erro e se autocorrige.
Exemplo 2: Use o modo de planejamento para migração
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 refactoringMelhores práticas para modos de edição
Guia de seleção de modo
| Situazione | Modalità Consigliata | Motivazione |
|---|---|---|
| Conclua uma única função | Inline Suggestions | Veloce, contesto immediato sufficiente |
| Modificare 2-3 file correlati | Edit Mode | Controllo sui file, modifica coordinata |
| Implemente um recurso completo | Agent Mode | Crea file, esegue comandi, si auto-corregge |
| Refatoração crítica com muitos arquivos | Plan Mode | Plano verificável antes da execução |
| Rinomina e aggiornamenti ripetitivi | NES | Preditivo, rápido, Tab para navegar |
| Mudança de assinatura de método em projeto grande | Symbol-Aware + NES | Comprensione semantica cross-file |
| Tarefa não urgente, base de código desconhecida | Plan Mode + Agent Mode | Planeje primeiro e depois execute com supervisão |
Troubleshooting e Problemi Comuni
Modos de edição avançados podem apresentar problemas em determinadas configurações situações. Veja como diagnosticar e corrigir os problemas mais comuns.
Problemi Comuni e Soluzioni
| Problema | Causa | Solução |
|---|---|---|
| O Modo Agente não encontra arquivos relevantes | Estrutura não convencional ou arquivos ocultos | Especifique caminhos de arquivo no prompt |
| Self-healing loop infinito | Erro estrutural que a correção não resolve | Pare, corrija manualmente o problema básico |
| Edit Mode modifica troppo | Prompt troppo ampio | Seja específico sobre o que mudar e o que NÃO mexer |
| NES não aparece | Extensão desatualizada ou recurso desativado | Aggiorna l'estensione, verifica settings |
| Plan Mode genera piano incompleto | Contexto insuficiente ou projeto muito grande | Adicione mais contexto ou limite o escopo |
| Comandi terminal falliscono | Ambiente não configurado ou dependências ausentes | Verifique se o projeto é compilado manualmente primeiro |
| Mudanças inconsistentes entre arquivos | O agente perde contexto entre as mudanças | Divida em tarefas menores ou use o Modo Plano |
Quando parar o agente
Sinais de alerta
- Mais de 3 iterações no mesmo erro
- As mudanças pioram o problema
- O agente modifica arquivos irrelevantes
- O código gerado não faz sentido lógico
- Dependências desnecessárias são adicionadas
- Os testes passam, mas a lógica está errada
Azioni Correttive
- Imprensa
Ctrl+Cparar - EUA
git diffpara ver todas as mudanças - Você faz
git stashogit checkoutrestaurar - Reformule a solicitação com mais contexto
- Divida a tarefa em subtarefas
- Mude para o modo de planejamento para ter mais controle
Resumo e próximas etapas
Os modos de edição avançados do Copilot transformam a forma como trabalhamos em nosso IDE. De sugestões inline à edição coordenada de vários arquivos, a partir de um agente autônomo da autocura ao planejamento antes da ação, cada modalidade tem seu lugar no kit de ferramentas do desenvolvedor moderno.
Pontos-Chave
- Modo de edição para alterações coordenadas em arquivos específicos: você escolhe os arquivos, o Copilot gera as alterações consistentes.
- Modo Agente para tarefas autônomas com autocura: o agente explora o projeto, executa comandos e se autocura.
- Modo de planejamento para controle total: planeje primeiro, execute depois. Ideal para tarefas complexas e código crítico.
- Próximas sugestões de edição para uma edição suave: Tab para navegar, Tab para aceitar. Renomeie e atualizações repetitivas em segundos.
- Edição com reconhecimento de símbolos para refatoração semântica: compreensão em nível de compilador para C++ e C# no Visual Studio.
Progresso da série
| # | Artigo | Status |
|---|---|---|
| 1 | Fundamentos e Mindset | Concluído |
| 2 | Ideação e Requisitos | Concluído |
| 3 | Arquitetura Backend | Concluído |
| 4 | Estrutura Frontend | Concluído |
| 5 | Prompt Engineering | Concluído |
| 6 | Testes e Qualidade | Concluído |
| 7 | Documentação | Concluído |
| 8 | Deploy e DevOps | Concluído |
| 9 | Evolução | Concluído |
| 10 | Coding Agent | Concluído |
| 11 | Code Review Automático | Concluído |
| 12 | Copilot Edits e Agent Mode | Concluído |
| 13 | GitHub Spark | Prossimo |
| 14 | Copilot Spaces | In arrivo |
| 15 | Modelos de IA | In arrivo |
| 16 | Personalização | In arrivo |
| 17 | Enterprise | In arrivo |
| 18 | Extensions | In arrivo |
| 19 | Segurança | In arrivo |
No próximo artigo exploraremos GitHub Spark, a plataforma para crie microaplicativos nativos de IA diretamente do navegador usando a linguagem natural, sem a necessidade de escrever código ou configurar infraestrutura.