Ingénieur logiciel AI-native

• L’ingénieur AI-native est un développeur qui fait de l’IA un partenaire de son travail quotidien afin de maximiser sa productivité et sa créativité
• Il considère l’IA non comme un substitut, mais comme une collaboratrice, en lui déléguant les tâches répétitives pour se concentrer sur la résolution de problèmes de plus haut niveau et l’innovation
• Il acquiert de nouvelles compétences comme le prompt engineering afin d’utiliser l’IA efficacement, tout en vérifiant toujours lui-même les résultats
• Il cultive l’habitude d’utiliser activement l’IA de l’extension IDE à la génération de code, en passant par les tests, la documentation et les opérations, sur l’ensemble du cycle de développement
• Il met l’accent sur la responsabilité, l’éthique, la collaboration en équipe et l’apprentissage continu, et considère que l’adoption d’une culture d’usage de l’IA est essentielle à la compétitivité des individus comme des organisations

---

# Qu’est-ce qu’un ingénieur logiciel AI-native ?

• Un ingénieur logiciel AI-native est un développeur qui intègre profondément l’IA à son flux de travail quotidien et l’utilise comme un partenaire qui amplifie ses capacités
• Au lieu de raisonner en termes de « l’IA va-t-elle me remplacer ? », il prend l’habitude de se demander, pour chaque tâche : « L’IA peut-elle m’aider à faire cela plus vite, mieux, ou autrement ? »

• Il conserve un état d’esprit optimiste et proactif, voyant l’IA comme un outil qui démultiplie la productivité et la créativité
• Avec la bonne approche, l’IA peut multiplier par 2, 5, voire 10 la production d’un développeur
• Les développeurs expérimentés, en particulier, obtiennent de l’IA des réponses de niveau collègue grâce à des techniques avancées de prompt comme le context engineering

• Être AI-native, c’est adopter une attitude fondée sur l’apprentissage et l’adaptation continus, en construisant des logiciels dès le départ avec des mécanismes d’assistance et d’automatisation par l’IA intégrés
• Cet état d’esprit conduit non pas à la peur, mais à l’enthousiasme et à l’attente de nouvelles possibilités
• Même s’il peut y avoir de l’incertitude et une courbe d’apprentissage face à de nouveaux outils et modes de travail, cela débouche au final sur une attente d’opportunités et de progression
• L’ingénieur AI-native délègue à l’IA certaines parties répétitives et chronophages du développement (code boilerplate, premières versions de documentation, génération de tests, etc.) et se concentre lui-même sur la résolution de problèmes de plus haut niveau et sur l’innovation

[Principe clé] – L’IA est une collaboratrice, pas un substitut

• L’ingénieur AI-native considère l’IA comme un pair programmer disponible 24 h/24, très informé (mais de niveau junior)

• L’humain garde toujours le pilotage du développement, tout en s’appuyant activement sur l’aide de l’IA dans de nombreux domaines : idées, solutions, alertes, etc.
• Exemple : faire brainstormer l’IA sur une approche d’architecture, puis l’affiner avec sa propre expérience et son expertise. Cette collaboration peut accélérer considérablement le développement et améliorer la qualité (à condition que le développeur conserve impérativement la supervision)

• Le point crucial est de ne pas transférer la responsabilité à l’IA. L’IA peut fournir une grande quantité d’informations, comme un développeur junior ayant lu tout StackOverflow et toute la documentation API, mais la responsabilité de guider et de valider le résultat revient en dernier ressort au développeur
• Ce principe de « faire confiance, mais vérifier » (trust, but verify) est indispensable

• Pour être clair, la baisse de qualité du code généré par l’IA (low-quality work) est une réalité, et ne peut en aucun cas servir d’excuse
• Le risque persistant des outils d’IA est que l’approbation automatique, les hallucinations discrètes et une simple paresse se combinent pour produire des résultats très en dessous des standards de l’ingénierie professionnelle
• Par conséquent, l’étape de vérification est un élément central qui ne peut jamais être omis, et le développeur n’est pas un simple utilisateur d’outils d’IA, mais le garant final de la qualité, de la lisibilité, de la sécurité et de l’exactitude du code

[Principe clé] – Désormais, tous les développeurs sont des managers

• Le rôle de l’ingénieur est en train de changer en profondeur. En travaillant avec des agents IA, il évolue vers un rôle d’« orchestration » des tâches plutôt que d’implémentation directe

• Le développeur reste pleinement responsable de chaque commit qui entre sur la branche main, mais il consacre davantage de temps à définir et répartir le travail réel
• Dans un futur proche, l’idée selon laquelle « tous les développeurs sont désormais des managers » (Every engineer is a manager now) pourrait se généraliser
• Le travail concret peut être confié à des agents en arrière-plan comme Jules ou Codex, ou à Claude Code, Gemini CLI, OpenCode, etc.
• L’ingénieur joue aussi un rôle actif pour « orchestrer » le codebase afin que l’IA travaille mieux (par exemple avec des fichiers de règles comme GEMINI.md, un bon README ou un code structuré)
• Le développeur endosse ainsi un rôle de superviseur, mentor et validateur
• Les équipes AI-first obtiennent plus de résultats avec moins de personnes, raccourcissent les étapes du SDLC (compressing steps of the SDLC) et livrent plus vite (faster) avec une meilleure qualité

Bénéfices de haut niveau (High-Level Benefits)

• L’intégration complète de l’IA dans le workflow améliore fortement la productivité, ce qui permet de livrer davantage de fonctionnalités plus rapidement, sans dégrader la qualité (même si cela dépend bien sûr de la complexité des tâches)

• Les tâches répétitives comme le formatage du code ou la génération de tests unitaires sont traitées en quelques secondes
• L’IA renforce aussi la compréhension : elle aide comme si l’on obtenait instantanément les conseils d’un expert sur des domaines moins familiers
• L’ingénieur AI-native peut prendre en charge des projets plus ambitieux avec une petite équipe, et au final « l’IA étend les capacités humaines »
• Mais pour en tirer efficacement parti, il faut le bon état d’esprit et de bonnes pratiques

Exemple – Mise en pratique de l’état d’esprit

