J’ai demandé à mon IA de créer mon code VBA Excel à ma place… et le résultat est bluffant

Dans ce tutoriel, je vais vous montrer comment utiliser la nouvelle fonctionnalité de Code Assistant dans IA Excelformation.fr pour améliorer, expliquer ou corriger une macro VBA directement depuis Excel, même si vous n’êtes pas développeurs.

Nous allons partir d’un cas très concret, voir comment préparer notre feuille, créer une première macro utile, puis demander à l’IA de travailler soit sur tout le code, soit uniquement sur une portion précise, tout en conservant le contexte global du module.

Vous le savez probablement si vous suivez l’actualité de la chaîne, IA Excelformation.fr est mon complément Excel qui ajoute un ruban dédié pour intégrer l’IA dans Excel.

Nous avions déjà découvert les fonctionnalités propres à Excel, comme la génération de formules ou encore l’analyse de données, nous allons donc aller encore un cran plus loin en découvrant comment générer du code VBA, directement depuis l’éditeur de code.

Attention toutefois, pour rappel à ce jour, l’outil n’est pas compatible avec Excel sur Mac, et une clé API est nécessaire à son bon fonctionnement (cliquez-ici pour en savoir plus).

Etant donné qu’il s’agit d’une nouveauté majeure de l’outil, j’ai décidé de vous proposer une remise incroyable pour quelques jours seulement, que vous pourrez obtenir en utilisant le code « CODEASSISTANT » au moment de la commande.

Et bien entendu, si vous faites partie des nombreuses personnes ayant commandé votre version d’IA Excelformation.fr, il vous suffira de le télécharger à nouveau depuis votre espace pour bénéficier de cette nouveauté incroyable.

COMMANDER L'outil « IA Excelformation.fr V2 » avec Code Assistant :

Malheureusement, en raison des limitations d’Excel sur Mac , l’outil n’est pas compatible avec Excel macOS.

	« IA excelformation.fr » Version STANDARD	« IA excelformation.fr » Version DEVELOPPEUR	Pack « IA & Barre d'outils »
