Simpler, and safer

A laptop showing a Simpler program and the list of what it may run, fetch and write

From 1978 until 2025 I wrote code by hand. Mostly in Vim. Since more than a year now I haven’t personally written or read code.

In June this year I made a programming language for the AI to write. Small enough to fit in a prompt. I called it Simpler.

Then I got ambitious. I wanted the most AI friendly language there is. So Claude and I measured it. Against Rust and Python. Lots of small tools, written by an AI, compiled, run and compared. The idea is to create a programming language that is AI friendly rather than human friendly. A language that has built-in guardrails that make it safer for AI to write it without a human in the loop.

We started testing, and the numbers were not kind. Rust was just as right on the first try. Rust was cheaper. Claude had read millions of Rust programs and obviously none of mine. That was the point, though.

So I asked: what would make Simpler amazing, then?

One thing

As I said I don’t read the code anymore. Claude writes it and I run it.

That is a matter of trust. A script can delete my files. It can send my data anywhere. It can start any program on my laptop. In Python or Rust, I only know by reading every line. And even for an LLM that tracing is just unnecessary work.

In Simpler, the top of the program is the guardrail built in. It says what the program may touch:

runs "git"
fetches "api.github.com"
writes "notes/"

main(sys) {
  last = sys.programs.run("git", ["log", "-1", "--format=%s"]).trim
  zen = sys.net.fetch("https://api.github.com/zen")
  day = sys.clock.date(sys.clock.now).slice(0, 10)
  sys.files.append("notes/log.txt", day + " " + last + " (" + zen + ")\n")
  sys.screen.print("noted")
}

Three lines. One program it may run. One host it may reach. One folder it may write to. Nothing else.

Change git to rm further down and the compiler says no:

input.smplr:6: this program may not run "rm"; add it to the runs line at the top

What about a name the program makes up while running? Checked as it is used. If it’s not on the list: the program stops.

And I don’t have to read even those three lines. I ask:

$ simpler what
screen  prints  (in main)
files   adds to "notes/log.txt"  (in main)
program runs "git"  (in main)
net     fetches "https://api.github.com/zen"  (in main)
clock   reads the time  (in main)
env     not used
mail    not used
stdin   not used
args    not used
may write  anything under "notes/"
may run    "git"
may fetch  "api.github.com"
nothing else: a program reaches the world only through what is listed here

That is the whole reach of the program. Guardrailed before it runs.

Useful too

A safe language that can do nothing is of no use. So Simpler now does what you’d expect of a script. Files and folders. Other programs. The web. The clock. Environment variables.

I also added conventions that Claude writes from habit: !=, for x in xs, break, + between two texts.

And the spec shrank. One page is what Claude gets now. It turned out to work better than the longer one, resulting in half the token cost.

The test

Twenty everyday script jobs. Count lines with wc. Fetch a page and sum the numbers. Rename the files with spaces in them. Written by Claude Sonnet in Simpler, Rust and Python, run without me reading a line.

Simpler Rust Python
Right on the first try 20 20 20
Lines of code 323 830 340

To be fair to Rust: it had only its standard library, so it wrote its web requests by hand. And Simpler still costs more to ask for, since the page goes along with every job.

But as short as Python. As right as Rust. And only Simpler tells what the code can touch.

Next

A program can’t feed text into another program yet. A failed fetch stops the run. Full-screen terminal programs are not there. We keep going.

Simpler is public domain. And it is self compiled: the Simpler compiler is written in Simpler.

Update

Same evening. Thirteen minutes after this post went out.

The first two points under “Next” are done. A program can feed text into another program. A program can ask a web address for its status, and go on when the page is missing.

Then a harder test. Twenty bigger scripts: a line diff, a month calendar, the shortest path through a maze. Simpler got 19 right on the first try. Rust and Python got 20.

The miss showed what was lacking: finding a text inside a text, capitals, joining a list into one text. Added. Run again:

Simpler Rust Python
Right on the first try 20 20 20
Lines of code 1108 1238 711

Claude still thinks longer when writing Simpler than when writing Rust or Python. That is next.

Update 2

Still the same evening. Less than an hour after the post.

The thinking first. We tried four ways to make Claude think less when it writes Simpler. None of them worked. A language it has never seen costs more tokens. This demonstrates the value of initial model training. So that one stays open.

The rest went better.

Full-screen programs. A Simpler program can now take the whole terminal and read one key at a time. Claude wrote a two-pane file manager in it. 183 lines. Right after one fix.

Mail. A program must say at the top whom it may mail:

mails "me@example.com"

main(sys) {
  sys.mail.send("me@example.com", "Backup done", "All 3 folders copied.")
}

Any other address: refused. I got the first mail from a Simpler program in my inbox tonight.

Wildcards. reads "logs/*.log". mails "*@example.com". fetches "*.example.com". A star never crosses a slash, so logs/*.log gives no way into logs/private/.

Links. A link inside an allowed folder that points out of it is not followed.

And you can try it. One line to install, with only a C compiler and curl:

curl -fsSL https://raw.githubusercontent.com/isene/simpler/master/install.sh | sh

Then:

simpler run hello.smplr
simpler what hello.smplr
simpler prompt

The last one prints the page to hand to your AI. Ask it for a script. Run simpler what on the result. Read the list, not the code.

Update 3

Past midnight now.

I stopped giving Claude made-up jobs. I gave it my own scripts instead. Ten scripts straight from my ~/bin. Shell and Python. “Port this to Simpler. Same output.”

Most worked. The rest showed what was missing. So we added it:

JSON. text.json("user").json("name") gives the value.

Files that are no text. A file comes in as bytes. Numbers and texts are picked out of it.

Regex. The full thing: groups, lazy counts, back references, looking ahead and behind. Written into every compiled program, no library. It agrees with Python on 57 test patterns.

main(sys) {
  t = "Mail bob@site.com before 2026-11-16"
  for m in t.reAll("(\w+)@[\w.]+") {
    sys.screen.print(m.at(1))
  }
  sys.screen.print(t.reReplace("(\d+)-(\d+)-(\d+)", "$3.$2.$1"))
}

And safer here too. A pattern like (a+)+$ can make Python hang for minutes. Simpler stops the program and says which pattern, on which line.

Now nine of the ten scripts print exactly what the originals print. The tenth needs a program I don’t have installed.

Then the big one. My own style checker. 505 lines of Python with 31 patterns. It reads every answer Claude gives me. Claude ported it to Simpler. Same output on every text I tried.

But the first run was slower than Python. A compiled program should NEVER be slower than Python. So we fixed the search.

Simpler Python
Style checker, one run 21 ms 67 ms
Calendar reader, 7 MB of bytes 11 ms 42 ms

Modules. A program can now use a library. The first one is crust, for panes on a full screen. With it the file manager shrank from 183 lines to 154. The library obeys the same top lines as the program. It can’t touch more than they say.

Still open: Claude thinks longer when it writes Simpler. And I still haven’t read a line of the code.


Link to this post: https://isene.org/2026/11/Safer.html