• Par exemple, lorsqu’il faut déboguer un bug difficile ou évaluer une nouvelle stack technique, l’approche traditionnelle nécessitait des recherches et une lecture approfondie de la documentation
• L’approche AI-native consiste à collaborer avec un assistant IA capable de recherche et d’investigation approfondie : on lui décrit le bug ou on lui demande les avantages et inconvénients d’une stack, et l’IA fournit des insights ainsi que des exemples de code
• Le développeur garde le pouvoir de décision final pour l’interprétation et l’application, tandis que l’IA accélère la collecte d’informations et la proposition de solutions
• À mesure que ce mode de résolution collaborative devient familier, on en vient à se demander spontanément « comment l’IA peut-elle m’aider sur cette tâche ? », et avec le temps, on identifie intuitivement les points forts de l’IA et les prompts les plus adaptés

En résumé

• AI-native désigne un état d’esprit qui intègre l’IA au cœur de la résolution de problèmes et de la construction logicielle
• L’essentiel est une logique de partenariat qui combine les forces de la machine (vitesse, connaissance, reconnaissance de motifs) et de l’humain (créativité, jugement, contexte)
• Sur cette base, viennent ensuite des pratiques concrètes d’intégration réelle de l’IA dans le développement quotidien

# Getting Started – Intégrer l’IA au travail quotidien

• Un workflow AI-native peut sembler intimidant au début, mais l’essentiel est de commencer petit et de développer progressivement sa capacité à utiliser l’IA
• Voici un guide pratique pour introduire naturellement l’IA dans le quotidien de l’ingénierie

> Remarque : à l’avenir, le rôle de l’IA grandira sur l’ensemble du cycle de vie logiciel, mais la nécessité d’une intervention humaine (human-in-the-loop) pour maintenir la qualité ne changera pas.

Step 1: Premier changement ? Commencer avec l’IA

• Un workflow AI-native ne consiste pas à se demander de temps en temps « y a-t-il quelque chose que l’IA peut faire ? », mais à commencer d’emblée par confier la tâche à l’IA
• Retour d’expérience d’une équipe : « La plupart des tâches sont d’abord confiées à des modèles d’IA (Cursor, CLI, etc.), en sachant que la qualité des résultats varie selon les cas »
• Pour l’analyse métier, l’étude des concurrents, etc., on commence aussi par faire d’abord tenter l’IA, avec Gemini Deep Research par exemple ; et lorsqu’on s’enlise dans des débats de design, on privilégie une approche consistant à générer rapidement plusieurs prototypes avec l’IA plutôt que de tout construire soi-même
• Les développeurs de Google utilisent déjà largement l’IA pour la création de slides, le débogage d’incidents et bien d’autres tâches
• Plutôt que de retarder l’adoption sous prétexte que « les LLM hallucinent » ou que « les chatbots répondent mal », il est temps de mettre à jour la toolchain
• Pour les développeurs qui utilisent activement l’IA en conditions réelles, un usage fondé sur les agents est indispensable. Les hallucinations peuvent aussi être suffisamment contrôlées et réduites via le context engineering et des boucles de feedback
• Le plus important reste l’état d’esprit AI-first

Étape 2 : configurer les bons outils IA

• Mettre en place un environnement où au moins un assistant de code (par ex. GitHub Copilot) est installé dans l’IDE et prêt à être utilisé immédiatement
• Pour les utilisateurs de VS Code, Cursor (éditeur de code IA dédié) et Cline (extension d’agent IA pour VS Code) sont aussi recommandés
• En dehors de l’éditeur, utiliser en parallèle ChatGPT, Gemini, Claude dans des fenêtres séparées pour les questions-réponses
• Ces outils peuvent proposer du code en temps réel en arrière-plan, ce qui réduit au minimum le coût de friction lié à l’usage de l’IA
• Dès qu’on se dit « l’IA pourrait-elle être utile pour ça ? », on peut essayer immédiatement

Étape 3 : bases du prompt – précision et contexte

• La clé d’un usage efficace de l’IA, c’est le prompt engineering
• Erreur fréquente : des consignes vagues et courtes → des résultats décevants
• L’IA ne lit pas dans les pensées ; il faut donc expliquer clairement l’intention du code et les exigences
• Exemple
  • Mauvais prompt : « Écris des tests pour un composant React »
  • Bon prompt : « Rédige un fichier de tests Jest pour le composant LoginForm (email, mot de passe, bouton de soumission, affichage de messages en cas de succès/échec, utilisation du callback onSubmit), couvrant 1) le rendu, 2) la validation des entrées, 3) la soumission, 4) la vérification des arguments de onSubmit, 5) les états UI de succès/échec »
• Des prompts précis augmentent considérablement l’exactitude et l’utilité des résultats. Passer 1 à 2 minutes de plus à rédiger un prompt peut faire gagner des heures de corrections sur la sortie de l’IA
• Voir aussi Google’s Prompting Guide 101 :
  • préciser le format de sortie (« renvoyer au format JSON », etc.)
  • pour les tâches complexes, décomposer la demande en étapes ou en liste
  • fournir des données d’exemple
  • acquérir ses propres formulations et schémas par la pratique répétée

Étape 4 : utiliser l’IA pour la génération de code et l’autocomplétion

• Une fois l’environnement prêt et les prompts maîtrisés, appliquer l’IA à la génération de code répétitif ou boilerplate
• Exemple : demander l’écriture d’une fonction Python qui parse des chaînes de date dans plusieurs formats
• Lire systématiquement le résultat initial de l’IA, puis l’exécuter/le tester soi-même
• Avec le temps, étendre progressivement l’usage à la génération de classes/modules entiers, au refactoring, etc.
• Cursor propose aussi des fonctions avancées comme la génération ou le refactoring de fichiers entiers
• Au début, mieux vaut déléguer d’abord le code helper/utilitaire plutôt que le cœur algorithmique, afin d’éprouver la fiabilité et l’utilité de l’outil

Étape 5 : intégrer l’IA aux tâches non liées au code

