Ask, Edits, Agent et Plan

3.7 Ask Mode

Définition

Ask Mode est le mode où tu poses des questions à Copilot sans forcément lui demander de modifier directement ton code.

C’est le mode idéal pour :

• comprendre ;
• explorer ;
• comparer ;
• diagnostiquer ;
• demander des explications ;
• demander une stratégie ;
• apprendre une codebase.

Dans les environnements qui exposent Ask/Edit, GitHub décrit Ask Mode comme le mode permettant d’obtenir des réponses à des questions de code et des suggestions, tandis que Copilot Edits en edit mode sert à effectuer des modifications contrôlées.

Quand utiliser Ask Mode ?

Utilise Ask Mode quand tu veux répondre à une question comme :

What does this function do?

Why is this test failing?

What are the security risks in this endpoint?

How should I refactor this module?

What files are likely involved in this feature?

Exemple : comprendre une codebase

Prompt :

Explain the role of this service in the application.
Identify its dependencies and summarize the main business rules.

Copilot peut répondre :

This service handles payment authorization.
It depends on PaymentGatewayClient, FraudDetectionService, and OrderRepository.
The main business rules are:
- payments are rejected if the order is already paid
- payments above a threshold require fraud validation
- failed payments are logged and retried

Ensuite, tu peux demander :

Which parts of this service are risky or hard to test?

Exemple : analyse sécurité

Prompt :

Review this Express route for security issues.
Focus on authentication, authorization, input validation, injection risks, and error handling.

Copilot peut identifier :

• absence de middleware auth ;
• validation insuffisante ;
• risque d’injection ;
• message d’erreur trop détaillé ;
• absence de rate limiting.

3.8 Copilot Edits (edit mode)

Définition

Copilot Edits, en edit mode, sert à demander à Copilot de modifier un ensemble de fichiers de manière contrôlée. Tu définis le working set, puis tu acceptes ou rejettes les changements fichier par fichier.

Contrairement à Ask Mode, ici tu veux que Copilot applique ou propose directement des changements.

Exemple simple

Tu sélectionnes :

def get_user_name(user):
    return user["first_name"] + " " + user["last_name"]

Prompt Copilot Edits (edit mode) :

Update this function to handle missing first_name or last_name safely.
Keep the return type as string.

Suggestion possible :

def get_user_name(user):
    first_name = user.get("first_name", "").strip()
    last_name = user.get("last_name", "").strip()
    return f"{first_name} {last_name}".strip()

Exemple plus professionnel

Code :

export function calculateFinalPrice(price: number, discount: number) {
  return price - discount;
}

Prompt :

Update this function to validate inputs.
Price and discount must be non-negative.
Discount cannot be greater than price.
Throw descriptive errors.
Add TypeScript return type.

Suggestion :

export function calculateFinalPrice(price: number, discount: number): number {
  if (price < 0) {
    throw new Error("Price must be non-negative");
  }

  if (discount < 0) {
    throw new Error("Discount must be non-negative");
  }

  if (discount > price) {
    throw new Error("Discount cannot be greater than price");
  }

  return price - discount;
}

Quand utiliser Copilot Edits en edit mode ?

Utilise Copilot Edits en edit mode pour :

• modifier une fonction ;
• ajouter une gestion d’erreur ;
• améliorer la lisibilité ;
• ajouter du typage ;
• refactorer un bloc ;
• adapter un fichier ;
• corriger un bug localisé ;
• ajouter des tests dans un fichier existant.

Quand éviter Copilot Edits en edit mode ?

Évite Copilot Edits en edit mode si :

• tu ne sais pas encore quoi modifier ;
• la modification touche beaucoup de fichiers ;
• tu dois d’abord analyser une architecture ;
• tu as besoin d’une stratégie de migration ;
• le domaine est sensible et nécessite une réflexion préalable.

Dans ces cas, commence par Ask Mode ou Plan Mode.

3.9 Plan Mode

Définition

Plan Mode sert à demander à Copilot de produire un plan structuré avant d’écrire ou modifier du code.

C’est très important pour les tâches non triviales.

Dans la documentation GitHub Copilot CLI, GitHub explique que le Plan Mode crée un plan d’implémentation structuré avant l’écriture de code, et qu’un plan concret peut améliorer les résultats du modèle.

Pourquoi Plan Mode est important ?

Parce que beaucoup de problèmes ne doivent pas être résolus en générant directement du code.

Exemples :

• migration d’un module ;
• refactoring large ;
• correction d’un bug complexe ;
• ajout d’une fonctionnalité ;
• amélioration de sécurité ;
• modification multi-fichiers ;
• changement d’architecture ;
• upgrade de framework.

Exemple simple

Prompt :

Create a plan to add pagination to this API endpoint.
Do not modify the code yet.
Include required changes, affected files, tests, and risks.

Plan possible :

1. Identify the current endpoint and query mechanism.
2. Add page and pageSize query parameters.
3. Validate pagination inputs.
4. Update the repository query to use limit and offset.
5. Return pagination metadata.
6. Add unit tests for default pagination.
7. Add tests for invalid page and pageSize.
8. Update API documentation.

Exemple cloud/dev réaliste

Prompt :

Create a plan to migrate this service from hardcoded AWS credentials to IAM role-based authentication.
Do not edit files yet.
Include security risks, configuration changes, and tests.

Bon plan attendu :

1. Locate hardcoded credential usage.
2. Replace explicit credentials with the default AWS credential provider chain.
3. Ensure the runtime environment has an IAM role attached.
4. Remove secrets from configuration files.
5. Rotate exposed credentials.
6. Update deployment documentation.
7. Add tests or validation for missing permissions.
8. Verify least-privilege IAM permissions.

Exemple refactoring

Prompt :

Create a refactoring plan for this legacy payment module.
Goals:
- improve testability
- preserve behavior
- avoid large risky rewrites
- introduce dependency injection
- add unit tests before changing logic

Pourquoi c’est bon ?

Parce que tu forces Copilot à réfléchir comme un ingénieur :

• comprendre ;
• découper ;
• sécuriser ;
• tester ;
• agir progressivement.

Ask Copilot to immediately rewrite the entire module.

Ask Copilot to create an implementation plan, review it, then apply changes incrementally.