Discussion :

[Namanyay Goel]

Mon guide d'ingénierie des prompts ou instructions génératives d'IA pour les développeurs, par Namanyay Goel

Vous savez maintenant que l'IA peut accélérer considérablement votre processus de développement (lorsqu'elle est utilisée correctement).

Mais la clé est de savoir comment communiquer correctement avec l'IA.

Voici ma collection de prompt (instruction générative) qui fonctionnent dans des scénarios réels.

Aller à la source des problèmes

L'erreur la plus courante commise par les développeurs est de traiter les symptômes plutôt que les causes. Ce prompt (instruction générative) vous aide à rompre ce cycle :

Analysez cette erreur/bogue :
[coller l'erreur]

Ne vous contentez pas de résoudre le problème immédiat. Identifiez la cause sous-jacente en procédant comme suit :
1. Examiner les problèmes architecturaux potentiels
2. Envisager les cas limites qui pourraient déclencher ce problème
3. Proposer une solution globale permettant d'éviter des problèmes similaires.

Concentrez-vous sur la résolution du problème central, et pas seulement sur les symptômes. Avant de proposer une solution, faites une analyse raisonnée de la raison et de la manière dont vous corrigez la cause première.

Quand l'utiliser ? Chaque fois que vous rencontrez un bogue frustrant qui revient malgré vos corrections. Cette approche permet d'économiser des heures de débogage.


Comprendre le code généré par l'IA

Ne mettez jamais en œuvre aveuglément un code que vous ne comprenez pas. Ce prompt (instruction générative) vous permet de savoir exactement ce que vous ajoutez à votre base de code :

Pouvez-vous expliquer en détail ce que vous avez généré ?
1. Quel est le but de cette section ?
2. Comment fonctionne-t-elle étape par étape ?
3. Quelles alternatives avez-vous envisagées et pourquoi avez-vous choisi celle-ci ?

Quand l'utiliser ? Chaque fois que vous recevez un code d'une IA. Sans exception. Votre futur vous remerciera.


Débogage

Lorsque vous êtes vraiment bloqué sur un problème, vous devez parfois sortir de vos schémas de pensée habituels. Ce prompt (instruction générative) vous aide à explorer systématiquement les possibilités sous plusieurs angles :

Aidez-moi à déboguer ce problème : [code et journaux]

Réfléchissez à 5-7 sources possibles du problème, en pensant à une variété d'angles créatifs que vous n'auriez pas envisagés normalement.

Réduisez-les à 1 ou 2 sources les plus probables.

Trouvez une idée sur celle qui pourrait être à l'origine du problème et ajoutez des logs pour la tester.

Faites une analyse détaillée des raisons pour lesquelles vous pensez avoir compris le problème, de la manière dont il se produit et de la façon la plus simple de le résoudre.

Quand l'utiliser ? Lorsque l'on est bloqué dans le débogage de problèmes graves. Ce prompt (instruction générative) oblige l'IA à prendre du recul et à considérer le problème dans sa globalité plutôt que de plonger trop rapidement dans une seule explication possible.


Examens du code

L'IA peut détecter des problèmes que des réviseurs humains pourraient manquer :

Examinez le code dans les fichiers [inclure les fichiers ici]

Concentrez-vous sur :
1. Les failles logiques et les cas limites
2. Les goulots d'étranglement de la performance
3. Les vulnérabilités en matière de sécurité
4. Les problèmes de maintenabilité

Proposez des améliorations spécifiques en les expliquant brièvement. Présentez d'abord un plan détaillé. Ensuite, mettez-le en œuvre en apportant le moins de changements possible et en mettant à jour un minimum de code.

Quand l'utiliser ? Avant de soumettre des PR, ou après avoir terminé une fonctionnalité mais avant de la considérer comme « terminée ».


Refactorisation

Transformer un code spaghetti en quelque chose de maintenable :

Refactorisez cette fonction pour qu'elle soit plus :
[coller le code]

Rendez-la :
- Plus lisible (noms de variables clairs, structure logique)
- Maintenable (fonctions plus petites avec des responsabilités uniques)
- Testable (plus facile d'écrire des tests unitaires)

Assurez-vous que vous ne changez pas trop de choses et que cette partie du code reste utilisable sans modifier d'autres parties qui pourraient en dépendre.

Expliquez d'abord vos changements et pourquoi ils améliorent le code.

Quand l'utiliser ? Lorsque votre code est devenu trop lourd au fil du temps. N'utilisez cette méthode que pour de petites parties du code, vous risquez de casser des choses si vous remaniez trop de choses à la fois.


Sécurité

J'ai récemment écrit un guide complet sur la sécurité dans lequel j'explique comment auditer votre code pour détecter les vulnérabilités les plus courantes.


Le prompt (instruction générative) avec rage

Parfois, la frustration peut réellement aider l'IA à obtenir des résultats. Le « rage prompt » (instruction générative avec rage) fonctionne étonnamment bien. N'hésitez pas à ajouter plus de rage en fonction de votre niveau de patience :

Ce code ME REND FOU. Il devrait faire [comportement attendu] mais au lieu de cela, il fait [comportement réel].
S'IL VOUS PLAIT, aidez-moi à comprendre ce qui ne va pas :
[coller le code]

Quand l'utiliser ? Lorsque vous avez besoin de résultats directs sans trop d'explications.


Conclusion

Les bons prompt (instructions génératives) ne font pas que gagner du temps : ils changent fondamentalement la rapidité avec laquelle vous pouvez livrer des produits fiables.

En utilisant ces prompts (instructions génératives) de manière cohérente, vous éviterez les problèmes courants liés au développement de l'IA tout en tirant parti de ses atouts.



Source : My AI Prompt Engineering Playbook for Developers

Et vous ?

Pensez-vous que ces propositions sont crédibles ou pertinentes ?
Quels sont les prompts (instructions génératives) qui vous ont permis de gagner du temps dans votre propre processus de développement ?

Voir aussi :

Mon flux de travail avec Cursor AI qui fonctionne réellement, par Namanyay Goely

Le jour où j'ai appris à l'IA à comprendre le code comme un développeur senior, par Namanyay Goel

L'IA aurait radicalement transformé le codage au point de remplacer bientôt tous les développeurs ? Il n'y a pas de "Vibe Engineering", par Sergey Tselovalnikov

[shenron666]

Quand l'utiliser ? Chaque fois que vous rencontrez un bogue frustrant qui revient malgré vos corrections. Cette approche permet d'économiser des heures de débogage.

Cette approche peut permettre d'économiser des heures de débogage, grosse nuance.
Dans des cas de bugs fonctionnels où le secret professionnel entre en condition, l'IA peut s'avérer à double tranchant.

Ne mettez jamais en œuvre aveuglément un code que vous ne comprenez pas. Ce prompt (instruction générative) vous permet de savoir exactement ce que vous ajoutez à votre base de code.

le Vibe Coding est une énorme erreur, un développeur qui utilise un code généré par l'IA sans le comprendre n'est pas un développeur
demander des explications à l'IA, commenter le code, c'est bien mais il est impératif de le comprendre en détails

d'une manière générale, un prompt n'est pas juste une phrase avec ou sans "bout de code"
c'est une description la plus détaillée possible du problème ou du besoin
le but étant de demander à "quelqu'un" de produire quelque chose qu'il ne comprend pas
correctement utilisé, ça peut faire gagner du temps
mal utilisé, tout est possible, surtout la Loi de Murphy

[lamaison]

Je m'amuse avec l'IA depuis une semaine et je dois dire que je passe par tous les états.
Lors de mon premier essai j'ai conçu une petite architecture objet bien propre et je lui ai dit de la prendre. Les débuts étaient blufants. Puis au fur et à mesure je me suis rendu compte qu'il n'utilisait pas vraiment les objets comme il aurait fallu.
Je suis donc reparti de zéro en lui laissant plus de libertés. C'est allé beaucoup mieux, puis à un moment il n'arrivait plus à se corriger.
Je lui ai dit "Mais tu a développé une SPA" ? Oui m'a t-il dit fièrement, c'est très moderne.
Sauf que c'était une montagne de code spaguettis indémerdable.
Troisième essai dans lequel, effectivement, j'ai imposé un choix d'architecture pour bien partitionner le code en fonction des besoins.
(je n'ai pas voulu utiliser de framework, je craignais que ça ne consomme trop de "jetons" d'IA, car c'est lourd à inspecter, peut-être à tort ?!)
On est allé beaucoup plus loin. Je dirais 50% en 3 jours du projet que j'aurai mis 3 mois à développer tout seul.
Puis reblocage sur des bugs qu'il n'arrivait pas à résoudre, malgré les infos de debug et la console.
Je me suis résolu à mettre les mains dans le camboui et je lui ai dit : Tu t'appuies trop sur l'interface et le DOM; ça ne serait pas mieux que tu t'appuies d'abord sur du Json et que tu impacte l'interface seulement sur la base du Json ?
C'est drôle parcequ'il tout de suite dit que c'était beaucoup mieux pour plein de raisons.
Ah et puis à un moment je lui ai suggéré une structure algorithmique beaucoup plus simple et qui lui a permis de résoudre des difficultés.
Très étonnant alors que je suis bien incapable de coder 10% de ce qu'il produit (surtout le CSS...).
Bref : J'ai l'impression d'avoir un cheval fougueux mal dressé qu'il faut surveiller en permanence.
Mais que c'est bluffant !
A 63 ans j'ai retrouvé le plaisir de "coder" (enfin, plutôt de produire de l'applicatif ;o)
Dommage que j'ai lu cet article un peu trop tard, j'aurai gagné du temps !