Data Science avec copilote IA : écrire, exécuter, vérifier

Laissez l’IA écrire le code — laissez le runtime décider s’il est juste

Utilisez un assistant IA pour écrire du R plus vite sans faire confiance à un code que vous ne pouvez pas contrôler. Une boucle écrire-exécuter-vérifier reproductible où le runtime — pas le chatbot — décide si la réponse est correcte et reproductible.

AstucePoints clés

• Écrivez avec l’IA, vérifiez avec le runtime. Un copilote rédige vite, mais il ne peut pas exécuter son code sur vos données — la version proposée est donc une hypothèse, pas une réponse. C’est le runtime, qui exécute, qui tranche.
• « Ça a tourné » n’est pas « c’est juste ». L’erreur d’IA la plus dangereuse s’exécute proprement et renvoie un chiffre d’apparence plausible — comme un regroupement sur la mauvaise colonne. Aucune erreur n’apparaît ; seul un contrôle la détecte.
• Quatre portes, toutes franchies en exécutant. Est-ce que ça tourne ? Est-ce que ça calcule ce que vous avez demandé (réconcilier une valeur par une voie indépendante) ? Le chiffre est-il défendable (poser un invariant avec stopifnot()) ? Est-il reproductible (set.seed(), puis exécuter deux fois) ?
• Demandez le contrôle, pas seulement le code. Demandez à l’assistant de renvoyer le code et une assertion qui échouerait si le résultat était faux — puis exécutez l’assertion vous-même.
• C’est le jugement qu’une IA ne peut pas simuler. Le goulot d’étranglement est passé de l’écriture du code à son évaluation. Distinguer le juste du seulement plausible est la compétence durable, et elle exige plus de compréhension, pas moins.

Le raccourci qui n’en est pas un

Un assistant IA vous écrit du code R en quelques secondes. C’est réellement utile — la rédaction est la partie lente et fastidieuse d’une analyse, et un copilote y excelle. Le piège est de traiter cette version proposée comme la réponse. Le code écrit par une IA est plausible par construction : il est optimisé pour avoir l’air juste, pas pour être juste sur vos données. Il appellera avec assurance une fonction qui n’existe pas, regroupera sur la mauvaise colonne, ou vous rendra un chiffre faussé par un facteur que vous ne remarqueriez jamais à l’œil.

La compétence qui compte vraiment à l’ère de l’IA n’est donc pas le prompting — c’est la vérification. Vous laissez l’IA écrire, vous exécutez le code immédiatement, puis vous faites prouver le résultat par le runtime. L’avis du chatbot ne compte pas ; l’exécution, si. C’est toute la leçon, et c’est une boucle que vous pouvez dérouler à chaque fois :

flowchart LR
  W["**Écrire**<br/>l'IA propose le code"] --> R["**Exécuter**<br/>lancer sur de vraies données"]
  R --> V["**Vérifier**<br/>the runtime is the judge"]
  V -->|réussite| S["**Expédier**<br/>se fier au résultat"]
  V -->|échec| W

À la fin, vous aurez un workflow concret — et un contrôle exécutable qui attrape en direct, dans votre navigateur, une erreur de l’IA, sans aucune installation de R.

Note

Les cellules {webr} ci-dessous exécutent du vrai R dans votre navigateur. Modifiez n’importe quel bloc et appuyez sur Run Code — c’est le runtime, pas un chatbot, qui vous dit si votre changement tient. C’est là tout l’enjeu.

Écrire : laissez l’IA proposer

Partez d’une vraie tâche et d’un prompt clair. Supposons que vous exploriez le jeu de données intégré mtcars et que vous demandiez à un assistant :

« En R, donne-moi la moyenne de miles-par-gallon pour chaque nombre de cylindres dans mtcars. »

Un copilote pourrait renvoyer ceci :

# AI-drafted answer
tapply(mtcars$mpg, mtcars$gear, mean)

C’est propre, ça utilise une vraie fonction base R, et ça s’exécutera sans erreur. On l’expédie ? Pas encore. Remarquez ce que la simple lecture ne vous dit pas : si cela répond bien à la question que vous avez réellement posée.

Exécuter : lancez tout de suite

Le premier rôle du runtime est d’exécuter la proposition sur de vraies données, pour que vous voyiez la sortie au lieu de l’imaginer. Appuyez sur Run Code :

