Chapitre 1 : IA générative : bouleverser les conventions d'ingénierie

1.1 Le changement est en cours « maintenant ».
Que faire maintenant ?
1.2 L’écart entre les attentes excessives et la réalité concernant l’IA générative
1.3 Des compétences techniques rapides ne sont pas vraiment si importantes.
1.3.1 Comprendre la signification exacte des termes
1.3.2 La stabilité et la précision sont au cœur de l’ingénierie rapide.
1.3.3 La plupart des travaux d'ingénierie sont ponctuels.
1.3.4 Les compétences en ingénierie rapide ne sont pas une panacée
1.4 Les emplois de développeur ne disparaîtront pas.
1.4.1 Devenez un développeur capable de détecter les mensonges
1.4.2 Développer la capacité d’assigner des tâches appropriées à l’IA.
1.4.3 Une notion de nombre de jetons
1.4.4 Maintenir la précision en ajustant le nombre de jetons
1.4.5 Devenez un pro de la revue de code
1.4.6 Revue de code à la bonne vitesse
1.4.7 Examiner de petites portions de code à la fois
1.4.8 La véritable valeur des développeurs mise à l'épreuve par l'évolution de l'IA
1.5 L'IA n'est pas réservée aux développeurs exceptionnels
1.5.1 L'IA est un outil puissant pour aider les développeurs juniors à apprendre.
1.5.2 Acquisition de connaissances par l'IA
1.5.3 Essais et erreurs rapides grâce à la collaboration avec l'IA
1.6 Utilisons correctement les outils d'IA qui soutiennent le développement.
1.6.1 Saisie semi-automatique - Suggérer de courts extraits de code en temps réel
1.6.2 Interactif - Assistance flexible à la résolution de problèmes
1.6.3 Type d'agent - Prend en charge le traitement de tâches complexes
1.6.4 Utiliser les outils de manière appropriée en fonction de la situation.
1.7 Améliorez la compétitivité de votre équipe grâce à l'IA
1.7.1 Différenciez votre équipe grâce à une IA personnalisée
1.7.2 Le code source est-il prêt à être fourni à l'IA ?
1.7.3 Tirer le meilleur parti de l'IA grâce à l'internalisation
1.7.4 Développement du code au niveau organisationnel
1.7.5 Introduisons-nous l'IA uniquement dans le but de réduire les coûts ?

Chapitre 2 : Contrôler l’IA générative par des invites

2.1 Messages système et messages utilisateur
2.1.1 Déterminer s'il convient de réutiliser une invite métier
2.1.2 Création de messages d'alerte ponctuels, rapides et concis
2.1.3 Synthèse et raffinement des incitations à la réutilisation
2.2 Composantes d'une invite - Stratégies d'information pour fournir à l'IA des informations appropriées
2.2.1 Trois éléments de la structuration de l'information
2.2.2 Spécification des conditions à l'aide de puces
2.2.3 Introduction progressive des contraintes
2.2.4 Modification de l'invite
2.2.5 Réagir à une IA qui ne tient pas ses promesses
2.2.6 Définir des rôles qui favorisent l'expertise
2.2.7 Attribution des rôles à la volée
2.2.8 Incitation à quelques coups
2.2.9 Incitation à la prise de vue zéro
2.3 Stratégie d'optimisation des invites dépendante du contexte
2.3.1 Équilibre entre la qualité et la quantité des invites
2.3.2 Invites minimales
2.3.3 Choix de la langue pour une efficacité optimale : utilisation appropriée de l’anglais et du coréen
2.3.4 Répétition rapide en utilisant la langue maternelle
2.3.5 Amélioration à l'aide d'invites en anglais
2.3.6 Délimiteurs pour séparer les contextes

Chapitre 3 : Études de cas et analyse des consignes

