70% Completion Trap : Dernier défi 30% pour le codage assisté par l'IA

Après m'être fortement impliqué dans le développement assisté par l'IA au cours des dernières années, j'ai remarqué un phénomène intéressant. Alors que les ingénieurs font état de gains de productivité significatifs grâce à l'IA, les logiciels que nous utilisons au quotidien ne semblent pas s'améliorer de manière significative. Qu'est-ce qui se passe ici ?

Je pense savoir pourquoi, et la réponse révèle quelques faits fondamentaux sur le développement de logiciels auxquels nous devons faire face. Permettez-moi de vous faire part de mes conclusions.

Comment les développeurs utilisent-ils l'IA ?

J'ai observé deux schémas différents dans la manière dont les équipes développent l'IA. Nous les appelons "guides" et "itérateurs". Tous deux aident les ingénieurs (et même les utilisateurs non techniques) à passer de l'idée à l'exécution (ou MVP).

Facilitateur : De zéro à MVP

Des outils tels que Bolt, v0 et l'IA de la capture d'écran au code sont en train de révolutionner la façon dont nous démarrons de nouveaux projets. Ces équipes sont généralement :

• Commencer par un dessin ou un concept sommaire
• Utiliser l'IA pour générer une base de code initiale complète
• Obtenez un prototype fonctionnel en quelques heures ou quelques jours, et non en quelques semaines !
• Se concentrer sur la validation et l'itération rapides

Les résultats peuvent être impressionnants. J'ai récemment vu un développeur indépendant utiliser Boulon J'ai transformé le projet Figma en une application web fonctionnelle en très peu de temps. Elle n'est pas encore prête pour la production, mais elle est suffisamment bonne pour recueillir les premiers commentaires des utilisateurs.

Itérateurs : développement quotidien

Le second camp utilise des logiciels tels que Cursor, Cline, Copilot et WindSurf des outils de ce type pour les flux de travail de développement quotidiens. C'est moins spectaculaire, mais potentiellement plus transformateur. Ces développeurs sont :

• Utiliser l'IA pour compléter le code et faire des suggestions
• Exploiter l'IA pour les tâches de reconfiguration complexes
• Générer des tests et de la documentation
• Utiliser l'IA comme un "programmeur en binôme" pour résoudre les problèmes

Mais c'est là que le bât blesse : si ces deux approches permettent d'accélérer considérablement le développement, elles s'accompagnent de coûts cachés qui ne sont pas immédiatement visibles.

Le coût caché de la "vitesse de l'IA"

Lorsque vous voyez un ingénieur senior utiliser Curseur peut-être Copilote Les outils d'IA de ce type ressemblent à de la magie. Ils peuvent créer une fonctionnalité entière en quelques minutes, y compris les tests et la documentation. Mais en y regardant de plus près, vous remarquerez quelque chose d'essentiel : ils ne se contentent pas de suivre les conseils de l'IA. Ils sont constamment à l'écoute :

• Refonte du code généré en modules plus petits et plus ciblés
• Ajouter le traitement des cas de bords manquants par l'IA
• Amélioration des définitions de types et des interfaces
• Remise en question des décisions en matière d'architecture
• Ajout d'une gestion complète des erreurs

En d'autres termes, ils appliquent des années de sagesse technique durement acquise pour façonner et limiter les résultats de l'IA. L'IA accélère leurs mises en œuvre, mais c'est leur expertise qui va permettre de maintenir le code à jour.

Les ingénieurs débutants passent souvent à côté de ces étapes critiques. Ils sont plus susceptibles d'accepter les résultats de l'IA, ce qui conduit à ce que j'appelle un "code château de cartes" : il semble complet, mais il s'effondre sous la pression du monde réel.

paradoxe intellectuel

C'est la chose la plus contre-intuitive que j'ai trouvée : les outils d'IA aident davantage les développeurs expérimentés que les débutants. L'IA ne devrait-elle pas démocratiser le codage ?

En réalité, l'IA revient à avoir dans son équipe un développeur junior très enthousiaste. Ils peuvent écrire du code rapidement, mais ils ont besoin d'une supervision et d'une correction constantes. Plus vous en savez, mieux vous pouvez les encadrer.

Cela crée ce que j'appelle le "paradoxe de la connaissance" :

• Les seniors utilisent l'IA pour accélérer ce qu'ils savent déjà faire
• Les jeunes employés essaient d'utiliser l'IA pour apprendre ce qu'ils doivent faire
• Les résultats ont été très différents

Je vois des ingénieurs chevronnés utiliser l'IA pour :