Vous obtenez trois nombres, étiquetés 3, 4, 5. Ils ressemblent à une réponse tout à fait correcte. Mais les étiquettes sont l’indice : vous avez demandé les cylindres (soit 4, 6, 8 dans mtcars), et ces groupes sont 3, 4, 5. L’IA a regroupé sur gear, pas sur cyl. Ça tourne, et c’est faux — le mode de défaillance le plus dangereux qui soit, car rien ne provoque d’erreur.

Voilà pourquoi « ça a tourné » n’est jamais la même chose que « c’est juste ».

Vérifier : the runtime is the judge

La vérification tient en quatre questions, chacune tranchée en exécutant quelque chose — jamais en demandant à l’IA si elle est sûre. Traitez-les dans l’ordre.

Porte 1 — est-ce que ça tourne, tout simplement ?

Beaucoup de code d’IA échoue dès le premier obstacle : une fonction hallucinée, un package non installé, un argument qui n’existe pas. Pas besoin de les repérer à la lecture — le runtime les attrape à la seconde où vous exécutez. Un assistant pourrait par exemple inventer un helper d’apparence soignée :

# AI-drafted — looks reasonable, but summarise_by() is not a real function
mtcars |> summarise_by(cyl, avg = mean(mpg))
#> Error: could not find function "summarise_by"

L’exécuter, voilà le contrôle. Une erreur ici est une bonne nouvelle : le runtime a réfuté une mauvaise proposition en une seconde, avant qu’elle n’atteigne votre rapport.

Porte 2 — est-ce que ça calcule ce que vous avez demandé ?

C’est la porte qui attrape notre bug gear-au-lieu-de-cyl, et c’est celle que la lecture ne peut pas franchir. La méthode : recalculer une valeur par une voie indépendante et comparer. Si l’IA affirme que la moyenne d’un groupe vaut X, calculez ce même groupe vous-même avec une autre expression. Quand les deux divergent, l’IA a tort — sans débat.

La moyenne à 4 cylindres est de 26.66. La réponse de l’IA comportait bien un groupe étiqueté 4 — mais sa valeur était 24.53, parce qu’il s’agissait de gear == 4, un autre ensemble de voitures. Deux nombres qui divergent ; le runtime vient de vous dire quelle proposition garder.

Porte 3 — le chiffre est-il défendable ?

Certains résultats sont faux d’une manière qu’aucun contrôle ponctuel ne révèle — un filtre qui a discrètement supprimé des lignes, une jointure qui les a dupliquées. Protégez-vous avec un invariant : un fait qui doit tenir si le calcul est sain, exprimé sous forme d’assertion. stopifnot() est le runtime qui joue le rôle de juge automatiquement — il ne dit rien quand le contrôle passe, et s’arrête bruyamment quand il échoue.

Quand ces appels stopifnot() restent silencieux, le runtime a certifié la forme de votre résultat. Transformez les contrôles que vous feriez à la main en assertions, et ils s’exécutent à chaque fois — gratuitement.

Porte 4 — est-ce reproductible ?

Si le code fait intervenir la moindre part d’aléa — un échantillonnage, une découpe entraînement/test, une simulation — « juste une fois » ne suffit pas. Il doit donner la même réponse la fois suivante, sinon le résultat n’en est pas un. La parade : fixer la graine du générateur, puis le prouver en exécutant deux fois.

Même graine, sortie identique : le runtime confirme que le résultat est reproductible. Sans la graine, ces deux moyennes différeraient — et celles de tous les autres aussi, y compris les vôtres, demain.

Figure 1

Un workflow adoptable dès aujourd’hui

Les quatre portes se replient en une seule boucle répétable. Déroulez-la pour chaque tâche que vous confiez à une IA :

Étape	Ce que vous faites	Qui décide
1. Écrire	Décrivez la tâche et laissez l’IA proposer le code	IA
2. Exécuter	Lancez-le tout de suite sur vos vraies données	Runtime
3. Vérifier	Réconciliez une valeur, posez un invariant, fixez la graine de tout aléa	Runtime
4. Expédier ou boucler	Réussite → gardez-le. Échec → confiez à l’IA l’erreur ou l’écart et refaites une proposition	Vous

Deux habitudes accélèrent la boucle :

