L’info a tourné comme une traînée de poudre : « OpenAI engineer confirms AI is writing 100% now ». Un screenshot, un post Reddit, 800+ upvotes, et une avalanche de commentaires mi-fascinés mi-cyniques.
Sauf qu’entre “100%” et la réalité du terrain, il y a un monde. Et ce monde est intéressant, parce qu’il dit quelque chose de très concret : le job n’est plus “écrire du code”, le job devient “faire ship un système fiable”. L’IA accélère, oui. Elle remplace la saisie, souvent. Mais elle ne remplace pas la responsabilité.
Dans cet article, on va :
- décortiquer ce que veut dire “100%” (et pourquoi ça peut être vrai pour quelqu’un, sans être vrai pour une org)
- mettre des chiffres récents sur la table (OpenAI, Anthropic, Google/Microsoft)
- te donner une méthode pragmatique pour atteindre ton “80–95%” sans transformer ton repo en décharge
Le post Reddit : une punchline, pas un audit
Le post source sur r/OpenAI est un “link post” vers un screenshot (pas un papier, pas un mémo interne, pas une annonce officielle). Les top comments résument bien l’ambiance :
- « Wow, quelqu’un qui bosse dans l’IA dit que l’IA est incroyable… »
- « Il codait déjà pas beaucoup »
- « 100% ? Peut-être, mais sur du code commun, c’est facile »
Traduction : c’est un témoignage individuel, pas une preuve industrielle.
Et c’est exactement le point : quand quelqu’un dit “l’IA écrit 100% de mon code”, il parle souvent de qui tape les lignes, pas de qui conçoit, qui valide, qui assume.
Les chiffres récents : on est déjà très haut… mais pas à 100% “autonome”
Le plus important, c’est de sortir du débat religieux et d’aller voir les ordres de grandeur.
Anthropic : “90% du code écrit par l’IA”
En octobre 2025, Dario Amodei (CEO d’Anthropic) a déclaré qu’environ 90% du code chez Anthropic est désormais écrit par des modèles d’IA, tout en précisant que les humains restent essentiels (revue, sécurité, architecture). Source : LiveMint (reprise d’une déclaration publique).
90%, c’est énorme. Mais note la nuance : “écrit par” ne veut pas dire “livré sans contrôle”.
OpenAI : “presque tout” + métriques de PR
Côté OpenAI, des comptes-rendus autour de DevDay 2025 mentionnent que “presque tout” le nouveau code est rédigé avec Codex, avec :
- ~70% d’augmentation du volume de pull requests hebdomadaires
- un projet interne (“Agent Builder”) réalisé en <6 semaines avec ~80% des PR générées par Codex
Source : regulatingai.org (à prendre comme une source secondaire, mais les chiffres sont cohérents avec ce qu’on observe ailleurs).
Individus chez OpenAI : 80% (voire plus) sur certains projets
Un employé d’OpenAI (Aidan McLaughlin) affirme que 80% de son code est écrit par IA. Source : OfficeChai.
Ce genre de chiffre est crédible… parce qu’il dépend énormément du type de travail.
Big Tech : plutôt 20–30%
Dans les grandes boîtes, on parle souvent de 20–30% (Google “well over 30%”, Microsoft dans le même ordre). Là aussi, ce sont des déclarations et des articles de presse, pas des audits publics. Mais la tendance est claire : plus l’organisation est grosse et contrainte (compliance, legacy, process), plus le pourcentage baisse.
Pourquoi “100%” peut être vrai (et en même temps trompeur)
“100%” devient plausible quand :
- tu fais du CRUD, des intégrations API, du front standard, des scripts, des migrations simples
- tu utilises un framework populaire (Next.js, FastAPI, Django, Spring, etc.)
- tu as une base de code propre + des tests
- tu sais spécifier clairement ce que tu veux
En clair : tout ce qui est pattern-driven.
Un des commentaires Reddit le dit très bien : OOP, design patterns, data access… c’est du pattern. Les LLM sont des machines à patterns. Donc oui, elles performent.
Mais “100%” devient trompeur parce que :
- la spec est rarement complète
- le contexte (contraintes métier, edge cases, dette technique) n’est pas dans le prompt
- les bugs ne disparaissent pas : ils se déplacent (du “je me suis trompé en tapant” vers “j’ai fait confiance à une hallucination plausible”)
Ce qui change vraiment : tu passes de “coder” à “diriger un atelier de production”
Le shift utile à comprendre :
Avant
Tu écrivais du code.
Maintenant
Tu orchestras :
- tu décris le comportement attendu
- tu fais générer
- tu fais tester
- tu fais relire (par l’IA + par toi)
- tu merges
Le rôle devient plus proche d’un chef d’atelier que d’un artisan qui sculpte chaque ligne.
Et c’est là que les entrepreneurs gagnent : moins de temps perdu sur le boilerplate = plus de temps sur le produit, la distribution, le support client.
Les limites : sécurité, fiabilité, et coût caché de la “relecture”
Le Financial Times (et beaucoup de retours terrain) rappelle un point : les gains sont souvent surestimés parce qu’on oublie le temps de :
- débogage
- tests
- revue de sécurité
- refactor
L’IA peut te pondre une fonction “qui a l’air correcte” mais :
- avec une dépendance obsolète
- une faille (injection, SSRF, mauvais contrôle d’accès)
- une complexité inutile
Donc oui, tu peux monter à 80–95% de génération… si tu as un système de garde-fous.
Méthode pragmatique pour atteindre 80–95% sans flinguer ton produit
Pas de bullshit : voilà un process qui marche pour des équipes petites (solo, PME, startup).
1) Définis “100%” correctement : lignes vs responsabilité
Objectif réaliste :
- IA écrit 80–95% des lignes
- toi tu gardes 100% de la responsabilité
Si tu mélanges les deux, tu vas te faire mal.
2) Standardise ton architecture (sinon l’IA improvise)
- un template de repo
- conventions de nommage
- structure de dossiers
- lint + format
Plus c’est standard, plus l’IA est efficace.
3) Mets des tests comme filet de sécurité (sinon tu joues au casino)
Minimum viable :
- tests unitaires sur la logique critique
- tests d’intégration sur les flux principaux
- CI qui bloque si ça casse
Ensuite, tu peux demander à l’IA d’écrire les tests aussi. Mais c’est la CI qui tranche.
4) Utilise l’IA en mode “patches” (PR petites) plutôt qu’en mode “big bang”
- PR de 50–200 lignes : reviewable
- PR de 2 000 lignes : injouable
Le “100%” est souvent un mensonge statistique : tu as généré un énorme bloc, puis tu as passé 2 jours à le réparer.
5) Fais une revue sécurité explicite
Checklist simple :
- authz/authn : qui a le droit de faire quoi ?
- validation d’input
- secrets (jamais dans le code)
- logs (pas de données sensibles)
Si tu es en B2B, c’est non négociable.
Cas d’usage concrets (entrepreneurs) où l’IA est déjà un cheat code
Support client → automatisation de réponses + tri
- classification des tickets
- réponses brouillon
- extraction des infos (commande, contrat, SLA)
Ops → génération de scripts et intégrations
- sync Stripe ↔ Notion/HubSpot
- alerting (Slack) sur événements clés
Produit → itération rapide
- landing pages
- A/B tests
- instrumentation analytics
Le point commun : beaucoup de code “standard”, donc très générable.
Ce que tu dois retenir
- Le post Reddit est un signal culturel, pas une preuve scientifique.
- Les chiffres récents montrent une réalité : 90% chez Anthropic (déclaration CEO), ~80% sur certains projets chez OpenAI, 20–30% dans des grosses orgs.
- “100%” est plausible à l’échelle d’un individu sur des tâches standard… mais ça ne supprime pas l’ingénierie. Ça déplace l’effort vers la spec, la validation, la sécurité.
- Si tu veux en profiter, arrête de fantasmer sur l’autonomie totale : construis un pipeline (templates, tests, CI, PR petites) et tu gagneras du temps tout de suite.
Tu veux automatiser tes opérations avec l'IA ? Réserve un call de 15 min pour en discuter.