• Prototyper rapidement des idées qu'ils comprennent déjà
• Générer des implémentations de base qu'ils pourront améliorer par la suite
• Explorer des solutions alternatives à des problèmes connus
• Automatiser les tâches de codage de routine

Dans le même temps, le personnel subalterne est souvent sollicité :

• Acceptation de solutions incorrectes ou dépassées
• Absence de considérations essentielles en matière de sécurité et de performance
• Difficile de déboguer le code généré par l'IA
• Construire des systèmes vulnérables qu'ils ne comprennent pas entièrement

70% Problème : Le paradoxe de la courbe d'apprentissage de l'IA

Un tweet récent qui a attiré mon attention reflète parfaitement ce que j'ai observé sur le terrain : les non-ingénieurs qui codent avec l'IA se heurtent à des obstacles frustrants. Ils peuvent réaliser 70% à une vitesse alarmante, mais à la fin, 30% devient un exercice aux rendements décroissants.

Cette "question 70%" révèle quelques informations clés sur l'état actuel du développement assisté par l'IA. Au début, les progrès étaient étonnants : vous pouviez décrire ce que vous vouliez et un outil d'IA comme v0 ou Bolt générait un prototype fonctionnel qui semblait impressionnant. Puis la réalité s'est imposée.

Mode de retour en arrière en deux étapes

Un schéma prévisible apparaît ensuite :

• Vous avez essayé de résoudre un petit problème.
• AI a proposé une modification qui semblait raisonnable
• Ce correctif a cassé quelque chose d'autre.
• Vous avez demandé à l'IA de résoudre un nouveau problème.
• Cela soulève deux questions
• encore et encore

Ce cycle est particulièrement pénible pour les non-ingénieurs, car ils ne disposent pas des modèles mentaux nécessaires pour comprendre ce qui n'a pas fonctionné. Lorsqu'un développeur expérimenté rencontre une erreur, il peut en déduire les causes et les solutions potentielles en s'appuyant sur des années de reconnaissance des schémas. Sans ce bagage, vous jouez essentiellement à un jeu de cartes avec un code que vous ne comprenez pas entièrement.

La poursuite du paradoxe de l'apprentissage

Le problème est plus profond : ce qui rend les outils de codage de l'IA faciles à utiliser pour les non-ingénieurs - ils représentent votre capacité à gérer la complexité - peut en fait entraver l'apprentissage. Lorsque le code "apparaît" et que vous ne comprenez pas les principes sous-jacents :

• Vous ne développez pas de compétences en matière de débogage.
• Vous n'apprenez pas les modèles de base
• On ne peut pas extrapoler les décisions architecturales
• Vous avez des difficultés à maintenir et à développer du code

Cela crée une dépendance qui vous oblige à revenir sans cesse à l'IA pour résoudre les problèmes au lieu de développer votre propre expertise pour les traiter.

Lacunes dans les connaissances

Les non-ingénieurs les plus performants que j'ai vus utiliser les outils de codage de l'IA ont adopté une approche hybride :

1. Prototypage rapide avec l'IA
2. Prendre le temps de comprendre le fonctionnement du code généré
3. Apprendre les concepts de base de la programmation tout en utilisant l'IA
4. Construire la base de connaissances étape par étape
5. Utiliser l'IA comme un outil d'apprentissage et non comme un simple générateur de code

Mais cela demande de la patience et du dévouement - le contraire de ce que beaucoup espèrent obtenir en utilisant des outils d'IA.

Implications pour l'avenir

Le "problème du 70%" suggère que les outils actuels de codage de l'IA sont mieux considérés comme tels :

• Accélérateur de prototypes pour les développeurs expérimentés
• Aides à l'apprentissage pour ceux qui s'engagent à comprendre le développement
• Générateur de MVP pour une validation rapide des idées

Mais ils ne constituent pas encore la solution à la démocratisation du codage que beaucoup espèrent. Enfin, 30% - la partie qui rend les logiciels prêts à la production, maintenables et robustes - nécessite encore de véritables connaissances en ingénierie.

La bonne nouvelle ? Au fur et à mesure que les outils s'améliorent, l'écart peut se réduire. Mais pour l'instant, l'approche la plus pragmatique consiste à utiliser l'IA pour accélérer l'apprentissage, et non pour le remplacer complètement.

Ce qui fonctionne réellement : un modèle pratique

Après avoir observé des dizaines d'équipes, voici ce que j'ai vu fonctionner régulièrement :

1. le modèle "AI first draft

• Laisser l'IA générer une mise en œuvre de base
• Révision manuelle et refonte pour la modularité
• Ajout d'une gestion complète des erreurs
• Rédiger des tests complets
• Documentation des décisions clés

