Aller au contenu
English

Rapports prêts pour un agent à partir de vrais tickets de logiciels libres

  • Étude de cas 2
  • 120 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Cette étude de cas applique le rapport prêt pour un agent du module 5 à de vrais tickets de logiciels libres. Vous mesurez combien de vrais rapports en disent assez pour un agent de programmation, et vous réécrivez les plus faibles.

Étude de cas 2 sur 3 · Tester les applications d'IA : assurance qualité manuelle et assistée par l'IARapports prêts pour un agent à partir de vrais tickets de logiciels libres
Aperçu du cours

Ce que vous saurez faire

Découvrez à quelle fréquence les tickets réels donnent assez d’information pour qu’un agent de programmation produise la correction acceptée. Vous évaluez 30 tickets réels avec une courte grille et vérifiez chacun avec sa correction et son test fusionnés. Ensuite, vous comparez des façons de décider quels tickets peuvent être confiés tels quels à un agent. Enfin, vous réécrivez les tickets peu solides dans un format prêt pour un agent. Vous vérifiez une réécriture en exécutant le vrai test.

Étude de casPièce de portfolio

Licence
MIT
Durée
Environ 2 h
S’exécute dans
Colab, Kaggle ou VS Code
Compétences utilisées
  • Une grille de préparation
  • Le test fusionné comme corrigé
  • Des règles de tri comparées avec une seule mesure
  • Un modèle évaluateur vérifié avec vos étiquettes
  • Des réécritures prêtes pour un agent
  • Des critères d'acceptation comparés à un vrai test

Les carnets sont en anglais. Colab et Kaggle ouvrent votre propre copie. Pour utiliser VS Code, téléchargez le carnet depuis GitHub. Vous êtes bloqué ? Consultez le carnet de solution.

Le carnet (notebook) Jupyter exécute chaque étape de cette page, avec le même code et les mêmes sorties. Il comprend aussi quatre tâches avec des vérifications. Il télécharge neuf petits fichiers et utilise seulement la bibliothèque standard de Python. Il s’exécute dans Colab ou Kaggle sans configuration, en quelques secondes. Vous n’avez besoin ni de compte ni de clé. Les évaluations du modèle ont été enregistrées une fois, et le carnet les rejoue. Une partie facultative télécharge Django et exécute le vrai test.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 120 minutes

Ce que vous devez savoir

Cette étude de cas utilise surtout le module 5. Voici les leçons les plus importantes :

Ce qu’il vous faut sur votre ordinateur (seulement pour l’exécution locale; Colab et Kaggle n’en ont pas besoin)

  • Python 3.10 ou une version plus récente, et le carnet téléchargé de GitHub, dans VS Code ou JupyterLab. L’application d’exercice et votre espace de travail d’assurance qualité ne sont pas nécessaires.
  • La première cellule du carnet télécharge les données dans un nouveau dossier agent-ready-issues. Pour recommencer, supprimez ce dossier.
  • Pour la partie facultative sur Django seulement : Python 3.10 à 3.12 et le programme patch. macOS et Linux l’ont; sous Windows, utilisez WSL ou sautez cette partie.

Testé sur macOS avec Python 3.12 et 3.13, dans Jupyter après un démarrage à neuf. Windows, Linux, Colab et Kaggle n’ont pas été testés.

Amara (elle) dirige l’assurance qualité d’une petite équipe qui maintient des bibliothèques Python libres. L’équipe a une longue liste de tickets d’utilisateurs en attente. Son gestionnaire, Jonas (il), a un plan : « Nous avons maintenant un agent de programmation. Donnons-lui les tickets ouverts tels quels, puis révisons ce qu’il produit. »

Amara a vu ce qu’un agent fait avec un rapport vague : il devine. Elle demande d’abord des preuves. « Avant de lui confier des centaines de tickets, laissez-moi mesurer deux choses. À quelle fréquence un ticket donne-t-il assez d’information pour produire la correction que les responsables acceptent? Une courte grille peut-elle repérer ces tickets? »

Chaque mauvaise décision a un coût. Confier un ticket trop tôt à l’agent gaspille une exécution et une révision, puis oblige à rouvrir le ticket. Retenir un ticket pour le réécrire coûte quelques minutes à une personne qui teste. Jonas veut aller vite; Amara veut réduire les exécutions inutiles. Amara, Jonas et leur équipe sont inventés pour ce cours; les tickets sont réels.

Vous allez créer une étude de préparation de tickets réels et en tirer une règle de tri. Vous suivrez les étapes de l’image ci-dessous. À la fin, vous appliquez toute la méthode à un nouveau ticket.

SWE-bench est un ensemble public de tickets réels provenant de GitHub. Chaque ticket comprend la modification qui l’a corrigé, telle que les responsables l’ont fusionnée, et le test associé. Les chercheurs l’utilisent pour évaluer les agents de programmation. L’agent reçoit le texte du ticket, et le test caché détermine si sa correction fonctionne. SWE-bench Lite est un sous-ensemble plus petit : 300 tickets de 12 projets Python bien connus. On y trouve notamment Django, SymPy, pytest et Flask.

Le cours a comparé Lite avec SWE-bench Multilingual (neuf langues) et SWE-Gym (2 438 tickets Python non filtrés). Lite a été retenu parce qu’il est petit, limité à Python et fixé à une seule version. La fiche du jeu de données présente la comparaison et les sommes de contrôle.

L’échantillon contient 31 tickets. Trente servent à l’étude, sélectionnés pour représenter chaque projet : 6 de Django, 5 de SymPy et 1 à 3 des autres projets. Un autre ticket Django est gardé à part jusqu’à la fin, comme nouvelle entrée.