Boostez Excel avec l'IA
Création de code VBA par IA sans quitter Excel
Accès au code VBA (entièrement commenté)
« Barre d'outils by excelformation.fr » version PRO  (Valeur unitaire : 57€)
Prix	47€	67€ 51€ avec le code CODEASSISTANT	97€ 73€ avec le code CODEASSISTANT  (valeur à l'unité 124,00 euros)

Attention, le code « CODEASSISTANT » est valable jusque dimanche (22/03) seulement !!

Tutoriel Vidéo

1. Présentation

Pour illustrer cet article, nous allons pouvoir utiliser le tableau suivant dans lequel nous retrouvons un suivi de commandes fournisseurs avec des dates prévues de livraison, des dates réellement reçues, des quantités et un statut.

Cet exemple est intéressant, car nous avons des données simples, mais nous voyons immédiatement qu’une petite macro pourrait nous faire gagner du temps pour repérer les retards.

Comme nous pouvons le constater, ce tableau est mis sous la forme d’un tableau structuré, lequel s’étendra automatiquement si nous ajoutons de nouvelles lignes à la suite, ce qui évite de réécrire les plages plus tard.

Si nous nous rendons dans le menu « Création du Tableau », nous pouvons constater que celui-ci s’appelle « Livraisons ».

C’est un petit détail, mais cela améliore énormément la lisibilité, et la manipulation en VBA.

Au lieu d’écrire des références du type $E$2:$E$11, nous pourrons utiliser des références structurées beaucoup plus parlantes.

Pour commencer proprement, nous ajoutons une colonne « Retard ? ».

Puis, nous allons demander à l’IA de générer la formule correspondante, en nous rendant dans le menu « IA Excelformaiton.fr », puis « Tous les prompts » et enfin « Créer formule Excel – Cellule active automatique » :

L’IA analyse alors les cellules et génère la formule :

  =SI(F7="";SI(AUJOURDHUI()>E7;"Oui";"Non");SI(F7>E7;"Oui";"Non"))  

2. Créer une première macro utile sur ce cas concret

Maintenant que la base est prête, nous allons imaginer un besoin très courant. Nous voulons une macro qui parcourt le tableau, repère les commandes en retard et colore la ligne pour attirer immédiatement l’attention.

Nous ouvrons donc l’éditeur VBA avec [Alt]+[F11].

Nous insérons un nouveau module, et nous appelons le Code Assistant en effectuant un clic-droit sur une zone vide > Assistant IA Excelformaiton.fr.

Une boîte va alors s’afficher, et nous allons demander : « Je souhaite colorer les lignes de mon tableau structuré "Livraisons" en rouge si la colonne "Retard ?" = Oui. Le tableau se trouve sur la feuille "Excelformation.fr" » :

Puis, nous cliquons sur le bouton « envoyer la demande à l’IA.

En quelques secondes, nous obtenons une macro VBA qui va nous permettre d’effectuer l’opération :

Pour l’insérer dans le module, nous cliquons sur « Insérer/Modifier dans le module ».

Ensuite, nous pouvons tester la macro en cliquant sur le triangle vert :

Et voilà le résultat :

Sympa, mais un peu brutal visuellement.

Nous relançons donc l’outil et nous lui demandons d’utiliser des couleurs plus légères.

C’est bien mieux ainsi :

Maintenant, imaginons que nous souhaitions améliorer la règle et modifier la couleur en fonction du retard.

Nous pourrons alors préciser : « Je souhaite que l’intensité du rouge dépende du nombre de jours de retard. Utilise les colonnes « Date prévue » et « Date reçue ». Si la valeur de « Date reçue » est vide, utilise la date du jour. »

Le résultat est alors bien plus intéressant :

3. Utiliser le Code Assistant pour modifier ou analyser le code pas à pas

Nous allons maintenant utiliser le Code Assistant comme un assistant de travail, pas comme un simple générateur automatique.

C’est une nuance importante.

Dans l’interface, nous pouvons saisir notre demande dans la zone de prompt, puis choisir si nous voulons afficher la réponse dans « Aperçu IA » ou l’appliquer directement au code.

Si nous cochons la case « Afficher dans l’aperçu IA », la réponse va dans la zone d’aperçu.

Si nous la décochons, l’objectif devient la modification directe du code.

Par exemple, si le code généré nous parait assez complexe, nous pouvons en obtenir rapidement une explication en nous rendant dans les actions rapides, et en cliquant sur Expliquer le code :

Cela nous affiche la fenêtre d’aperçu IA avec une explication du code :

Cette commande est particulièrement utile lorsque nous reprenons une macro écrite il y a plusieurs mois, lorsque nous héritons d’un fichier conçu par une autre personne, ou tout simplement lorsque nous voulons comprendre précisément ce qu’une procédure fait avant d’y toucher.

Au lieu de relire chaque ligne à la main et d’essayer de reconstruire mentalement la logique, nous demandons directement à l’outil de nous reformuler le fonctionnement du code avec des mots beaucoup plus simples

Les autres actions rapide permettent de également de gagner du temps sur des besoins très concrets :

- Lorsque nous cliquons sur « Optimiser le code », nous demandons à l’outil de conserver le résultat attendu tout en améliorant la manière dont le code travaille. Selon le contexte, cela peut consister à simplifier certaines boucles, éviter des répétitions inutiles, clarifier la structure ou rendre le traitement un peu plus propre. C’est utile lorsque la macro fonctionne déjà, mais que nous sentons qu’elle pourrait être mieux écrite.

- L’action « Commenter le code » est, elle aussi, très pratique, surtout si nous voulons garder une macro compréhensible dans le temps. L’outil va enrichir le code avec des commentaires explicatifs. Cela peut sembler secondaire, mais en réalité c’est souvent ce qui fait la différence entre une macro que nous comprenons encore dans six mois et une macro que nous devons redécoder entièrement. C’est aussi un bon moyen de documenter un fichier avant de le transmettre à un collègue.

- L’action « Gestion des erreurs » sert à renforcer la robustesse de la procédure. Dans beaucoup de macros, le code fonctionne très bien tant que tout se passe comme prévu. En revanche, dès qu’une feuille change de nom, qu’une cellule contient une valeur inattendue ou qu’un objet n’est pas trouvé, la macro peut s’interrompre brutalement. Avec cette action rapide, nous pouvons demander à l’IA d’ajouter une structure plus sécurisée, avec par exemple un On Error GoTo, une sortie propre et un message plus clair en cas de problème. C’est particulièrement utile lorsque la macro doit être utilisée régulièrement par d’autres personnes.

- L’option « Refactoriser le code » va plus loin que la simple optimisation. Ici, l’idée n’est pas seulement d’aller un peu plus vite, mais surtout de rendre le code plus lisible, mieux organisé et plus facile à maintenir. L’outil peut, par exemple, proposer des noms de variables plus parlants, découper un traitement trop long en plusieurs blocs logiques ou simplifier certaines conditions. C’est une action intéressante lorsque le code fonctionne, mais que sa structure commence à devenir difficile à suivre.

Enfin, l’action « Auditer le code » nous place dans une logique de relecture critique. Au lieu de modifier directement la macro, l’IA va nous signaler les points faibles possibles du code, les zones à surveiller, les risques d’erreurs, les choix techniques discutables ou encore les améliorations envisageables. C’est une étape très utile avant de diffuser un classeur, avant d’automatiser un traitement important, ou simplement lorsque nous voulons prendre un peu de recul sur ce que nous avons écrit.

Il est également possible de puiser dans la bibliothèque de prompts pré-enregistrés. Cette fonctionnalité fonctionne de manière légèrement différente des actions rapides que nous venons de voir.

Lorsque nous utilisons une action rapide, la demande est envoyée immédiatement à l’IA avec un prompt déjà construit. C’est donc une solution très pratique lorsque nous voulons aller vite, par exemple pour optimiser un code ou ajouter une gestion des erreurs sans réfléchir à la formulation.

La bibliothèque de prompts, elle, fonctionne plutôt comme une boîte à outils de requêtes prêtes à l’emploi. Lorsque nous sélectionnons un prompt dans la liste, celui-ci est inséré dans la zone de demande, mais il n’est pas encore envoyé. Nous pouvons donc le relire, l’adapter, ajouter des précisions, ou même changer complètement l’objectif avant de lancer l’analyse.

Cette approche est très intéressante lorsque nous voulons garder un certain contrôle sur la demande, ou lorsque notre cas est un peu particulier.

Parmi les prompts proposés dans la bibliothèque, nous retrouvons par exemple le prompt « Indenter et formater le code ». Ce prompt demande à l’IA de réorganiser le code pour améliorer la lisibilité. Concrètement, l’IA va réaligner les blocs If, For, With, ajouter des sauts de lignes logiques et rendre la structure générale beaucoup plus claire. C’est particulièrement utile lorsque nous travaillons sur un code récupéré dans un ancien fichier, ou écrit rapidement sans trop se soucier de la mise en forme.

Nous trouvons également le prompt « Remplacer Select et Activate ». Les débutants en VBA utilisent souvent Select ou Activate, car c’est la manière dont Excel enregistre les macros automatiquement. Le problème est que ces instructions ralentissent le code et le rendent parfois fragile. Ce prompt demande donc à l’IA de réécrire les lignes concernées en utilisant des références directes aux objets Range, Worksheet ou Workbook, ce qui rend le code plus propre et généralement plus rapide.

Un autre prompt très utile est « Optimiser une boucle Range vers Array ». Dans beaucoup de macros, les cellules sont parcourues une par une, ce qui peut devenir très lent lorsque le tableau contient des milliers de lignes. Ce prompt demande à l’IA de charger la plage de données dans un tableau en mémoire (un array), d’effectuer les calculs dans ce tableau, puis de réécrire le résultat en une seule opération dans Excel. Cette technique est très utilisée par les développeurs VBA expérimentés, car elle améliore énormément les performances.

Enfin, nous pouvons utiliser le prompt « Ajouter une gestion d’erreur complète ». Ce prompt demande à l’IA d’ajouter une structure de gestion des erreurs avec On Error GoTo, un bloc de sortie propre et éventuellement un message explicatif. Cela permet d’éviter que la macro s’arrête brutalement si un élément attendu n’est pas trouvé dans le classeur.

L’avantage de cette bibliothèque est donc double. D’une part, elle nous évite d’avoir à rédiger nous-mêmes des prompts techniques. D’autre part, elle nous laisse la possibilité de personnaliser la demande avant de l’envoyer, ce qui est souvent très utile lorsque nous travaillons sur un cas réel avec des contraintes spécifiques.

Avec ces deux approches — actions rapides pour aller vite, et bibliothèque de prompts pour garder la main sur la demande — nous disposons finalement d’un environnement assez confortable pour travailler sur du code VBA directement depuis Excel.

4. Création d’une synthèse visuelle

Maintenant je vous propose de découvrir un deuxième exemple de génération de macro.

L’objectif ici surtout de montrer une méthode de travail très efficace avec l’IA : fonctionner par petites demandes successives, plutôt que d’essayer d’obtenir immédiatement une macro très complexe avec un seul prompt.

En pratique, cette approche fonctionne beaucoup mieux.

L’IA comprend plus facilement ce que nous voulons faire, et nous gardons la maîtrise du résultat à chaque étape.

Nous allons donc créer une macro qui génère un petit tableau de bord visuel des retards, directement dans Excel.

L’idée est simple :
nous voulons créer une feuille qui affiche :

- le nombre total de commandes

- le nombre de commandes en retard

- un graphique qui montre la proportion.

   4.1. Première étape : créer la feuille de synthèse

Pour cela, nous allons commencer par créer un nouveau module, et lancer Code Assistant afin de lui faire une première demande très simple :

« Crée une macro qui génère une feuille appelée "Tableau de bord" et affiche le nombre total de lignes du tableau structuré "Livraisons" (sur la feuille "Excelformation.fr") ainsi que le nombre de retards (colonne "Retard ?" : Oui/Non). »

L’idée ici, c’est quand même d’être assez précis pour ne pas que l’IA ait besoin de deviner les choses.

L’IA nous propose alors un premier code :

Nous exécutons la macro avec le triangle vert.

Une nouvelle feuille apparaît avec les indicateurs.

Parfait, mais ce n’est que la première étape, ce n’est pas encore très visuel.

   4.2. Deuxième étape : améliorer la présentation

Nous retournons dans le Code Assistant et nous faisons une seconde demande : « Améliore la macro pour créer un tableau de bord plus visuel avec des titres centrés, une mise en forme élaborée, des bordures et des couleurs. »

L’IA enrichit alors le code en ajoutant par exemple une mise en forme.

Le tableau devient alors plus lisible avec des cellules centrées, des titres et des couleurs.

Nous voyons déjà l’intérêt de la méthode.

Plutôt que de demander directement un tableau de bord complexe, nous avons commencé par créer la structure, puis seulement nous en avons amélioré la présentation.

   4.3. Troisième étape : ajouter un graphique

Nous pouvons maintenant aller encore un peu plus loin.

Nous relançons le Code Assistant et nous demandons :

« Ajoute un graphique circulaire montrant la proportion de commandes en retard. »

L’IA va alors compléter la macro pour générer un graphique.

Lorsque nous relançons la macro, Excel crée automatiquement un petit tableau de bord avec un graphique.

Visuellement, c’est beaucoup plus parlant.

Et surtout, nous avons obtenu ce résultat en trois petites demandes très simples.

C’est exactement la logique que je recommande.

Plutôt que d’écrire un prompt énorme du type : « Crée un tableau de bord complet avec graphiques, calculs et mise en forme… » nous avançons progressivement.

Cette méthode donne généralement de meilleurs résultats et permet aussi de comprendre ce que fait le code.

Pour finir, si nous le souhaitons, nous pouvons maintenant demander d’améliorer le rendu visuel de l’ensemble : « Finalise le tableau de bord en améliorant le rendu visuel en cherchant à obtenir un effet wahou ! Et masque le cadrillage. »

C’est subtile, mais c’est toujours plus sympa.

   4.4. Pourquoi les demandes successives fonctionnent mieux

Lorsque nous travaillons avec l’IA, il est souvent tentant de rédiger un prompt très long pour obtenir immédiatement le résultat final.

Pourtant, dans la pratique, les meilleurs résultats sont souvent obtenus avec plusieurs petites demandes successives.

Nous pouvons par exemple :

1. demander une structure simple
2. améliorer la logique
3. ajouter des options visuelles
4. optimiser le code

Chaque étape permet de vérifier que nous allons dans la bonne direction.

C’est exactement ce que nous avons fait ici.

Et c’est précisément dans ce type de situation que le Code Assistant devient particulièrement utile : il ne remplace pas notre réflexion, mais il accélère considérablement la mise en œuvre.

5. Debogguer une macro qui ne fonctionne pas

Une autre utilisation très intéressante du Code Assistant consiste à corriger une macro qui ne fonctionne pas correctement.

C’est probablement l’un des cas les plus fréquents dans la vraie vie.

Nous avons récupéré un fichier Excel avec du code VBA, mais celui-ci génère une erreur ou ne produit pas le résultat attendu.

Voyons un exemple concret.

Imaginons que nous ayons écrit la macro suivante pour compter les retards.

  Sub CompterRetards()
Dim ws As Worksheet
  Dim lo As ListObject
  Dim totalRetards As Long
  Dim i As Long
  
  Set ws = ThisWorkbook.Worksheets("Excelformation.fr")
  Set lo = ws.ListObjects("Livraisons")
  
  For i = 1 To lo.ListRows.Count
  
      If lo.ListRows(i).Range.Cells(1, "Retard ?").Value =  "Oui" Then
          totalRetards = totalRetards + 1
      End If
  
  Next i
  
  MsgBox "Nombre de retards : " & totalRetards
End Sub
 

Si nous essayons d’exécuter ce code, Excel va afficher une erreur.

Pourquoi ?

Parce que l’instruction : « Cells(1, "Retard ?") » n’est pas valide en VBA.

En effet, la méthode Cells attend un numéro de colonne, pas un nom de colonne.

Pour nous en assurer, nous pouvons lancer un audit de la macro :

Celui-ci nous confirme bien que le problème vient de la ligne que nous avions identifiée plus tôt.

Pour corriger cela, nous pouvons simplement lancer le Code Assistant et demander : « Corrige cette macro »

L’IA va immédiatement repérer le problème et proposer une version corrigée.

La correction est intéressante à comprendre.

L’IA commence par récupérer l’index de la colonne « Retard ? » grâce à : « ListColumns("Retard ?").Index »

Ensuite, elle utilise cet index pour accéder correctement à la cellule.

Cette approche est beaucoup plus robuste, car elle continue de fonctionner même si l’ordre des colonnes change dans le tableau.

C’est justement le type d’erreur qui peut être difficile à repérer lorsqu’on débute en VBA.

Avec le Code Assistant, nous pouvons simplement demander « Explique pourquoi ce code ne fonctionne pas » ou « Corrige cette macro ».

L’outil va alors analyser le code, identifier le problème et proposer une solution.

Dans la pratique, cela permet souvent de gagner beaucoup de temps.

Au lieu de passer plusieurs minutes à chercher dans la documentation ou sur internet, nous pouvons obtenir une explication claire et une correction directement dans l’éditeur VBA.

Conclusion

Avec cette nouveauté de Code Assistant dans IA Excelformation.fr, nous pouvons travailler le VBA de manière plus souple et plus concrète. Nous gardons notre logique métier, nous conservons le contexte global du code, et nous pouvons cibler précisément la portion à modifier quand c’est nécessaire. C’est ce point qui change vraiment la pratique au quotidien, car nous ne sommes plus obligés de tout refaire pour corriger une seule boucle ou une seule condition.

Dans notre exemple, nous sommes partis d’un simple tableau de livraisons en retard. Nous avons d’abord préparé la feuille proprement avec un tableau structuré et des formules simples, puis nous avons construit une première macro, avant d’utiliser l’IA soit pour améliorer le code, soit pour l’expliquer, soit pour l’auditer.

Cette manière de travailler est à la fois plus rapide et plus confortable, surtout lorsque nous voulons progresser sans passer notre temps à chercher la bonne syntaxe.