2. le modèle de "dialogue continu

• Lancer un nouveau chat AI pour chaque tâche différente
• Concentrer et minimiser le contexte
• Révision et soumission fréquentes des modifications
• Maintenir une boucle de rétroaction étroite

3. le modèle "faire confiance mais vérifier

• Génération du code initial à l'aide de l'IA
• Examen manuel de tous les chemins critiques
• Cas limites des tests automatisés
• Effectuer des audits de sécurité réguliers

Perspectives d'avenir : quel est le véritable avenir de l'IA ?

Malgré ces difficultés, je suis optimiste quant au rôle de l'IA dans le développement de logiciels. La clé est de comprendre ce qu'elle sait vraiment faire :

1. Accélération connue
   L'IA est douée pour nous aider à réaliser des schémas que nous comprenons déjà. C'est comme avoir un programmeur jumeau infiniment patient qui peut taper très vite.
2. Explorer les possibilités
   L'IA est idéale pour prototyper rapidement des idées et explorer différentes approches. C'est comme si nous disposions d'un bac à sable dans lequel nous pouvons rapidement tester des concepts.
3. Routine d'automatisation
   L'IA réduit considérablement le temps consacré aux échantillons et aux tâches de codage habituelles, ce qui nous permet de nous concentrer sur les problèmes intéressants.

Qu'est-ce que cela signifie pour vous ?

Si vous débutez dans le développement assisté par l'IA, voici mes recommandations :

1. Commencer modestement
   • Utiliser l'IA pour des tâches isolées et bien définies
   • Examiner chaque ligne du code généré
   • Construire progressivement une plus grande fonctionnalité
2. Maintien de la modularité
   • Tout diviser en petits documents ciblés
   • Maintenir des interfaces claires entre les composants
   • Documenter les limites de votre module
3. Faites confiance à votre expérience.
   • Utiliser l'IA pour accélérer et non remplacer votre jugement
   • Remise en question de la génération d'un code qui ne semble pas correct
   • Maintenir vos normes d'ingénierie

L'essor du génie logiciel par agents

À l'aube de 2025, le paysage du développement assisté par l'IA est en train de changer radicalement. Si les outils actuels ont modifié la façon dont nous réalisons des prototypes et des itérations, je pense que nous sommes à l'aube d'un changement encore plus important : l'essor de l'ingénierie logicielle basée sur les agents.

Qu'est-ce que j'entends par "agent" ? Ces systèmes ne se contentent pas de répondre à des invites, ils planifient, exécutent et répètent des solutions avec une autonomie croissante.

Si vous souhaitez en savoir plus sur les proxies, et notamment sur Cursor/Cline/v0/Bolt, vous pouvez vous adresser à moi.

Nous voyons déjà les premiers signes de cette évolution :

De la réaction à la collaboration

L'outil actuel attend principalement nos commandes. Mais jetez un coup d'œil aux fonctionnalités mises à jour, telles que Anthropique existent Claude (a) l'utilisation d'ordinateurs dans les Cline La possibilité de lancer automatiquement des navigateurs et d'exécuter des tests. Il ne s'agit pas de simples compléments automatiques glorifiés - ils comprennent réellement la tâche et prennent l'initiative de résoudre le problème.

Pensez au débogage : ces agents ne se contentent pas de proposer des correctifs :

• Identification proactive des problèmes potentiels
• Mise en place de la suite de tests
• Inspection des éléments de l'interface utilisateur et capture d'écran
• Proposer et mettre en œuvre des mesures correctives
• Vérifier que la solution fonctionne (cela peut être important)

L'avenir multimodal

Les outils de la prochaine génération peuvent faire plus que gérer du code - ils peuvent être intégrés de manière transparente :

• Compréhension visuelle (captures d'écran de l'interface utilisateur, modèles, diagrammes)
• langue orale dialogue
• Interaction avec l'environnement (navigateur, terminal, API)

Cette capacité multimodale signifie qu'ils peuvent comprendre et utiliser les logiciels comme le font les humains - globalement, et pas seulement au niveau du code.

Autonome mais guidé

La principale leçon que j'ai tirée de l'utilisation de ces outils est que l'IA ne remplacera pas les développeurs à l'avenir, mais qu'elle deviendra un collaborateur de plus en plus compétent, capable de prendre l'initiative tout en respectant les conseils et l'expertise de l'homme.

Les équipes les plus efficaces en 2025 pourraient être celles qui apprennent :

