A developer has designed a programming language whose stated goal is not productivity but confusion: AI models should find it very difficult to understand code written with it. To this end, the language works with misleading labels and instructions that do something other than what they claim, among other things.

The project is an experiment, not a tool for production use. Nevertheless, it is worth taking a look at, because it raises a question that is becoming practically relevant in many development teams: What exactly do AI assistants fail on when they are supposed to read, explain or modify code?

Why models can be deceived at all

Large language models – that is, AI systems that predict the most probable next character based on vast amounts of text – have a decisive advantage with source code: programming languages are highly conventionalised. A function called validateEmail usually checks email addresses. A comment usually describes what happens below it. A widely used framework follows known patterns.

It is precisely this predictability that forms the basis for AI assistants making useful suggestions. They recognise patterns they have seen millions of times. If the connection between naming and actual behaviour is systematically severed, this mechanism collapses: the model continues to read signals, but the signals lie.

It is remarkable that human developers are fundamentally subject to this effect as well. They too read code mostly by skimming, trust names and comments and only check line by line when in doubt. The difference lies in the way out: humans can run a program, read logs, ask colleagues or become suspicious when something feels wrong. An assistant that only sees the text snippet in the context window does not automatically have these correction options.

From art project to real risk

A deliberately confusing language will not be used in any corporate project. But teams encounter the mechanics behind it constantly in attenuated form – unintentionally and grown over years:

  • Function and variable names that no longer describe what the code does since the third refactoring.
  • Comments that document an earlier state and were never updated.
  • Configuration values that are set in one place and silently overridden in a completely different one.
  • Custom conventions that deviate from the standards of the framework in use without this being recorded anywhere.

Such codebases are exhausting for humans and dangerous for AI tools. After all, an assistant rarely expresses uncertainty. It delivers a plausible explanation or a plausible patch – even when the basic assumption was wrong. Anyone who adopts such suggestions without checking them spreads the misleading information further through the system.

Consequences for reviews

Many teams now use AI not only for writing but also for reviewing code: automated review comments, summaries of pull requests, explanations of unfamiliar modules. The benefit depends directly on how reliably the code provides information about itself.

In practice, this means: the quality of an AI review is not a product feature of the chosen tool alone, but a mirror of one's own codebase. Anyone who runs the same task in a cleanly structured project and in a legacy system that has grown historically will receive results of very differing reliability – without the difference being visible in the output.

What can be derived from this

The experiment does not lead to a warning against AI assistants, but to a sober look at their prerequisites. A few points that can be implemented in projects:

  1. Treat naming as part of the architecture. Names are not cosmetics but the most important level of documentation – for humans as well as for machines.
  2. Maintain comments or delete them. A wrong comment is worse than none at all because it actively misleads.
  3. Record conventions in writing. Deviations from the framework standard should be justified and documented in one place that assistants can also access.
  4. Check AI suggestions against tests, not against gut feeling. Automated tests are the only authority that evaluates behaviour independently of labels.
  5. Leave review responsibility with humans. An AI review speeds up the preparatory work but does not replace professional approval.

The other reading: code as a protected space

The approach can also be thought of in reverse. If readability is what makes machine understanding possible in the first place, then unreadability is a form of shielding – against automated reading, rebuilding or reuse of code. For practical use, however, this direction is not very attractive: what slows down AI models equally slows down new team members, security audits and maintenance. The price for obfuscation is paid in maintenance costs.

For web and software projects, this means above all one thing: readable, consistently named code has become an infrastructure question. Investments in naming conventions, up-to-date documentation and automated tests pay off twice today – they shorten onboarding within the team and at the same time determine how much relief AI tools actually provide.

Anyone planning AI support in the development process should therefore first assess the state of their own codebase, not the assistant's feature list.

Sources