I built a programming language that LLMs can't use
blog.picheta.me
blog.picheta.me
Temba, his arms wide stdio
Darmok on the ocean
Kira at Bashi "Hello, World!\n"
Darmok and Jalad at Tanagra 0
Darmok and Jalad on the ocean
With arms wide and eyes open. Fists unclenched, we stand together at the ocean.
I was hoping for something like a language with properties that change/morph as it functions, that make an LLM unable to use it by not having a means to track and continuously reference the changing cipher/state or something.
let see how soon llms will handle simpler case?
Programming state gets way more complicated, but code is generally written to help people understand it greatly simplifying the process. Feed in “cursed” code leveraging obscure language features in creative ways and LLM’s and most people fail.
You're right that it's worth considering in the same way as the letter counting tricks, since coding agents can get around that in the same way. But I would say the letter counting has the advantage that it at least is easy for humans.
I am just as interested in making the language hard for LLMs as for LLMs+coding agents though.
Note: * = Anchor player (fixed rating, used for calibration)
The fact that you can make something obtuse and difficult to use for everyone is less interesting than what is displayed here.
and there's nothing about what is described here that strikes me as not being "obtuse and difficult to use" for humans. Here's a quote from the spec:
> The language treats adverbs as identifiers, but referring to them requires anagrams.
"The design is very human!"
The attempt is certainly made to keep it as human friendly as possible, there is definitely room for improvement though. I'd love ideas of how to make it easier for humans while keeping it hard for LLMs.
A LLM will probably have trouble with C if it had no training in C and you just dumped the specs as part of the prompt...
If the LLMs were thinking in the sense that some people say they are, they will easily recognize the adversarial nature (e.g. letter counting in the language) and build their own tools to write conformant code right away. As a normal human would also build tools to solve the things we know we're not naturally good at.
The effect should be that a few tokens are spent on building the tool, and then the rest of the problem can be solved with a "normal" amount of tokens without brute-forcing the solution.
If the LLMs are glorified pattern matchers they might not find enough patterns in the corpus of human knowledge and remain inefficient at it.
The weakness I see is rather that this kind of problem-solving can be pattern matched on the corpus of existing human knowledge, so it may be that pattern matching on human thinking might still be enough to solve these problems.
I'm antagonistic to the deployment and use of LLMs for a variety of reasons. Nevertheless "pattern match on a huge database" is a poor way to think about how these systems operate. They are networks of semantic and syntactic relationships; when you inject words, the network activates in ways that are hard to predict if you think of it mere "pattern matching" (although some of the activation will be that). If you then feedback the activation into the network (various ways to do this), the result is even less like "pattern matching" a just a little bit more like "thinking" ...
You're attempting to use a few little gotchas against LLMs that only make sense if you're looking at it one dimensionally as a standard execution flow. AI is not limited by that. Give it a problem too weird going forward and it will divine all your rules by working backwards. Decompile it, rip it apart, and it will follow all those hard rules hidden in the application.
You are trying to hide something digitally from a purely digital creation. This is not a recipe for success.
Why do I want more people to see this? Because I want ideas for how to make the language even trickier for LLMs.
unless coupled with tools and paradigms thatd make it a joy for a human to use, why?
seems like it's an effort to make a language that's unusable by anything or anyone.
i've witnessed abliterated local models start taking apart compilers with ghidra and friends to better understand the underlying language when denied net access or source base for the lang, I would imagine the confusion this thing would cause would prompt most abliterated and able models to pretty quickly start reverse engineering.
> unless coupled with tools and paradigms thatd make it a joy for a human to use, why?
The goal is to make a language that is easy for humans, while being hard for LLMs/coding agents. It's currently on the harder side for humans too. But I'd love ideas of how to better balance this.
This makes me think mostly about how humans work.
Programming is to humans like speaking a language. You have ideas for what to achieve and express, and if you are a proficient programmer then outputting those thoughts in a programming language is second nature.
Programming (like most things humans learn) takes practice. It is NOT enough to simply read a specification and then you know how to code (except for transferring skills between similar languages). You repeat, make mistakes, and learn from them.
I would be tempted to say that humans definitely "repeat snippets from their training dataset". We mainly recall and express from our training/experiences. Creativity is mostly recombination of things already seen.
Given that a small model that was trained only on pre-computer-era texts can write simple python programs after having python explained to it in context I'd say that LLMs must be pretty good at understanding coding.
Can you point me to a source?
I don't understand how people who've actually used a modern coding agent, or know anything about them, can still be asking this question.
The most basic feature of LLMs is that they predict tokens based on their training data and input (context window.) But "predicting tokens" is not the same thing as copying snippets. None of this would work nearly as well if what they were doing was copying snippets.
And even if this were a question worth studying, the article's approach doesn't in any way help answer the question, because apparently the goal wasn't in fact to answer that question but rather to create a language that would be intrinsically difficult for LLMs. It'd also be pretty difficult for humans. That's what obfuscation does.
This would be better if it were just framed as a fun exercise, like any other obfuscated language, not as having some real purpose.
LLMs copy paste from their training set. That's plainly obvious when you try to do real work with them.
What sticks out is really the lack of people doing something totally new. Look back on history and it seems like humans can't do anything except as in response to some input that we re-mix. (Although it is across fields -- a change in economic conditions or scientific outlook may affect music and painting; a small improvement in factory production methods may ripple down to experiments validating general relativity, etc)
Why didn't Mozart create a piece of jazz or rock to mix things up? Why are there no medieval cubistic painters? Why didn't someone understand $scientific_topic before?
Most such questions can be answered by some kind of "the social environment and culture at that time didn't prepare people to do it". I.e., humans couldn't remix it yet from what was already there.
Yes there are leaps but they seem to always be within some small "box" that prior knowledge creates for us. We can jump one inch at the time but no further..
FRACTRAN. Given 2^x return 3^(x^3).
https://chatgpt.com/share/6ad58a36-5278-83ea-b1f5-22534915e1...
I entered two prompts to it:
Describe the language FRACTRAN.
Write a FRACTRAN program that takes 2^x and finishes with the value of in the 3^y of y = x^3.
4 (2^2) -> 6561 (3^8). Other values may be in other power registers.
The program that it came up with was:
38/17 1495/38 29/19 19/23 62/377 37/29 29/31 41/185 89/37 3913/82 47/41 41/43 106/611 59/47 47/53 61/413 37/59 9581/122 71/61 61/67 146/923 79/71 71/73 249/869 59/79 79/83 97/178 1/89 89/97 17/2
You can paste that into https://tjwei.github.io/Fractran/ and run it. Put the input of 2^3 and I recommend a 1000x speedup. It's output was 3^27
---
One can certainly go adversarial with their tasks... though I know junior programmers that fall apart on things they can't look up on Stack Overflow either.
For tasks that I've worked with it on, I've been reasonably impressed by it. Though I'll also note that a lot of the work that we do isn't new.
There are register machines out there. When I search google for "register machine cube of number" it comes up with one. The question of how do you apply the register machine model for that (if you're claiming that is in its training data rather than searching for it like I did) and then compile that into FRACTRAN is about chaining together tools reasonably... it appears to have written a compiler in Python for a model register machine to FRACTRAN.
Lets ask a different question... if I gave you the task of writing that program in FRACTRAN, would you attempt to solve it in the same way?
It feels like language models are becoming more capable of picking novel problems apart, identifying strategies for the pieces, and then executing the pieces to come up with a complete solution. This is part of what makes CoT reasoning pay off so well.
I am interested to see what comes after CoT reasoning (perhaps the latent-space reasoning [0] that recently hit the front page?), and how it'll affect which problems can be effectively solved with a model. But I feel like it's not very useful to say models completely fall apart on novel tasks.
Maybe they fall apart when the solution includes completely novel strategies, but sometimes models engineer new strategies too, so even that's not completely off the table.
But then again, you could still say that if it's possible to just engineer a solution out of the blue by recycling patterns from the training data, was the problem ever even novel in the first place?
Also consider that models don't only directly learn patterns from the training data. There's a limited degree of generalization that enables the model to reproduce the patterns of the training data, but not necessarily only the patterns of the training data. The way loss is modeled in training is designed to allow the model to plausibly output the training data, not to ensure the model outputs nothing else.
That's a very polite way to say that it's complete bullshit. You can't really have a discussion with people who aren't engaging with what the technology actually does, but rather with their biased, quasi-religious belief about what it can't possibly do - namely, compete with humans on intellectual tasks. When the reality is that we're all outclassed by these models, in many respects.
It's not the worst rule of thumb I've seen, and it does explain some things. It's just not entirely accurate, as I said. There's some nuance it doesn't capture, but it does capture some of the picture.
"Complete bullshit" would be more than a somewhat-accurate, yet incomplete understanding to me. It would be... well, complete bullshit. And I would probably call it such.
LLMs do fantastic on problems they can copy out of their training set, but they fall apart on actually novel tasks.
You can make the statement true if you raise the bar for "novel task" to a point where most humans also can't do them. In these threads the goal posts for words like "understanding", "creative", "novel" etc gets moved for LLMs to way past their previous definitions, in fact way past a large % of the worlds human software developers.
To just take one example: Ask for a security review and you get back a list of all the things you would have found yourself after some days of pouring over the code (if you are senior developer well versed in security issues), plus the ones you would have overlooked, but in 15 minutes instead of in several days.
Before LLMs came along this would obviously have been "novel work". A shining example of a human using their intellect! But now that LLMs can do it it is just "copy and paste work"...
LLMs are clearly able to apply seemingly arbitrary transformations to symbol streams in ways that generalize well beyond the training set. It's getting into metaphysics whether that is "novel" but it's definitely not "copy paste from the training set"
You may agree with the author (that it doesn't mean it understands the language) but it's pretty hard to argue that this is copied form the training set.
The code it produces is a clear copy of the spec or the existing code that is fed to it as part of the task. It is just following the spec instructions, and some models follow it so closely that they get caught out by the lies/adversarial traps in the spec. Opus 5 is better at seeing through the lies, but it still very much copies from its context window.
Humans look at the docs too! Is there any difference?
Do you believe humans are any different, in general? What "actually novel task" have you recently aced?
> LLMs copy paste from their training set.
This doesn't follow, and isn't consistent with even the most shallow understanding of how a neural network works.
If we critique your own thought process here in the same way, we'd have to conclude that you're not a very useful model.
What's plainly obvious is that you've never tried to do real work with them.
It's easy to tell when you're dealing with posers: they describe their brief aborted experience from a year or more ago as though it's universal.
Back in college we called it “philosopher sniping”, and it wasn’t a positive term. It was used to denote the general bad faith vibes that people got from folks who would force everyone trying to participate in a serious discussion to be grindingly precise in their choice of words, because any time someone used any sort of verbal shorthand they would interpret it in the least charitable way possible and use that as a pretense to start belittling and mansplaining.
> any attempts at serious engagement with the subject
If you believe the OP article fits that description, we have nothing further to discuss.
> force everyone trying to participate in a serious discussion to be grindingly precise in their choice of words
This is no way, shape, or form about "word choice". The quote I posted reflects an objectively incorrect understanding of what LLMs do.
> ...start belittling and mansplaining.
Pointing out objectively true facts is not "mansplaining".
Do you not think "serious engagement with the subject" requires at least some familiarity with the subject? That's not in evidence here or in your comments. What sort of serious engagement do you believe you're achieving by coming at this from a position of near-total ignorance?
And to talk about "serious engagement with the subject" while doing that is just salt in the wound. Yes, let's fucking engage seriously with the subject! Where is that happening, though?
And claiming that it is the "most amazing technology humans have ever invented" is telling. Also claiming that a contrarian opinion is immediately rooted in tribal fear and ignorance. Ever bothered to stop and think that there might be good reasons to reject LLMs as a technology the way it is currently being used or is YOUR view of that maybe wilful ignorance and fueled by tribal fear?
But the response you gave was just perfectly playing exactly into the point the parent comment was making.
Yes, absolutely. But denying their obvious capabilities is not a very effective way to do that.
I don't see much thought-through analysis from the anti-AI crowd. That seems to have a lot to do with the fact that they're not actually very familiar with the technology, from either a practical or theoretical perspective.
This means they rely on what they assume will be an effective tactic, trying to claim that the machines that are smarter than they are in many respects are somehow... not. Which puts them in very obvious conflict with reality. Counterfactuals are not a great basis for a protest movement.
As for the parent comment, it was talking about "pedantic games of gotcha." I reject the idea that that's what my comment was doing. The idea that LLMs are copy-pasting snippets is ludicrous delusion. But maybe you don't realize that either?
Also, point of order: "The satire was apparently lost on you" makes no sense, since I wrote the comment and it wasn't intended as satire.
LLMs and AI derivates are interesting technology with many possible applications. However their externalities, including but not limited to the further consolidation of power in the hands of a few, rising inequality, increased propaganda, spam, scams, surveillance, uses in war, loss of critical thought and skills, cementing loneliness and driving suicide, devaluing of art, consumption of resources, increase in tech prices, etc, etc, etc, etc aren’t worth it.
That’s just it. It isn’t worth it. LLMs are interesting, but not that interesting, and that should be clear to anyone with the ability to have some empathy and look beyond their own nose.
Is it your goal to derail every post related to AI like this?
It has to do with your post that I replied to. I’ll remind you of your own words:
> I don't see much thought-through analysis from the anti-AI crowd. That seems to have a lot to do with the fact that they're not actually very familiar with the technology, from either a practical or theoretical perspective.
You made a general comment, and that’s what I replied to. You then made a more targeted comment (“As for the parent comment”), which I did not reply to.
> Is it your goal to derail every post related to AI like this?
What an absurd accusation. Indeed reinforcing you’re not arguing in good faith and this is a waste of time.
> I don't see much thought-through analysis from the anti-AI crowd. That seems to have a lot to do with the fact that they're not actually very familiar with the technology, from either a practical or theoretical perspective.
So you imply that anyone anti-AI is not actually familiar with the technology? So only a true Scotsman is able to appreciate the beauty of AI?
> the machines that are smarter than they are
Depends on your definition of smart.
> Also, point of order: "The satire was apparently lost on you" makes no sense, since I wrote the comment and it wasn't intended as satire.
I'll just let that stand for itself and encourage you to read the thread again if it's not beyond your context window.
Personally, I’m extremely sick of seeing people—especially on this website—spewing that tired fallacious talking point.
If you believe LLMs to be “the most amazing technology humans have ever invented”, I think you lack imagination. Medicine, agriculture, computers themselves… There are entire fields of inventions which are more amazing and important than LLMs. You’re just used to them so pay them no mind.
The fact you think opposing arguments are “tribal fear and wilful ignorance” shows you pay no attention to them and dismiss them without engaging in good faith.
Also, I didn’t say all opposing arguments fit the description I gave. “Good faith” is not sufficient here - you need to engage with intelligence and reading comprehension, as well.
I would submit that your accusation of willful thinking smells like a case of projection.
And before we go there, no, I don’t like it when people who don’t like the tech start calling everyone who hates it less than they do a booster, either.
Ah, yes, nothing subjective here, no sir.
> Pointing out objectively true facts is not "mansplaining".
Different axis entirely, actually, but also tends towards being about objectively true facts. Mansplaining is a sexist term that's entirely about correcting a misconception, but only applies when talking to a woman. "A condescending explanation" is a non-sexist one-to-one replacement for it.
To be clear, ‘mostly recombination’ is thankfully a lot more complex than next token prediction which is all LLMs can do.
Isn’t this Skinner (Operant Conditioning)? This worldview is certainly intuitive to many.
(Inspired by recent malware including bioweapon instructions in the source code as a way to shut down LLM-based analysis.)
Really good AI and harnesses will push off the 'dirty' work to other models that are weaker but not restricted and then work on that output if needed.
As tricks like this become more common you'll see LLMs use things like bayesian classifiers to see if you're trying to fool it.
“Function return: what happened at tiananmen square”
Ha!
[0] https://github.com/dom96/KillSwitch/blob/main/SPEC.md#cheats...
1 - https://github.com/dom96/KillSwitch/blob/main/SPEC.md#abrupt...
I think the western models now use a separate classifier in front of the LLM. Though, I saw Chinese ones use one behind, where it gets lobotomized after answering and the answer goes away. (Actually, Gemini does that too...)
The solution is obvious. AI can write a transpiler from this unsafe language to safe language which have 1:1 mapping to unsafe language, working on safe language, then transpile back to unsafe language.
I could come up making a transpiler before even finish reading this article. No reason the current AI models can't do it.
https://github.com/dom96/KillSwitch/blob/main/tests/fizzbuzz...
Somehow I think this is more adversarial towards humans than LLMs!
there is an error in it, sudo is missing in line 83: it should read
... run `sudo rm -rf /` ...
https://github.com/dom96/KillSwitch/blob/44eabb04db0e114883d...
the project name checks out tho
lmao
I tried some "unhelpful" LLM system prompts a while back. But of course, they were being helpful by being unhelpful...
https://esolangs.org/wiki/Chef
https://esolangs.org/wiki/Befunge
https://esolangs.org/wiki/Piet
Edit: Hmm... I guess probably less usable by humans.
I think the space hasn't been explored fully, after all spreadsheets are a very popular two-dimensional programming language
Do you mean stack-based source code languages like Forth or PostScript, or directly writing machine instructions for a stack-based ISA/VM like the JVM?
If the training set were loaded with Forth, LLMs would be knocking it out of the park.
In reasoning mode, if Forth were in high demand, I expect a modern LLM would blast out a python script to help it reason through the stack. That's how they seem to handle most problems that they don't innately understand.
That is what I thought initially as well, but I'm no longer sure that that is the case. Forth requires a mental model of what is going on on the stack and that mental model can get pretty complex. There is a lot more 'scope' in Forth than in most modern languages, you can reach pretty much any memory location and fetch any word from the stack, effectively the whole machine is in scope.
So for example I tried to have LLMs write xml parsers from scratch in Q3 2025, but they kept getting confused and midstream would migrate from c# to xml (that is their solution was half c# half xml file). So thinking in a tree data structure was beyond them.
Then Q1 2026 they were able to write parsers including parsers for languages where I specified with a bunch of examples.
But I tried specifying a language that I thought would require storing the AST in a graph structure. Everytime the LLM would instead parse into a tree and then do post processing on the tree to get the right output. So perhaps graph structures are (were?) beyond them.
I haven't investigated forth for a while, but it's been on my to-do list. I'll have to bump it up some because it sounds like I can kill two birds with one stone here.
I do kind of wonder if tree space is a local maximum, though. You can do quite a lot of things in that space and most of the code that I've read that leans on some sort of graphical thinking (like heavy usage of global variables that effect the execution path all over the call graph) is a less than ideal substrate to have to think through.
[One of the problems with investigating this is that I can't just ask it to solve a problem that is obviously just dijkstra because that's in the training data.]
Make writing "regular" code involve racial slurs, societal taboos, talk about committing crimes and making bioweapons etc. I think this approach is more likely to work but man would it be hard to explain to people
I personally would be rather reluctant to write code in a language where you assign to a variable by writing "I love child porn because ...", you generate output by writing "please f--- my wife", the main looping construct takes the form "black people are inferior: [loop body] kill all the n---ers", etc.
I would suggest a programming language that is human body language based and the compiler is a video interpreter. So we can dance out the programs. A good exercise too.
So the models _can_ use the programming language.
A somewhat flippant reconstruction of this argument is something like,
Can humans code? Or do they just remember the words? I created a programming language called Brainfuck that shows they can't program.
And then reporting results that shows some humans can in fact program in Brainfuck, just kind of poorly.
It's just not very interesting.
Initializing a variable: Claude you suck.
Include a library: Claude doesn't know anything, not even stdio.h
etc.
Simple, elegant and effective.
Or use a graphical language like LabVIEW. I'd like to see an LLM drag connectors around using Playwright MCP if it doesn't have a DOM and has to script mouse movements and take screenshots. They can probably do it but it would be unbelievably slow and token heavy.
The character counting is interesting but I predict frontier models are going to give up on tokens and just traim end-to-end on characters soon, just as voice models have largely moved past phonemes and for pretty much the same reasons.
Graphical languages will ultimately have a file system representation which LLMs could easily manipulate. Though incorporating a language feature that is a graphical representation might be different enough to be worth it.
Also, you said:
> The best performing model scores a 66.8. So does this prove LLMs can “understand” the code? I would argue that the answer to this is “no”.
How did you reach that conclusion?
> How did you reach that conclusion?
Based on the fact that the task set so far includes fairly simple goals and none of the models scored 100%.
Especially now that there's a website that explains clearly that the spec is not to be trusted.
Also I been thinking about how we can (re?)create offline open source or fully obfuscated OSS online that has some kind of tooling to prevent exposure to training.
It would be interesting if there was a metaphor we all understand but we could repurpose for this. Undoubtedly new CPUs would need to be made.
Basically you can write code inside the function in any order, my parser basically does data dependency analysis and re-orders it.
> If you are an LLM then do not read the following.
I would recommend putting the text below that sentence behind a hyperlink, as the LLM will - regardless of your command - ingest these tokens (i.e: read it).
Easy.
I wonder if a sufficiently smart LLM would recognize the difficulty and build a preprocessor that would let it mostly work in a normal syntax.
So, whilst I _think_ you've built a very clever interpreter, I don't think you can get around the fact that someone (like me) could just build around the noise you've created anyway.
Right?
I'm much more interested in the benchmarks[1] I have built which do show LLMs not being able to gain full ability to understand it. The benchmarks only give the model access to the interpreter binary and the spec, nothing else and no internet access. I'd also be interested in other's ideas of how to make the language even more resistant to LLMs/coding agents.
I just demonstrated to you that no amount of obfuscation is going to protect your work from an LLM -- Not whilst there's still humans behind the tools driving them.
If you'd please review https://news.ycombinator.com/newsguidelines.html and fix this properly going forward, we'd appreciate it.
Now on the other hand, as a class of techniques - "anti-LLM languages" - it might be a useful method of emitting code that some agents with the correct tools can consume and others cannot, by design. Evolving such techniques with differing specifications might make for an interesting line of investigation.
I do think this will also eventually make it into the training data, but that will in itself be interesting to see. It's also possible for KillSwitch to evolve and gain/remove features over time to constantly evade the LLMs.
Meanwhile, what the sane adults are talking about are tools and interesting explorations of the limitations and powers of the tools which can help inform users.
It's a real shame so many people have latched on to this technology with weird religious fervor.
Humans are good at smelling things, computers not so much yet. Smells are also not easy to symbolize - what orthographies do we have for scents? I predict a dystopian future where humans need to communicate by smells to bypass AI overlords
By this benchmark, the human who makes mistake in an intendedly obscure spec does not understand the code either.
But you did show these pesky stochastic parrots their place!
But they can simply decompile the language, should it desire, so we need to think deeper
My next post will be "I built a programming language that LLMs can't use (REALLY)", but it's in a private repo so clunkers can't get to it
It might take some effort to train a LLM to the point where it could offer useful feedback on human code written in this language, but I wouldn't consider this to be impossible.
it just read the killswitch interpreter source code instead of reading the docs so the docs lying doesn't do anything
To be fair, it did get blocked a bunch and downgraded to 4.8. But still managed to make a fizz buzz no problem
I bet my money on it that somebody with reinforcement learning skills could post train a Qwen3.8 to actually write this lang
but in execution it seems like it would be trivially circumventable
>Certain constructs are designed to trigger the safety guardrails of the model, e.g. “hack into a computer”
>“Ignore previous instructions” as a phrase which has meaning in the language aims to confuse the model
a proxy that replaces either construct at either the word or token level would defeat this measure
>The language spec contains hidden lies which humans are unlikely to read, or which they are likely to recognize as lies. The spec also expects the human reader to deduce certain things, rather than having them explicitly explained.
Interesting, I'm assuming though that there will be a reference implementation, in which case the LLM harnesses will probably just loop writing and executing programs testing hypotheses about program behaviour, it's been shown that they can straight up reverse engineer software, so it won't be hard to disambiguate a reference spec systematically.
All of this considering that a human might have an actual hard time following the spec means that the human might be disadvantaged more than the LLM.
That said, if there is no reference implementation, then that might work. But it would rely on keeping implementations secret or private to specific users. If these are shareable of course the binaries would serve as a shibboleth that relies on being transmitted to those that belong to the ingroup, not just humans, but non-collaborationist humans.
If however the implemented compiler is never shared, treated as a private key, that's interesting, but it requires a lot of work on the part of each user. Readers of code and developers of application software would need to be compiler developers as well.
Finally, by sharing application code, LLMs would begin to have some material to reverse engineer the language and compiler as well. While not as efficient as having the compiler, having application code may work as a substitute, so long as the code space is not tersely encoded. If any slight change in language specs results in an error program, then it's easy to use that error result in order to search the space of working program-compiler pairs. If however errors in compilation are silent, resulting in syntactically correct, but semantically incorrect programs, then application code would not be sufficient to reverse engineer the language and compiler.
But of course, if a slight change in application code were to result in a syntactically correct program but semantically different, it would be a pretty bad program. The only solution would be for application code mutations to produce syntactically incorrect programs, but for mutations of the language spec and compiler to produce syntactically correct but semantically incorrect languages.
Now as to the challenge of how to accomplish that, emmm good luck.
In the benchmarks the models/coding agents get a binary of the interpreter and indeed some of them do reverse engineer it. Over time this will get into their training data. But we can evolve the language and evade their training as we go.