Copilot Edits und Agent Mode: Multi-File-Editing und autonome Entwicklung in der IDE
Bisher haben wir Copilot als Inline-Vorschlagsassistent und als Agent untersucht Selbständige Arbeit auf GitHub. Es gibt jedoch ein äußerst mächtiges Zwischengebiet: Copilot-Änderungen e Agentenmodus, die die Fähigkeiten mit sich bringen Bearbeitung mehrerer Dateien und eigenständige Ausführung direkt in Ihrer IDE. Anstatt zu bearbeiten Sie können eine Änderung, die sich auf mehrere Dateien auswirkt, einzeln beschreiben und verlassen dass Copilot alle Änderungen konsequent koordiniert.
In diesem Artikel werden wir die verfügbaren erweiterten Bearbeitungsmodi im Detail untersuchen: Bearbeitungsmodus für die geführte Bearbeitung mehrerer Dateien, Agentenmodus für autonome Ausführung mit Selbstheilung, Planmodus zunächst für die Planung der Aktion, z Nächste Bearbeitungsvorschläge (NES) für einen prädiktiven Bearbeitungsablauf und flüssig.
Übersicht der Serie
| # | Artikel | Schwerpunkt |
|---|---|---|
| 1 | Grundlagen und Mindset | Setup und Denkweise |
| 2 | Ideenfindung und Anforderungen | Von der Idee zum MVP |
| 3 | Backend-Architektur | API und Datenbank |
| 4 | Frontend-Struktur | UI und Komponenten |
| 5 | Prompt Engineering | Prompts und MCP-Agenten |
| 6 | Testing und Qualität | Unit, Integration, E2E |
| 7 | Dokumentation | README, API Docs, ADR |
| 8 | Deploy und DevOps | Docker, CI/CD |
| 9 | Evolution | Skalierbarkeit und Wartung |
| 10 | Coding Agent | Autonome Entwicklung |
| 11 | Automatisches Code Review | KI-gestützte Reviews |
| 12 | Aktuell → Edits e Agent Mode | Multi-File-Editing |
| 13 | GitHub Spark | KI-native Micro-Apps |
| 14 | Copilot Spaces | Geteilter Kontext |
| 15 | KI-Modelle | Multi-Model und Auswahl |
| 16 | Personalisierung | Benutzerdefinierte Anweisungen |
| 17 | Enterprise | Organisatorische Adoption |
| 18 | Extensions | Copilot Extensions |
| 19 | Sicherheit | Sicherheit und Compliance |
Bearbeitungsmodi des Copiloten
Copilot bietet in der IDE mehrere Interaktionsmodi, die jeweils für Folgendes konzipiert sind ein anderes Maß an Autonomie und Komplexität. Die Unterschiede zu verstehen ist Es ist wichtig, für jede Situation den richtigen Modus zu wählen.
Vergleich der Bearbeitungsmodi
| 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 | Koordinierte Änderungen über mehrere ausgewählte Dateien hinweg |
| Agent Mode | Alta | Ganzes Projekt | VS Code, Visual Studio, JetBrains | Autonome Aufgaben mit Selbstheilung |
| Plan Mode | Controllata | Ganzes Projekt | VS Code, JetBrains, Eclipse, Xcode | Planung vor der Ausführung |
| Coding Agent | Massima | Vollständiges Repository | GitHub (cloud) | Task completamente autonomi (PR) |
Copilot Edits: Editing Multi-File
Copilot-Änderungen Es ist die Modalität, die es Ihnen ermöglicht, zu beschreiben eine Änderung der natürlichen Sprache und wenden Sie sie auf mehrere Dateien gleichzeitig an. Im Gegensatz zu Inline-Vorschlägen, die auf dem unmittelbaren Kontext basieren, werden Änderungen vorgenommen berücksichtigt die Beziehung zwischen den ausgewählten Dateien und generiert konsistente Änderungen.
Copilot-Bearbeitungsworkflow
- Dateien auswählen: Fügen Sie die zu bearbeitenden Dateien zum Copilot-Kontext hinzu
- Beschreiben Sie die Änderung: Erklären Sie in natürlicher Sprache, was Sie erreichen möchten
- Überprüfungsänderungen: Copilot zeigt für jede Datei einen Unterschied mit den vorgeschlagenen Änderungen an
- Iterieren: Wenn die Änderungen nicht perfekt sind, verfeinern Sie die Anfrage
- Anwenden: Akzeptieren Sie die Änderungen, die Sie für richtig halten, und lehnen Sie die anderen ab
So greifen Sie auf Copilot-Bearbeitungen zu
Aktivierung in verschiedenen IDEs
| IDE | Shortcut | Menu | Note |
|---|---|---|---|
| VS Code | Ctrl+Shift+I (Win/Linux) / Cmd+Shift+I (Mac) |
View > Copilot Edits | Spezielles Panel in der Seitenleiste |
| Visual Studio | Ctrl+Shift+. |
Edit > Copilot Edits | Integriert in das Copilot-Chat-Panel |
| JetBrains | Ctrl+Shift+I |
Tools > Copilot > Edits | IntelliJ IDEA, WebStorm, PyCharm, etc. |
Praxisbeispiel: Multi-File-Refactoring
Stellen wir uns vor, wir möchten die Validierungslogik von einem Controller in einen extrahieren dedizierte Middleware, die gleichzeitig den Controller, Routen und Tests aktualisiert.
// 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 analysiert die 5 Dateien und generiert koordinierte Bearbeitungen. Schauen wir uns das Ergebnis an für jede Datei.
// 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
Der grundlegende Unterschied zwischen dem Bearbeitungsmodus und dem Agentenmodus liegt im Grad der Autonomie und in den Arten von Aktionen, die Copilot ausführen kann.
Differenze Operative
| Aspetto | Edit Mode | Agent Mode |
|---|---|---|
| Arbeitsdateien | Nur explizit ausgewählte Dateien | Trova e modifica file autonomamente |
| Creazione file | Erstellt keine neuen Dateien | Es kann neue Dateien und Ordner erstellen |
| Esecuzione comandi | Führt keine Terminalbefehle aus | Kann Befehle ausführen (npm, build, test) |
| Auto-correzione | Erfordert manuelles Feedback | Rileva errori e si auto-corregge |
| Contesto | File selezionati + file aperti | Intero workspace + terminal output |
| Conferma utente | Bitte um jede Änderung | Nur für Terminalbefehle erforderlich |
| Velocità | Schneller (weniger Kontext) | Langsamer (eingehende Analyse) |
| Rischio | Niedrig (begrenzter Umfang) | Mittel (mehr autonome Aktionen) |
Agentenmodus: Autonome Entwicklung in der IDE
Agentenmodus ist der fortschrittlichste Modus von Copilot in der IDE. Im Gegensatz zum Bearbeitungsmodus kann der Agent das Dateisystem durchsuchen, Dateien erstellen, Befehle im Terminal ausführen und vor allem: Selbstkorrektur wenn etwas schief geht.
Self-Healing: Auto-Correzione Intelligente
Das herausragendste Merkmal des Agentenmodus ist Selbstheilung. Wenn der Agent fehlererzeugenden Code generiert (Kompilierung, Linting, Testen), analysiert er ihn Beheben Sie die Fehlermeldung selbst und versuchen Sie, das Problem durch Wiederholen zu beheben Schleife bis zum Erfolg oder bis das Iterationslimit erreicht ist.
Selbstheilungszyklus
- Generation: Der Agent schreibt Code basierend auf der Anfrage
- Verifizieren: Führt den Build oder Tests aus, um die Richtigkeit zu überprüfen
- Fehleranalyse: Wenn ein Fehler vorliegt, wird die vollständige Fehlermeldung gelesen
- Diagnose: Identifizieren Sie die Ursache (fehlender Typ, falscher Import, falsche Syntax)
- Korrektur: Wenden Sie den Fix an und kehren Sie zu Schritt 2 zurück
- Erfolg oder Eskalation: Wenn es nach N Iterationen fehlschlägt, wird der Benutzer um Hilfe gebeten
Arten der behandelten Fehler
Fehler, die der Agent-Modus autonom verwaltet
| Art des Fehlers | Beispiel | Strategie festlegen | Success Rate |
|---|---|---|---|
| TypeScript-Typfehler | Property 'x' does not exist on type 'Y' |
Fügt einen Eigenschafts- oder Fixtyp hinzu | Hoch (90 %+) |
| Import mancanti | Cannot find module '../services/user' |
Fügt den richtigen Import hinzu oder erstellt die Datei | Hoch (95 %+) |
| Syntaxfehler | Unexpected token, expected ';' |
Korrigiert die Syntax | Hoch (95 %+) |
| Dipendenze mancanti | Cannot find package 'lodash' |
Esegue npm install |
Hoch (90 %+) |
| Test falliti | Expected 42 but received undefined |
Analysieren Sie den Test und korrigieren Sie die Implementierung | Mittel (60–70 %) |
| Errori runtime | TypeError: Cannot read property of undefined |
Fügt Nullprüfungen hinzu oder korrigiert die Logik | Mittel (50–70 %) |
| Konfigurationsfehler | Invalid configuration option 'x' |
Korrigiert die Konfigurationsdatei | Mittel (60–80 %) |
| Errori logici complessi | Falsches Ergebnis ohne klare Botschaft | Potrebbe necessitare aiuto umano | Niedrig (30–40 %) |
So aktivieren und konfigurieren Sie den Agentenmodus
// .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"
]
}Sicherheitsgeländer
Der Agentenmodus umfasst Leitplanken, die potenziell gefährliche Aktionen verhindern sollen. Insbesondere in Produktionsumgebungen ist es von entscheidender Bedeutung, sie richtig zu konfigurieren.
Standardmäßiger aktiver Schutz
- Für jeden Terminalbefehl ist eine Bestätigung erforderlich
- Auf Dateien kann nicht zugegriffen werden
.env - Kann nicht ausgeführt werden
git pushohne Bestätigung - Systemkonfigurationsdateien werden nicht geändert
- Begrenzung der Iterationen, um Endlosschleifen zu vermeiden
- Abhängigkeiten können nicht ohne Bestätigung installiert werden
Protezioni Personalizzabili
- Liste der selbst genehmigten Befehle
- Liste blockierter Befehle
- Geschützte Routen (nicht editierbar)
- Maximale Anzahl von Iterationen
- Timeout für einzelne Operation
- Benachrichtigungen für sensible Vorgänge
Planmodus: Planung vor der Aktion
Planmodus ist ein Modus, der einen Schritt hinzufügt Planung vor der Ausführung. Anstatt sofort mit der Bearbeitung von Dateien zu beginnen, Copilot analysiert die Anfrage, stellt bei Bedarf klärende Fragen und baut auf einen detaillierten Ausführungsplan, den Sie zunächst genehmigen, ändern oder ablehnen können dass irgendein Code berührt wird.
So aktivieren Sie den Planmodus
Attivazione in Diversi IDE
| IDE | Metodo | Detail |
|---|---|---|
| VS Code | Shift+Tab im Copilot-Chat |
Wechseln Sie zwischen Agentenmodus und Planmodus |
| JetBrains | Symbol „Plan“ in der Copilot-Chat-Symbolleiste | Verfügbar in allen JetBrains-IDEs |
| Eclipse | Menu Copilot > Plan Mode | Integriert in das Copilot-Panel |
| Xcode | Menu Copilot > Plan Mode | Supporto nativo |
Workflow del Plan Mode
- Anfrage: Beschreiben Sie die Aufgabe in natürlicher Sprache
- Analysen: Copilot analysiert die Codebasis und identifiziert relevante Dateien
- Fragen (optional): Wenn die Anfrage nicht eindeutig ist, stellen Sie klärende Fragen
- Piano: Genera un piano strutturato con:
- Dateien zum Erstellen, Bearbeiten oder Löschen
- Reihenfolge der Operationen
- Abhängigkeiten zwischen Änderungen
- Befehle zur Ausführung
- Rezension: Sie überprüfen den Plan und können ihn ändern
- Ausführung: Nach der Genehmigung wird der Plan Schritt für Schritt umgesetzt
Wann Sie den Planmodus verwenden sollten
Ideale Szenarien für den Planmodus
| Scenario | Warum Planmodus | Alternativa |
|---|---|---|
| Refactoring complesso | Sie möchten sicherstellen, dass der Plan alle erforderlichen Dateien umfasst | Agent Mode potrebbe saltare file |
| Nuova feature multi-componente | Sie möchten die Architektur vor der Implementierung validieren | Edit Mode richiederebbe troppo lavoro manuale |
| Bibliotheksmigration | Sie möchten die vollständige Liste der betroffenen Dateien sehen | Agent Mode potrebbe dimenticare file |
| Aufgaben mit unklaren Anforderungen | Durch die Klärung von Fragen wird unnötiger Aufwand vermieden | Agent Mode potrebbe assumere e sbagliare |
| Codice critico | Sie möchten die vollständige Kontrolle über jede Änderung | Keine: Der Planmodus ist die beste Wahl |
Praxisbeispiel: Planmodus für komplexe Features
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)
Weiter Vorschläge bearbeiten es ist eine Funktion, die vorhersagt die Reihenfolge der Änderungen was Sie wahrscheinlich nach einer Operation tun werden initial. Anstatt nur die Fertigstellung der aktuellen Linie vorzuschlagen, analysiert NES sie Erkennen Sie das Muster Ihrer Veränderung und antizipieren Sie, wo Sie als nächstes eingreifen müssen.
Wie NES funktioniert
Der Mechanismus ist intuitiv: Nehmen Sie eine Änderung an einer Stelle im Code vor und Copilot identifiziert automatisch andere Stellen in der Datei (oder im Projekt), die vorhanden sein müssen entsprechend aktualisiert. Im Randbereich des Editors wird eine visuelle Anzeige angezeigt. Zeigt an, wo Bearbeitungsvorschläge verfügbar sind.
Interaktion mit NES
| Azione | Shortcut | Effetto |
|---|---|---|
| Navigare al prossimo suggerimento | Tab |
Der Cursor bewegt sich zum nächsten Bearbeitungspunkt |
| Akzeptieren Sie den Vorschlag | Tab (wenn am Trinkgeld) |
Die Änderung wird übernommen |
| Lehnen Sie den Vorschlag ab | Esc |
Der Hinweis verschwindet |
| Vedere tutti i suggerimenti | Symbole im Randbereich des Editors | Visuelle Indikatoren zeigen alle Positionen an |
NES-Anwendungsfälle
Szenarien, in denen NES herausragend ist
| Scenario | Modifica Iniziale | Suggerimenti NES |
|---|---|---|
| Rinomina variabile | Rinomini userData in userProfile |
Schlägt eine Aktualisierung an allen Stellen vor, an denen die Variable verwendet wird |
| Aggiunta parametro | Fügen Sie einen Parameter hinzu options zu einer Funktion |
Es wird empfohlen, alle Anrufer und das JSDoc zu aktualisieren |
| Cambio tipo | Ändern Sie die Art der Rückgabe von string a UserResponse |
Suggerisce aggiornamenti nei consumatori del valore |
| Aggiunta campo | Fügen Sie ein Feld hinzu avatar zur Schnittstelle User |
Schlägt Aktualisierungen in Fabriken, Tests und Kartierungen vor |
| Cambio pattern | Konvertieren Sie einen Rückruf in async/await | Schlägt die Konvertierung in alle ähnlichen Muster in der Datei vor |
| Aggiunta import | Sie verwenden einen neuen Typ in der Datei | Suggerisce l'import statement corretto |
Beispiel: Mit NES umbenennen
Angenommen, wir benennen eine Variable um data in userProfile
in einer Datei mit 15 Vorkommen. Ohne NES müssten Sie manuell suchen und ersetzen oder
Verwenden Sie IDE-Refactoring. Mit NES wird der Prozess nahtlos.
// 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 TabIndikatoren in der Dachrinne
NES verwendet visuelle Indikatoren im Randbereich des Editors (die Spalte links von den Zahlen). Zeile), um anzuzeigen, wo Vorschläge verfügbar sind. In VS Code die Indikatoren Sie enthalten außerdem eine Syntaxhervorhebung im Tooltip, um die visuelle Überprüfung zu erleichtern der vorgeschlagenen Änderung.
Vorteile von NES
- 3-5x schnellere Bearbeitung für sich wiederholende Bearbeitungen
- Reduziert Fehler bei teilweiser Umbenennung
- Es funktioniert auch dateiübergreifend
- Versteht semantischen Kontext
- Erfordert weder Regex noch Suchen-Ersetzen
- Es prognostiziert auch nicht offensichtliche Änderungen
NES-Einschränkungen
- Nur in VS Code verfügbar (vorerst)
- Es könnte auf unerwünschte Änderungen hinweisen
- Es werden nicht immer alle Übereinstimmungen gefunden
- Die Qualität hängt von der Klarheit des Musters ab
- Es werden keine komplexen Refactorings durchgeführt
- Erfordert Aufmerksamkeit bei der Überprüfung von Vorschlägen
Editing Symbol-Aware
Für Sprachen wie C++ e C#, Copilot hat integriert ein Verständnis auf Compiler-Ebene, das über den einfachen Mustervergleich hinausgeht textlich. DER'symbolbewusste Bearbeitung analysiert Symbole, Typen und Abhängigkeiten zwischen Dateien, was semantisch korrekte Refactoring-Vorgänge auf Projektebene ermöglicht.
Wie es funktioniert
Im Gegensatz zur herkömmlichen textbasierten Bearbeitung verwendet die symbolbewusste Bearbeitung Zu den LSP-Informationen (Language Server Protocol) gehören:
- Aussagen: Wo ein Symbol definiert ist
- Referenzen: Wo ein Symbol verwendet wird
- Typen: Der Typ jedes Symbols und seine Beziehungen
- Geltungsbereiche: Die Sichtbarkeit jedes Symbols
- Abhängigkeiten: Welche Dateien hängen von einem Symbol ab
Symbolbasierte Sprachunterstützung
| Linguaggio | IDE | Unterstützungsstufe | Unterstützte Operationen |
|---|---|---|---|
| C++ | Visual Studio 2026 | Vollständig | Rinomina, cambio firma, estrai metodo, sposta tipo |
| C# | Visual Studio 2026 | Vollständig | Rinomina, cambio firma, estrai interfaccia, genera implementazione |
| TypeScript | VS Code | Parziale (via LSP) | Mit NES umbenennen, Import aktualisieren |
| Java | JetBrains | Parziale | Rinomina, aggiornamento riferimenti |
| Python | VS Code / JetBrains | Base | Mit kontextbezogenen Vorschlägen umbenennen |
Beispiel: Änderung der Methodensignatur in 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
Sehen wir uns einige reale Szenarien an, in denen die verschiedenen Bearbeitungsmodi kombiniert werden komplexe Probleme zu lösen.
Beispiel 1: Fügen Sie eine Funktion mit Agent-Modus hinzu
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 crealoDer Agent-Modus analysiert die Codebasis, findet die drei Endpunkte, erstellt das Paging-Dienstprogramm, Ändern Sie Controller und Dienste, aktualisieren Sie Tests und Dokumentation. Wenn ein Test Wenn während des Vorgangs ein Fehler auftritt, analysiert der Agent den Fehler und korrigiert ihn selbst.
Beispiel 2: Planmodus für die Migration verwenden
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 refactoringBest Practices für Bearbeitungsmodi
Leitfaden zur Modusauswahl
| Situazione | Modalità Consigliata | Motivazione |
|---|---|---|
| Vervollständigen Sie eine einzelne Funktion | Inline Suggestions | Veloce, contesto immediato sufficiente |
| Modificare 2-3 file correlati | Edit Mode | Controllo sui file, modifica coordinata |
| Implementieren Sie eine vollständige Funktion | Agent Mode | Crea file, esegue comandi, si auto-corregge |
| Kritisches Refactoring mit vielen Dateien | Plan Mode | Plan vor der Ausführung überprüfbar |
| Rinomina e aggiornamenti ripetitivi | NES | Vorausschauend, schnell, Tab zum Navigieren |
| Änderung der Methodensignatur in einem großen Projekt | Symbol-Aware + NES | Comprensione semantica cross-file |
| Nicht dringende Aufgabe, unbekannte Codebasis | Plan Mode + Agent Mode | Zuerst planen, dann unter Aufsicht umsetzen |
Troubleshooting e Problemi Comuni
Erweiterte Bearbeitungsmodi können in bestimmten Einstellungen zu Problemen führen Situationen. Hier erfahren Sie, wie Sie die häufigsten Probleme diagnostizieren und beheben.
Problemi Comuni e Soluzioni
| Problem | Causa | Lösung |
|---|---|---|
| Der Agentenmodus findet keine relevanten Dateien | Unkonventionelle Struktur oder versteckte Dateien | Geben Sie in der Eingabeaufforderung Dateipfade an |
| Self-healing loop infinito | Struktureller Fehler, der durch den Fix nicht behoben wird | Stoppen Sie, beheben Sie das Grundproblem manuell |
| Edit Mode modifica troppo | Prompt troppo ampio | Legen Sie genau fest, was Sie ändern und was Sie NICHT anfassen sollten |
| NES wird nicht angezeigt | Erweiterung veraltet oder Funktion deaktiviert | Aggiorna l'estensione, verifica settings |
| Plan Mode genera piano incompleto | Unzureichender Kontext oder zu großes Projekt | Fügen Sie mehr Kontext hinzu oder schränken Sie den Umfang ein |
| Comandi terminal falliscono | Umgebung nicht konfiguriert oder fehlende Abhängigkeiten | Überprüfen Sie zunächst, ob das Projekt manuell kompiliert wird |
| Inkonsistente Änderungen zwischen Dateien | Der Agent verliert zwischen Änderungen den Kontext | Unterteilen Sie die Aufgaben in kleinere Aufgaben oder nutzen Sie den Planmodus |
Wann muss der Agent gestoppt werden?
Warnzeichen
- Mehr als 3 Iterationen mit demselben Fehler
- Die Änderungen verschlimmern das Problem
- Der Agent ändert irrelevante Dateien
- Der generierte Code ergibt keinen logischen Sinn
- Unnötige Abhängigkeiten werden hinzugefügt
- Die Tests bestehen, aber die Logik ist falsch
Azioni Correttive
- Drücken
Ctrl+Caufzuhören - USA
git diffum alle Änderungen zu sehen - Du tust
git stashogit checkoutwiederherstellen - Formulieren Sie die Anfrage mit mehr Kontext um
- Teilen Sie die Aufgabe in Teilaufgaben auf
- Wechseln Sie in den Planmodus für mehr Kontrolle
Zusammenfassung und Nächste Schritte
Die erweiterten Bearbeitungsmodi von Copilot verändern unsere Arbeitsweise in unserer IDE. Von Inline-Vorschlägen bis zur koordinierten Bearbeitung mehrerer Dateien durch einen autonomen Agenten Von der Selbstheilung bis zur Planung vor dem Handeln hat jede Modalität ihren Platz im modernen Entwickler-Toolkit.
Wichtige Punkte
- Bearbeitungsmodus für koordinierte Änderungen an bestimmten Dateien: Sie wählen die Dateien aus, Copilot generiert die konsistenten Änderungen.
- Agentenmodus für autonome Aufgaben mit Selbstheilung: Der Agent erkundet das Projekt, führt Befehle aus und heilt sich selbst.
- Planmodus Für die vollständige Kontrolle: zuerst planen, später ausführen. Ideal für komplexe Aufgaben und kritischen Code.
- Weiter Vorschläge bearbeiten Für eine reibungslose Bearbeitung: Tab zum Navigieren, Tab zum Akzeptieren. Umbenennen und wiederholte Aktualisierungen in Sekundenschnelle.
- Symbolbasierte Bearbeitung für semantisches Refactoring: Verständnis auf Compilerebene für C++ und C# in Visual Studio.
Serienfortschritt
| # | Artikel | Status |
|---|---|---|
| 1 | Grundlagen und Mindset | Abgeschlossen |
| 2 | Ideenfindung und Anforderungen | Abgeschlossen |
| 3 | Backend-Architektur | Abgeschlossen |
| 4 | Frontend-Struktur | Abgeschlossen |
| 5 | Prompt Engineering | Abgeschlossen |
| 6 | Testing und Qualität | Abgeschlossen |
| 7 | Dokumentation | Abgeschlossen |
| 8 | Deploy und DevOps | Abgeschlossen |
| 9 | Evolution | Abgeschlossen |
| 10 | Coding Agent | Abgeschlossen |
| 11 | Automatisches Code Review | Abgeschlossen |
| 12 | Copilot Edits und Agent Mode | Abgeschlossen |
| 13 | GitHub Spark | Prossimo |
| 14 | Copilot Spaces | In arrivo |
| 15 | KI-Modelle | In arrivo |
| 16 | Personalisierung | In arrivo |
| 17 | Enterprise | In arrivo |
| 18 | Extensions | In arrivo |
| 19 | Sicherheit | In arrivo |
Im nächsten Artikel werden wir es untersuchen GitHub Spark, die Plattform für Erstellen Sie mithilfe der Sprache KI-native Mikroanwendungen direkt aus dem Browser natürlich, ohne dass Code geschrieben oder die Infrastruktur konfiguriert werden muss.