• Être AI-native, ce n’est pas seulement « coder plus vite », mais viser une amélioration de la qualité du travail dans son ensemble
• Exemple : utiliser l’IA pour rédiger des messages de commit et des descriptions de PR. Coller un git diff et demander « résume cela sous forme de description de PR professionnelle »
• La vraie valeur : utiliser activement l’IA dans toutes les tâches annexes — réflexion, planification, documentation, recherche, communication, etc.
• Génération automatique de commentaires de code ou de documentation technique, première ébauche d’idées d’implémentation lors de l’explication d’exigences, aide à la rédaction d’explications complexes pour des emails ou Slack, etc.
• Exemple : pour expliquer à un PM la difficulté d’un bug, demander à l’IA de produire une explication simplifiée
• « Le code n’est pas toujours la seule chose importante » : réunions, brainstorming, structuration d’opinions, etc., sont aussi des contextes où l’IA doit être exploitée activement

Étape 6 : amélioration itérative basée sur le feedback

• En collaborant avec l’IA au quotidien, observer attentivement ce qui doit être corrigé dans ses résultats
• Analyser si le prompt était incomplet ou si le contexte manquait, puis améliorer le prompt la fois suivante
• La plupart des assistants IA permettent des itérations et interactions du type « corrige encore cela ici »
• En répétant le processus, on peut constituer une bibliothèque de schémas de prompts efficaces, partageable au sein de l’équipe
• Exemple : le schéma « explique X du point de vue d’un coéquipier » est efficace pour la documentation ; pour les transformations de données, fournir des exemples d’entrée/sortie améliore la qualité

Étape 7 : toujours vérifier et tester les résultats

• Ne jamais faire confiance à 100 % aux résultats de l’IA
• Même si le code compile et que le résultat semble plausible, il faut impérativement le valider par exécution, tests, revue, analyse statique, etc.
• En pratique, il arrive souvent que cela fonctionne seulement en apparence et que des edge cases ou des bugs subtils subsistent
• Les habitudes existantes de revue de code, de tests et d’analyse statique doivent s’appliquer aussi systématiquement au code produit par l’IA
• Comme il est plus rapide de lire et valider du code que de l’écrire soi-même, la productivité globale reste malgré tout améliorée
• Avec l’expérience, on identifie les domaines où l’IA est faible (par ex. l’arithmétique de précision, les domaines spécialisés, etc.), ce qui permet de faire soi-même une double vérification ou d’éviter de s’y reposer sur l’IA
• Traiter l’IA comme un collègue très efficace, tout en gardant la validation finale du côté humain

Étape 8 : étendre progressivement vers des usages plus complexes

• Une fois à l’aise sur de petites tâches, élargir vers des intégrations et automatisations plus avancées
• Exemple : l’IA détecte automatiquement des erreurs ou des commentaires TODO dans le code et fait des suggestions régulières (mode agent de Cusor, Windsurf, etc.)
• Cline et d’autres outils peuvent gérer des tâches en plusieurs étapes (création de fichier → codage → tests, etc.) en mode agent autonome avec cycle plan-approbation-exécution
• Plus l’usage est avancé, plus un pilotage et une supervision réguliers sont nécessaires, comme lorsqu’on accorde davantage d’autonomie à un junior
• Tenter aussi le prototypage end-to-end : construire pendant un week-end une petite app « en grande partie avec l’aide de l’IA », puis compléter manuellement ce qui manque.
  • Avec Replit AI, Bolt, etc., on peut éprouver à la fois la vitesse d’implémentation d’une idée et les limites de ces outils
  • Terminer en 2 à 3 heures un prototype qui demandait auparavant plusieurs jours permet de ressentir concrètement le gain de productivité

En suivant ces étapes et en gagnant progressivement en aisance, il devient possible d’intégrer naturellement l’IA dans son flux de développement.
La section suivante explique concrètement comment choisir les outils et plateformes les plus adaptés selon les situations.

# Outils et plateformes IA – du prototypage à la production

• Pour un ingénieur logiciel AI-native, la capacité à choisir quel outil IA utiliser pour quel type de travail est essentielle.
• Les outils et plateformes de codage IA se répartissent globalement en deux grandes catégories :
  • Assistants de codage IA : intégrés à l’IDE/à l’éditeur, ils aident à écrire, comprendre et refactorer le code
  • Outils de prototypage basés sur l’IA : capables de générer rapidement une application ou un module entier à partir d’un simple prompt

Lors de l’utilisation de n’importe quel outil, il est essentiel d’adopter un réflexe de confidentialité des données : « Est-ce que ce prompt/code peut rester enregistré dans les logs d’un serveur tiers sans poser de problème ? »
Il est indispensable de distinguer les travaux sûrs (IA publique) des travaux sensibles (solutions enterprise ou modèles locaux)

Assistants de codage IA (intégrés à l’IDE)

Les assistants de codage IA agissent comme des « programmeurs en binôme IA » dans l’éditeur ou l’IDE, et sont particulièrement puissants pour étendre une base de code existante ou construire un projet fichier par fichier

• GitHub Copilot
  • A évolué de la simple autocomplétion vers un véritable agent de codage
  • Lorsqu’on lui assigne une issue ou une tâche, il peut agir de manière autonome jusqu’à l’analyse de la base de code → la configuration de l’environnement (GitHub Actions, etc.) → les modifications multi-fichiers / l’exécution de commandes / les tests / la soumission d’un brouillon de PR
  • Grâce aux derniers modèles et au MCP (Model Context Protocol), il se connecte aussi aux outils externes et au contexte du workspace, avec prise en charge de structures complexes comme les monorepos, la CI, les images, les API, etc.
  • En revanche, il reste optimisé pour les tâches de difficulté faible à intermédiaire, donc une supervision humaine est nécessaire pour la sécurité, l’architecture et la collaboration multi-agents
• Cursor – éditeur de code AI-native
  • Éditeur autonome basé sur VS Code, repensé autour d’une approche centrée sur l’IA
  • Propose notamment la navigation de code assistée par IA (comme le suivi des usages d’une fonction), le refactoring intelligent, l’explication de code, la génération de tests et le mode Agent (automatisation de tâches à grande échelle)
  • Particulièrement puissant pour les grandes bases de code et les environnements enterprise. Permet de définir des règles personnalisées par projet via des fichiers comme .cursorrules
  • Le mode “Ask” permet de prévisualiser le résultat avant d’appliquer des changements, ce qui réduit les erreurs
  • Inconvénients : éditeur indépendant (installation séparée), payant. La prise en main reste facile pour les utilisateurs de VS Code
  • Son efficacité est validée par son usage chez des millions de développeurs et de grandes entreprises