• Demandez le contrôle, pas seulement le code. Demandez à l’assistant de « renvoyer le code et un stopifnot() qui échouerait si le résultat est faux ». Vous exécutez toujours l’assertion vous-même — mais l’IA a fait la partie fastidieuse de l’écrire, et vous en avez fait votre propre vérificateur.
• Gardez des tâches petites. Un copilote est bien plus fiable sur une seule étape bien cadrée que sur toute une analyse d’un coup, et une petite étape est bien plus facile à vérifier. Proposez, vérifiez, avancez — n’acceptez pas cinquante lignes que vous ne contrôlerez jamais entièrement.

Lorsque de l’aléa, des contrôles de données ou toute une suite de tests entrent en jeu, cela monte proprement en puissance vers de vrais tests et de la validation de données — voir R robuste et digne de confiance pour testthat et pointblank, la version industrielle des portes ci-dessus.

Pourquoi « the runtime is the judge »

Cette boucle n’est pas un pansement sur une mauvaise IA — c’est la seule chose qui sépare structurellement une analyse correcte d’une analyse plausible. Un chatbot ne peut pas exécuter son propre code sur vos données, donc il ne peut pas savoir si sa réponse est juste ; il peut seulement sonner juste. Le runtime, lui, le peut, parce qu’il exécute. Cette asymétrie est permanente, et c’est exactement pourquoi une réponse que vous pouvez exécuter l’emporte sur une réponse que vous pouvez seulement lire.

C’est aussi le principe derrière l’assistant de Datanovia, Prova : chaque affirmation qu’il fait est adossée à du code que vous pouvez exécuter sur la page, si bien qu’on ne vous demande jamais de croire une réponse générée sur parole. L’habitude est la même, que le copilote soit Prova, ChatGPT, Claude ou Copilot — écrivez avec lui, mais laissez le runtime être le juge.

Problèmes fréquents

La réponse de l’IA tourne et a l’air juste, mais un chiffre est subtilement faux. C’est la Porte 2. N’acceptez jamais une valeur calculée que vous n’avez pas réconciliée au moins une fois par une voie indépendante — recalculez un seul groupe, un seul total ou une seule ligne autrement, et comparez. L’accord ne coûte rien ; un chiffre faux dans votre article, si.

Le résultat change à chaque exécution. Quelque chose est aléatoire et sans graine. Ajoutez set.seed() avant tout échantillonnage, découpe ou simulation, et prouvez-le en exécutant le bloc deux fois (Porte 4). Si les deux sorties diffèrent, la graine ne couvre pas tout l’aléa — trouvez l’étape sans graine.

L’IA invente une fonction ou un package. Une erreur could not find function ou there is no package called est le runtime qui attrape une hallucination (Porte 1). Ne partez pas en chasse de la « bonne » orthographe d’un nom inventé — demandez à l’assistant un équivalent en base R ou dans un package bien connu, puis exécutez-le.

Questions fréquentes

NoteChatGPT (ou Claude, ou Copilot) est-il assez fiable pour écrire du R en conditions réelles ?

Assez fiable pour proposer, pas pour faire confiance sans contrôle. Ces modèles produisent vite du code plausible, ce qui fait gagner un temps réel — mais ils ne peuvent pas exécuter leur code sur vos données, donc ils ne peuvent pas distinguer une réponse correcte d’une réponse convaincante. Traitez chaque proposition comme une hypothèse et laissez le runtime la tester avec les quatre portes de cette leçon. Utilisé ainsi, un copilote IA est un véritable accélérateur ; pris pour un oracle, il finira par vous rendre un chiffre faux avec une confiance totale.

NoteComment savoir vraiment qu’un code écrit par une IA est correct ?

On ne vérifie pas en lisant — on vérifie en exécutant. Exécutez le code, puis (1) réconciliez au moins une valeur de sortie avec un calcul indépendant, (2) posez un invariant avec stopifnot() qui échouerait si la logique était fausse, et (3) fixez la graine de tout aléa et confirmez que le résultat se répète. Si les trois tiennent, c’est le runtime — pas l’IA, ni vos yeux — qui a confirmé le résultat.

NoteDevrais-je laisser une IA écrire toute mon analyse d’un coup ?

Non. Un copilote est nettement plus fiable sur une petite étape bien cadrée que sur un script tentaculaire, et une petite étape est bien plus facile à vérifier. Travaillez dans une boucle serrée écrire-exécuter-vérifier : proposez une étape, prouvez-la avec le runtime, puis avancez. Un bloc de cinquante lignes que vous n’avez jamais entièrement contrôlé est un risque, aussi bon soit son aspect.