Champ Signification
instance_id, repo, pull_request L’identifiant du ticket, son projet et un lien vers la demande de tirage fusionnée
problem_statement Le texte du ticket, tel que la personne l’a rédigé
patch La correction fusionnée par les responsables (un diff, ou relevé des différences)
test_patch La modification du test associée à la correction (un diff)
fail_to_pass Les tests qui échouent avant la correction et réussissent après
base_commit, version Le commit (enregistrement des modifications) avant la correction, et la branche de version du projet

Le carnet charge l’échantillon et compte les tickets :

issues = read_jsonl("issues_sample.jsonl")
by_id = {i["instance_id"]: i for i in issues}
sample = [i for i in issues if i["role"] == "sample"]
new_input = next(i for i in issues if i["role"] == "new-input")
print(len(sample), "issues to rate, 1 kept apart:", new_input["instance_id"])
print("words per issue text, median:", median(len(i["problem_statement"].split()) for i in sample))

La sortie :

30 issues to rate, 1 kept apart: django__django-11133
words per issue text, median: 120.5

Ce que cela nous apprend. Un ticket typique compte environ 120 mots : quelques paragraphes, souvent avec un extrait de code ou une erreur. On peut en évaluer trente rapidement à la main.

Amara et Jonas s’entendent sur quatre points avant que quiconque évalue un ticket.

  • L’unité : un ticket, tel qu’il est rédigé, avant toute discussion.
  • La décision : le confier tel quel à l’agent, ou le retenir pour le réécrire.
  • Ce qui compte comme « prêt ». Le test fusionné est la vérification d’acceptation des responsables. Un ticket est prêt quand ce test vérifie ce que son texte demande. Si le test vérifie quelque chose que le texte ne mentionne jamais, un agent qui suit le texte peut échouer.
  • Deux passes. Évaluez d’abord chaque ticket à partir de son texte seulement. Ouvrez ensuite les corrections et les tests. Sinon, le corrigé influencerait les évaluations.

Pensez au bon de commande d’un tailleur. Le client écrit « raccourcir le pantalon ». Le tailleur le raccourcit de 3 cm. À l’essayage, le client voulait 5 cm. Le bon n’était pas faux, mais la vraie vérification, l’essayage, portait sur quelque chose qu’il ne précisait pas. Le test fusionné est l’essayage. Les responsables l’ont écrit quand ils ont corrigé le ticket. La personne qui a signalé le problème ne l’a jamais vu. Il montre donc, après coup, ce que « corrigé » voulait vraiment dire. Quand le texte du ticket et le test concordent, l’agent avait une chance raisonnable de réussir. Sinon, même un lecteur parfait du texte pourrait échouer.

Le plan de l'étude, en huit étapes. SWE-bench Lite : 300 tickets réels, chacun avec sa correction et son test fusionnés. Échantillon : 30 tickets de 12 projets, plus 1 nouveau ticket gardé à part. Passe 1, le texte seulement : noter 5 critères de 0 à 2, une fois par l'auteur du cours et 3 fois par un modèle. Passe 2, le corrigé : ouvrir la correction et le test fusionnés. Le texte indique-t-il la correction, et le test vérifie-t-il ce que le texte demande? Comparer les règles de tri avec une seule mesure : les tickets mal orientés. Réécrire 3 tickets peu solides dans le format prêt pour un agent. Vérifier 1 réécriture par une exécution : échoue-t-elle avant la correction fusionnée et réussit-elle après? Nouvelle entrée : appliquer toute la méthode au ticket gardé à part.
Le plan de l'étude. La passe 1 utilise seulement le texte; la correction et le test fusionnés sont ouverts seulement à la passe 2.
Description textuelle du diagramme

Huit étapes. Les données contiennent 300 tickets; l’échantillon en prend 30, plus 1 gardé à part. La passe 1 évalue seulement le texte : une fois par l’auteur du cours, trois fois par un modèle. La passe 2 ouvre le corrigé. Viennent ensuite la comparaison des règles de tri, trois réécritures, l’exécution réelle d’une réécriture et la nouvelle entrée.

La grille transforme le modèle de Modèles de tickets prêts pour un agent en cinq critères. Chacun reçoit une note de 0, 1 ou 2, à partir du texte seulement. Le modèle a été conçu pour des fonctions d’IA; trois champs changent donc pour une bibliothèque de code. « Version du modèle et de la requête » devient « version de la bibliothèque ou commit ». « La conversation jointe » devient « le code qui montre le bogue ». « Couche soupçonnée » devient « endroit soupçonné dans le code ».

Critère La question 2 1 0
Reproduction Peut-on exécuter le cas en échec à partir du texte? S’exécute tel quel, et la sortie réelle est montrée Un point de départ, mais la personne doit deviner Aucun
Versions Dans quelle version le problème s’est-il produit? Version ou commit de la bibliothèque, et environnement pertinent Information partielle ou vague (« actuelle ») Aucune
Résultat attendu Que doit-il se passer à la place? Une valeur exacte ou une règle claire : doit / ne doit pas Implicite, vague ou indécis Non indiqué
Acceptation Comment savoir que c’est terminé? Une condition de réussite au-delà du seul exemple Seulement cet exemple Rien à vérifier
Portée Où est le problème; que faut-il préserver? Cause ou endroit soupçonné dans le code, ou limites Seulement la fonction ou l’API Seulement le symptôme

Le total va de 0 à 10. Avant de regarder un test, Amara fixe un seuil. Un ticket avec 7 ou plus obtient surtout des notes maximales et peut être confié tel quel à l’agent.