• Windsurf – agent spécialisé pour les grosses bases de code et la sécurité
  • Particulièrement avantageux quand les exigences en confidentialité et conformité (self-hosting, non-rétention des données, certifications HIPAA/FedRAMP, etc.) sont importantes
  • Au-delà de la complétion et de la modification de code, l’IA comprend aussi les gros fichiers et la documentation, ce qui le rend adapté aux refactorings sur des dizaines de milliers à des centaines de milliers de lignes
• Cline – agent de codage IA autonome pour VS Code
  • Extension open source pour VS Code. Au-delà des simples suggestions de code, elle permet aussi la création de fichiers, l’exécution de commandes et des tâches en plusieurs étapes
  • Alterne entre le mode Plan (présentation préalable du plan global) et le mode Act (exécution), toujours sous validation humaine
  • Exemple : « ajouter un nouvel endpoint API, une route, un contrôleur et une migration DB » → il élabore le plan, puis implémente étape par étape après validation
  • Il peut aussi comprendre et modifier l’architecture globale du système
  • Inconvénients : comme il exécute de manière autonome plusieurs fichiers et commandes, une relecture préalable minutieuse est indispensable ; avec un modèle puissant, le coût en tokens augmente
  • « Le style d’un vrai junior qui continue de demander : “on fait comme ça ?” »
  • Le grand nombre de questions répétées réduit le risque de mauvais fonctionnement, et plaît à ceux qui préfèrent un style de collaboration étroit

Quand utiliser un assistant de codage IA ?

• Idéal pour les cycles quotidiens : maintenance et extension d’une base de code, écriture de fonctions, refactoring, explication de code, etc.
• S’intègre naturellement à la boucle « edit-compile-test » et permet de traiter très vite des tâches répétitives ou routinières, des dizaines de fois
• Plus efficace non pas pour générer toute une application d’un coup, mais pour améliorer et étendre en continu un projet existant
• Un ingénieur expérimenté peut l’utiliser plusieurs fois par jour comme un « moteur de recherche à la demande »

• Les agents de codage asynchrones / autonomes comme OpenAI Codex et Google Jules vont encore plus loin
  • Codex : automatise dans le cloud des tâches parallèles en environnement sandbox (développement de fonctionnalités, correction de bugs, tests, soumission de PR), puis permet une revue via les logs et les diffs
  • Jules : basé sur Gemini 2.5 Pro ; lorsqu’une issue GitHub lui est assignée, il clone le dépôt dans une VM → effectue des modifications multi-fichiers / exécute le code / résume les changements (y compris à l’oral) / va jusqu’à la PR
  • Contrairement à la « simple autocomplétion », ils accomplissent de façon autonome des tâches importantes en arrière-plan et ne livrent au développeur que le “résultat final”
  • Le développeur peut ainsi se concentrer sur des tâches de plus haut niveau

Outils de prototypage et de création de MVP basés sur l’IA

En parallèle des outils d’assistance dans l’IDE, on voit apparaître des outils capables de générer une application ou une fonctionnalité complète (ou une grande partie) à partir d’un simple prompt d’une ligne.
Ils sont particulièrement utiles lorsqu’on veut amorcer très rapidement un nouveau projet ou une nouvelle fonctionnalité ; même si le produit final demandera du développement supplémentaire, ils sont excellents comme point de départ (premier draft).

• Bolt (bolt.new)
  • Génération d’un MVP full-stack à partir d’un seul prompt
  • Exemple : « un site d’offres d’emploi avec connexion utilisateur + tableau de bord administrateur » → génère automatiquement un frontend React + Tailwind CSS, un backend Node.js/Prisma et même les modèles de base de données
  • Lors de tests réels, il a produit l’ossature complète d’un projet en environ 15 secondes, avec du code aligné sur les tendances actuelles (composants, API REST/GraphQL, etc.)
  • Très rapide pour le prototypage et les itérations (modifier le prompt → régénération immédiate / ajustements via GUI), avec prise en charge de l’export GitHub, etc.
  • Fortement recommandé aux fondateurs, participants de hackathons et développeurs qui veulent terminer rapidement la configuration initiale
  • Inconvénient : la créativité reste limitée au cadre des styles et patterns appliqués par défaut par Bolt ; pour des besoins très atypiques, des ajustements manuels sont nécessaires
  • Excellente solution notamment pour la cohérence d’une UI propre, le déploiement rapide et les démos de prototype
• v0 (v0.dev by Vercel)
  • Outil de génération d’applications spécialisé Next.js
  • Génère un projet à partir d’un prompt d’une ligne, avec en particulier une cohérence de design dans le style ShadCN UI (bibliothèque de composants minimaliste et tendance)
  • Il y a des limites pour obtenir un design très personnalisé, mais il est idéal pour le prototypage rapide de fonctionnalités et le déploiement sur Vercel
  • Basé sur Next.js/React, avec support du serverless, des Edge Functions, etc.
  • Particulièrement adapté à la « génération rapide d’un prototype orienté fonctionnalité + déploiement immédiat »
• Lovable
  • Centré sur un éditeur visuel, pour débutants et non-développeurs
  • En saisissant la description d’une app, il génère automatiquement l’UI et une partie du code, et permet aussi l’assemblage visuel de l’interface
  • Usage intuitif, proche du no-code, mais peu pratique dès qu’il faut personnaliser le code
  • Adapté pour concrétiser des idées avec des non-développeurs comme des designers ou PM ; les développeurs pourront toutefois regretter certaines limites fonctionnelles
• Replit
  • IDE en ligne + IA, avec exécution et tests en temps réel
  • Exemple : « crée-moi un jeu 2D style Zelda » → l’IA génère le code + l’exécute + compare les captures d’écran pour améliorer le résultat par itérations
  • Intègre frontend et backend, avec lancement/déploiement immédiats et support de l’environnement cloud
  • Il existe des cas où il a produit des jeux ou applications réellement fonctionnels avec le niveau de finition le plus élevé
  • Le code n’est pas toujours parfait, mais il convient bien si l’objectif est de créer rapidement « une application qu’on peut au moins lancer »
