Tag: Small-Python

AI agents are good at producing Rust code, way too good. But I think it’s worth evaluating whether agents would do the same using the C language. I wonder if there is a formal investigation on Rust vs C regarding development velocity.

Rust is known for memory safety, but that doesn’t mean a program written in C is memory unsafe, especially with the recent trend of adding formal verification (TLA+, Lean, Blend, etc.) to code. It used to be impractical to ship something like TLA+ specs along with C code, but with AI it’s almost zero friction.

As a result, when I was working on Small Python, in one of the sessions Claude Code kept trying to find ways to segfault the program, yet it failed. After several hours of trying, it gave up and claimed the implementation was rock solid.

Today is another day of me staying completely outside my home office. I enjoyed a short road trip, dined on Chicken Alexander, and watched my wife play chess with my son (he won in the end with a promotion). Meanwhile, Claude Code kept running, and as of writing, it is still running. Wow. What an entire day!

What it’s working on is a metering feature for Small Python, which is essential for the upcoming sandbox features.

A traditional language wouldn’t pay much attention to this feature, because its programs are supposed to run as long as possible, like server applications or GUI applications. Small Python is different. It is intended to be embedded or run by agents, so being metered is essential: the host application must be able to stop the code if it eats too much.

The current design is pretty much aligned with QuickJS. It introduces meters over running steps and memory, so that code like while True: pass won’t run forever.

A fun thing I observed during the run is that it often reverts its changes or keeps refactoring. That’s because I have a rule: optimize or revert if the benchmark shows degradation. It even reverted once because of a +0.01% performance loss that it couldn’t find a way to work around. I feel I may be too harsh, and I doubt I could do it myself, but Opus 5.5 did it pretty well.

As the sessions went on, I gained more confidence. It’s not just passing the tests, the fuzzing, the formal verification, and the benchmarks. It’s how it gets there: it’s showing the characteristics of a C programmer with 30 years of experience.

This is a follow-up to the Small Python idea. I burned one more day of tokens to benchmark it and improve the performance. The setup is the same: one single Claude Code session, with /remote-control enabled so that I can prompt it while I’m out. In the morning I attended a local farm event, and in the afternoon we went trick-or-treating for Halloween.

The agent is capable of finding opportunities and fixing them correctly. Often it can run a few hours before it prompts me with more potential things to fix. I generally just ask it to continue.

At one point it stopped and claimed it wouldn’t gain much more, while it was still 1.3x–1.5x slower than CPython. I gave it a few ideas, and now it runs at 0.98x–1.1x of CPython.

In the end, I’m more than happy to ship a new version: Small Python v0.4.0.

I’m working on a fun project: small-python. Implement a QuickJS-like single C11 source file that can do the same for Python language core, no Lib included. This goal is ambitious and it could be used for agents to run untrusted code.

To make that happen, I cannot simply say “hey Claude, implement a QuickJS-like project but for Python.” Instead, a few constraints are needed:

• Well-written specification
• Fuzzy testing
• A test262-like test spec (like test262)
• TLA formal verification
• Unittest, lots ported from CPython or RustPython

I’ve burned about $450 so far. Mostly using one single Claude Opus 5.5 session. The agent has been running for two days, and I’m steering, playing with my son, or going to sleep in the middle. Typically one steering session can run for several hours as I often say “don’t stop until.”

To be fair, I peeked at the C code once. It’s pretty understandable—just like the C parser code I wrote over the years. Nothing magic, but it’s substantial already.