Pseudo-code, Framework-less - Le futur du code

L'intelligence artificielle dans le monde du travail

Il y a quelques années, cette idée aurait pu surprendre. Aujourd’hui, il n’y a plus de doute : l’avenir sera marqué par l’IA. Par « intelligence artificielle », on désigne essentiellement les grands modèles de langage (LLM) comme ChatGPT, qui vont s’inviter dans la plupart des domaines, à commencer par les métiers de la connaissance (« Knowledge Work »).

Récemment, Anthropic — la société à l’origine de Claude, une alternative à ChatGPT — a publié une étude sur l’impact économique de l’IA conversationnelle. Cette étude présente un graphique comparant la proportion de conversations avec Claude à la répartition des travailleurs par secteur aux États-Unis :

On y voit clairement se démarquer le domaine « Computer and mathematical » : les développeurs représentent 3,4 % de la population active américaine, alors qu’ils constituent 37,2 % des conversations sur Claude. Cela suggère que ce domaine est le plus touché, seulement trois ans après la démocratisation de l’intelligence artificielle.

On observe également que les secteurs que l’on aurait pu croire à l’abri n’y échappent pas : 0,3 % des travailleurs américains sont employés dans le secteur « Farming, fishing and forestry » (agriculture, pêche et sylviculture), qui représente 0,1 % des conversations. Par ailleurs, Anthropic précise que pour les développeurs, les tâches principales effectuées par l’intelligence artificielle touchent directement au cœur du métier. C’est d’ailleurs le cas pour cinq autres catégories professionnelles étudiées, dont la médecine, qui devrait à terme être l’une des branches les plus impactées : c’est celle qui fait actuellement l’objet de la plus grande attention, et qui connaît certains des progrès les plus marquants.

Ainsi, même si l’IA aura un impact important sur l’ensemble des secteurs, c’est sans doute le métier de développeur qui sera le premier profondément transformé, probablement parce que ce sont eux qui créent ces IA et sont ainsi les premiers à l'adopter.

L'avenir des développeurs avec l'IA

Avec l'émergence rapide de l'intelligence artificielle, le métier de développeur évolue considérablement. De nombreux outils basés sur l'IA, comme GitHub Copilot ou Gemini Code Assist, assistent déjà les programmeurs en complétant, refactorisant et documentant leur code. Des environnements de développement intégrés (IDE) spécialisés tels que Cursor et Windsurf vont encore plus loin en automatisant des tâches complexes.

Plus impressionnant encore, les agents d'IA deviennent de plus en plus autonomes. Par exemple, Bolt permet de générer une application mobile entièrement fonctionnelle à partir d'un simple prompt, en itérant sur le code, en lançant l'application et en analysant les logs pour l'améliorer jusqu'à obtenir un résultat optimal.

De nouvelles approches du développement

Deux concepts émergent dans cette ère de l’IA appliquée au code :

La question se pose alors : les développeurs continueront-ils à coder, ou deviendront-ils plutôt des architectes logiciels ? En d’autres termes, allons-nous toujours apprendre des langages et frameworks, ou laisserons-nous l’IA gérer cette partie pendant que nous nous concentrons sur la planification et l’orientation des projets ?

Expérimentation : l’IA en tant que développeur

Pour tester cette idée, j’ai conçu une maquette d’application affichant une liste d’acteurs récupérée via l’API TheMovieDB. L’application comprend une barre de recherche et un défilement infini pour afficher progressivement tous les acteurs existants.

Je vais utiliser le modèle ChatGPT o3-mini-high pour créer cette application. J'utilise le prompt suivant :

I will give you a some instruction to create a vanilla "HTML + CSS + Javascript" application. Your task is to generate every files of the application, preceded with a tree-like file structure.
Instructions : A application named ActorsDB, which is a single page app with a list of actor cards from IMDB api, hovering a card displays the films for which that actor is known for. There is a search bar on top to filter displayed actors.

