Gains :
- Capacité à écrire des fonctions, des classes et des modules pour l'IA avec des définitions claires d'entrées-sorties et de contraintes
- Capacité à utiliser l'IA comme partenaire de programmation en binôme et à progresser étape par étape, par petits morceaux vérifiables
- Capacité à détecter les erreurs de logique et les cas extrêmes en compilant le code généré par l'IA et en l'exécutant avec de petits exemples
La programmation en binôme, c'est lorsque deux développeurs travaillent sur le même problème, l'un écrivant et l'autre révisant. Le codage avec l'IA est la version numérique de cette relation : vous fixez la direction, les contraintes et les critères d'acceptation ; L'IA produit une ébauche rapide ; Vous vérifiez chaque étape en la compilant et en la testant. Le plus gros piège ici est de dire à l’IA « écrivez-moi cette application du début à la fin » et d’accepter aveuglément un bloc de 200 lignes. Une bonne programmation en binôme se déroule par petites étapes : chaque étape doit être compréhensible, testable et réversible.
Dans cette unité, vous apprendrez à imprimer des fonctions, des classes et des modules avec un contrat d'entrée-sortie clair ; Comment guider l’IA étape par étape ; et nous verrons comment détecter les erreurs de logique et de cas extrêmes en exécutant le code qu'il produit avec de petits exemples. Le but n’est pas la vitesse, mais la vitesse vérifiée.
Concepts : Contrat d'entrée-sortie : une définition claire de l'entrée qu'une fonction prend et du comportement de sortie et d'erreur qu'elle promet. Cas limite : entrée qui n'est pas ordinaire mais qui peut réellement se produire (vide, zéro, négative, très grande, nulle). Développement incrémental : procéder à de petites pièces de travail et valider chaque étape.
Impression du code avec contrat net
La base du code qualité est de définir exactement « ce que vous voulez » avant de commencer le travail. Lorsque vous écrivez une fonction dans AI, donnez-lui cinq éléments : langue et version, types d'entrée et significations, sortie, conditions d'erreur et contraintes (performances, interdiction de bibliothèque externe, style). Cela empêche l'IA de deviner.
- Rédigez le contrat. Entrée, sortie, erreur, contrainte.
- Demandez une petite unité. Une fonction avec une seule responsabilité ; Ce n'est pas un énorme module.
- Demandez un bloc de test. Ajoutez quelques exemples d’exécutions/tests à côté du code.
- Compilez et exécutez. Essayez-le avec des cas extrêmes, vérifiez le résultat à l'œil nu.
- Passez à l'étape suivante. Une fois une pièce confirmée, construisez dessus.
Invite de fonction contractée : "Écrivez une fonction pour TypeScript 5. Objectif : calculer le montant total des articles dans un panier. Entrée : { prix : nombre, quantité : nombre }[] tableau. Sortie : nombre (total). Règles : lancer une erreur si la quantité ou le prix est négatif ; renvoyer 0 pour un tableau vide ; arrondir le montant à 2 décimales pour une erreur décimale. N'utilisez pas de bibliothèque externe. Ajoutez 5 cas de test sous la fonction (normal, vide, quantité négative, prix décimal, article unique).
Guider l’IA en binôme
De bons progrès dans la programmation en binôme sont un dialogue plutôt qu’une grande demande. Tout d’abord, demandez le squelette et exécutez-le ; puis ajoutez un état de bord ; puis corrigez un bug. Cette approche permet de garder le code compréhensible et vous donne le contrôle à chaque étape.
Invite de progression incrémentielle : "Nous allons écrire un lecteur qui lit un fichier CSV et convertit les lignes en objet. Allons ÉTAPE PAR ÉTAPE, en passant à l'étape suivante sans que je confirme chaque étape. Étape 1 : écrivez simplement le squelette qui divise le fichier en lignes et sépare la ligne d'en-tête. N'ajoutez pas encore de conversion de type ou de gestion des erreurs. Soyez bref, expliquez. "
Expliquez et justifiez l'invite de code : "Expliquez la fonction que vous venez d'écrire, non pas ligne par ligne, mais décision par décision : quelle décision de conception vous avez prise et pourquoi, quel cas limite vous avez traité et comment, quels cas vous avez délibérément exclus ? Énumérez 3 hypothèses dans le code que je ne devrais pas manquer. "
Astuce : n'acceptez pas le code généré par l'IA sans le comprendre. « Expliquez-moi cela, quelles hypothèses avez-vous faites ? » La question révèle à la fois des erreurs cachées et permet de défendre ce code, puisque celui-ci reste sous votre responsabilité. Mettre en production du code que vous ne comprenez pas, c'est comme envoyer un contrat sans le signer.
Invite faible/Invite forte
FAIBLE : "Écrivez une fonction de tri." (Résultat : quel langage, ce qui est trié, est-il stable, quelle est la contrainte de performances, un code vague et ne correspond probablement pas à l'exigence.) FORT : "Pour Java 17, écrivez une méthode qui trie un objet List<Employee> d'abord par service (alphabétique), puis par salaire (décroissant). NE REMPLACEZ PAS la liste d'origine, renvoyez la nouvelle liste. Laissez le service de complexité nulle venir en dernier. Expliquez la complexité de la méthode dans la ligne de commentaire précise ajouter un bloc de test principal avec 4 échantillons.
Invite puissante ; Comprend un critère de tri (deux niveaux), une règle d'effet secondaire (remplacement de l'original), un comportement nul et une attente de test. Sans ces détails, l’IA produit une solution plausible mais incorrecte ; par exemple, cela peut corrompre la liste d'origine, ce qui entraînera une erreur silencieuse ailleurs.
Validation avec des cas Edge et de petits échantillons
Le code qui fonctionne dans le scénario heureux n’est pas le bon code. Forcer consciemment chaque fonction produite :
Type de cas de bord
exemple d'entrée
comportement attendu
entrée vide
Tableau/chaîne vide
Pas une erreur, résultat logique vide
Zéro/négatif
0, -1
Comportement défini et correct
grande valeur
Des millions d'enregistrements
Contrôle des débordements/performances
nul/indéfini
espace manquant
Erreur contrôlée ou défaut
Duplicata/inhabituel
répétitif, ordre inverse
résultat correct
Mini-étuis
Cas 1 — Erreur d’arrondi silencieux. L'IA écrit une fonction qui collecte de l'argent avec des types décimaux (float) ; 0,1 + 0,2 donne 0,30000000000000004. L'erreur est résolue lorsque l'ingénieur ajoute la règle « Arrondissez à 2 chiffres et utilisez des centimes entiers ». Une règle de 3 lignes évite des milliers de centimes d'écart dans le rapprochement mensuel.
Cas 2 — Piège à effets secondaires. L'IA écrit une méthode qui « trie » une liste, mais modifie la liste d'origine sur place. Un comportement inattendu se produit car un autre module utilise la même liste. Si la contrainte « modifier l'original » était dans l'invite, l'erreur ne se produirait jamais ; est pris dans la révision du code et empêche 2 heures de débogage.
Cas 3 — Gains étape par étape. Un développeur imprime un module d'importation de 150 lignes à la fois ; Lorsqu’il trouve une erreur, il ne parvient pas à trouver d’où elle vient. Un autre développeur divise le même travail en 5 petites étapes, teste chaque étape en 2 minutes et détecte immédiatement l'erreur à la 3ème étape.
Erreurs courantes
- Impression de gros blocs en une seule requête. Un code risqué, difficile à comprendre et à déboguer, est né.
- Demander un code sans donner de contrat. Si l’erreur d’entrée-sortie est ambiguë, l’IA devinera et se trompera.
- Je teste juste le scénario heureux. Si une entrée vide, nulle, négative et volumineuse n'est pas essayée, l'erreur est laissée à la production.
- Accepter sans comprendre. Le code que vous ne divulguez pas est une dette que vous ne pouvez pas défendre.
- Ignorer les types sensibles comme les effets secondaires et l’argent/la date. L’argent flottant avec une histoire intemporelle est une source d’erreur classique.
En résumé
L'écriture de code avec l'IA est une programmation en binôme disciplinée : contrat clair, petites étapes, construction et test à chaque étape. Donner le quatuor entrée-sortie-erreur-contrainte dès le début détermine la qualité du code. Expliquer le code qu'il produit et le forcer avec des cas extrêmes fait ressortir les erreurs cachées sous le scénario heureux. La source de la rapidité n’est pas l’acceptation aveugle ; est une ébauche rapide et une vérification rapide.
Tâche de candidature
Choisissez une fonction petite mais réelle (par exemple, total du panier, différence de date, analyse de texte). Imprimez à l'aide de l'invite de fonction contractée ; Ajoutez au moins 5 scénarios de test à côté. Exécutez le code et essayez consciemment 5 cas extrêmes, en utilisant le tableau comme guide. Trouvez un bogue dans au moins un cas limite (sinon, concevez une nouvelle entrée pour forcer la fonction), corrigez-le avec l'IA et vérifiez en retestant que le correctif a fonctionné.
liste de contrôle
- [ ] J'ai écrit un contrat qui comprend les entrées, les sorties, les erreurs et les contraintes.
- [ ] J'ai généré le code par petites étapes au lieu d'un gros bloc.
- [ ] J'ai ajouté un bloc d'exécution de test/exemple à côté du code.
- [ ] J'ai consciemment testé au moins 5 cas extrêmes.
- [ ] J'ai expliqué le code à l'IA et révisé ses hypothèses.
- [ ] J'ai corrigé l'erreur trouvée et confirmé le correctif en retestant.