3.1 Invite de création de composant React
3.1.1 L’objectif principal est simple : jeu de rôle et instructions de base.
3.1.2 Améliorer la précision : Instructions qui satisfont précisément aux exigences
3.1.3 Contrôle de l'affichage des invites : Instructions de formatage
3.1.4 Spécification de la technologie à utiliser : conditions explicites
3.1.5 Utilisation dans les programmes : Instructions sur les formats de sortie
3.1.6 Les fondements de l'ingénierie rapide
3.2 Invite à créer une interface utilisateur à partir d'une capture d'écran
3.2.1 Vous êtes un développeur expérimenté : Jeu de rôle
3.2.2 Écrivez chaque ligne ! : Instructions pour mettre l'accent sur le contexte
3.2.3 Technologie fournie par un tiers : Conditions claires
3.2.4 Retourner uniquement le code complet : instructions relatives au format de sortie
3.2.5 Conception d'invites spécifiques pour des objectifs spécifiques
3.3 Invite de création de requête SQL
3.3.1 Vous êtes un expert SQL : Jeu de rôle et formation
3.3.2 Ne faites jamais ceci : Instructions d’interdiction formelle
3.3.3 Remarque : Instructions prioritaires
3.3.4 Nettoyage de la sortie : Mise en forme
3.3.5 Spécification des commandes avant exécution : Insertion de contenu
3.4 L'importance des informations contextuelles dans les invites
3.5 Invites pour l'agent universel
3.5.1 Les invites destinées à l'agent général sont-elles utiles ?
3.5.2 Conception d'invites dans OpenHands
3.5.3 Compétences claires et champ d'action : définition des rôles
3.5.4 Élaboration d'un plan d'exécution de tâches multiples : planification globale
3.5.5 Organisation des dépendances entre les tâches : ordonner les tâches
3.5.6 Garantir la cohérence dans l'exécution des travaux : Gestion de l'historique
3.5.7 Spécification du comportement de l'agent : définition des actions
3.5.8 Équilibrer la pensée et l'action de l'IA : contrôle des flux
3.6 L'essence de l'ingénierie rapide
3.6.1 Les invites à l'utilisateur n'ont pas besoin d'être élaborées.
3.6.2 Conseils pour améliorer la qualité des réponses rapides

Chapitre 4 : Stratégies d’incitation adaptées aux outils d’IA

4.1 Outils d'IA de saisie automatique
4.1.1 Minimisation des invites à l'utilisateur
4.1.2 Soutien à la mise en œuvre progressive
4.1.3 Réponse rapide et maintien de la concentration
4.1.4 Renforcer les instructions par des commentaires
4.1.5 Fourniture et gestion d'informations sur les outils d'IA
4.1.6 Fournir des définitions de code explicites
4.1.7 Épingler les fichiers importants pour un accès immédiat
4.2 Outils d'IA conversationnelle
4.2.1 Contrôle flexible du contexte
4.2.2 Prise en charge de différents formats de fichiers
4.2.3 Accès aux informations externes
4.2.4 Accumulation et réutilisation de l'historique
4.2.5 Messages clairs
4.2.6 Évaluation précoce de la qualité rapide
4.2.7 Génération d'invites basée sur l'IA
4.2.8 Refactorisation automatisée à l'aide de l'IA
4.2.9 Conception de l'information tenant compte de la lisibilité de l'IA
4.3 Outils d'IA de type agent
4.3.1 Évaluation préliminaire de la pertinence de la tâche d'IA et ajustement du niveau de granularité
4.3.2 Commission partielle versée à l'agent
4.3.3 Trouver les outils dont vous avez besoin

Chapitre 5 : Techniques de programmation pour la collaboration avec l’IA

5.1 Optimisation des unités de travail grâce à l'IA
5.1.1 Optimisation du code par la séparation des préoccupations
5.1.2 Organisation des fichiers en tenant compte de l'efficacité de l'IA
5.1.3 Travaillez par étapes, en commençant par de petites unités de code.
5.2 Améliorer la lisibilité du code pour l'IA
5.2.1 Nommage pensé pour la collaboration avec l'IA
5.2.2 Stratégie de nommage optimisée pour la recherche
5.2.3 Propositions pour une dénomination appropriée de l'IA
5.2.4 Nommage cohérent des variables
5.3 Styles de codage pour la collaboration avec l'IA
5.3.1 Fournir explicitement un guide de style
5.3.2 Personnalisation du guide de style
5.4 Fournir des informations supplémentaires pour aider l'IA à comprendre
5.4.1 Documentation au sein d'un code standardisé
5.4.2 Ajouter des commentaires minimaux
5.4.3 Communiquer une intention à l'aide d'annotations
5.5 Optimiser les connaissances de l'IA
5.5.1 Choisir l’outil adapté à vos besoins d’information
5.5.2 Questions ouvertes qui stimulent la créativité
5.5.3 Spécifier le nombre d'idées à générer pour encourager l'IA à en générer.
5.5.4 Extraction d'idées inconnues à partir de l'IA
5.5.5 Création d'une liste de contrôle pour l'évaluation des idées

Chapitre 6 : Méthodes de développement qui libèrent le potentiel de l’IA

