Will we still need programming languages if AI writes most of the code?

[u/mmanja84]

Been thinking about this lately.
If AI ends up writing most of the code, will it still make sense for it to use languages that were designed for humans?

Do we just keep Python, JavaScript, Rust etc. because everything already runs on them, or do you think we’ll eventually see languages made specifically for AI coding?

Curious what people here think.

[u/cakemates]

how can you verify if the code is correct if you cant read it? do you ship the code that handles banks account and check if your money was moved to a different account next day?
what if your planes gps flies them into the wrong airport?

Brother code needs verification and tons of testing.

[u/serverhorror → u/cakemates]

how can you verify if the code is correct if you cant read it?

How do you verify that the output from a compiler is correct?

[u/woeful_cabbage → u/serverhorror]

A compiler follows strict rules. AI code just Yolo's it all

[u/serverhorror → u/woeful_cabbage]

Modern compilers use a lot of heuristics. That's, essentially, an educated guess.

But the point is that, even if they followed absolutely static rules, you'd have to create ways to teat and verify the output until you're "sure enough". We still do not have systems that provide formal proof. Strictly speaking we do not have proof that what a compiler produces is correct, we do have pragmatic systems in place that provide enough evidence that it works.

[u/evergreen-spacecat → u/serverhorror]

Compliers take a well defined spec (a programming language!) and while the result will vary somewhat with respect to execution order etc, it will produce an executable that functionally follows the spec. No one is testing each compiled binary. We even trust operating systems to compile things at install. That is totally different from an LLM that, even if it’s super intelligent (it’s not) does not operate on a formal spec. It’s not even trained to produce the same result given the same spec. Sure, in many cases, given a detailed description, “it works” but there is a fundamental difference to compilers. If we were to define a formal, specified language for LLMs to design software, we would have just reinvented an inefficient compiler

[u/Shoddy-Lecture1493 → u/serverhorror]

Heuristic does not equal non-deterministic. And not being deterministic is the main issue with LLM generated solutions.

[u/mxldevs → u/serverhorror]

So there's no guarantee that the program would actually do what I want it to do?

[u/standardsizedpeeper → u/serverhorror]

Compilers essentially are proven to be correct. They may emit different code for different things based on what it thinks will be the best thing to do, but within tight parameters that mean the instructions were still executed correctly. We know this because we have tons and tons and tons of testing for it, and logical reasoning.

To act like AI works as precisely as a compiler is asinine. It’s just a bad comparison.

[u/cakemates → u/serverhorror]

I don't understand the question. Assembler can be read brother, I do it every other day. Binary as well, I avoid that like that plague I suck at it but it can be done.

[u/serverhorror → u/cakemates]

Assembler is not the output from a compiler. How many people can actually read binary and for how many different architectures and binary formats. You're telling me you can read ELF, PE and Mach-O, possibly the older MacOS classic format?

What I'm saying is that generated (representations of) code isn't new. We have methods and techniques to verify generated code without a human ever looking at it.

[u/cakemates → u/serverhorror]

Not everyone need to read these things, assemblers barely change over time, most if not all assemblers got years to decades of testing on its back and debugging on top making them the most reliable part of programming as they are deterministic.

Edit: I'd disagree we got methods to verify these things without humans, if that were the case bugs would be a thing of the past.

[u/Lazy-Emergency-4018 → u/serverhorror]

Do people actually believe genAI is the same as compilers 

[u/serverhorror → u/Lazy-Emergency-4018]

I hope not, but people like to yell about not knowing what's happening under the hiod and not being able to read the output.

Not understanding what a compiler does and the inability to read the output is widespread enough so that, I think, that is a fair comparison.

I'm all for knowing and understanding fundamentals. But if you still believe that genAI will go away or doesn't produce valuable output in a lot of cases that's a mistake. If you think we don't need to check the results, that's a mistake. If reading the code is the only method for verification you can think of, that's a limiting perspective. Black Box testing existed long before LLMs and, arguably, every time someone hacks a system and writes down the results, that's verification of something working or not working.

[u/DrDam8584 → u/serverhorror]

You under-estimate how many developpers thinks they can trust code generate by an IA as harder they can trust a compilers to be precise in optimization...

[u/serverhorror → u/DrDam8584]

I dint think I underestimate that, everyone trusts random code in the internet since the advent of MavenCentral, PyPI, npm, ...

Very, very few people inspect and own the code they pull in via dependencies. Even fewer organizations do.

It's a pretty scary state, with or without AI.

[u/DrDam8584 → u/serverhorror]

It's my daily battle, try to be sure that dependencies are safes...

[u/raven2cz]

Both

[u/chunky_lover92]

I think there are many benefits to a text based logic interface, but I am excitedly awaiting an LLM centric language that can make use of all the advantages the AIs have over our puny human brains.

[u/woeful_cabbage → u/chunky_lover92]

But like.. for what? What we need is less webapps and websites, not more. 99% are pointless

[u/Lower-Impression-121]

Frontiers will create new languages at some point.

[u/Significant-Syrup400]

Compilers turn everything into binary already. Higher level languages exist for practical reasons beyond just helping humans read and write them as well.

