Tutoriel niveau nounou de l'assistant de programmation IA : de la complétion du code à l'utilisation efficace du mode Agent

🛒 Pour les développeurs, utilisez un ensemble de méthodes réutilisables pour utiliser les assistants de programmation IA avec une réelle efficacité.

Objectifs du didacticiel

Ce didacticiel prend Cursor et GitHub Copilot comme exemples pour vous aider à mettre à niveau l'assistant de programmation IA de « achèvement occasionnel » à « outil d'ingénierie quotidien stable », et à maîtriser la transformation, la reconstruction et la génération de tests multi-fichiers en mode Agent.

Liste de contrôle de préparation

  • [ ] Installez VS Code ou Cursor (ce tutoriel utilise Cursor comme exemple).
  • [ ] Connectez-vous à votre compte et confirmez votre statut de quota/abonnement gratuit.
  • [ ] Un exemple de projet géré par Git (il est recommandé de s'entraîner d'abord puis d'utiliser le véritable entrepôt).
  • [ ] Node/Python et d'autres environnements d'exécution sont déjà disponibles localement (utilisés pour exécuter la vérification des tests).
  • [ ] Comprendre la structure de votre base de code (entrée, dépendances, commandes de test).

Première étape : Installation et configuration de base

  1. Téléchargez et installez Cursor (ou plugin VS Code + Copilot).
  2. Connectez-vous à votre compte et confirmez les changements de modèle et d'achèvement dans les paramètres.
  3. Ouvrez l'exemple de projet et conservez visibles les fichiers clés (README, documents d'interface) dans le répertoire racine de l'entrepôt.

Définir des suggestions : activez les fonctions « Autocomplete (Tab) » et « Code Review » ; désactivez les options à haut risque telles que « Accepter automatiquement toutes les suggestions ».

Étape 2 : Maîtriser trois types d'usages de base

  1. Complétion en ligne : saisissez un nom de fonction ou un commentaire et appuyez sur Tab pour accepter la suggestion.
  2. Question de la boîte de dialogue : ⌘ + L Ouvrez la boîte de dialogue, collez l'extrait de code et demandez « Qu'est-ce qui ne va pas avec ce code ».
  3. Sélectionnez l'opération de code : sélectionnez un morceau de code, cliquez avec le bouton droit et sélectionnez "Expliquer/Refactoriser/Générer un test".

Idée clé : Donnez le contexte de l'IA, plutôt que de simplement « écrivez-le pour moi ». Sélectionnez d’abord les fichiers concernés ou publiez la signature de l’interface.

Étape 3 : Écrivez des mots d'invite de haute qualité

Mauvais mot d'invite : « Écrivez une interface de connexion pour moi ».

Exemples de bons mots d’invite :

Implémentez une interface de connexion dans src/auth/login.ts :
- Paramètres d'entrée : {nom d'utilisateur, mot de passe}
- Vérification : comparaison des mots de passe à l'aide de bcrypt
- JWT renvoyé avec succès, le délai d'expiration est de 2 heures
- L'échec renvoie 401 et le code d'erreur
- Suivre la gestion des erreurs existante du projet (voir src/utils/errors.ts)
- Générer des tests unitaires en même temps

Trois points clés : Des objectifs clairs, des limites et une identification du code existant.

Étape 4 : Utilisez le mode Agent pour modifier plusieurs fichiers

Appuyez sur ⌘ + I dans le curseur pour passer en mode Compositeur/Agent et entrez :

Extrayez le calcul du montant du module de commande dans une fonction d'outil indépendante et placez-le dans src/utils/money.ts.
Mettez à jour tous les points d'appel et ajoutez des tests unitaires, en conservant le style de dénomination existant.

L'agent modifiera tous les fichiers. À ce moment-là, assurez-vous de :

  1. Opérez sur une succursale indépendante.
  2. Examinez les différences de l'agent une par une au lieu de toutes les accepter en un seul clic.
  3. Exécutez le test pour confirmer qu’il n’y a pas de régression.

Étape 5 : Laissez l'IA vous aider à générer et corriger des tests

  • Générer des tests : Générer des tests unitaires couvrant les conditions aux limites pour src/utils/money.ts.
  • Échec de la réparation : publiez le message d'erreur CI sur AI : "Le test xx a échoué, l'erreur est la suivante... Veuillez localiser la cause première et la corriger".

Expérience : si vous publiez ensemble « rapport d'erreur + documents associés + comportement attendu », le taux de réussite est bien plus élevé que la simple publication du rapport d'erreur.

Étape 6 : Définir les spécifications au niveau du projet (.cursorrules)

Créez « .cursorrules » dans le répertoire racine du projet pour que la sortie de l'IA corresponde au style de l'équipe :

- Langage du projet : TypeScript, en mode strict
- Gestion des erreurs : utilisation unifiée d'ApiError dans src/utils/errors.ts
- Naming : le verbe de fonction commence par le composant PascalCase
- Doit passer eslint et plus joli avant la soumission
- Toute nouvelle logique doit avoir des tests unitaires

Après sauvegarde, la nouvelle session prendra automatiquement effet et les spécifications unifiées de l'équipe pourront être placées dans l'entrepôt partagé.

Étape 7 : Vérification et limite de sécurité

