The End of Developers in 2026? Elon Musk is right... but wrong.

> AI can generate code. But code is not just syntax: it’s a language for thinking about systems. It’s time to clarify why. In recent years, discussions about software development automation have multiplied. Some technology leaders, such as Elon Musk, claim that developers could **disappear**. At first glance, this idea seems radical: if AI can generate code from simple natural language instructions, why would we still need developers? It could generate machine binaries too. Yet this reasoning relies on a very narrow definition of code, where code is seen purely as a translation process, an intermediate step in a production chain: ```text Natural human idea --Developer--> Code --Compiler--> Phenomenon in the machine world ``` In short: ```text Ν --Δ--> C --Κ--> Μ ``` And we all know that AI (Α) and the compiler (Κ) help us in writing code: ```text Ν --Δ+Α+Κ--> C --Κ--> Μ ``` In this sense, coding is only about transforming human ideas into executable binary instructions. On this ground, Musk is probably right: many repetitive or syntactic implementation tasks could indeed be automated. ```text Ν --Α+Κ--> C --Κ--> Μ ``` And AI could even do a better job than any compiler (as he said himself). So: ```text Ν --Α+Κ--> Μ ``` Ok… that may happen to a lot of companies. Musk may be right. Note that in this picture, we've **lost control**. We cannot see what's going on in the machine… Because that was one of the many advantages of traditional code. Right? But anyway, that's another topic. Let's discuss another aspect of things, and see where Musk is wrong. --- ## The Missing Definition These debates are very often truncated by a cut (sometimes accidental, sometimes deliberate) in the definitional scope of what we call "code". Let us put aside announcements, speculative interests, and stock prices for a moment, and **focus** instead on the **definition**. In my experience with functional programming (which I have studied for two years), I (re)discovered another dimension of code. Something absolutely essential. Here, coding primarily means **formalizing an idea**, modeling a domain, **expressing** invariants, and **structuring** a complex system. In this perspective, code becomes an intermediate symbolic language, a **tool for thought**, **not** merely a translation to the machine. --- ## Code as Maths In FP, code is absolutely not reduced to a translative layer from one language to another, from one world to another. It is an **extensive layer of language itself**. It is then transpiled (e.g. PureScript → JavaScript). ```text Ν --Δ+Α+Τ--> Σ --Τ--> C --Κ--> Μ ``` And here comes the difference. We cannot prune the chain the same way we did before (i.e. remove Δ): ```text Ν --Α+Τ--> Σ --Τ--> C --Κ--> Μ ``` Why? Because Σ is a **extension** of Ν. Not a translation, not another shape, not another physicality we give to a substance. This is the substance itself, going further: Σ > N. It is there to express what Ν cannot express. And guess who does the expression job? Δ. The delta. The difference. The added value. The developer. AI **cannot** generate human knowledge **outside** of humanity. If AI generates Σ autonomously, with tangible results, humans will be interested in knowing them. They will want to know the formula, the symbols that are useful to manipulate reality. There will always be Bob, to check a generated idea. His Σ will then become his new N, and a new cycle of territory extension will begin. It will give him more power on reality. And people who have been ignoring their Σ (letting it to AI) will try to imitate Bob's one, will learn his Σ (which became his N). His Σ will become the new N, for everyone. AI will never generate an everlasting and independent Σ, with no human to catch up with it. _Note that these assumptions are based on an **ideal world**, where AI is truly capable of validating its Σ ideas. Current practice shows something different. It can barely iterate through several validation cycles by attaching itself to your browser to validate the visual reality of your website. It is impressive, but it is still imperfect. And it is pure 2D virtuality. Nothing to do with reality and 3D-world human stakes._ There will always be Σ. There will always be the need to compress ideas or express something new and interesting for the rest of humanity. We need someone to understand the move: that will not come from the entirety of the group, at the same time. Experts are, in my humble opinion, **consubstantial** to humans. They will always be there. As long as Ν exists, Σ will exist. Ν is indeed a social convention. It can grow, it can extend its limits. And Σ is in fact one of the many special corners of Ν. Like math vocabulary, like biology vocabulary… Ν and Σ are two faces of the **same cube**, and cannot be dissociated. We can invent, with AI help (but only help, by definition), ways of expressing intuitions of Ν into Σ, or vulgarize Σ into Ν. But Ν and Σ are none of AI's real business; they are the very core of human ideas, desires, viewpoints, and knowledge. And they work hand in hand: ```text [Ν <~~Δ+Α+Τ~~> Σ] --Τ--> C --Κ--> Μ ``` Σ is richer than English N. More compact, declarative, and precise than traditional code C (it focuses on _what_, not _how_). In Musk’s world, companies will add value if they bring Ν in: ```text Ν --Α--> Μ ``` The more efficient they are in providing Ν and helping Α to translate, the more they will succeed. That's why we see numerous tutorials to help us speak to AI, in a sort of infinitely recursive (and sometimes absurd) loop. Just to improve the final Ν in the chain. Of course, the diagram goes far beyond something linear, and becomes indigestible (and costly). But. Us humans will still persist information within groups, and make tech companies, to produce Μ. In the FP chain, we can play on Σ, not Ν. That is necessary to add value. Here, should we call Σ "code"? In my opinion, yes. Because it is not Ν, it is not C or Μ. It is technical, read on screen. It just not the traditional intermediary layer it used to be. Eliminating code, in this respect, would mean reducing the added value. This is obviously not what the industry prefers. --- ## Code as Expression It is here that expression becomes central to the modern definition of code. Code is no longer just translation. It is the terrain for expressing particular ideas, with a strong **epistemological dimension**. This is exactly what languages like Haskell or Rust enable: code becomes almost an executable **specification** rather than a mere sequence of instructions. The ability to model and formalize is far more resistant to automation than simple syntax writing. --- ## The AI Wave In other words, your "protection" against the AI wave lies in your ability to think and formalize a problem correctly. If your language gives you that power, this is the way to go. Musk is both right and wrong. He is right with the **traductive** flavour of code definition. He is wrong with the **expressive** flavour of code definition. The good news is that in this expressive sense, the role of developers remains **central**. It simply changes in nature. I am inclined to think that this reasoning can and should extend beyond FP. The rules have changed. But human, expression and "code" are **still** at the heart of the game. In the AI village, you'll never be the fool. --- {% embed https://www.youtube.com/watch?v=bWIms21MybA %}