Les ingénieurs de Google expliquent comment utiliser l'IA pour améliorer le développement de logiciels

En 2024, l'écriture de code par l'IA a pénétré tous les domaines de la vie, affectant profondément l'ensemble du cycle de vie du logiciel. La question est donc la suivante : les outils de codage de l'IA utilisés par les gens disent que c'est bien, mais pourquoi utilisons-nous généralement le logiciel sans ressentir beaucoup de progrès ? Est-ce parce que nous utilisons l'IA de la mauvaise manière ?

Récemment, Addy Osmani, responsable de l'ingénierie chez Google et auteur de best-sellers sur Amazon, nous a révélé à quoi ressemble réellement le codage assisté par l'IA dans le développement de première ligne, en partageant les défis et les opportunités que les outils d'IA présentent dans le développement du monde réel.

Comment les ingénieurs utilisent-ils l'IA ?

En général, il existe deux modèles différents pour les équipes qui développent avec l'IA : les "bootstrappers" et les "itérateurs". Ces deux modèles aident les ingénieurs (et même les utilisateurs ayant un faible bagage technique) à réduire la distance entre l'idée et le code réel.

Les bootstrappers

Cette catégorie comprend des outils d'IA tels que Bolt, v0 et screenshot-to-code, qui se caractérisent par les éléments suivants :

• Commencez par un dessin ou une ébauche de concept ;
• Utiliser l'IA pour générer une base de code initiale complète ;
• Capacité à obtenir un prototype fonctionnel en quelques heures ou quelques jours ;
• L'accent est mis sur la validation rapide de la faisabilité des idées.

Il s'agit d'un flux de travail impressionnant. Par exemple, un développeur indépendant peut utiliser Bolt pour transformer une conception Figma en une application web fonctionnelle en un rien de temps. Ce n'est pas tout à fait un niveau de production, mais c'est suffisant pour obtenir un premier retour d'information de la part des utilisateurs.

Itérateurs

Cette catégorie est principalement responsable du flux de travail de développement quotidien, y compris Cursor, Cline, Copilot et WindSurf Ces outils ne sont pas aussi "tape-à-l'œil" que les précédents, mais sont plus pratiques, par exemple :

• Automatiser la complétion du code, fournir des suggestions de code ;
• Effectuer des tâches complexes de remaniement du code ;
• Générer du code de test et de la documentation ;
• Le "jumelage de partenaires de programmation" comme solution aux problèmes de programmation

Bien que ces deux méthodes puissent accélérer considérablement le développement, comme le dit l'adage, "il n'y a pas de repas gratuit".

Les coûts cachés de la "vitesse de l'IA"

Utilisé par des ingénieurs confirmés Curseur peut-être Copilote Les outils d'IA tels que celui-ci peuvent construire en quelques minutes le cadre de base d'une fonctionnalité entière, avec les tests et la documentation appropriés - c'est comme de la magie.

Mais un examen plus approfondi révèle qu'en plus de se référer aux recommandations de l'IA, les ingénieurs seniors font ce qui suit :

• Refonte du code généré par l'IA en modules plus petits ;
• Ajouter la gestion de diverses situations extrêmes ;
• Optimisation de la définition des types et de la conception des interfaces ;
• Ajout d'un mécanisme complet de gestion des erreurs ;
• Même en remettant en question les solutions architecturales proposées par l'IA.

En d'autres termes, ils appliquent des années de savoir-faire technique accumulé pour façonner et limiter les résultats de l'IA, qui est responsable de l'accélération de la mise en œuvre du code, mais l'expertise humaine garantit que le code est maintenable - l'un ne va pas sans l'autre.

Cependant, les ingénieurs débutants ont tendance à négliger ces étapes critiques. Ils sont plus susceptibles d'accepter les résultats de l'IA dans leur intégralité, ce qui conduit à ce que l'on appelle un "code château de cartes", c'est-à-dire quelque chose qui semble complet en surface mais qui peut facilement s'effondrer sous la pression du monde réel.

paradoxe intellectuel

En fait, l'IA aide mieux les développeurs expérimentés que les débutants, ce qui est quelque peu contre-intuitif.

Les ingénieurs chevronnés utilisent l'IA pour prototyper rapidement des idées (afin de comprendre les exigences), générer des implémentations de base (pour faciliter les améliorations ultérieures), explorer des solutions alternatives à des problèmes connus, et bien plus encore ;

Au lieu de cela, les débutants adoptent souvent directement des solutions incorrectes ou dépassées fournies par l'IA, ignorent les questions clés de sécurité et de performance, ne savent pas comment déboguer le code généré par l'IA et finissent par construire un système fragile qu'ils ne comprennent pas entièrement.

70% Question

Les non-ingénieurs qui écrivent du code à l'aide de l'IA se heurtent souvent à un dilemme frustrant : ils peuvent effectuer 70% de travail étonnamment rapidement, mais les 30% finales sont exceptionnellement pénibles.

Le "problème 70%" révèle l'état actuel du développement assisté par l'IA, qui commence comme une aubaine avant d'être "frotté au visage" par la réalité.

La réalité est généralement la suivante :

• Essai de correction d'un petit bug -->
• L'IA propose une modification apparemment raisonnable -->
• Cette modification perturbe le reste du code -->
• Demander à l'IA de résoudre les problèmes émergents -->
• Deux nouveaux bogues ont été créés -->
• boucle infinie

Ce cycle est particulièrement pénible pour les non-ingénieurs qui n'ont pas l'expertise nécessaire pour comprendre ce qui n'a pas fonctionné.

