Copilot Edits and Agent Mode: Multi-File Editing and Autonomous Development in the IDE
So far we have explored Copilot as an assistant for inline suggestions and as an autonomous agent working on GitHub. However, there is an extremely powerful middle ground: Copilot Edits and Agent Mode, which bring multi-file editing and autonomous execution capabilities directly into your IDE. Instead of modifying one file at a time, you can describe a change that involves multiple files and let Copilot coordinate all the modifications consistently.
In this article we will explore in detail the advanced editing modes available: Edit Mode for guided multi-file changes, Agent Mode for autonomous execution with self-healing, Plan Mode for planning before action, and Next Edit Suggestions (NES) for a predictive and fluid editing flow.
Series Overview
| # | Article | Focus |
|---|---|---|
| 1 | Foundation and Mindset | Setup and mindset |
| 2 | Ideation and Requirements | From idea to MVP |
| 3 | Backend Architecture | API and database |
| 4 | Frontend Structure | UI and components |
| 5 | Prompt Engineering | Prompts and MCP Agents |
| 6 | Testing and Quality | Unit, integration, E2E |
| 7 | Documentation | README, API docs, ADR |
| 8 | Deploy and DevOps | Docker, CI/CD |
| 9 | Evolution | Scalability and maintenance |
| 10 | Coding Agent | Autonomous development |
| 11 | Code Review | AI-powered review |
| 12 | You are here → Copilot Edits and Agent Mode | Multi-file editing |
| 13 | GitHub Spark | AI-native micro-apps |
| 14 | Copilot Spaces and Memory | Shared context |
| 15 | AI Models | Multi-model and selection |
| 16 | Customization | Custom instructions |
| 17 | Enterprise and Business | Organizational adoption |
| 18 | Extensions and Marketplace | Copilot Extensions |
| 19 | Security | Security and compliance |
Copilot Editing Modes
Copilot offers different interaction modes in the IDE, each designed for a different level of autonomy and complexity. Understanding the differences is essential for choosing the right mode for each situation.
Editing Modes Comparison
| Mode | Autonomy | Scope | Supported IDEs | Use Case |
|---|---|---|---|---|
| Inline Suggestions | Minimal | Current line/block | All | Real-time code completion |
| Edit Mode | Medium | Specified files | VS Code, Visual Studio, JetBrains | Coordinated changes across selected files |
| Agent Mode | High | Entire project | VS Code, Visual Studio, JetBrains | Autonomous tasks with self-healing |
| Plan Mode | Controlled | Entire project | VS Code, JetBrains, Eclipse, Xcode | Planning before execution |
| Coding Agent | Maximum | Full repository | GitHub (cloud) | Fully autonomous tasks (PR) |
Copilot Edits: Multi-File Editing
Copilot Edits is the mode that allows you to describe a change in natural language and apply it simultaneously to multiple files. Unlike inline suggestions that operate on the immediate context, Edits takes into account the relationships between selected files and generates consistent changes.
Copilot Edits Workflow
- Select the files: Add to the Copilot context the files that need to be modified
- Describe the change: Explain in natural language what you want to achieve
- Review the changes: Copilot shows a diff for each file with the proposed modifications
- Iterate: If the changes are not perfect, refine the request
- Apply: Accept the changes you consider correct, reject the others
How to Access Copilot Edits
Activation in Different IDEs
| IDE | Shortcut | Menu | Notes |
|---|---|---|---|
| VS Code | Ctrl+Shift+I (Win/Linux) / Cmd+Shift+I (Mac) |
View > Copilot Edits | Dedicated panel in the sidebar |
| Visual Studio | Ctrl+Shift+. |
Edit > Copilot Edits | Integrated in the Copilot Chat panel |
| JetBrains | Ctrl+Shift+I |
Tools > Copilot > Edits | IntelliJ IDEA, WebStorm, PyCharm, etc. |
Practical Example: Multi-File Refactoring
Imagine we want to extract the validation logic from a controller into a dedicated middleware, simultaneously updating the controller, routes, and tests.
// File: src/controllers/user.controller.ts (BEFORE)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';
export class UserController {{ '{' }}
constructor(private userService: UserService) {{ '{' }}}
async createUser(req: Request, res: Response) {{ '{' }}
// Inline validation in the 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);
}
}Extract all the validation logic from UserController into a
dedicated middleware. Create:
1. A file src/middleware/validation.middleware.ts with reusable
validation functions using class-validator
2. A file src/dto/user.dto.ts with DTO classes for CreateUser and UpdateUser
3. Update the controller to remove inline validation
4. Update src/routes/user.routes.ts to use the validation middleware
5. Update the tests in tests/controllers/user.controller.test.tsCopilot Edits analyzes the 5 files and generates coordinated changes. Let's see the result for each file.
// File: src/dto/user.dto.ts (GENERATED by 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 (GENERATED)
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 (AFTER - without validation)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';
export class UserController {{ '{' }}
constructor(private userService: UserService) {{ '{' }}}
async createUser(req: Request, res: Response) {{ '{' }}
// Validation is handled by the 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
The fundamental difference between Edit Mode and Agent Mode lies in the level of autonomy and the type of actions that Copilot can perform.
Operational Differences
| Aspect | Edit Mode | Agent Mode |
|---|---|---|
| Working files | Only explicitly selected files | Finds and modifies files autonomously |
| File creation | Does not create new files | Can create new files and folders |
| Command execution | Does not run terminal commands | Can run commands (npm, build, test) |
| Auto-correction | Requires manual feedback | Detects errors and self-corrects |
| Context | Selected files + open files | Entire workspace + terminal output |
| User confirmation | Required for every change | Required only for terminal commands |
| Speed | Faster (less context) | Slower (deeper analysis) |
| Risk | Low (limited scope) | Medium (more autonomous actions) |
Agent Mode: Autonomous Development in the IDE
Agent Mode is the most advanced Copilot mode in the IDE. Unlike Edit Mode, the agent can navigate the filesystem, create files, run commands in the terminal, and most importantly, self-correct when something goes wrong.
Self-Healing: Intelligent Auto-Correction
The most distinctive feature of Agent Mode is self-healing. When the agent generates code that produces errors (compilation, lint, test), it autonomously analyzes the error message and tries to fix the problem, repeating the cycle until success or reaching the iteration limit.
Self-Healing Cycle
- Generation: The agent writes the code based on the request
- Verification: Runs the build or tests to verify correctness
- Error analysis: If there is an error, reads the complete error message
- Diagnosis: Identifies the cause (missing type, wrong import, syntax)
- Correction: Applies the fix and returns to step 2
- Success or escalation: If after N iterations it fails, asks the user for help
Types of Errors Handled
Errors That Agent Mode Handles Autonomously
| Error Type | Example | Fix Strategy | Success Rate |
|---|---|---|---|
| TypeScript type errors | Property 'x' does not exist on type 'Y' |
Adds the property or corrects the type | High (90%+) |
| Missing imports | Cannot find module '../services/user' |
Adds the correct import or creates the file | High (95%+) |
| Syntax errors | Unexpected token, expected ';' |
Corrects the syntax | High (95%+) |
| Missing dependencies | Cannot find package 'lodash' |
Runs npm install |
High (90%+) |
| Failed tests | Expected 42 but received undefined |
Analyzes the test and corrects the implementation | Medium (60-70%) |
| Runtime errors | TypeError: Cannot read property of undefined |
Adds null check or corrects the logic | Medium (50-70%) |
| Configuration errors | Invalid configuration option 'x' |
Corrects the configuration file | Medium (60-80%) |
| Complex logic errors | Wrong result without a clear message | May need human assistance | Low (30-40%) |
How to Enable and Configure Agent Mode
// .vscode/settings.json
{{ '{' }}
// Enable Agent Mode (enabled by default in recent versions)
"github.copilot.chat.agent.enabled": true,
// Configure which commands the agent can run without confirmation
"github.copilot.chat.agent.autoApprove": {{ '{' }}
// Commands that do not require confirmation
"allowedCommands": [
"npm test",
"npm run lint",
"npm run build",
"npx tsc --noEmit"
],
// Commands that always require confirmation
"blockedCommands": [
"rm",
"git push",
"npm publish",
"docker"
]
},
// Iteration limit for self-healing
"github.copilot.chat.agent.maxIterations": 5,
// Files and folders the agent cannot modify
"github.copilot.chat.agent.protectedPaths": [
".env",
".env.*",
"secrets/",
"*.key",
"*.pem"
]
}Security Guardrails
Agent Mode includes guardrails designed to prevent potentially dangerous actions. It is essential to configure them correctly, especially in production environments.
Active Protections by Default
- Confirmation required for every terminal command
- Cannot access
.envfiles - Cannot run
git pushwithout confirmation - Does not modify system configuration files
- Iteration limit to prevent infinite loops
- Cannot install dependencies without confirmation
Customizable Protections
- List of auto-approved commands
- List of blocked commands
- Protected paths (non-modifiable)
- Maximum number of iterations
- Timeout for individual operations
- Notifications for sensitive operations
Plan Mode: Planning Before Action
Plan Mode is a mode that adds a planning step before execution. Instead of immediately starting to modify files, Copilot analyzes the request, asks clarifying questions if necessary, and builds a detailed execution plan that you can approve, modify, or reject before any code is touched.
How to Activate Plan Mode
Activation in Different IDEs
| IDE | Method | Detail |
|---|---|---|
| VS Code | Shift+Tab in Copilot chat |
Toggles between Agent Mode and Plan Mode |
| JetBrains | "Plan" icon in the Copilot Chat toolbar | Available in all JetBrains IDEs |
| Eclipse | Copilot menu > Plan Mode | Integrated in the Copilot panel |
| Xcode | Copilot menu > Plan Mode | Native support |
Plan Mode Workflow
- Request: Describe the task in natural language
- Analysis: Copilot analyzes the codebase and identifies relevant files
- Questions (optional): If the request is ambiguous, it asks clarifying questions
- Plan: Generates a structured plan with:
- Files to create, modify, or delete
- Order of operations
- Dependencies between changes
- Commands to execute
- Review: You examine the plan and can modify it
- Execution: After approval, the plan is executed step by step
When to Use Plan Mode
Ideal Scenarios for Plan Mode
| Scenario | Why Plan Mode | Alternative |
|---|---|---|
| Complex refactoring | You want to verify the plan touches all necessary files | Agent Mode might skip files |
| New multi-component feature | You want to validate the architecture before implementation | Edit Mode would require too much manual work |
| Library migration | You want to see the complete list of impacted files | Agent Mode might forget files |
| Task with ambiguous requirements | Clarifying questions avoid unnecessary work | Agent Mode might assume and get it wrong |
| Critical code | You want total control over every change | None: Plan Mode is the best choice |
Practical Example: Plan Mode for a Complex Feature
Add an in-app notification system to the project.
Requirements:
- Notification model with title, message, type, read/unread
- Service for notification CRUD
- Controller with REST endpoints
- Angular component with bell icon and counter badge
- WebSocket for real-time updates
- Tests for service and controller# Implementation Plan: Notification System
## Clarifying Questions
1. Do you want to persist notifications in a database or only in memory?
-> Answer: Database (PostgreSQL with Prisma)
2. Should notifications be per specific user or broadcast?
-> Answer: Per user, with broadcast capability
3. Which WebSocket library do you prefer?
-> Answer: Socket.io (already in dependencies)
## Files to Create (5)
1. src/models/notification.model.ts - Prisma schema and types
2. src/services/notification.service.ts - Business logic
3. src/controllers/notification.controller.ts - REST endpoints
4. src/gateways/notification.gateway.ts - WebSocket gateway
5. frontend/src/app/components/notification-bell/ - Angular component
## Files to Modify (4)
1. prisma/schema.prisma - Add Notification model
2. src/routes/index.ts - Register notification routes
3. src/app.ts - Register WebSocket gateway
4. frontend/src/app/app.component.ts - Add notification-bell
## Commands to Execute (3)
1. npx prisma migrate dev --name add-notifications
2. npm test -- --testPathPattern=notification
3. npm run build
## Execution Order
Phase 1: Backend (model, service, controller)
Phase 2: WebSocket (gateway, events)
Phase 3: Frontend (component, integration)
Phase 4: Tests and verification
## Estimate: ~45 minutes of agent executionNext Edit Suggestions (NES)
Next Edit Suggestions is a feature that predicts the sequence of changes you will likely make after an initial operation. Instead of only suggesting the completion of the current line, NES analyzes the pattern of your change and anticipates where you will need to intervene next.
How NES Works
The mechanism is intuitive: you make a change at one point in the code, and Copilot automatically identifies other points in the file (or the project) that need to be updated accordingly. A visual indicator appears in the editor gutter, showing where edit suggestions are available.
Interacting with NES
| Action | Shortcut | Effect |
|---|---|---|
| Navigate to the next suggestion | Tab |
The cursor moves to the next edit point |
| Accept the suggestion | Tab (when on the suggestion) |
The change is applied |
| Reject the suggestion | Esc |
The suggestion disappears |
| See all suggestions | Icons in the editor gutter | Visual indicators show all positions |
NES Use Cases
Scenarios Where NES Excels
| Scenario | Initial Change | NES Suggestions |
|---|---|---|
| Variable rename | You rename userData to userProfile |
Suggests updating all points where the variable is used |
| Parameter addition | You add an options parameter to a function |
Suggests updating all callers and the JSDoc |
| Type change | You change the return type from string to UserResponse |
Suggests updates in consumers of the value |
| Field addition | You add an avatar field to the User interface |
Suggests updates in factories, tests, mapping |
| Pattern change | You convert a callback to async/await | Suggests the conversion in all similar patterns in the file |
| Import addition | You use a new type in the file | Suggests the correct import statement |
Example: Rename with NES
Suppose you rename a variable data to userProfile
in a file with 15 occurrences. Without NES, you would have to search and replace manually or
use the IDE's refactoring. With NES, the process becomes fluid.
// Step 1: You rename the first occurrence
const userProfile = await fetchUserData(userId);
// ^^^^^^^^^^^ manual change
// Step 2: NES shows indicators in the gutter on all other occurrences
// Line 15: [NES] data.name -> userProfile.name
// Line 23: [NES] data.email -> userProfile.email
// Line 31: [NES] return data; -> return userProfile;
// Line 45: [NES] if (data) -> if (userProfile)
// Step 3: Press Tab to navigate to the first suggestion
// Step 4: Press Tab to accept
// Step 5: Repeat until all occurrences are completed
// Result: all 15 occurrences updated with a few TabsGutter Indicators
NES uses visual indicators in the editor gutter (the column to the left of the line numbers) to show where suggestions are available. In VS Code, the indicators also include syntax highlighting in the suggestion to facilitate visual review of the proposed change.
Advantages of NES
- 3-5x faster editing for repetitive changes
- Reduces partial rename errors
- Works cross-file too
- Understands semantic context
- Does not require regex or find-replace
- Predicts even non-obvious changes
Limitations of NES
- Available only in VS Code (for now)
- May suggest unwanted changes
- Does not always find all occurrences
- Quality depends on the clarity of the pattern
- Does not handle complex refactoring
- Requires attention when reviewing suggestions
Symbol-Aware Editing
For languages like C++ and C#, Copilot has integrated a compiler-level understanding that goes beyond simple textual pattern matching. Symbol-aware editing analyzes symbols, types, and dependencies across files, enabling semantically correct refactoring operations at project scale.
How It Works
Unlike traditional text-based editing, symbol-aware editing uses Language Server Protocol (LSP) information to understand:
- Declarations: Where a symbol is defined
- References: Where a symbol is used
- Types: The type of each symbol and its relationships
- Scope: The visibility of each symbol
- Dependencies: Which files depend on a symbol
Symbol-Aware Support by Language
| Language | IDE | Support Level | Supported Operations |
|---|---|---|---|
| C++ | Visual Studio 2026 | Full | Rename, signature change, extract method, move type |
| C# | Visual Studio 2026 | Full | Rename, signature change, extract interface, generate implementation |
| TypeScript | VS Code | Partial (via LSP) | Rename with NES, import update |
| Java | JetBrains | Partial | Rename, reference update |
| Python | VS Code / JetBrains | Basic | Rename with contextual suggestions |
Example: Method Signature Change in C#
// BEFORE: Original method in UserService.cs
public async Task<User> GetUserById(int id)
{{ '{' }}
return await _repository.FindAsync(id);
}
// CHANGE: Add 'includeOrders' parameter to the signature
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 identifies ALL 23 callers in the project
// and suggests updates for each one:
// File: UserController.cs (line 45)
// BEFORE: var user = await _userService.GetUserById(id);
// AFTER: var user = await _userService.GetUserById(id, false);
// File: OrderController.cs (line 78)
// BEFORE: var user = await _userService.GetUserById(userId);
// AFTER: var user = await _userService.GetUserById(userId, true);
// File: UserServiceTests.cs (line 112)
// BEFORE: var result = await service.GetUserById(1);
// AFTER: var result = await service.GetUserById(1, false);
// ... and so on for all 23 referencesAdvanced Practical Examples
Let's look at some real-world scenarios where the different editing modes combine to solve complex problems.
Example 1: Adding a Feature with Agent Mode
Add pagination to all endpoints that return lists.
Requirements:
- Query params: page (default 1), limit (default 20, max 100)
- Response: {{ '{' }} data: T[], meta: {{ '{' }} page, limit, total, totalPages } }
- Endpoints involved: GET /users, GET /orders, GET /products
- Update existing tests to verify pagination
- Update the OpenAPI documentation
Pattern to follow: see src/utils/pagination.ts (if it exists) or create itAgent Mode analyzes the codebase, finds the 3 endpoints, creates the pagination utility, modifies the controllers and services, updates tests and documentation. If a test fails during the process, the agent analyzes the error and self-corrects.
Example 2: Using Plan Mode for Migration
Migrate the project from Moment.js to Day.js.
Context:
- Moment.js is used in 15 files
- We use the plugins: timezone, relative-time, duration
- Tests use Moment.js mocks
- The date format in DB is ISO 8601
Requirements:
- Replace all moment imports with dayjs
- Configure the equivalent plugins
- Update format strings if necessary
- Update all tests
- Remove moment from dependencies
- Verify the build compiles without errors# Migration Plan: Moment.js -> Day.js
## Impact Analysis
Files impacted: 15
Tests impacted: 8
Plugins to replace: 3
## Phase 1: Setup (5 min)
1. npm install dayjs
2. Create src/utils/dayjs-config.ts with plugins
## Phase 2: File Migration (20 min)
Files to modify (ordered by dependencies):
1. src/utils/date-helpers.ts (shared utility)
2. src/services/report.service.ts
3. src/services/scheduling.service.ts
4. src/controllers/report.controller.ts
... (11 more files)
## Phase 3: Tests (10 min)
1. Update mocks in tests/setup.ts
2. Update assertions in tests
3. Run complete test suite
## Phase 4: Cleanup (5 min)
1. npm uninstall moment @types/moment
2. Verify build
3. Verify bundle size (expected: -200KB)
## Identified Risks
- Day.js timezone plugin has a different API
- Some format strings are different
- Test mocks may require refactoringBest Practices for Editing Modes
Guide to Choosing the Right Mode
| Situation | Recommended Mode | Rationale |
|---|---|---|
| Complete a single function | Inline Suggestions | Fast, immediate context is sufficient |
| Modify 2-3 related files | Edit Mode | Control over files, coordinated changes |
| Implement a complete feature | Agent Mode | Creates files, runs commands, self-corrects |
| Critical refactoring with many files | Plan Mode | Verifiable plan before execution |
| Renames and repetitive updates | NES | Predictive, fast, Tab to navigate |
| Method signature change in large project | Symbol-Aware + NES | Cross-file semantic understanding |
| Non-urgent task, unfamiliar codebase | Plan Mode + Agent Mode | Plan first, then execute with supervision |
Troubleshooting and Common Issues
Advanced editing modes can present problems in certain situations. Here is how to diagnose and resolve the most common issues.
Common Problems and Solutions
| Problem | Cause | Solution |
|---|---|---|
| Agent Mode does not find relevant files | Unconventional structure or hidden files | Specify file paths in the prompt |
| Self-healing infinite loop | Structural error that the fix does not resolve | Stop, manually fix the underlying problem |
| Edit Mode modifies too much | Prompt too broad | Be specific about what to modify and what NOT to touch |
| NES does not appear | Extension not updated or feature disabled | Update the extension, check settings |
| Plan Mode generates incomplete plan | Insufficient context or project too large | Add more context or limit the scope |
| Terminal commands fail | Environment not configured or missing dependencies | Verify the project compiles manually first |
| Inconsistent changes between files | The agent loses context between modifications | Break into smaller tasks or use Plan Mode |
When to Stop the Agent
Warning Signs
- More than 3 iterations on the same error
- The changes make the problem worse
- The agent modifies unrelated files
- The generated code does not make logical sense
- Unnecessary dependencies are being added
- Tests pass but the logic is wrong
Corrective Actions
- Press
Ctrl+Cto interrupt - Use
git diffto see all changes - Use
git stashorgit checkoutto restore - Rephrase the request with more context
- Break the task into sub-tasks
- Switch to Plan Mode for more control
Summary and Next Steps
Copilot's advanced editing modes transform how we work in our IDE. From inline suggestions to coordinated multi-file editing, from autonomous agents with self-healing to planning before action, each mode has its place in the modern developer's toolkit.
Key Takeaways
- Edit Mode for coordinated changes on specific files: you choose the files, Copilot generates consistent modifications.
- Agent Mode for autonomous tasks with self-healing: the agent explores the project, runs commands, and self-corrects.
- Plan Mode for total control: plan first, execute after. Ideal for complex tasks and critical code.
- Next Edit Suggestions for fluid editing: Tab to navigate, Tab to accept. Renames and repetitive updates in seconds.
- Symbol-Aware editing for semantic refactoring: compiler-level understanding for C++ and C# in Visual Studio.
Series Progress
| # | Article | Status |
|---|---|---|
| 1 | Foundation and Mindset | Completed |
| 2 | Ideation and Requirements | Completed |
| 3 | Backend Architecture | Completed |
| 4 | Frontend Structure | Completed |
| 5 | Prompt Engineering | Completed |
| 6 | Testing and Quality | Completed |
| 7 | Documentation | Completed |
| 8 | Deploy and DevOps | Completed |
| 9 | Evolution | Completed |
| 10 | Coding Agent | Completed |
| 11 | Code Review | Completed |
| 12 | Copilot Edits and Agent Mode | Completed |
| 13 | GitHub Spark | Next |
| 14 | Copilot Spaces and Memory | Coming soon |
| 15 | AI Models | Coming soon |
| 16 | Customization | Coming soon |
| 17 | Enterprise and Business | Coming soon |
| 18 | Extensions and Marketplace | Coming soon |
| 19 | Security | Coming soon |
In the next article we will explore GitHub Spark, the platform for creating AI-native micro-applications directly from the browser using natural language, without the need to write code or configure infrastructure.