6.1 Architecture de code adaptée à l'IA
6.1.1 Améliorer l'efficacité de la collaboration en IA en réduisant les chevauchements
6.1.2 Code séparé de l'IA
6.1.3 Conception du code en tenant compte de l'évolutivité
6.1.4 Application des techniques de refactorisation systématiques
6.1.5 Petite réimplémentation open source
6.2 Amélioration de la qualité du code grâce à l'IA
6.2.1 Génération de tests unitaires à l'aide de l'IA
6.2.2 Conditions de test claires 25
6.2.3 Utilisation des tables de décision pour la conception de tests complets
6.2.4 Génération de code de test à partir d'un diagramme de transition d'état
6.2.5 Suppression des tests inutiles
6.3 Utilisation de l'IA dans la lecture de code
6.3.1 Explication de la logique du code en langage naturel
6.3.2 Création de représentations visuelles de la logique complexe
6.4 Utilisation de l'IA dans la revue de code
6.4.1 Amélioration des performances basée sur la notation Big-O
6.4.2 Optimisation du code à l'aide du framework BUD
6.4.3 Évaluation de la pertinence des structures de données
6.4.4 Amélioration de la qualité du code basée sur les principes SOLID
6.4.5 Incitation à la chaîne de pensée

Chapitre 7 : Comment maximiser la puissance de l'IA générative

7.1 Stratégie de développement organisationnel pour renforcer la compétitivité à l'ère de l'IA
7.1.1 Instaurer une culture open source au sein de votre organisation
7.1.2 Principe de la source intérieure
7.1.3 Fonctionnement de la source interne
7.1.4 Partage systématique du code au sein de l'organisation
7.1.5 Rôles clairs des responsables de la maintenance
7.1.6 Création d'un catalogue de logiciels interne
7.1.7 Stratégies de partage de la technologie avec la participation de la direction
7.1.8 Mise en place d'un système de partage de code sécurisé
7.2 Mise en œuvre des méthodes de développement logiciel de l'ère de l'IA au niveau de l'équipe
7.2.1 Programmation de foules IA
7.2.2 Programmation en binômes en IA
7.2.3 Cas d'utilisation de l'invite de partage
7.2.4 Développer les talents pour piloter l'utilisation de l'IA au sein de l'organisation
7.3 IA et documentation
7.3.1 Organisation de l'information adaptée à l'IA
7.3.2 Rédaction de spécifications orientées implémentation
7.4 Optimisation de l'infrastructure technologique de votre équipe pour l'ère de l'IA
7.4.1 Sélection d'une pile technologique adaptée à l'ère de l'IA
7.4.2 Amélioration de la portabilité de l'information
7.4.3 Mesures de sécurité pour le code généré par l'IA
7.5 Évaluation des effets de l'IA générative Introduction
7.5.1 Expérience développeur
7.5.2 Évaluation du processus de développement à l'aide de quatre clés
7.5.3 Évaluation de l'expérience des développeurs avec le framework SPACE
7.5.4 Évaluation de l'introduction des outils d'IA de soutien au développement
7.5.5 Évaluation de la valeur de la mise en œuvre de l'outil

Chapitre 8 : Conseils pour tirer parti de l’IA dans le développement

8.1 Maîtriser l'éditeur et le terminal
8.1.1 Suppression des informations inutiles dans l'éditeur
8.1.2 Utiliser la vérification automatique des licences
8.1.3 Utilisation du terminal intégré de l'éditeur
8.1.4 Utilisation des informations d'aide pour prévenir les hallucinations
8.1.5 Amélioration de la qualité des messages de commit grâce à l'exploitation des différences dans l'historique des modifications
8.2 Manipulation libre des données
8.2.1 Prise en charge de la génération d'expressions régulières à l'aide de l'IA
8.2.2 Reconnaissance des différents formats de date
8.2.3 Création du format POSIX CRON
8.2.4 Conversion de format de données spécial
8.2.5 Classification des données non structurées à l'aide de l'IA
8.2.6 Amélioration de l'efficacité du prétraitement des données
8.3 Techniques d'IA pour un développement web rapide
8.3.1 Suggestions d'amélioration du référencement
8.3.2 Évaluation de l'accessibilité
8.4 Comment utiliser les outils essentiels lors de la collaboration avec l'IA
8.4.1 Identification des points de changement à l'aide de la commande diff
8.4.2 Construction et utilisation de la bibliothèque d'invite de commande
8.4.3 Conversion en Markdown compatible avec l'IA
8.4.4 Création de diagrammes lisibles par l'IA avec Mermaid
8.4.5 Lisibilité par l'IA des diagrammes complexes utilisant PlantUML

Chapitre 9 : Diriger l'ère de l'IA

9.1 Tirer parti de l'IA pour accomplir davantage
9.2 Partager les compétences et les connaissances et évoluer ensemble au sein de l'organisation
9.3 La « curiosité » est le moteur des développeurs.

Annexe A Guide pratique