NoteS’appuyer sur un copilote IA veut-il dire que je n’ai plus besoin d’apprendre R ?

Au contraire. Le goulot d’étranglement est passé de l’écriture du code à son évaluation, et évaluer exige plus de compréhension, pas moins — vous ne pouvez pas réconcilier un résultat, choisir un invariant solide ou repérer une confusion gear-au-lieu-de-cyl sans savoir à quoi ressemble une réponse correcte. Le copilote écrit plus vite ; c’est toujours à vous d’être celui qui sait distinguer le juste du plausible.

ImportantTestez votre compréhension

Tâche. On a demandé à une IA le nombre de voitures dans chaque groupe de cylindres de mtcars, et elle a proposé la cellule ci-dessous. Elle tourne — mais le regroupement est-il correct ? Ajoutez une ligne qui fait du runtime le juge : un stopifnot() affirmant que les effectifs des groupes s’additionnent pour donner chaque voiture du jeu de données. Si l’IA a mal regroupé, votre contrôle doit échouer.

Note

La fonction base R qui s’arrête bruyamment quand une condition est fausse — et reste silencieuse quand elle est vraie — est celle que vous avez vue à la Porte 3. Elle prend une ou plusieurs expressions logiques.

Note

stopifnot() transforme l’invariant en juge d’exécution : silencieux en cas de succès, une erreur en cas d’échec.

counts <- table(mtcars$cyl)
print(counts)

stopifnot(sum(counts) == nrow(mtcars))

Ici, ça passe, parce que table(mtcars$cyl) compte réellement chacune des 32 voitures. Si l’IA avait regroupé sur la mauvaise variable et supprimé ou dupliqué des lignes, sum(counts) ne serait pas égal à nrow(mtcars) et le runtime se serait arrêté — exactement le contrôle que vous voulez voir tourner sur du code que vous n’avez pas écrit vous-même.

ImportantContrôle rapide

Une IA vous remet du code R, vous l’exécutez, et il produit un tableau propre, d’apparence sensée, sans erreur ni avertissement. Qu’avez-vous réellement confirmé ?

A. Le résultat est correct et vous pouvez l’expédier B. Seulement que le code s’exécute — pas qu’il calcule ce que vous avez demandé C. Rien, car une sortie que l’on peut lire n’est jamais digne de confiance

AstuceAfficher la réponse

B. Une exécution sans erreur franchit la Porte 1 (ça s’exécute) mais ne dit rien de la Porte 2 (est-ce que ça répond à votre question ?). Le bug gear-au-lieu-de-cyl tournait parfaitement et était pourtant faux. Réconciliez une valeur et posez un invariant avant de lui faire confiance.

Conclusion

Un copilote IA change qui écrit la première version, pas qui est responsable du résultat. Laissez-le écrire — c’est un vrai gain de vitesse — mais fermez la boucle à chaque fois : exécutez le code sur vos propres données, réconciliez une valeur, posez un invariant et fixez la graine de tout aléa. Chacun de ces gestes est le runtime qui vous donne une réponse que le chatbot n’a jamais pu fournir, parce que le runtime exécute là où le chatbot ne fait que prédire. Écrivez avec l’IA, et laissez le runtime être le juge.

Leçons associées

• R robuste et digne de confiance — testthat et pointblank, la version industrielle des quatre portes. · Écrire des fonctions — empaquetez une étape vérifiée pour la réutiliser et la tester. · Code interactif et en direct dans Quarto — le mécanisme webR derrière les cellules exécutables de cette page. · Obtenir de l’aide dans R — lire les erreurs et les exemples reproductibles, l’autre moitié du débogage des propositions d’IA.
• Aller plus loin : Fondamentaux de R — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

🟢 Avec un agent IA

Vous avez utilisé une IA pour écrire du R et vous n’êtes pas sûr que ce soit juste ? Collez le code et demandez à Prova « est-ce que ça fait ce que j’ai demandé, et comment le vérifier ? » — il réconcilie le résultat, suggère les contrôles stopifnot() à ajouter, et parce que le runtime est ici même, vous exécutez ces contrôles sur vos données et les regardez passer ou échouer. Demander à Prova →

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché. Les cellules {webr} exécutent du vrai R dans votre navigateur — modifiez n’importe quel bloc et appuyez sur Run Code pour reproduire ces sorties vous-même. The runtime is the judge.