Pseudo-code, Framework-less - The future of code

Artificial Intelligence in the Workplace

A few years ago, this idea might have been surprising. Today, there is no doubt: the future will be marked by AI. By "artificial intelligence," we mainly refer to large language models (LLMs) like ChatGPT, which are becoming integrated into most fields, starting with knowledge work.

Recently, Anthropic—the company behind Claude, an alternative to ChatGPT—published a study on the economic impact of conversational AI. This study presents a graph comparing the proportion of conversations with Claude to the distribution of workers by sector in the United States:

We can clearly see that the "Computer and Mathematical" field stands out: developers make up 3.4% of the U.S. workforce but account for 37.2% of conversations on Claude. This suggests that this field is the most affected, just three years after the democratization of artificial intelligence.

We also observe that sectors previously thought to be safe are not spared: 0.3% of American workers are employed in the "Farming, Fishing, and Forestry" sector, which represents 0.1% of conversations. Additionally, Anthropic specifies that for developers, the main tasks performed by artificial intelligence directly impact the core of the profession. This is also the case for five other professional categories studied, including medicine, which is expected to be one of the most affected fields in the long run. It is currently receiving the most attention and experiencing some of the most significant advancements.

Thus, even though AI will have a major impact across all sectors, the developer profession will likely be the first to undergo profound transformation—probably because developers are the ones creating these AIs and are, therefore, the first to adopt them.

The Future of Developers with AI

With the rapid emergence of artificial intelligence, the developer profession is evolving considerably. Many AI-powered tools, such as GitHub Copilot or Gemini Code Assist, already assist programmers by completing, refactoring, and documenting their code. Specialized integrated development environments (IDEs) like Cursor and Windsurf go even further by automating complex tasks.

Even more impressive, AI agents are becoming increasingly autonomous. For example, Bolt can generate a fully functional mobile application from a simple prompt, iterating on the code, launching the application, and analyzing logs to refine it until an optimal result is achieved.

New Approaches to Development

Two concepts are emerging in this era of AI-driven coding:

This raises the question: Will developers continue to code, or will they become more like software architects? In other words, will we still learn languages and frameworks, or will we let AI handle that part while we focus on planning and project direction?

Experimenting with AI as a Developer

To test this idea, I designed a mockup of an application displaying a list of actors retrieved via TheMovieDB API. The application includes a search bar and infinite scrolling to progressively display all existing actors.

I used the ChatGPT o3-mini-high model to create this application. I used the following prompt:

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

Result: poor-quality code, far from my mockup, and most importantly, non-deterministic (each request returns a different version of the application).

This highlights a key point: it's not enough to explain what we want; we must also explain how to achieve it. As developers, we have a precise vision of our expectations and must structure our request accordingly.

A Structured Pseudo-Code to Guide AI

To improve result accuracy, I defined a YAML-inspired structure describing each component, its layout, style, interactions, and data sources. Here is an example:

• component: the name of the component (e.g. Page, ActorsList, SearchBar...)
• layout: the list of sub-elements that make up the interface (text, button, SearchBar...)
• styles: visual properties (color, size, position, etc.)
• interactions: behaviors in response to the user (hover, click, etc.)
• data: the source of the information to be displayed (for example, a call to an API)

For our application, this gives the following pseudo-code:

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
          }

I used ChatGPT o3-mini-high again, with the following prompt, followed by my written schema.

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

This time, the result was very impressive—even though the model had not seen the mockup, the output was extremely similar and met all requirements (mirror animation, infinite scroll, search, etc.).

With this method, AI becomes much more deterministic because we provide it with an exhaustive specification document. The first part of this experiment is therefore conclusive: AI can already generate code that meets "high" technical and aesthetic requirements, provided we formulate these requirements precisely.

Towards Universal and Framework-Free Development

One of the key takeaways from this experience is the notion of determinism. A well-guided AI with a structured specification document can produce reproducible and coherent code.

But how far can this go? Can we generate the same application by simply changing the technology without modifying the specifications?

By applying the exact same schema, I was able to generate the application in different technologies: HTML, React, VueJS, Streamlit, and even Tkinter for Python. Each version retained the layout and design defined in the initial pseudo-code.

This result paves the way for an approach where developers no longer write code specific to a technology but instead create a universal specification document that AI translates into code, regardless of the framework or language used.

This demonstration is not limited to web frameworks; I can also generate this interface for Python using Tkinter. The result is not as polished, but anyone who has worked with Tkinter knows how impressive this is.

Conclusion

Artificial intelligence will play an increasingly significant role in all our lives because its ability to process information rapidly boosts productivity. The economic impact of this productivity increase is substantial, which is why it will inevitably affect everyone.

But will artificial intelligence replace everyone? As demonstrated, AI will replace tasks, not people. Like any tool, it needs someone to operate it. And if the person using the tool is skilled in their field, they will be able to accomplish greater things than others.