Liste de contrôle de vérification :

  • [ ] les suggestions de complétion sont acceptées par Tab et sont grammaticalement correctes.
  • [ ] Les mots d'invite peuvent produire de manière stable un code conforme aux spécifications et exécutable.
  • [ ] L'agent est entièrement vert lors des tests après modification.
  • [ ] Les informations sensibles (clés, adresses intranet) ne sont jamais collées dans Cloud AI.

Lignes rouges de sécurité : les codes confidentiels ne sont pas collés, les sessions partagées ne sont pas ouvertes dans les entrepôts sensibles et les agents ne sont pas poussés directement vers le coffre.

Étape 8 : Combinaison de flux de travail efficace au quotidien

En combinant des usages épars en « actions standards », l’efficacité s’en trouve évidemment améliorée :

  1. Obtenez les exigences → utilisez l'IA pour démonter la liste des tâches et les limites de l'interface.
  2. Écrivez le code → sélectionnez les fichiers pertinents et utilisez l'agent pour générer la première version de l'implémentation.
  3. Autotest → Laissez l'IA générer des tests unitaires et les exécuter.
  4. Débogage conjoint → Publiez le rapport d'erreur sur AI pour localiser la cause première et la corriger.
  5. Finition → Laissez l'IA générer des instructions de modification et valider les informations.

Cette combinaison peut gagner 1 à 2 heures chaque jour. La clé est « une contribution claire et une acceptation à chaque étape ».

Erreurs et précautions courantes

  1. Acceptez toutes les différences de l'Agent en un seul clic : assurez-vous de les examiner une par une et ne les fusionnez que si le test est entièrement vert.
  2. Demandez sans donner de contexte : sélectionnez d'abord le fichier ou collez la signature de l'interface.
  3. Publier la clé de l'IA : Il s'agit d'une ligne rouge de sécurité et est strictement interdite.
  4. N'exécutez pas de tests après des modifications de l'IA : toute modification de l'IA doit être vérifiée par des tests et ne peut pas être crue aveuglément.
  5. Le mot d'invite reste inchangé : prenez l'initiative d'itérer le modèle lorsque l'effet diminue.

Méthode de vérification

  • Vérification 1 : Les suggestions de complétion peuvent être acceptées par Tab et sont grammaticalement correctes.
  • Vérification 2 : les mots d'invite peuvent produire de manière stable un code conforme aux spécifications et exécutable.
  • Vérification 3 : L'Agent est entièrement vert après modification.
  • Vérification 4 : Les informations sensibles (clés, adresses intranet) n'ont jamais été collées dans Cloud AI.

Foire aux questions et dépannage (FAQ)

  1. La complétion suggère-t-elle toujours du code indésirable ?

    Donnez plus de contexte (sélectionnez des fichiers, collez des interfaces), utilisez « .cursorrules » pour contraindre le style et passez à un modèle plus fort si nécessaire.

  2. Que dois-je faire si l'agent corrompt le fichier ?

    Utilisez Git pour restaurer le fichier : git checkout <file> ; prendre l'habitude de « couper les branches avant transformation et de les revoir une à une après transformation ».

  3. L'effet du mot d'invite est instable ?

    Notez les quatre éléments « objectifs, limites, code existant et vérification attendue » ; si l'effet n'est pas bon, réessayez avec une autre formulation.

  4. Pas assez de quotas gratuits ?

    Laissez l'IA gérer en premier les tâches à faible fréquence telles que « générer des tests, interpréter du code et rédiger des commentaires » ; quittez la refactorisation à haute fréquence jusqu'à ce que le quota soit suffisant ou lorsque vous mettez à niveau votre abonnement.

  5. Comment l'équipe unifie-t-elle les spécifications d'utilisation de l'IA ?

    Précipitez les « .cursorrules », les modèles Word d'invite et les lignes rouges de sécurité dans les documents partagés et incluez-les lors de l'intégration des nouveaux utilisateurs.

  6. Que dois-je faire si les styles des différents projets sont très différents ?

    Conservez les « .cursorrules » séparément pour chaque projet et gérez-les uniformément dans l'entrepôt pour éviter les styles inter-projets.

Résumé et prochaines étapes

À ce stade, vous maîtrisez l'utilisation complète, de « Achèvement » à « Transformation d'agent » en passant par « Test de réparation ». Il est recommandé de s'entraîner d'abord avec des exemples de projets pendant 2 à 3 jours, puis de s'entraîner sur des modules à faible risque dans de vrais entrepôts ; enfin, les modèles « .cursorrules » et d'invite peuvent être accumulés en tant qu'actifs d'équipe.

Avancement et expansion

  • Agent de ligne de commande : utilisez Claude Code pour terminer la reconstruction par lots dans le terminal.
  • Examen automatisé : laissez l'IA générer des opinions d'auto-évaluation et d'examen, et l'examen final sera effectué manuellement.
  • Modèle de privatisation : les projets à haute sensibilité sont connectés au modèle de déploiement local pour garantir que le code ne quitte pas l'intranet.
  • Mesure de l'efficacité : taux d'adoption record et taux de retouche, examen trimestriel et invite d'itération des actifs de mots.

Avis des utilisateurs

  • Chargement des avis...