Le code écrit à la main va-t-il disparaître ?

Les agents écrivent de plus en plus notre code, mais la responsabilité reste humaine. Mon avis, celui des ingénieurs en 2026, et pourquoi l'abstraction progresse de l'assembleur à Python.

IA

Publié le · Lecture : 9 min

Mi-novembre 2026, une question tourne dans les médias : GTA VI sera-t-il le dernier blockbuster fabriqué « à la main » ?

Je me suis posé la même question pour mon métier. Le code écrit à la main va-t-il disparaître ?

Ma réponse courte : on ne code déjà presque plus à la main. Mais on n'a jamais été aussi responsables du code qu'on livre.

Points essentiels à retenir :

  • L'histoire du code est une histoire d'abstraction : les agents ne sont que la marche suivante
  • Ce sont les agents qui écrivent le code, mais la responsabilité reste humaine
  • En 2026, les ingénieurs sont partagés : le débat porte sur qui écrit, jamais sur qui répond du code
  • De l'assembleur à Python, les langages bas niveau reculent sans disparaître : ils deviennent des langages de spécialistes
  • Le code écrit à la main deviendra une compétence de spécialistes, la compréhension restera indispensable

1. Mon avis : l'abstraction n'est pas nouvelle, la responsabilité non plus

On a commencé à moins écrire bien avant les agents. L'autocomplétion, les snippets, les générateurs de projets : on tapait déjà de moins en moins de lignes nous-mêmes.

En réalité, l'histoire du code est une histoire d'abstraction. On est passé de l'assembleur au C, du C aux langages de haut niveau, puis aux frameworks. Personne ne pense qu'un dev React « ne code pas vraiment » parce qu'il n'écrit pas le JavaScript compilé.

Pour visualiser : l'échelle de l'abstraction

L'échelle de l'abstraction Un escalier de six marches, de bas en haut : binaire (des 0 et des 1), assembleur (mov, add, jmp), C (boucles, pointeurs), Python et TypeScript (sum(nombres)), frameworks (React, Laravel), agents IA (une phrase en français). En montant, on s'éloigne de plus en plus de la machine et on tape de moins en moins de lignes. Le long de tout l'escalier, une bande jaune fixe : la responsabilité reste humaine. L'échelle de l'abstraction Binairedes 0 et des 1 Assembleurmov, add, jmp Cboucles, pointeurs Python, TypeScriptsum(nombres) FrameworksReact, Laravel Agents IAune phrase en français La responsabilité reste humaine de plusen plus loinde la machine de moinsen moins delignes tapées L'échelle de l'abstraction Un escalier de six marches, de bas en haut : binaire (des 0 et des 1), assembleur (mov, add, jmp), C (boucles, pointeurs), Python et TypeScript (sum(nombres)), frameworks (React, Laravel), agents IA (une phrase en français). En montant, on s'éloigne de plus en plus de la machine et on tape de moins en moins de lignes. Le long de tout l'escalier, une bande jaune fixe : la responsabilité reste humaine. L'échelle de l'abstraction Agents IAune phrase en français FrameworksReact, Laravel Python, TypeScriptsum(nombres) Cboucles, pointeurs Assembleurmov, add, jmp Binairedes 0 et des 1 de plus en plus loin de la machinede moins en moins de lignes tapées La responsabilité reste humaine

À chaque marche, on écrit moins de lignes. Mais à aucune marche, quelqu'un d'autre ne répond du résultat à ta place.

Je ne suis pas la seule à le voir ainsi. Anil Dash décrit les agents de code comme les nouveaux compilateurs : chaque génération de code a fini par masquer la précédente. Chris Lema va plus loin : selon lui, chaque transition fait monter la responsabilité d'un cran. Moins sur le « comment », plus sur le « quoi » et le « pourquoi ».

C'est exactement mon point de vue. Ce sont les agents qui écrivent le code, mais la responsabilité reste humaine. Quand un bug part en production, ce n'est pas l'IA qui répond au client. Donc l'humain doit toujours comprendre le code généré.

2. Ce que disent les ingénieurs : loin d'être unanimes

Mon avis n'est pas le seul. En 2026, les ingénieurs sont partagés, et certains contre-arguments méritent d'être entendus.