• Firebase Studio
  • IDE cloud de Google basé sur Gemini
  • À partir de différents types d’entrées comme du langage naturel, des images ou des croquis, il génère automatiquement des prototypes d’apps full-stack Next.js, avec intégration de Firestore/Auth/Hosting, etc.
  • Basé sur un code OSS (donc compatible avec l’écosystème VS Code), avec connexion aux émulateurs, aperçu en direct et déploiement complet en one-stop shop
  • Gemini prend aussi en charge les suggestions de code, le débogage, les tests, les migrations, la documentation et même l’exécution de commandes terminal

Quand utiliser un outil de prototypage ?

• Quand on veut éliminer le travail de configuration initiale d’un nouveau projet ou d’une nouvelle fonctionnalité (démo de concept, POC, exploration d’idée, etc.)
• Pour générer et comparer rapidement différentes variantes d’une idée (« cette approche / cette autre approche ») sans devoir tout construire à la main
• Il est efficace d’adopter une approche hybride : considérer le résultat généré comme un “premier draft”, puis le raffiner ensuite dans un IDE ou avec un assistant IA
  • Exemple : générer un MVP avec Bolt → reprendre ensuite avec Cursor pour améliorer la qualité du code et la logique

Limites et points d’apprentissage

• Le code généré peut aussi servir à apprendre les patterns et bonnes pratiques des frameworks (comme « lire 10 tutoriels d’un coup »)
• En revanche, les 20 à 30 % finaux d’une application (the 70% problem) — réglage des performances, logique métier, sécurité, etc. — doivent être complétés manuellement
• La clé pour maximiser la productivité est une bonne répartition des rôles : « les 70 % ennuyeux pour l’IA, le reste créatif et avancé pour l’humain »
• Il faut impérativement vérifier la sécurité, la qualité et l’adéquation au contexte avant mise en œuvre (ex. : attention aux clés API codées en dur)

Résumé des usages par outil et conseils pratiques

• Les assistants IDE (par ex. Cursor, Cline) sont optimisés pour l’extension, la maintenance et le refactoring d’une base de code existante
  • Pour gérer et améliorer en continu un grand projet, un assistant IDE devient un partenaire du quotidien
• Les outils de prototypage génératif (par ex. Bolt, v0) servent à « bootstrapper rapidement » un nouveau projet ou module
  • L’IA prend en charge tout le travail initial fastidieux, comme la configuration du build tool et la génération du boilerplate
• En pratique, il est courant d’utiliser les deux outils en combinaison
  • Exemple : créer l’ossature du projet avec Bolt → développer la qualité du code et les fonctionnalités détaillées avec Cursor
• En interne, il faut reconnaître et verbaliser le réflexe de “not invented here” autour du code généré par l’IA (méfiance/réticence envers du code qu’on n’a pas écrit soi-même)
  • Réponse efficace : indiquer explicitement dans la PR « ce contrôleur a été généré avec v0.dev, à partir du prompt ci-dessous », etc., afin de favoriser la transparence et d’encourager la review
  • En démontrant à la fois la vitesse et la qualité (après validation), on construit la confiance dans l’équipe et on installe une culture où l’usage de l’IA devient naturel
• Le chapitre suivant traite des méthodes concrètes pour appliquer l’IA à l’ensemble du cycle de développement logiciel, de la conception au déploiement (exigences, tests, etc., où l’IA joue un rôle clé)

# Utilisation transverse de l’IA dans tout le cycle de vie du développement logiciel (SDLC)

L’ingénieur logiciel AI-native ne se limite pas au code : il exploite l’IA à toutes les étapes du SDLC afin de maximiser l’efficacité et l’innovation
Voici les usages concrets étape par étape

1. Recueil des exigences & brainstorming d’idées

• Utiliser l’IA comme partenaire de brainstorming / analyste des besoins
  • « Je veux créer une app X » → demander à l’IA de proposer les fonctionnalités essentielles et des user stories → suggestions spécialisées selon les cas, comme une app de gestion de budget ou un task manager
  • Automatisation possible aussi pour 5 user stories de MVP ou pour des questions de clarification sur une exigence donnée
  • Analyse des services concurrents également possible : « résume les problèmes fréquents et les fonctionnalités clés des apps de gestion de tâches » → l’IA synthétise les connaissances issues de nombreux blogs et documents
• Soutien à la collaboration avec des non-développeurs : génération d’une première version de PRD → partage / feedback → documentation finale, ce qui raccourcit le workflow
• Passer d’une expansion quantitative des idées à une base de discussion qualitative : collecter rapidement diverses options pour stimuler les échanges entre l’équipe et les parties prenantes

2. Conception système & architecture

• Utiliser l’IA comme assistant de feedback sur la conception et d’aide à la décision
  • Expliquer une première ébauche d’architecture (par ex. microservices, API Gateway, frontend React) → l’IA signale avantages, inconvénients et enjeux de scalabilité
  • Poser des questions de conception précises (SQL vs NoSQL, architecture des notifications en temps réel, etc.) → l’IA liste des éléments de réflexion objectifs
  • Génération automatique de diagrammes de conception (mermaid, etc.) : décrire la structure en texte → l’IA produit automatiquement le code et le schéma
  • Une ébauche de conception d’API (endpoints, exemples de payload, etc.) peut aussi être rédigée rapidement
  • Checklist des risques : « quels risques si on n’utilise qu’un seul DC pour le cache de session ? » → identification de points comme les pannes, les incidents de datacenter ou les problèmes de scaling
  • Support pour la contre-argumentation logique et le cadrage d’alternatives : en cas d’opposition à une conception, l’IA aide à structurer les inquiétudes et à explorer des options → fournit des éléments de persuasion rationnels
• Basculer vers un développement centré sur les spécifications : rédiger les specs avant le code, demander à l’IA de générer une ébauche de plan d’implémentation / de spécifications de conception, puis les réutiliser (documentation, PRD, manifestes de déploiement, etc.)
• Compétences des développeurs seniors : évoluer du simple problem solving vers un rôle de concepteur de solutions, capable d’anticipation, de roadmap et d’analyse des tendances

3. Implémentation (codage)

