The Story

June 15, 2006. I had just returned from a year-long deployment to Baghdad. I was restarting my life with my wife and kids, trying to remember what it felt like to think about something other than survival. I needed to get excited about technology again.

So I did what any sane person returning from a war zone would do. I started studying artificial intelligence.

I wrote about it that day, the very first blog post after coming home. That entry, timestamped June 15, 2006, is still online: "The Start of a New Life". In it I wrote: "Today is the day I have started my studies of Artificial Intelligence (AI). AI has always interested me, but I have only studied what I could do with program code, not what it can do for me." Within hours I had learned about Alan Turing and stumbled onto LISP.

The next day I wrote another post. I was learning LISP, the second oldest programming language still in active use, created by John McCarthy, the father of artificial intelligence himself. I emailed a fellow architect, Derek Burt, about it: "I have been trying to learn Lisp (yeah... I said Lisp). Since I started down this path, I am learning more about programming languages than I have ever before."

I was a Java developer at IBM. I was used to class hierarchies, interfaces, design patterns, and semicolons everywhere. LISP felt alien. It also felt inevitable, like I was looking at something fundamental that the industry had paved over with decades of syntactic sugar.

Then life happened. Career at IBM. Two more combat deployments to Afghanistan. Air Combat Command Federal Laboratory, the U-2 Fed Lab. A pandemic. FinTech. Twenty years of building things in Java, Python, and the enterprise stack. LISP went to the back of my mind. But it never left.

A few weeks ago, I wrote an article about building a space debris tracking game in COBOL after Anthropic announced Claude Code could modernize legacy COBOL codebases and IBM's stock fell 13% in a day. Writing that piece kicked something loose. I kept thinking about a question that wouldn't leave me alone.

If AI is writing the code, why does the code need to be readable by humans?

When a C compiler generates machine code, nobody reads the assembly output. We don't expect to. We trust the compiler to faithfully translate intent into instructions the CPU can execute. Now look at the AI code generation pipeline: human prompt in English, AI generates Python, Python interpreter produces a result. Who is that Python for? Not the machine. Not the AI. It is for the human developer who wants to inspect and understand the output.

But what happens when the AI gets good enough that you don't need to inspect it? Then the human-readable layer becomes what it actually is: unnecessary overhead.

ARIA

That question became ARIA. AI Representation for Instruction Architecture.

Instead of having AI generate code in languages designed for human consumption, give it a representation optimized for the AI-to-compiler pipeline. S-expressions, unambiguous, tree-structured, with zero precedence rules. Explicit types on every operation. First-class intent annotations that say what a function is supposed to do, not just how it does it. Effect declarations that the compiler enforces. One representation that compiles to any target.

Then the circle closed.

ARIA-IR is s-expressions. The same notation I discovered in June 2006 when I was trying to relearn how to be excited about technology after a year in a war zone. When I looked at the toolchain, a lexer, parser, type checker, and code generator, all written in Python to process s-expression files, a thought hit me that felt less like an engineering decision and more like something clicking into place after twenty years.

Why Clojure

Why am I using Python to parse s-expressions when there is a language built on s-expressions?

Clojure is the most modern dialect of LISP. It runs on the JVM. It has immutable persistent data structures that mirror ARIA's SSA semantics. Its reader can parse s-expressions natively, meaning the 400-line Python lexer practically disappears. The toolchain and the representation share the same structural DNA. ARIA-IR is s-expressions. Clojure is s-expressions. The compiler for an AI language is written in the same notation as the language itself.

That is not a coincidence. It is the right choice.

The parentheses were always there, waiting. Twenty years. Two wars. One question.

This is the answer.

If you believe this too, contribute.