Résultat : un code de faible qualité, loin de ma maquette et surtout non déterministe (chaque requête retourne une version différente de l'application).

Ce constat met en évidence un point clé : il ne suffit pas d’expliquer ce que l’on veut, il faut aussi expliquer comment y parvenir. En tant que développeurs, nous avons une vision précise de nos attentes et devons structurer notre demande en conséquence.

Un pseudo-code structuré pour guider l’IA

Pour améliorer la précision des résultats, j’ai défini une structure inspirée de YAML décrivant chaque composant, son agencement, son style, ses interactions et ses sources de données. Voici un exemple :

• component: le nom du composant (par exemple Page, ListeActeur, BarreRecherche...)
• layout: la liste des sous-éléments qui composent l’interface (texte, bouton, BarreRecherche...)
• styles: les propriétés visuelles (couleur, taille, position…)
• interactions: les comportements en réponse à l’utilisateur (survol, clic, etc.)
• data: la source de l'information à afficher (par exemple l’appel à une API)

Pour notre application, cela donne le pseudo-code suivant :

component: ActorCard
layout:
  - image: actor image in background
  - text: actor name
    styles:
      - bottom of the card
      - black
      - bold
      - large font
      - white background
      - opacity 100%
styles:
  - rounded (28px)
  - drop shadow
interaction:
  - hover:
      - horizontal flip transition (200ms)
      - verso of the card:
          - layout:
              - ActorCardVerso

---
component: ActorCardVerso
layout:
  - text: Actor Name
    styles:
      - bold
      - large font
      - center
  - text: Known for
    styles:
      - grey
  - text: List of movies
    styles:
      - black
      - bullet point

---
component: ActorsList
layout:
  - each actor: ActorCard
styles:
  - flex column of 4 actors
  - flex wrap for responsive
interraction:
  - on reach end: fetch next page

---
component: Page
layout:
  - title:
      text: ActorsDB
      styles:
        - black
        - bold
        - center
        - large font
  - searchbar:
      placeholder: Search for an actor...
      on_change: update actors displayed
      styles:
        - search icon on left
        - color grey
        - drop shadow
        - full rounded
        - centered in page
  - ActorsList:
styles:
  - gap: 80px
data:
  - "paginated actors list ordered by popularity":
      call: "GET https://api.themoviedb.org/3/person/popular"
      params:
        api_key: eyxxx
        language: en-US
        page: 1
      example:
        curl: "curl --request GET  --url 'https://api.themoviedb.org/3/person/popular?language=en-US&page=1' --header 'Authorization: Bearer <api_key>' --header 'accept: application/json'"
        reponseType: |
          Root {
            page: number
            results: Result[]
            total_pages: number
          }

          Result {
            id: number
            name: string
            profile_path: string
            known_for: KnownFor[]
          }

          KnownFor {
            id: number
            name?: string
          }

J'utilise toujours ChatGPT o3-mini-high, avec le prompt suivant, suivi du schéma que j'ai écrit.

I will give you a some instruction to create a vanilla "HTML + CSS + Javascript" application. Your task is to generate every files of the application, preceded with a tree-like file structure.
Instructions :
<my schema>

Cette fois-ci le résultat est très impressionant, alors même que le modèle n'a pas vu la maquette, le rendu est extrêmement similaire, et répond à toutes les exigences (animation miroir, scroll infini, recherche, etc.)

Par cette méthode, l’IA se montre beaucoup plus déterministe, car nous lui offrons un cahier des charges exhaustif. La première partie de cette expérimentation est donc concluante : l’IA peut déjà générer du code aux exigences techniques et esthétiques "élevées", à condition que nous formulions ces exigences de manière précise.

Vers un développement universel et sans framework

L’un des enseignements majeurs de cette expérience est la notion de déterminisme. Une IA bien guidée avec un cahier des charges structuré est capable de produire un code reproductible et cohérent.

Mais jusqu’où cela peut-il aller ? Peut-on générer la même application en changeant simplement de technologie, sans modifier les spécifications ?

En appliquant exactement le même schéma, j’ai pu générer l’application sous différentes technologies : HTML, React, VueJS, Streamlit, et même Tkinter pour Python. Chaque version conservait l’agencement et le design définis dans le pseudo-code initial.

Ce résultat ouvre la voie à une approche où les développeurs n’écrivent plus directement du code spécifique à une technologie, mais rédigent un cahier des charges universel que l’IA transforme en code, quel que soit le framework ou le langage utilisé.

La démonstration ne se limite évidement pas qu'aux framework web, je peut aussi générer cette interface pour Python avec Tkinter. Le rendu n'est pas aussi bon, mais tout ceux qui ont déjà mis les mains dans Tkinter savent à quel point le résultat est impressionnant.

Conclusion

L'intelligence artificielle va prendre de plus en plus de place dans nos vies à tous, parce que sa rapidité de traitement des informations décuple la productivité de chacun. L'impact économique de cette amélioration de la productivité est fort, c'est la raison pour laquelle elle va inévitablement impacter tout le monde.

Mais l'intelligence artificielle va-t-elle remplacer tout le monde ? Comme appuyé par cette démonstration, l'intelligence artificielle va remplacer des tâches et non des gens. Comme tout outil, elle a besoin de quelqu'un qui la manie. Et si la personne qui manie l'outil est bon dans son domaine, alors elle pourra faire de plus grandes choses que les autres.