• Automatiser avec l’IA les tâches répétitives et la configuration : boilerplate, configuration d’environnement, exemples de bibliothèques, génération des fichiers de base pour Docker/CI/ESLint, etc.
• Partenaire de développement de fonctionnalités : définir la structure d’une fonction / classe / module → l’IA implémente le code et la logique détaillés, tandis que l’humain fixe l’intention
• Réutilisation de code / recherche de références : si l’on ne se souvient plus d’un ancien code ou algorithme, demander à l’IA « quelle est la manière efficace de gérer cette logique ? » → proposition de code immédiate
• Maintien des patterns et de la cohérence : fournir un fichier exemple → lors de la création d’un nouveau module, l’IA écrit dans le même style et selon les mêmes patterns
• Prendre l’habitude de générer les tests en même temps : écrire une fonction → demander « rédige le code de tests unitaires, y compris les edge cases » → aide à la vérification du code et au TDD
• Support au débogage et à l’exécution : entrer des logs d’erreur / stack traces → l’IA explique la cause ; elle peut aussi servir de debugger d’exécution en suivant les variables selon les entrées
• Performance / refactoring : on peut aussi déléguer à l’IA l’amélioration structurelle avec des demandes comme « réduis la complexité de cette fonction » ou « découpe cette fonction de 50 lignes et ajoute des commentaires »
• Gestion de version / code review : même pour du code généré par l’IA, git diff, code review et tests restent indispensables

4. Tests & assurance qualité

• Génération automatique de tests unitaires : expliquer les fonctions publiques et classes d’un module → génération de cas de test, particulièrement efficace pour compléter les tests de code legacy
• Tests property-based / fuzzing : demander à l’IA « quelles sont les garanties d’une fonction de tri ? », « génère 10 JSON d’edge cases », etc., pour automatiser
• Tests d’intégration / end-to-end : décrire un scénario → l’IA génère une première version de script de test (Cypress/Selenium, etc.), ce qui diversifie les parcours testés
• Génération de données de test : automatisation de dummy data comme des JSON réalistes ; les données sensibles doivent être anonymisées
• Tests exploratoires avec des agents IA : l’IA essaie diverses entrées comme le ferait un utilisateur → détection précoce de bugs et de vulnérabilités
• Vérification de la couverture de test : fournir les tests actuels et leur description → demander « quels cas manquent ? » pour les compléter
• Globalement : moins de charge de tests manuels, plus de couverture, meilleure maintenabilité

5. Débogage & maintenance

• Explication et documentation de code legacy : même une longue fonction ou un code obscur peuvent être résumés avec « explique-moi simplement, étape par étape » → meilleure compréhension et onboarding accéléré
• Identification de la cause : fournir le contexte du bug et le code → l’IA raisonne à partir de patterns et aide à trouver rapidement l’origine
• Suggestion automatique de corrections : « corrige cette fonction pour qu’elle ne plante pas avec une entrée vide » → l’IA propose un patch, à valider impérativement avant application
• Refactoring à grande échelle : transformations comme le passage à async/await ou l’injection de dépendances ; l’IA produit des exemples de code puis permet de les appliquer à l’ensemble
• Documentation et gestion des connaissances : après l’ajout d’une fonctionnalité ou un bug fix, l’IA peut générer une première version de la documentation ou des release notes → il ne reste qu’à corriger et compléter
• Communication d’équipe : automatisation des premières versions de guides de migration, release notes, annonces utilisateurs, etc.
• Des fichiers de contexte comme CLAUDE.md augmentent l’utilité de l’IA, et la génération automatique de tickets / PR devrait se généraliser à l’avenir

6. Déploiement & opérations

• Génération automatique d’IaC (Terraform/K8s) : « script Terraform pour une AWS EC2 t2.micro », etc. → génération automatique du code, mais sécurité, clés, etc. doivent être vérifiées manuellement
• Génération de pipelines CI/CD : conception et automatisation de scripts YAML pour GitHub Actions, Jenkins, etc. ; une simple correction des erreurs de syntaxe suffit souvent pour les utiliser
• Requêtes de monitoring / alerting : même des requêtes complexes pour PromQL/Grafana/Splunk peuvent être esquissées par l’IA
• Analyse des logs et métriques d’exploitation : en cas d’incident, fournir les logs → l’IA repère les anomalies ou aide à raisonner sur la cause (usage AIOps)
• ChatOps / automatisation : connecté à Slack, l’IA peut répondre à des questions comme « quel est l’état du dernier déploiement / quelles sont les erreurs ? » → elle fournit un résumé ; même un copier-coller manuel de logs peut être synthétisé
• Scaling / capacity planning : automatisation aussi pour des estimations du type « pour X requêtes et Y utilisateurs, combien d’instances faut-il ? »
• Rédaction de manuels d’exploitation / runbooks : première version des procédures étape par étape en cas d’incident ou de problème → stockage et partage dans la documentation, afin que l’expérience reste dans l’organisation
• Pour toutes les tâches d’automatisation d’infrastructure également, le workflow recommandé reste : l’IA produit une ébauche → l’ingénieur vérifie

Résumé général

• Tout au long du SDLC, l’IA prend en charge les tâches répétitives et l’apport de connaissances, tandis que l’humain garde l’orientation, le jugement et la responsabilité finale
• Se concentrer sur la conception créative, le jugement et la prise de décision, tout en réduisant le temps passé sur les corvées et la recherche d’information
• Bien utilisée, l’IA raccourcit le cycle de développement, améliore la qualité et augmente la satisfaction des développeurs
• Le chapitre suivant aborde les best practices pour utiliser l’IA de manière efficace et responsable

# Best practices pour une utilisation efficace et responsable de l’IA

L’usage de l’IA dans le développement logiciel peut entraîner des changements profonds, mais pour en tirer des bénéfices concrets, il est indispensable d’appliquer les bons principes et d’éviter les erreurs
Voici les guides essentiels pour utiliser l’IA de manière sûre et productive

1. Rédiger des prompts clairs et riches en contexte

• La rédaction de prompts est une compétence clé, au même niveau que le code ou les messages de commit
• Au lieu de « comment optimiser ce code ? », expliquez en détail jusqu’au contexte + objectif + exemples, par exemple : « proposer des pistes d’optimisation des performances en se concentrant sur la partie tri du code ci-dessous »
• Précisez aussi le format de sortie souhaité (JSON, explication étape par étape, etc.)
• Pour les tâches complexes, découpez-les en étapes ou fournissez un échantillon
• En cas d’échec du prompt, itérer et l’ajuster pour l’orienter vers le résultat voulu
• Construire une bibliothèque de prompts ayant fait leurs preuves (stockage et partage par format, objectif, situation)
• Voir aussi le guide avancé de Google sur les prompts