Voici un court ticket Django, django__django-15851, au complet :

dbshell additional parameters should be passed before dbname on PostgreSQL.
Description
psql expects all options to proceed the database name, if provided. So, if doing something like
`./manage.py dbshell -- -c "select * from some_table;" one will get this:
$ ./manage.py dbshell -- -c "select * from some_table;"
psql: warning: extra command-line argument "-c" ignored
psql: warning: extra command-line argument "select * from some_table;" ignored
psql (10.21)
Type "help" for help.
some_database=>
It appears the args list just need to be constructed in the proper order, leaving the database name
for the end of the args list.

Évaluez-le avant de poursuivre la lecture. Voici les notes de l’auteur du cours, avec chaque valeur visible :

  • Reproduction 2 : une commande exacte et la sortie réelle.
  • Versions 1 : psql 10.21, mais aucune version de Django.
  • Résultat attendu 2 : une règle claire : les options précèdent le nom de la base de données.
  • Acceptation 1 : seul cet exemple peut servir de vérification.
  • Portée 2 : le ticket nomme la cause : l’ordre de la liste d’arguments.

Le total est de 8 sur 10; le ticket dépasse donc le seuil. Plus tard, le corrigé confirme ce jugement. La correction fusionnée place les arguments supplémentaires avant le nom de la base de données, et le test vérifie exactement cet ordre.

L’auteur du cours a évalué les 30 tickets à partir de leur texte seulement, avec une justification d’une ligne par note. Il a enregistré les évaluations dans un commit avant d’ouvrir une correction. Le carnet compte les notes :

for c in CRITERIA:
counts = Counter(author[i][c] for i in ids)
print(f"{c:13} 2: {counts[2]:2} 1: {counts[1]:2} 0: {counts[0]:2}")
totals = [total(author[i]) for i in ids]
print("total: median", median(totals), "| 7 or more:", sum(t >= 7 for t in totals), "of", len(ids))

La sortie :

reproduction 2: 21 1: 5 0: 4
versions 2: 9 1: 5 0: 16
expected 2: 16 1: 13 0: 1
acceptance 2: 2 1: 24 0: 4
scope 2: 12 1: 18 0: 0
total: median 6.0 | 7 or more: 13 of 30
Nombre des 30 textes de tickets qui obtiennent la note maximale pour chaque critère de la grille (Repro : reproduction; Accept : acceptation), évalués à partir du texte seulement par l'auteur du cours.
Description textuelle du graphique

Un graphique à cinq colonnes, une par critère : reproduction 21 sur 30, versions 9, résultat attendu 16, acceptation 2, portée 12.

Ce que cela nous apprend. Les personnes montrent bien le problème : 21 textes sur 30 donnent un exemple exécutable avec sa sortie. Elles décrivent mal les éléments nécessaires ensuite pour le corriger. 16 textes ne donnent aucune version, et seulement 2 donnent une condition de réussite au-delà de leur seul exemple. Le résultat attendu est clair dans environ la moitié des textes (16). Le total médian est de 6, et 13 tickets atteignent le seuil de 7.

L’auteur du cours a ensuite ouvert chaque correction et test fusionnés, puis répondu à deux questions par ticket. Le texte indique-t-il l’endroit de la correction? Le test fusionné vérifie-t-il ce que le texte demande? Chaque réponse est yes (oui), partly (en partie) ou no (non), avec une justification.

Un partly illustre bien le problème. Dans pallets__flask-4992, un utilisateur demande une façon d’ouvrir un fichier de configuration en mode binaire :

flask = by_id["pallets__flask-4992"]
print([line for line in flask["problem_statement"].splitlines() if "mode=" in line])
print([line.strip() for line in added_lines(flask["test_patch"]) if "from_file" in line or "text=" in line])

La sortie :

['app.config.from_file("config.toml", tomllib.load, mode="b")']
['def test_config_from_file_json():', 'def test_config_from_file_toml():', 'app.config.from_file(', 'os.path.join(current_dir, "static", "config.toml"), tomllib.load, text=False']

Ce que cela nous apprend. Le texte propose mode="b". Les responsables ont choisi text=False, et leur test l’appelle ainsi. Un agent qui suit exactement le texte écrit une fonction qui marche, mais échoue au test. Le ticket a obtenu 8 : il était clair, mais précisait un détail que les responsables ont choisi autrement.

Pour l’ensemble des 30 tickets :

does the test check what the text expects? Counter({'partly': 16, 'yes': 10, 'no': 4})
does the text point to the fix? Counter({'partly': 14, 'yes': 14, 'no': 2})
yes 10 issues, rubric totals [6, 6, 7, 7, 7, 8, 8, 9, 9, 9]
partly 16 issues, rubric totals [3, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 8, 8, 9]
no 4 issues, rubric totals [2, 2, 3, 8]
Le total de chaque ticket, regroupé selon le corrigé : le test fusionné vérifie-t-il ce que le texte demande? Chaque point représente un ticket; le trait indique la médiane du groupe.
Description textuelle du graphique

Trois rangées de points. Le test correspond au texte, 10 tickets : totaux de 6, 6, 7, 7, 7, 8, 8, 9, 9, 9 (médiane 7,5). En partie, 16 tickets : totaux de 3 à 9 (médiane 6). Non, 4 tickets : totaux de 2, 2, 3 et 8 (médiane 2,5).

Ce que cela nous apprend. Seulement 10 tickets sur 30 sont prêts : leur test fusionné vérifie ce que le texte demande. Pour 16 tickets, le test vérifie davantage, ou un détail absent du texte. Par exemple : un nom de paramètre, un format de sortie, un type d’erreur ou un cas supplémentaire. Pour 4 tickets, il vérifie autre chose. Les totaux de la grille augmentent de « non » à « oui », mais les groupes se chevauchent. Le seul « non » élevé est un ticket xarray (8 points). Son texte était clair, mais les responsables ont corrigé un autre problème. Ils ont ajouté un avertissement plutôt que de garder les données en évaluation différée.

Le critère résultat attendu distingue le mieux les groupes. Sur les 10 tickets prêts, 9 y obtiennent la note maximale, contre 7 des 20 autres. Le critère acceptation est presque toujours absent, que les tickets soient prêts ou non.

Un ordinateur peut vérifier une partie de « indique la correction ». Le texte nomme-t-il un fichier, une fonction ou une classe que le diff fusionné modifie? C’était le cas pour 20 tickets. Quand l’auteur a jugé « indique la correction : oui », 12 textes sur 14 nommaient un tel endroit.

Erreur courante

Un nom dans le texte n'indique pas forcément la correction

La vérification automatique compte un nom quand le même mot apparaît dans le texte. Dans la nouvelle entrée de cette étude, elle trouve response. La correction modifie django/http/response.py, et la personne a écrit response = HttpResponse(...). Il s’agit d’une variable dans un exemple de code, pas d’une indication de fichier. Traitez la vérification automatique comme un indice pour une personne, pas comme un verdict.

Passons à la décision. Une règle de tri envoie certains tickets à l’agent tels quels et retient les autres pour les réécrire. Chaque règle fait deux types d’erreurs : elle envoie un ticket qui n’est pas prêt, ou retient un ticket qui l’était. Une même mesure pour chaque règle : le nombre de tickets mal orientés, les deux types d’erreurs additionnés.

Deux références de base encadrent la comparaison. « Tout envoyer » est le plan de Jonas. « Tout réécrire d’abord » est l’approche prudente opposée. Deux règles peu coûteuses n’exigent aucune grille : « contient du code ou une trace d’erreur » et « texte long ». Viennent ensuite deux règles fondées sur la grille : un total de 7 ou plus, et la note maximale pour résultat attendu seulement.

for name, flags in rules.items():
r = triage(flags, ready)
print(f"{name:29} sent {r['sent']:2} ({r['sent_ready']:2} ready) | misrouted {r['misrouted']:2}")

La sortie :

send everything sent 30 (10 ready) | misrouted 20
rewrite everything first sent 0 ( 0 ready) | misrouted 10
has code or a traceback sent 19 ( 7 ready) | misrouted 15
long text (above the median) sent 15 ( 5 ready) | misrouted 15
rubric total 7+ sent 13 ( 8 ready) | misrouted 7
expected = 2 sent 16 ( 9 ready) | misrouted 8

Ce que cela nous dit. Tout envoyer oriente mal 20 tickets. Deux sur trois arriveraient à l’agent avec un texte qui ne correspond pas au test des responsables du projet. Un bloc de code ou un texte long aide peu (15). Le total de la grille oriente mal 7 tickets : il en envoie 13, dont 8 sont prêts. La note maximale pour résultat attendu seulement fait presque aussi bien (8). Avec 30 tickets, une différence d’un ou deux peut tenir au hasard. Considérez donc ces deux règles comme équivalentes.

Le seuil de 7 était-il un choix chanceux? Le carnet (notebook) Jupyter le fait varier de 3 à 10 :

  • Auteur du cours
  • Modèle
  • Tout envoyer
  • Tout réécrire d'abord
Tickets mal orientés pour chaque seuil du total de la grille, selon les notes de l'auteur du cours et du modèle (médiane de 3 essais). Les lignes pointillées représentent les deux références de base : tout envoyer (20) et tout réécrire d'abord (10).
Description textuelle du graphique

Deux lignes continues et deux lignes pointillées. Pour les seuils de 3 à 10, les notes de l’auteur du cours orientent mal 18, 16, 15, 10, 7, 9, 8 et 10 tickets. Les notes du modèle en orientent mal 18, 15, 14, 11, 9, 7, 10 et 10. Les références de base pointillées restent à 20 (tout envoyer) et à 10 (tout réécrire d’abord).

Ce que cela nous dit. Les seuils de 7 à 9 orientent tous mal de 7 à 9 tickets. Le choix de 7 était raisonnable, pas chanceux. Sous 6, la règle en envoie trop. Et aucun seuil ne fait beaucoup mieux que « tout réécrire d’abord » : 7 contre 10.

Des poids égaux mettent un essai d’agent gaspillé au même niveau que quelques minutes de réécriture. Amara pense qu’un essai gaspillé coûte davantage : la modification de l’agent, une révision, un ticket rouvert. Elle pose l’hypothèse suivante : un essai gaspillé compte pour 3, et une réécriture inutile pour 1 :

send everything weighted cost 60
rewrite everything first weighted cost 10
has code or a traceback weighted cost 39
long text (above the median) weighted cost 35
rubric total 7+ weighted cost 17
expected = 2 weighted cost 22

Ce que cela nous dit. Avec ces poids, tout réécrire d’abord est la règle la moins coûteuse (10). La barrière fondée sur la grille coûte 17. La raison est la proportion de départ : seuls 10 tickets sur 30 étaient prêts. Une barrière qui en envoie 13 en envoie donc encore 5 qui ne le sont pas. Cela change la recommandation. Quand les essais d’agent coûtent cher et les réécritures coûtent peu, la grille sert mieux de liste de vérification que de barrière.

Amara ne notera pas des centaines de tickets à la main. Un modèle peut-il appliquer la grille? Le cours a enregistré les réponses de chat-small, un petit modèle hébergé sur Azure, aux mêmes 30 tickets. Il a reçu seulement la grille et le texte du ticket. Le cours a soumis chaque ticket trois fois, car la réponse d’un modèle peut changer entre les essais. Les 93 appels ont coûté environ 0,03 $ US. Les prix changent, alors consultez la page actuelle.

for c in CRITERIA:
same = sum(model_median[i][c] == author[i][c] for i in ids)
lower = sum(model_median[i][c] < author[i][c] for i in ids)
stable = sum(len({run[c] for run in model[i]}) == 1 for i in ids)
print(f"{c:13} same as the author {same:2}/30, model lower {lower}, same in all 3 runs {stable:2}/30")
changed = sum(len({total(run) for run in model[i]}) > 1 for i in ids)
print("issues whose model total changed between runs:", changed)
r = triage([total(model_median[i]) >= 7 for i in ids], ready)
print("model rubric total 7+: sent", r["sent"], "| misrouted", r["misrouted"])

La sortie :

reproduction same as the author 21/30, model lower 8, same in all 3 runs 27/30
versions same as the author 26/30, model lower 3, same in all 3 runs 28/30
expected same as the author 26/30, model lower 2, same in all 3 runs 27/30
acceptance same as the author 26/30, model lower 3, same in all 3 runs 25/30
scope same as the author 26/30, model lower 4, same in all 3 runs 28/30
issues whose model total changed between runs: 10
model rubric total 7+: sent 7 | misrouted 9
Fréquence à laquelle la note du modèle (médiane de 3 essais) égale celle de l'auteur du cours, par critère (Repro : reproduction; Accept : acceptation). Les notes du modèle sont des sorties enregistrées du modèle, pas des étiquettes humaines.
Description textuelle du graphique

Un graphique à cinq colonnes : reproduction 21 sur 30, versions 26, résultat attendu 26, acceptation 26, portée 26.

Ce que cela nous dit. Le modèle est d’accord avec l’auteur sur 26 tickets sur 30 pour quatre critères. La reproduction fait exception, à 21 : le modèle est plus strict et a donné une note inférieure à 8 tickets. Ses raisons montrent pourquoi : il voulait une description de la configuration, comme un projet Django, une base de données ou un fichier de configuration. L’auteur avait jugé cette configuration triviale. Le modèle n’est pas entièrement stable non plus : son total a changé entre les essais pour 10 tickets sur 30. Comme barrière, ses notes orientent mal 9 tickets, près des 7 de l’auteur. Comme dans Trier de nombreuses réponses avec un modèle juge, ces chiffres viennent d’une comparaison préalable avec vos propres étiquettes. Sans cette vérification, vous ne sauriez pas qu’il est strict sur la reproduction.

L’auteur du cours a réécrit trois tickets faibles dans le format prêt pour un agent. Ils concernent un plantage de Django (django__django-15213, total 5), une vérification manquante dans Flask (pallets__flask-4045, total 5) et une demande de fonction pour pytest (pytest-dev__pytest-5221, total 3). L’auteur les a rédigés après la passe 2 et connaissait donc les corrections fusionnées. Pour limiter cette connaissance après coup, chaque réécriture utilise seulement le texte du ticket et un essai réel au commit de base du ticket, soit la version enregistrée dans Git. Tout ce que les responsables du projet devaient décider reste une question ouverte, dans un champ absent du modèle : Décision requise.

Voici le ticket Django, côte à côte avec sa réécriture. La sortie réelle de la réécriture vient d’un véritable essai de Django au commit de base.

Champ du modèle Ticket original Réécriture
Résumé « ExpressionWrapper pour ~Q(pk__in=[]) provoque un plantage. » L’annotation produit du SQL invalide (SELECT AS "selected"), et la requête échoue.
Environnement Aucun Branche main de Django au commit 03cadb9 (4.1 en développement), Python 3.12, SQLite
Étapes queryset.annotate(...), avec « table » comme modèle La même annotation sur le modèle Author de l’application de test annotations de Django
Résultat réel SELECT AS "foo" FROM "table" SELECT AS "selected", puis OperationalError: near "AS": syntax error (erreur de syntaxe près de AS)
Résultat attendu Non précisé : seulement « la requête échoue » Doit : selected est vrai pour chaque ligne. Doit : Q(pk__in=[]) reste faux. Ne doit pas : changer ce que filter() retourne.
Taux de reproduction Aucun 3 essais sur 3
Endroit soupçonné Aucun Une hypothèse : la condition vide niée se compile en chaîne SQL vide
Critères d’acceptation Aucun Le cas en échec joint réussit (3 tests sur 3); la suite annotations réussit; aucun test existant n’est modifié
Contraintes Aucune Modifier seulement django/db/models/; ne pas traiter pk__in=[] comme un cas particulier; ne pas modifier les tests existants

Les deux autres réécritures rencontrent une limite qu’aucun testeur ne peut contourner. Le ticket Flask demande « une erreur » quand le nom d’un blueprint contient un point. La vérification existante des noms de points de terminaison utilise assert, qui déclenche AssertionError. La nouvelle vérification devrait-elle faire pareil ou déclencher ValueError? La réécriture ne devine pas : elle pose la question aux responsables sous Décision requise. La réécriture pytest laisse aussi le format exact de sortie et « afficher ou non la portée par défaut » comme décisions ouvertes.

Avec la même grille, les totaux augmentent : Django passe de 5 à 10, Flask de 5 à 9, pytest de 3 à 8. Les deux décisions ouvertes maintiennent résultat attendu à 1. Les totaux médians du modèle pour les réécritures sont 9, 10 et 7. Il a donné la note maximale au résultat attendu de Flask, même si sa propre justification disait que le type d’erreur restait ouvert.

Vérifier une réécriture avec la correction et le test fusionnés

Section intitulée « Vérifier une réécriture avec la correction et le test fusionnés »

La réécriture Django est-elle juste? Ses critères d’acceptation sont devenus un cas en échec, comme dans Transformer un bogue en cas en échec : trois tests Django, un par règle. L’auteur du cours a téléchargé Django au commit de base du ticket. Il a ensuite exécuté le cas, le test fusionné, la correction fusionnée, puis les deux tests à nouveau. La sortie enregistrée, abrégée :

### 0. Reproduce: the SQL on the base commit
Q(pk__in=[]) -> SELECT 0 AS "selected" FROM "auth_user"
~Q(pk__in=[]) -> SELECT AS "selected" FROM "auth_user"
### 1. The rewrite's case on the base commit
Ran 3 tests in 0.002s
FAILED (errors=1)
### 2. The merged test on the base commit
Ran 3 tests in 0.006s
FAILED (errors=3)
### 3. The SQL after the merged fix
Q(pk__in=[]) -> SELECT 0 AS "selected" FROM "auth_user"
~Q(pk__in=[]) -> SELECT 1 AS "selected" FROM "auth_user"
### 3a. The rewrite's case after the merged fix
Ran 3 tests in 0.001s
OK
### 3b. The merged test after the merged fix
Ran 3 tests in 0.006s
OK
### 3c. The whole annotations suite after the fix
Ran 80 tests in 0.028s
OK (skipped=3)

Ce que cela nous dit. Le cas de la réécriture se comporte comme un cas en échec le doit. Il échoue au commit de base, avec la même erreur que le test fusionné, et réussit après la correction fusionnée. Les deux tests qui réussissent avant la correction vérifient les règles « doit continuer à fonctionner ». Ils protègent contre une correction qui brise autre chose. Après la correction, toute la suite annotations réussit aussi.

Le critère d’acceptation de la réécriture correspond-il à ce que le vrai test vérifie? Règle par règle :

Correspondance entre les règles de la réécriture et les tests fusionnés. Réécriture, Doit : ~Q(pk__in=[]) est vrai pour chaque ligne; même vérification que le test fusionné test_full_expression_annotation (chaque livre est sélectionné). Réécriture, Doit : Q(pk__in=[]) reste faux pour chaque ligne; même vérification que le test existant test_empty_expression_annotation. Réécriture, Ne doit pas : changer ce que filter() retourne; seule la réécriture le vérifie, aucun test fusionné ne le fait. Absents de la réécriture : deux cas voisins ajoutés par les responsables, l'annotation dans Count() et Sum() sur l'annotation.
Les critères d'acceptation de la réécriture comparés aux tests fusionnés avec la correction. Deux règles correspondent exactement; les responsables ont ajouté deux cas voisins que la réécriture ne nommait pas.
Description textuelle du diagramme

Trois lignes et un groupe. La première règle Doit de la réécriture correspond à la vérification du test fusionné test_full_expression_annotation. Sa deuxième règle Doit correspond à la vérification d’un test existant. Seule la réécriture vérifie sa règle Ne doit pas. Deux tests fusionnés, l’annotation dans Count() et Sum() sur l’annotation, sont des cas voisins que la réécriture ne nommait pas.

Ce que cela nous dit. L’essentiel correspond : la première règle Doit de la réécriture est l’assertion principale du test fusionné, « chaque ligne est sélectionnée ». Les responsables ont aussi testé deux cas voisins : la même annotation dans une agrégation (Count(), qui ajoute un GROUP BY) et une somme (Sum()). La réécriture ne les nommait pas. Une correction d’agent pourrait réussir le cas de la réécriture et quand même échouer dans un GROUP BY. Voilà pourquoi Vérifier la correction de l’agent exécute les cas voisins, pas seulement le cas en échec. Une meilleure réécriture ajoute une ligne : « Doit : la même annotation fonctionne dans Count() et Sum(). »

Le ticket gardé à part, django__django-11133, passe maintenant par toute la méthode. Son texte indique que HttpResponse(memoryview(b"My Content")).content donne b'<memory at 0x7fcc47ab2648>', alors que l’auteur attend b'My Content'. Le contenu sous forme de chaîne et d’octets fonctionne.

Notez-le. L’auteur du cours : reproduction 2, versions 0, résultat attendu 2, acceptation 1, portée 1, soit 6 sur 10. La médiane du modèle donne les cinq mêmes notes.

Décidez. Sous le seuil de 7 : réécrire d’abord. La réécriture ajoute la version, le cas en échec joint et « le contenu sous forme de chaîne et d’octets garde ses résultats actuels ».

Ouvrez le corrigé.

author total 6 | model total 6 | decision with the bar of 7: rewrite first
merged test: ['def test_memoryview_content(self):', "r = HttpResponse(memoryview(b'memoryview'))", "self.assertEqual(r.content, b'memoryview')"]
names in the text that the fix changes: ['response']

Ce que cela nous dit. Le test fusionné vérifie exactement ce que le texte attend : le contenu memoryview donne les mêmes octets. Ce ticket était donc prêt, mais la règle l’a retenu parce que la version manquait. C’est l’erreur peu coûteuse, « prêt mais retenu ». La réécriture ajoute quand même un cas joint et une règle « doit continuer à fonctionner ».

Amara écrit à Jonas en mots simples :

  • N’envoyez pas les tickets à l’agent tels quels. Dans cette étude, seuls 10 tickets réels sur 30 indiquaient ce que le test des responsables vérifiait. Tout envoyer en orienterait mal deux sur trois.
  • Faites de la réécriture prête pour un agent l’étape habituelle. Si un essai gaspillé coûte trois réécritures (une hypothèse), tout réécrire d’abord était la règle la moins coûteuse.
  • Si le temps de réécriture manque, laissez la grille choisir l’ordre. Un total de 7 ou plus, ou la note maximale pour « résultat attendu », repérait la plupart des tickets prêts.
  • Demandez d’abord aux responsables quand le texte laisse une décision ouverte. Les noms de paramètres, les formats de sortie et les types d’erreurs étaient les lacunes les plus fréquentes. Aucun testeur ne peut les deviner, et aucun agent ne devrait le faire.
  • Nommez les cas voisins dans les critères d’acceptation. Les tests fusionnés vérifiaient souvent des cas connexes, comme la même fonction dans un autre appel.
  • Un modèle peut donner des notes préliminaires aux tickets. Il était d’accord avec l’auteur sur la plupart des critères. Vérifiez-le d’abord sur un échantillon de vos propres tickets, et attendez-vous à plus de sévérité sur la reproduction.

Et voici à quoi ne pas utiliser l’étude :

  • Pas pour juger les personnes qui signalent les problèmes. Les auteurs des tickets écrivaient pour les responsables, pas pour des agents. Une note faible concerne l’adéquation à un agent, pas une personne.
  • Pas comme chiffre valable pour tous les projets. Mesurez votre propre liste de tickets en attente avant d’en citer un.
  • Un filtrage pour faciliter le travail. SWE-bench Lite a retiré les tickets contenant des images, des liens, des textes très courts et des corrections touchant plusieurs fichiers. Une vraie liste de tickets en attente contient davantage de tickets faibles.
  • Petit échantillon et un seul évaluateur. Trente tickets, avec les notes et les vérifications d’une seule personne. Un deuxième évaluateur serait en désaccord sur certaines notes. Des différences d’un ou deux tickets peuvent tenir au hasard.
  • Une correction est une réponse. Le test fusionné montre ce que les responsables ont choisi. Une autre correction juste pourrait y échouer. « Le test vérifie quelque chose que le texte ne dit pas » peut signaler un texte faible ou des responsables qui ont choisi d’aller plus loin.
  • La connaissance après coup dans les réécritures. L’auteur connaissait les corrections au moment de réécrire les tickets. Les décisions ouvertes sont restées ouvertes, mais un testeur sans cette connaissance pourrait écrire une réécriture plus faible.
  • Un modèle, trois essais. Un autre modèle ou une autre requête (prompt) donnerait des notes différentes.
  • L’agent n’a pas été exécuté. Cette étude vérifie les textes des tickets, pas les corrections d’un agent. Ce dont un agent de programmation a besoin montre une expérience enregistrée avec un agent.
  • Ce sont les mots de vraies personnes. Les textes des tickets sont publics, mais chacun vient d’une personne qui voulait de l’aide. Citez-les pour apprendre, reconnaissez le projet et ne vous moquez pas d’un rapport faible.
  • Dites qui a noté quoi. Les notes de la grille et les vérifications représentent le jugement de l’auteur du cours. Les notes du modèle sont des sorties du modèle. Gardez-les dans des colonnes séparées et n’appelez jamais une note de modèle une étiquette humaine.
  • Un rapport prêt pour un agent ne permet pas de sauter la révision. Une réécriture avec un cas en échec facilite la vérification d’une correction d’agent. Les personnes lisent toujours la modification, comme dans Vérifier la correction de l’agent.
  • Excluez les données privées des appels au modèle. Ici, les tickets étaient publics. Avant d’envoyer ceux de votre équipe à un modèle hébergé, vérifiez leur contenu et ce que votre organisation permet.

Cette étude montre à un employeur que vous pouvez transformer « l’agent va le corriger » en décision mesurée. Adaptez-la avec un seul changement. Par exemple, notez 30 tickets de votre propre projet ou de SWE-Gym. Ou ajoutez un deuxième évaluateur humain, ou exécutez un agent de programmation sur le texte original et sur votre réécriture. Rendez ensuite votre travail public et facile à lire en cinq minutes.

Quoi mettre dans le dépôt :

  • README.md, la page que les gens lisent d’abord (modèle ci-dessous).
  • Le carnet, exécuté du début à la fin, avec ses sorties.
  • RUBRIC.md : les cinq critères avec leurs niveaux 0, 1 et 2, et un exemple par niveau.
  • ratings.csv et checks.csv, avec une raison par note et le commit qui montre que la passe 1 précédait la passe 2.
  • Vos réécritures, chacune avec son cas en échec, et le journal d’exécution de la vérification avec le test fusionné.
  • La source des données et la licence : SWE-bench Lite, MIT, avec attribution aux projets.

Un modèle de README :

# Are real issues ready for a coding agent?
## Question
How often does an issue, as written, state what the maintainers' merged test checks?
Can a short rubric pick out the ready ones?
## Data and licence
SWE-bench Lite (Jimenez et al., 2024), MIT: 30 issues from 12 Python projects,
each with its merged fix and test; 1 more issue kept apart.
## Method
Pass 1: a 5-criterion rubric (0-2 each) from the text alone. Pass 2: the merged
fix and test as the answer key. Triage rules compared by misrouted issues.
A hosted model rated the same issues 3 times. 3 rewrites; 1 checked by running it.
## Results
Ready (test matches the text): 10 of 30. Misrouted: send everything 20,
rewrite everything 10, rubric total 7+ 7. Most often missing: versions (16 of 30),
acceptance criteria beyond one example (28 of 30). Model vs me: 21-26 of 30.
Django rewrite: fails before the merged fix, passes after; the maintainers'
test added 2 neighbours that my rewrite did not name.
## Limits
Filtered, easy issues; one rater; 30 issues; the agent itself was not run.

Comment le décrire en entrevue, en deux phrases : « J’ai évalué 30 vrais tickets de logiciels libres en les comparant aux tests fusionnés par leurs responsables : seulement un tiers disait ce que le test vérifiait, et une grille à cinq critères a réduit les tickets mal orientés de 20 à 7. J’ai réécrit des tickets faibles dans un format prêt pour un agent et vérifié l’un d’eux en l’exécutant : il échouait avant la vraie correction et réussissait après. »

Allez plus loin :

  • Exécutez la partie Django facultative du carnet, puis ajoutez les deux cas voisins au cas de la réécriture. Prédisez d’abord : échouent-ils au commit de base?
  • Demandez à un collègue de noter les mêmes 30 tickets avec la grille. Où êtes-vous le plus en désaccord?
  • Notez 30 tickets de SWE-Gym, qui n’a pas été filtré pour garder les textes clairs. Prédisez d’abord : plus ou moins de tickets prêts?
  • Donnez à un agent de programmation le texte original et votre réécriture du même ticket, puis exécutez le test fusionné sur les deux corrections.

Vérifiez votre compréhension

Le ticket Flask sur from_file() a obtenu 8 sur 10. Pourtant, le test fusionné ne vérifie qu'en partie ce que le texte attend. Comment un ticket clair peut-il échouer au corrigé, et qu'aurait dû faire la personne qui le signale ou le teste?

Afficher la réponse

Le texte décrivait clairement le problème et proposait une solution : un paramètre mode="b". Les responsables ont choisi une autre conception, text=False, et ont écrit le test correspondant. Un agent qui suit le texte crée une fonction qui marche, mais qui échoue au test. La grille juge la clarté du texte, pas si sa proposition correspond au choix des responsables. Il faut donc s’entendre sur l’interface avant de lancer l’agent. Indiquez que les responsables doivent décider du nom du paramètre, comme dans les versions réécrites. Transformez ensuite la réponse convenue en critère d’acceptation.

Vérifiez votre compréhension

À poids égaux, la barrière fondée sur la grille oriente mal 7 tickets, contre 10 pour « tout réécrire d'abord ». Si un lancement inutile de l'agent compte pour 3, la barrière coûte 17, contre 10 pour la réécriture complète. Qu'est-ce qui détermine la meilleure règle, et que recommanderiez-vous?

Afficher la réponse

Deux éléments le déterminent : la proportion de tickets prêts et le coût de chaque erreur. Seuls 10 tickets sur 30 étaient prêts. Toute barrière laisse donc passer certains tickets non prêts, qui coûtent chacun trois fois plus qu’une réécriture. Quand un lancement inutile coûte cher et qu’une réécriture coûte peu, tout réécrire d’abord est le meilleur choix. Recommandez la réécriture comme étape habituelle, et utilisez la grille pour ordonner le travail quand le temps manque. Si les lancements de l’agent devenaient peu coûteux et fiables, la barrière pourrait devenir le meilleur choix. Ce serait aussi possible si la liste de tickets contenait davantage de tickets prêts. Mesurez de nouveau avant de changer la règle.

Vérifiez votre compréhension

Le cas en échec de la réécriture Django échoue avant la correction fusionnée et réussit après. Cela prouve-t-il que les critères d'acceptation de la réécriture étaient complets? Expliquez à l'aide des tests fusionnés.

Afficher la réponse

Non. Cela prouve que le cas est un véritable cas en échec : il détecte ce bogue et accepte cette correction. La question de l’exhaustivité est différente. Les tests des responsables vérifiaient aussi deux cas voisins : l’annotation dans Count() (un GROUP BY) et Sum() appliqué à celle-ci. La réécriture ne les nommait pas. Une autre correction pourrait donc réussir son cas, mais faire échouer ces requêtes. Les critères d’acceptation doivent nommer les cas voisins. La vérification doit les exécuter, ainsi que toute la suite de tests.

Récapitulatif

  • Une grille à cinq critères tirée du modèle prêt pour un agent a évalué 30 vrais tickets, uniquement selon leur texte. Les versions (absentes dans 16 tickets) et les critères d’acceptation (note maximale dans 2 tickets) étaient les points les plus faibles.
  • Le test fusionné sert de corrigé : il montre ce que « corrigé » voulait dire. Il vérifiait les attentes du texte pour seulement 10 tickets sur 30.
  • Selon une mesure, les tickets mal orientés, un total de grille d’au moins 7 faisait mieux (7) que l’envoi systématique (20). Quand un lancement inutile de l’agent coûte plus qu’une réécriture, réécrire chaque ticket d’abord était le choix le moins coûteux.
  • Un modèle a appliqué la grille de façon proche de l’auteur, mais plus strictement pour la reproduction. Son total a changé entre les essais pour 10 tickets.
  • Une réécriture avec des règles obligatoires et un cas en échec correspondait à l’essentiel du vrai test. Elle échouait avant la correction fusionnée et réussissait après, mais omettait les cas voisins des responsables.

Ensuite, une autre sorte de passe de tests : des jeux d’attaques ouverts contre un assistant enregistré. Vous verrez des taux par catégorie et des rapports avec une évaluation de la gravité.

Leçon suivante : Une passe de tests de sécurité avec des jeux d'attaques ouverts