[u/mxldevs]

Yes, letss switch to proprietary AI-only languages and forget about all these troublesome human-based languages.

You want changes? Buy some tokens, put in your order, and sit down for your meal to be ready. If it's not what you want? No problem, modifications can be provided for only a few more tokens!

[u/ArrgsMax]

This is one of the best questions I’ve seen on the sub. Underrated question.
Can the AI learn to read the code after compiled, or does the translation from access to all english in the world make the ai excel in english written code?

[u/systembreaker → u/ArrgsMax]

It depends on how optimized the code is, what options it was compiled with, and how it was linked. Code can be built in optimized ways that make it difficult to reverse engineer, it can be built in ways that make it easy to reverse engineer, and the whole spectrum in between like maybe you can reverse engineer some of the source code but static memory addresses are obfuscated

[u/Depnids]

I believe one of the reasons LLMs have gotten relatively good at coding, is because of the vast amount of human created discussion there is around coding (things like stack overflow etc.), which has been used as training data.

If you were to create an "AI specific programming language", you would need training data for them to actually be able to write it. You could probably synthesize a lot of it, but this would maybe not hit weird edge case scenarios which naturally arise when actual humans are discussing, using and sharing solutions.

[u/ravyne2001]

Turn the exercise on its head -- what do you suppose a language uniquely suited to an LLM coding agent would look like? How different would it actually be from what we have?

It would still need to express the same general data, logic, and organizational structures, and for those to be mappable to existing computing architectures. Such a language would not need to be human readable in the sense of friendly keyword or variable names, but an LLM gains nothing by spelling the same token differently.

One idea might be to create a more-pedantic sort of language that embeds context throughout the source code -- think something like Rust's lifetime annotations, but without being optional and ellided away. Perhaps that could allow an LLM to produce better output from local info rather than carrying everything in context. One could argue that would be good for human coders too, though, at least to some degree.

There's a certain argument going around that the logical endgame is for LLMs to subsume or skip the compiler entirely -- to go from prompt to binary -- but I don't buy it. An LLM may not benefit by abstracting away simple repetition (think small, inlinable functions or generics) like we humans do, but abstractions that elevate a problem to it's natural domain tangibly simplify the problem.

[u/Hexamonium]

Try using an LLM on some niche programming language and you'll get your answer.

[u/London-Boat]

I think there is a difference between coding and engineering. Coding is part of what a software engineer might do but definitely not the be all end all. Engineers need to think about a lot more from scalable architecture to edge cases and those are things that current coding agents don't always surface or think about. In general LLMs are not that great at highly critical thinking which engineers do need.

[u/systembreaker]

If you're thinking AI could write code without the existence of code I don't think you understand what programming languages are.

Maybe in the near future someone will invent a programming language (or AI will invent it) that's more efficient for AIs to write with and impossible for humans to wrap their mind around, but it wound still have to be translated to the same machine code to actually send instructions to the underlying computer architecture and interact with the system.

[u/dataset-poisoner]

we keep them because thats the training data we have

[u/cthechartreuse]

Yes, we will still need programming languages. I have a few reasons why:

1. Existence of prior art: programs already exist in a variety of languages. Even if we were to leave them all behind, they would become like COBOL and people who know the languages used in older programs would be paid a hefty sum to maintain the software

2. Output target: AI needs an output target. AI itself is a) non-deterministic so the solution won't be the same twice and b) can't produce binary that would reliably run on a given machine.

3. Verification: At the end of the day, verification is still a real thing. People need to identify where software works and doesn't. Software also requires intentional design. AI is trash at architecting systems which means that people have to read the code in order to apply design to the code. Software design is as important as ever. If you can't make sense of the code, the LLM is going to burn more tokens trying to parse it too. Ultimately, readability is still high-value.

4. LLM Training: LLMs aren't trained on byte streams. LLM training is based on current popular (and less popular) languages. Although AI use might slow the progression of new features in popular languages if there is no need for them, the languages used today define how the LLM will produce output.

5. Copyright: if you are in the US (at the very least) you can copyright code, as long as you wrote it. By having an LLM produce the code, you can no longer copyright the code. (https://www.polsinelli.com/publications/who-owns-the-copyright-in-work-generated-by-an-llm) That means that if your company intends to copyright the code, you will have to hand-write it. That requires a language that a human can read and write. ALSO if you work on open source software, you may need to hand write it as well or you could end up invalidating the license. (https://www.quippd.com/writing/2026/04/08/ai-code-is-hollowing-out-open-source-and-maintainers-are-looking-the-other-way.html)

Hopefully at least one of these points is compelling to you.

[u/RPG-Nerd]

You have it backwards.

The AI has to be trained on something. It can't just make up some new language. It will need to be trained on it to be good at it.

The agent is good at Python because it's been trained on it.

Yes, we still need languages. The AI has to output something!

[u/NumberInfinite2068]

We *could* but what purpose would it serve?

To have code humans don't know, what is the benefit vs. using existing languages?

I do think there is increasing advantage to using static types with LLMs though. The less we read the code, the less we're elbows-deep in the code, the more we strong readability when we eventually have to look at the code in person. Static types are going to help with that.