2. Toujours relire et vérifier soi-même les résultats de l’IA

• Ne jamais accorder une confiance aveugle aux réponses de l’IA (trust, but verify)
• Le code écrit par l’IA doit toujours être relu directement, puis vérifié avec un débogueur et des tests
• Les explications et analyses doivent elles aussi faire l’objet d’une validation croisée des points essentiels (documentation officielle / raisonnement direct)
• En pratique, l’IA produit souvent des erreurs plausibles, ainsi que des noms d’API incorrects
• Ne pas confier à l’IA les politiques propres à l’organisation, les informations internes, etc.
• Combiner avec des contrôles automatiques du style, de la syntaxe et des tests (linter, vérificateur de types, etc.)
• Dans les systèmes sensibles ou liés à la sécurité, ne jamais générer avec l’IA des mots de passe, secrets ou code de chiffrement ; toujours s’appuyer sur une validation conforme aux standards du secteur
• Validation croisée entre IA : soumettre le résultat d’une IA à une autre avec une question du type « y a-t-il des bugs ou des problèmes de sécurité ? » → vérification complémentaire
• Garder en permanence un scepticisme sain et développer son intuition sur les forces et les limites de l’IA

3. Utiliser l’IA comme un « amplificateur » de productivité, tout en maintenant une supervision humaine plutôt qu’une automatisation totale

• L’idée selon laquelle l’IA automatiserait l’ensemble d’un système en un clic relève presque du fantasme ; en pratique, il est plus réaliste de l’utiliser sur de petites unités de travail répétitives
• Les applications et le code générés par l’IA doivent être traités comme des brouillons (prototypes), puis impérativement améliorés de manière itérative par soi-même ou par l’équipe
• Les tâches complexes doivent être divisées en plusieurs sous-tâches, avec une répartition étape par étape via l’IA (frontend → backend → intégration, etc.)
• Il faut reconnaître les limites de l’IA dans la compréhension des objectifs de haut niveau ; la conception et les contraintes doivent être fixées par l’humain
• Éviter la dépendance excessive : déléguer les tâches simples et répétitives, mais garder pour soi la pensée créative, complexe et l’apprentissage
• Définir clairement le périmètre des agents IA (approbation préalable pour de nouvelles dépendances, le réseau, etc., et usage actif des modes dry-run et plan)
• Accumuler du code IA que l’on comprend mal ou dont on maîtrise difficilement la qualité = risque de dette technique

4. Continuer à apprendre et rester à jour

• Le rythme d’évolution de l’IA et de l’écosystème des outils étant très rapide, il faut apprendre en continu
• Suivre les nouveaux outils, modèles et bonnes pratiques, et s’abonner aux newsletters et communautés concernées
• Partager entre collègues, en interne comme en externe, les expériences d’usage des prompts, workflows et agents
• Expérimenter activement l’IA dans des side projects, hackathons, etc., afin d’intérioriser les réussites comme les échecs
• Organiser du mentorat et des sessions internes : partager avec l’équipe le prompt engineering et les cas de réussite
• Continuer aussi à renforcer les fondamentaux (informatique, conception de systèmes, résolution de problèmes)
• L’IA peut automatiser 70 %, mais les 30 % restants (définition du problème, jugement, débogage) relèvent des capacités proprement humaines
• Maximiser les « 30 % humains »

5. Collaboration et standardisation au sein de l’équipe

• Partager les retours d’expérience sur l’usage de l’IA, établir des lignes directrices et privilégier le consensus de l’équipe
• Exemple : « même le code généré par l’IA doit être revu et testé par au moins une personne avant fusion », et l’indiquer de façon transparente dans la PR avec // Generated with Gemini, etc.
• Mettre en place de la code review assistée par l’IA (l’IA donne d’abord un feedback sur le diff, puis relecture humaine)
• Documenter dans une FAQ interne ou des documents d’onboarding des consignes comme : « dans notre codebase, pour la tâche X, on prompt l’IA de cette façon »
• Respecter aussi les avis des collègues prudents vis-à-vis de l’IA, et renforcer l’intelligence collective en partageant les cas d’échec
• Côté leadership : allouer du temps et des ressources à l’apprentissage et à l’expérimentation avec l’IA, gérer les licences / la PI, et établir une politique de sécurité
• L’adoption de l’IA est un sport d’équipe : assurer la compatibilité des outils et workflows pour améliorer la qualité et la maintenabilité de la codebase

6. Utiliser l’IA de façon responsable et éthique

• Vie privée et sécurité : en cas d’usage d’API externes ou de plugins, faire attention aux fuites de données et respecter les politiques en place, par exemple sur l’auto-hébergement ou l’anonymisation
• Biais et équité : filtrer les biais et le langage non inclusif dans les résultats orientés utilisateur ou dans les décisions produites par l’IA
• Transparence sur l’usage de l’IA : signaler clairement lorsque des fonctionnalités ou contenus reposent en partie sur l’IA, si nécessaire, et gérer les logs et le tagging
• Questions de PI (propriété intellectuelle) : faire attention aux bibliothèques, licences et citations, et se référer aux politiques internes ou aux conseils juridiques
• Maintenir une supervision humaine : lorsqu’un jugement important est requis ou qu’une erreur survient, l’humain doit faire la validation et la décision finales
• Développement responsable de l’IA : établir et appliquer des principes d’éthique et de fiabilité à un niveau dont on pourrait être fier comme si l’on avait soi-même écrit le résultat (voir les guides d’OpenAI, Google, Anthropic, etc.)

7. Bâtir une culture AI-first pour les dirigeants et managers

• Montrer l’exemple et porter une vision : partager ouvertement des cas concrets comme l’élaboration d’une stratégie ou la rédaction de propositions avec l’IA
• Investir dans les compétences : financer des outils payants, garantir du temps pour les hackathons et les expérimentations, et faire vivre un wiki ou des démos internes de bonnes pratiques
• Créer une sécurité psychologique : instaurer une culture où l’on peut partager ses échecs et poser des questions, en affirmant clairement que l’IA est un partenaire de collaboration
• Repenser la roadmap et les processus : faire évoluer les rôles des tâches répétitives vers la validation, la spécification et l’intégration, et renforcer la part de vérification humaine dans la code review

Résumé