• Fixer des limites et des lignes directrices claires pour leurs agents d'intelligence artificielle
• Construire des modèles architecturaux puissants dans lesquels les agents peuvent travailler
• Créer des boucles de rétroaction efficaces entre les personnes et les capacités d'IA
• Maintenir une supervision manuelle tout en tirant parti de l'autonomie de l'IA

Environnement de développement en anglais

Comme le souligne Andrej Karpathy :

"L'anglais est en train de devenir le nouveau langage de programmation le plus en vogue.

Il s'agit d'un changement fondamental dans la manière dont nous interagirons avec les outils de développement. La capacité à penser clairement et à communiquer avec précision en langage naturel devient aussi importante que les compétences traditionnelles en matière de codage.

Cette évolution vers le développement des agences nous obligera à développer nos compétences :

• Renforcement de la conception des systèmes et de la réflexion architecturale
• Amélioration de la spécification et de la communication des exigences
• Accent mis sur l'assurance qualité et la validation
• Améliorer la collaboration entre les personnes et les capacités d'IA

Le retour du logiciel en tant qu'ingénierie ?

Alors que l'IA permet plus que jamais de créer rapidement des logiciels, nous risquons de perdre quelque chose d'essentiel : l'art de créer des expériences véritablement peaufinées et de qualité pour le consommateur.

Démonstration des pièges à qualité

C'est de plus en plus fréquent : les équipes utilisent l'IA pour créer rapidement des démonstrations impressionnantes. Le parcours heureux se déroule à merveille. Les investisseurs et les réseaux sociaux en font l'éloge. Mais qu'en est-il lorsque de vrais utilisateurs commencent à cliquer ? C'est là que les choses s'effondrent.

Je l'ai vu de mes propres yeux :

• Des messages d'erreur qui ne signifient rien pour l'utilisateur moyen
• Cas marginaux entraînant le blocage de l'application
• États de l'interface utilisateur en désordre qui n'ont jamais été nettoyés
• Ignorer complètement l'accessibilité
• Problèmes de performance sur les appareils plus lents

Il ne s'agit pas seulement de bogues P2, mais de la différence entre un logiciel que les gens tolèrent et un logiciel qu'ils adorent.

L'art perdu de l'embellissement

La création d'un véritable logiciel en libre-service - le type de logiciel pour lequel les utilisateurs n'ont pas besoin de contacter l'assistance - nécessite un état d'esprit différent :

• Obsédés par la désinformation
• Test sur une connexion lente
• Traite élégamment tous les cas de figure
• faire en sorte que les fonctionnalités puissent être découvertes
• Tests avec des utilisateurs réels, souvent non techniques

Ce souci du détail (peut-être) ne peut être généré par l'IA. Elle est le fruit de l'empathie, de l'expérience et d'un profond intérêt pour le métier.

Renaissance des logiciels personnels

Je pense que nous allons assister à une renaissance du développement de logiciels personnels. Alors que le marché est inondé de MVP générés par l'IA, les produits qui se démarqueront seront ceux construits par des développeurs qui sont

• Fiers de leur savoir-faire
• Attention aux petits détails
• Se concentrer sur l'expérience complète de l'utilisateur
• Conçu pour les cas extrêmes
• Créer une véritable expérience de libre-service

Paradoxalement, les outils d'IA pourraient bien contribuer à cette renaissance. En s'occupant des tâches de codage de routine, ils permettent aux développeurs de se concentrer sur ce qui compte le plus : créer des logiciels qui servent et ravissent les utilisateurs.

souligner

L'IA n'améliore pas nos logiciels, car la qualité des logiciels n'a (peut-être) jamais été limitée par la vitesse de codage. Les aspects les plus difficiles du développement de logiciels - comprendre les exigences, concevoir des systèmes faciles à maintenir, traiter les cas extrêmes, assurer la sécurité et la performance - nécessitent toujours un jugement humain.

L'IA nous permet d'itérer et d'expérimenter plus rapidement, et en explorant plus vite, elle peut conduire à de meilleures solutions. Mais seulement si nous maintenons notre discipline d'ingénierie et si nous utilisons l'IA comme un outil, et non comme un substitut aux bonnes pratiques logicielles. N'oubliez pas : l'objectif n'est pas d'écrire plus de code plus rapidement. Il s'agit plutôt de créer de meilleurs logiciels. Utilisée à bon escient, l'IA peut nous y aider. Mais c'est à nous de comprendre ce que signifie "mieux" et comment y parvenir.

Quelle est votre expérience du développement assisté par l'IA ? J'aimerais connaître vos expériences et vos points de vue dans les commentaires.