Elon Musk recently posted that “code itself will go away in favor of just making the binary directly”. It is the sort of statement that sounds absurd right up until the industry starts drifting in that exact direction.

Here is his original post on X.

The obvious reaction is to ask whether coding is dead. That is a fun headline, but not a very useful question. A better one is this: if code matters less, what takes its place?

Because most people do not actually want to code. They want to build, change, automate, test, refine, and ship. Coding has traditionally been the painful interface between human intent and machine behaviour. If AI can shrink that gap, that is not the end of software. It is just a change in how we express what we want.

Why do people dislike coding?

For a small number of us, coding is joyful. For everyone else, it is often fiddly, brittle, and mentally expensive.

That is not because people are lazy. It is because writing software through formal syntax is an unnatural act for most humans. We think in goals, examples, language, diagrams, and visual models. We are much better at saying “make it work like this” than we are at remembering where the bracket goes and why one missing character has turned the afternoon into a hostage situation.

This is why AI-assisted development is resonating so quickly. Large language models are very good at translating intent into structure. They absorb the grunt work, reduce the need to hand-author every detail, and let people stay closer to the outcome they are trying to create.

That is a genuine improvement. For the vast majority of people, spending less time coding is a feature, not a tragedy.

Moving from code to English solves one problem and creates another

Here is the catch. Code is difficult because it is precise. English is comfortable because it is not.

So when software development shifts from code toward natural language, we remove one kind of friction and introduce another. The new problem is ambiguity.

A prompt can sound clear and still mean five different things. A request can look sensible until it collides with an edge case, a hidden dependency, or a business rule nobody bothered to mention. In conversation, that is manageable. In systems, it gets expensive quickly.

That is why the future is not just “everyone uses English now”. It is more likely to be a structured version of that: natural interaction, fast iteration, but with enough modelling, visibility, and guardrails to stop ambiguity from quietly becoming production behaviour.

The syntax burden may shrink. The clarity burden does not.

We learned this lesson years ago

This part is less theoretical for us than it may be for others.

At CodeBots, we were generating more than 90% of application code five years ago. That was exciting. It was also educational.

The lesson was not that code generation is impossible. Clearly it is possible. The lesson was that generating code is only the easy bit once the novelty wears off. The hard part is making sure the result remains coherent, maintainable, and aligned to intent as the system grows.

Speed without structure is fun right up until it isn’t. You can move very quickly into a mess.

That is one reason the current wave of AI-assisted development feels familiar. The LLM's are much better now. The underlying tension is not. Fast creation is valuable, but only if the outcome stays understandable and the quality stays high.

That is also why comments from Dario Amodei, CEO of Anthropic, land with some force. In a Council on Foreign Relations discussion, he described a future where AI can do much of the work humans currently do on computers, while also noting how hard these systems are to fully predict and control. We would put it more simply: generating more is the easy part. Keeping it coherent is the job.

Why chat beats drag-and-drop

One thing the market keeps rediscovering is that people want a tight feedback loop.

Drag-and-drop looks approachable on a slide, but in practice it often becomes slow and annoying. Too much mousing, too much fiddling, too much hidden logic. You spend more time arranging boxes than thinking.

Chat, on the other hand, is immediate. You say a thing, see a result, adjust, repeat. That loop is fast enough to feel natural. It keeps momentum high and lowers the effort needed to explore an idea.

That is why chat-based systems have become such a powerful way to build. They match how people already think: conversationally, iteratively, and with a preference for seeing progress quickly.

The problem is that chat on its own can become slippery. It is excellent for momentum, but weaker at showing structure. You can move fast without always seeing the model you are creating underneath. That is brilliant for flow, and less brilliant when you need consistency, maintainability, or anyone else to understand what just happened.

The next step is not chat or visual. It is both.

This is where things get interesting.

The future is not a choice between awkward drag-and-drop tools and pure chat-based prompting. The better path is combining the speed of chat with the visibility of visual modelling.

That is the direction we see for ChatStudio. People want to vibe at the speed of conversation, but they also want to see the shape of what they are building. They want to steer with intent, get rapid feedback, and still have a clear model in front of them that can produce reliable outputs.

That combination matters. It keeps the feedback loop short without making the system opaque. You get the ease of natural interaction, with enough structure to mitigate the ambiguity that natural language introduces.

In other words, less wrestling with syntax, and less guessing what the machine thought you meant. A rare double win.

What happens to software engineers?

Software engineers are not about to vanish into the mist. Their role is about to split.

Some will go deeper. As more software is created through AI systems, there will be even greater need for people who understand architecture, patterns, quality, performance, and failure modes at a serious level. The vibe coding cliff is real. Fast progress is easy at the start. Then complexity arrives, the system sprawls, and someone still needs to know how to stop the whole thing turning into a haunted forest of side effects.

Others will move toward managing AI more directly. Less typing syntax, more shaping intent. Less manually implementing every component, more guiding systems, validating outcomes, and governing how software gets produced.

That is not the end of engineering. It is engineering moving up the stack.

The valuable people will be the ones who can preserve quality while the interface to building keeps changing.

So, will code itself go away?

Not entirely. But it will matter less as the primary interface for creating software.

For many people, that is exactly what should happen. They should be able to describe what they need, refine it visually, collaborate with systems that understand intent, and get useful outputs without becoming syntax specialists.

The deeper challenge is not whether code disappears. It is whether we replace it with something better, or just something easier.

If the future is AI-mediated software delivery, then the winning platforms will not be the ones that merely generate more. They will be the ones that preserve speed while adding structure, visibility, and control.

That is the shift underway now. It is also why we are optimistic about where CodeBots fits. As the industry moves from writing every line by hand to guiding systems that can build with us, the need for governed, visual, fast, AI-native delivery gets stronger, not weaker.

Code may shrink.

Ambiguity will not.

And that is why the next chapter of software is not about removing engineering discipline. It is about embedding it where people can actually use it.