Qui Position Argument
Spotify, Gustav Söderström (co-CEO) Le code écrit à la main a déjà disparu Ses meilleurs développeurs n'ont pas écrit une ligne de code depuis décembre 2025 (février 2026).
The New Stack Soulagement Beaucoup de devs seniors se disent heureux de ne plus taper le code et gardent le plaisir de résoudre le problème.
Quy Hoang, développeur L'analogie du compilateur est trompeuse Un compilateur est déterministe, l'IA est probabiliste : on ne peut pas lui faire confiance sans relire.
Fiona Fung, Claude Code chez Anthropic Le goulot a changé de place Écrire du code ne ralentit plus son équipe. Ce sont la vérification, la revue de code et la sécurité (juin 2026).

Deux études complètent ce tableau.

Anthropic, étude de janvier 2026 — risque pour l'apprentissage : sur 52 ingénieurs surtout juniors, le groupe avec IA a eu 50 % au quiz de compréhension, contre 67 % pour ceux qui codaient à la main. Le débogage était le plus touché.

METR, labo de recherche — dépendance : en février 2026, METR n'a pas pu refaire son étude : des devs refusaient de travailler sans IA, même pour quelques tâches.

Ce que je retiens : même ceux qui ne tapent plus une ligne ne disent pas qu'on peut arrêter de comprendre. Le débat porte sur qui écrit, jamais sur qui répond du code.

3. Ceux qui codent encore à la main

Dans les petites structures, je croise encore des devs qui écrivent tout eux-mêmes. Et ils ont leurs raisons.

  • Garder la compréhension. Un développeur explique sur CodeUtopia qu'en écrivant lui-même, il sait pourquoi chaque choix a été fait. Relire du code généré ne lui donne pas cette vision.
  • Éviter la « dette cognitive ». Ankur Sethi a lancé un débat sur Hacker News en proposant de retaper à la main le code généré au lieu de le copier-coller, pour s'obliger à le lire vraiment (août 2026).
  • Reprendre la main sur un code devenu illisible. Dans un fil Hacker News, une équipe de 15 ingénieurs raconte avoir réécrit le cœur de son produit après une phase de prototypage rapide trop désordonnée.
  • Le plaisir du métier. LeadDev a rencontré des développeurs qui refusent l'IA, même au risque de leur emploi (septembre 2026).

Je comprends ces choix. Ces devs connaissent leur code par cœur, et c'est précisément ce qui les rend efficaces.

Mais je me pose une question : et les générations suivantes ? Les juniors qui arrivent aujourd'hui apprennent avec l'IA dès le premier jour. Leur demander de tout coder à la main n'est pas réaliste. Leur apprendre à comprendre, relire et piloter ce que l'IA écrit, si.

4. Les langages bas niveau reculent, sans disparaître

L'abstraction ne date pas des agents. À chaque génération, on s'éloigne un peu plus de la machine : l'assembleur, puis le C, puis des langages de haut niveau comme Python.

Aujourd'hui, Python, l'un des langages les plus abstraits, est toujours en tête de l'index TIOBE en novembre 2026, même si sa part a reculé de plus de deux points en un an (Blog du Modérateur).

Pour visualiser : la même tâche à quatre étages

Additionner les nombres d'une liste, à quatre niveaux d'abstraction :

Assembleur :

; Somme des nombres d'un tableau d'entiers 32 bits (x86-64, NASM)
; rdi = adresse du tableau, rsi = nombre d'éléments
global somme
section .text
somme:
    xor  eax, eax            ; total = 0
    xor  ecx, ecx            ; i = 0
.boucle:
    cmp  rcx, rsi            ; i < taille ?
    jge  .fin
    add  eax, [rdi + rcx*4]  ; total += nombres[i]
    inc  rcx                 ; i++
    jmp  .boucle
.fin:
    ret                      ; le résultat est dans eax

C :

int somme(const int *nombres, int taille) {
    int total = 0;
    for (int i = 0; i < taille; i++) {
        total += nombres[i];
    }
    return total;
}

Python :

total = sum([4, 8, 15, 16, 23, 42])

Agent IA :

Écris une fonction qui additionne les nombres d'une liste, avec ses tests.

Le résultat est le même. Ce qui change, c'est la quantité de détails que tu gères toi-même. Mais aux quatre étages, il faut toujours quelqu'un pour dire si le résultat est juste.

Les langages plus anciens ou plus proches de la machine n'ont pas disparu pour autant. En août 2026, COBOL est revenu dans le top 20 de TIOBE, et l'assembleur y figure à la 20e place (Blog du Modérateur). Ils restent là où ils sont indispensables : banque, assurance, systèmes embarqués, performance extrême. Mais ce sont devenus des langages de spécialistes. C'est, je pense, ce qui attend le code écrit à la main.