• En appliquant régulièrement les pratiques ci-dessus, il devient possible de gérer à la fois les effets positifs de l’adoption de l’IA (productivité, qualité du code, vitesse d’apprentissage ↑) et les risques d’erreur ou de mauvais usage
• La véritable force concurrentielle consiste à combiner les atouts de l’IA et la capacité d’analyse humaine
• Le dernier chapitre présentera le parcours vers une démarche AI-native et des ressources complémentaires

# Conclusion : accueillir l’avenir

Nous avons couvert ce qu’est un ingénieur logiciel AI-native, du mindset aux workflows opérationnels, en passant par l’environnement d’outils, l’intégration dans le cycle de vie et les bonnes pratiques
Il apparaît clairement que l’IA ne remplace pas les ingénieurs, mais qu’elle est un partenaire qui amplifie puissamment les capacités humaines
Adopter une approche AI-native permet de construire plus vite, d’apprendre plus en profondeur et de relever des défis plus ambitieux

• Résumé essentiel :
  • Être AI-native commence par considérer l’IA comme un « multiplicateur » de ses capacités
  • Prendre l’habitude de se demander : « l’IA peut-elle m’aider à résoudre cette tâche plus vite et de manière plus créative ? »
  • Les nouvelles compétences comme le prompt engineering ou l’orchestration d’agents, ainsi que les compétences intemporelles comme la conception, l’esprit critique et l’éthique, sont toutes importantes
  • Il faut apprendre en permanence avec l’IA, et l’utiliser aussi pour accélérer son apprentissage dans d’autres domaines (boucle vertueuse)
• Dans la pratique, les profils les plus compétitifs sont ceux qui savent combiner eux-mêmes divers outils (assistants IDE, générateurs de prototypes, etc.) et choisir, selon la situation, « quel outil utiliser »
• L’IA est un partenaire de collaboration à chaque étape : codage, tests, débogage, documentation, brainstorming sur l’architecture
  • Plus il y a d’IA, plus l’humain peut se concentrer sur sa créativité, son jugement et sa capacité d’insight
• Insistance sur la responsabilité et la vérification :
  • Il ne faut pas se laisser absorber uniquement par les capacités impressionnantes de l’IA ; un scepticisme sain, une relecture rigoureuse, des tests et une bonne conscience de ses limites permettent d’éviter les erreurs
  • Si l’on respecte les bonnes pratiques (prompts clairs, code review, itérations à petite échelle, conscience des limites), la fiabilité de l’usage de l’IA augmente
  • Les ingénieurs expérimentés contrôlent aussi plus efficacement les erreurs de l’IA, et leur valeur augmente encore sur les problèmes complexes et l’intégration de systèmes
• Perspectives :
  • L’IA va devenir de plus en plus puissante et s’intégrer profondément aux outils de développement (par exemple, des IDE qui inspectent en temps réel le code, la documentation et les performances avec l’IA)
  • Des IA spécialisées apparaîtront pour le frontend, les bases de données, etc.
  • Une époque approche où « AI-native » deviendra bientôt le standard de « l’ingénieur logiciel »
  • À mesure que l’IA abaissera les barrières à l’entrée, des développeurs non traditionnels pourront eux aussi créer plus facilement des logiciels
  • Les ingénieurs qui utilisent l’IA évolueront vers de nouveaux rôles, comme le développement d’outils ou le mentorat
  • En prenant en charge le travail répétitif, l’IA ouvrira une ère d’ingénierie créative centrée sur l’imagination et la capacité de conception
• Conseils pratiques :
  • Ne cherchez pas à tout changer d’un coup ; commencez par un ou deux outils ou par un domaine, puis élargissez progressivement
  • La joie de voir l’IA détecter pour la première fois un bug dans les tests, ou l’expérience d’une erreur en refactoring, sont autant d’occasions d’apprendre, qu’il s’agisse de succès ou d’échecs
  • Si cette culture se diffuse aussi dans l’équipe, on retrouve non seulement de la productivité, mais aussi le plaisir de développer
• Dernier conseil :
  • « Adopter l’IA » n’est pas un changement ponctuel, mais un parcours
  • Grâce à un apprentissage pratique et continu, ainsi qu’à une culture d’équipe adaptée, il faut accueillir de manière proactive l’époque où l’IA devient un collègue à nos côtés

# Ressources complémentaires

Voici quelques guides et ressources gratuits de référence pour approfondir l’ingénierie AI-native

• Google - Prompting Guide 101 (Second Edition)
  • Guide de base du prompting pour les modèles Gemini, riche en exemples concrets et en conseils
• Google - “More Signal, Less Guesswork” prompt engineering whitepaper
  • Techniques avancées de prompting, avec des cas spécialisés comme l’API et le Chain-of-thought
• OpenAI - A Practical Guide to Building Agents
  • Guide pratique de conception et d’implémentation d’agents, incluant les architectures à agent unique ou multiples, les boucles itératives et la gestion de la sécurité
• Anthropic - Claude Code: Best Practices for Agentic Coding
  • Savoir-faire pour utiliser Claude, structuration de CLAUDE.md, formats de prompt et conseils pour une collaboration itérative
• OpenAI - Identifying and Scaling AI Use Cases
  • Stratégies d’adoption et de déploiement de l’IA à l’échelle des organisations et des équipes, identification des domaines à fort levier, recommandations étape par étape du PoC au déploiement
• Anthropic - Building Trusted AI in the Enterprise (Trust in AI)
  • Confiance, sécurité et gouvernance de l’IA en entreprise, avec une approche centrée sur des cas réels
• OpenAI - AI in the Enterprise
  • Stratégies d’usage de l’IA dans les grandes entreprises, études de cas et guide pratique de déploiement en interne
• Google - Agents Companion Whitepaper
  • Ouvrage avancé sur les technologies d’agents, couvrant des sujets comme l’évaluation, l’intégration d’outils et l’orchestration multi-agents

Ces ressources offrent à la fois des techniques pratiques et des cadres théoriques, tout en rassemblant des best practices et les analyses d’experts du secteur.
N’hésitez pas à les étudier librement et à continuer à développer vos compétences en tant qu’ingénieur AI-native.

P.-S. : l’auteur (Addy Osmani) rédige actuellement avec O'Reilly AI-assisted engineering book. Si cet article vous a été utile, ce livre peut aussi être une bonne référence.