Les développeurs expérimentés qui rencontrent des bogues peuvent en déduire les causes et les solutions potentielles sur la base de leurs années d'expérience et de la reconnaissance des schémas. Sans ces connaissances de base, vous vous retrouvez en fait avec un code que vous ne comprenez pas entièrement, et les problèmes sont infinis.

paradoxe de l'apprentissage

Il y a aussi un problème plus profond : donner aux non-ingénieurs l'accès aux outils d'écriture de code d'IA peut en fait entraver leur apprentissage.

Le code est généré et s'exécute, mais les "développeurs" ne comprennent pas les principes sous-jacents. À ce stade, ils manquent l'occasion d'apprendre les modèles de programmation de base, de développer des compétences de débogage et de raisonner sur les décisions architecturales qui devront être maintenues et étendues à l'avenir.

En conséquence, les "développeurs" se tournent constamment vers l'IA pour résoudre des problèmes sans développer l'expertise nécessaire pour les gérer eux-mêmes.

La meilleure façon pour les non-ingénieurs d'utiliser les outils de rédaction de code d'IA est probablement le "mode mixte" :

1. Prototypage rapide avec l'IA
2. Prenez le temps de comprendre le fonctionnement du code généré
3. Apprendre les concepts de base de la programmation et comment utiliser l'IA
4. Construisez votre 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 de l'engagement, ce qui va à l'encontre de la raison pour laquelle de nombreuses personnes utilisent les outils d'IA : elles veulent juste une solution rapide.

Le "problème 70%" montre que l'IA actuelle n'est pas "l'IA parfaite" que beaucoup attendent. En fin de compte, le travail de 30% (rendre un logiciel utilisable dans un environnement de production, maintenable, etc.) nécessite toujours de véritables connaissances en ingénierie qui ne peuvent pas être complètement remplacées par l'IA.

meilleures pratiques

Addy Osmani, après avoir observé des dizaines d'équipes, a élaboré quelques bonnes pratiques :

• "Modèle "AI first draft
  Laissez l'IA générer la mise en œuvre de base du code, réviser manuellement et effectuer un remaniement modulaire, ajouter un traitement complet des erreurs, rédiger des cas de test complets et documenter les décisions clés.
• "Modèle de "dialogue continu
  Commencez un nouveau dialogue IA pour chaque tâche différente ; gardez le contexte ciblé et concis ; révisez et validez souvent les changements ; et maintenez une boucle de rétroaction étroite.
• "Modèle "faire confiance mais vérifier
  Utiliser l'IA pour générer le code initial, examiner manuellement tous les chemins critiques, automatiser les tests pour divers cas limites et effectuer des audits de sécurité réguliers.

Le véritable avenir de l'IA ?

Malgré ces défis, les auteurs sont optimistes quant au rôle de l'IA dans le développement de logiciels. L'essentiel est de tirer pleinement parti des avantages réels de l'IA :

• Accélération connue
  L'IA excelle à nous aider à réaliser des schémas que nous connaissons déjà, comme un partenaire de programmation jumeau doté d'une patience infinie et d'une grande rapidité de frappe.
• Explorer les possibilités
  L'IA est idéale pour prototyper rapidement des idées et explorer différentes approches, comme un bac à sable dans lequel nous pouvons rapidement tester des concepts.
• routine d'automatisation
  L'IA réduit considérablement le temps que nous consacrons aux exemples de code et aux tâches de programmation quotidiennes, ce qui nous permet de nous concentrer sur des problèmes plus intéressants.

Si vous commencez tout juste à expérimenter le développement assisté par l'IA, les auteurs vous conseillent de commencer modestement : utilisez l'IA pour des tâches découplées et bien définies, examinez minutieusement chaque ligne de code générée, puis développez progressivement des fonctionnalités plus importantes.

Maintenir la modularité dans le processus de développement : tout décomposer en petits documents bien ciblés, maintenir des interfaces claires entre les composants et documenter les limites des modules.

L'important est de faire confiance à votre propre expérience : l'IA est utilisée pour accélérer le développement, mais elle ne peut pas remplacer votre jugement ; ayez le courage de poser des questions lorsque quelque chose ne vous semble pas correct ; et respectez toujours vos normes d'ingénierie.

L'émergence des agents

Le paysage du développement assisté par l'IA est en train de changer radicalement à l'approche de 2025. Alors que les outils actuels ont changé la façon dont nous réalisons des prototypes et des itérations, nous sommes au début d'une transformation encore plus importante : l'essor du génie logiciel par agents d'IA (agents). Les agents d'IA ne seront pas seulement capables de répondre à des commandes, mais aussi de planifier et d'exécuter des solutions avec un degré d'autonomie croissant.

par exemple Anthropique (utilisé comme expression nominale) Claude avoir un accès direct à un ordinateur, ou Cline Vous pouvez lancer le navigateur et exécuter les tests automatiquement.

Pendant le débogage, l'agent IA ne se contente pas de proposer des corrections de bogues, mais il identifie également de manière proactive les problèmes potentiels, lance et exécute des suites de tests, examine les éléments de l'interface utilisateur et capture des captures d'écran, suggère et met en œuvre des corrections, et vérifie que les solutions fonctionnent.

La prochaine génération d'outils sera capable d'intégrer de manière transparente la compréhension visuelle (captures d'écran de l'interface utilisateur, modèles, diagrammes), le dialogue verbal et les interactions environnementales (navigateurs, terminaux, API).

L'IA du futur n'a pas vocation à remplacer les développeurs, mais à devenir un partenaire collaboratif de plus en plus puissant, capable d'assumer des tâches de manière proactive tout en respectant les conseils et l'expertise de l'homme.