Ce qui maintenait ces vieux systèmes en vie, c'était souvent le coût : les comprendre coûtait plus cher que les réécrire. L'IA change cette équation. En février 2026, Anthropic a annoncé que Claude Code pouvait analyser et moderniser du COBOL en quelques trimestres au lieu de plusieurs années, et un organisme a réduit de 94 % le temps d'analyse de son code (AI News). Si la refactorisation devient plus facile, je ne vois plus pourquoi on continuerait à maintenir ces systèmes par peur d'y toucher.

Mais les avis divergent. Rocket Software rappelle que réécrire du COBOL dépasse souvent les budgets et les délais, même avec l'IA. Et Amdocs titre que l'IA seule ne modernisera pas le mainframe. L'IA accélère, mais il faut toujours des humains qui comprennent le système métier.

5. Alors, le code écrit à la main va-t-il disparaître ?

Je pense que oui, en grande partie. Comme l'assembleur avant lui, il restera une compétence de spécialistes, pas le quotidien de la majorité des devs.

Mais ce qui ne disparaîtra pas, c'est la compréhension. Si on ne tape plus le code, on doit savoir :

  1. cadrer ce que l'agent doit produire (architecture, conventions, règles du projet) ;
  2. découper le travail en petits changements vérifiables ;
  3. relire et tester le code généré comme une pull request d'un collègue ;
  4. assumer ce qui part en production.

Pour visualiser : le cycle du pilotage

Le cycle du pilotage Quatre étapes en boucle autour de « Piloter l'IA » : 1. Cadrer (architecture, conventions, règles du projet), 2. Découper (de petits changements vérifiables), 3. Relire et tester (comme la PR d'un collègue), 4. Assumer (ce qui part en production). Une flèche ramène de l'étape 4 à l'étape 1. Le cycle du pilotage 1. Cadrerarchitecture, conventions,règles du projet 2. Découperde petits changementsvérifiables 3. Relire et testercomme la PRd'un collègue 4. Assumerce qui parten production Piloterl'IA on recommence Le cycle du pilotage Quatre étapes en boucle autour de « Piloter l'IA » : 1. Cadrer (architecture, conventions, règles du projet), 2. Découper (de petits changements vérifiables), 3. Relire et tester (comme la PR d'un collègue), 4. Assumer (ce qui part en production). Une flèche ramène de l'étape 4 à l'étape 1. Le cycle du pilotage Piloter l'IA 1. Cadrerarchitecture, conventions,règles du projet 2. Découperde petits changementsvérifiables 3. Relire et testercomme la PRd'un collègue 4. Assumerce qui parten production

La boucle ne s'arrête jamais : ce que tu assumes en production t'apprend à mieux cadrer la demande suivante.

Pour visualiser : la PR d'un agent à relire

On demande à un agent d'ajouter un code promo qui offre la livraison. Voici la fonction avant et après sa PR :

Avant :

export function livraisonGratuite(totalPanier: number): boolean {
  return totalPanier >= 50;
}

Après la PR de l'agent :

export function livraisonGratuite(totalPanier: number, codePromo?: string): boolean {
  if (codePromo === 'BIENVENUE') return true;
  return totalPanier > 50;
}

Le code promo fonctionne, et les tests sur des paniers de 30 € et 80 € passent. Mais un changement que personne n'a demandé s'est glissé : >= est devenu >. Pour un panier de 50 € pile, la livraison n'est plus gratuite. Seule une relecture qui comprend le code le voit.

C'est tout le sens de DevToTop, qu'on développe chez ScrollToTop : aider les devs qui codent tous les jours avec l'IA à piloter leurs agents plutôt qu'à les subir.

Et toi ? Le code écrit à la main restera-t-il, ou est-il déjà en train de disparaître dans ton équipe ?

À retenir

  • L'abstraction n'est pas nouvelle : de l'assembleur aux frameworks, on écrit de moins en moins de lignes nous-mêmes.
  • La responsabilité reste humaine : quand un bug part en production, ce n'est pas l'IA qui répond au client.
  • Les ingénieurs sont partagés : le débat porte sur qui écrit, jamais sur qui répond du code.
  • Le code écrit à la main deviendra une compétence de spécialistes, comme l'assembleur avant lui.
  • La compréhension ne disparaîtra pas : cadrer, découper, relire et tester, assumer ce qui part en production.

Sources