Theme: The Craft

Length: ~800 words

Hook: Personal — share the journey and lessons

We built a programming language for AI agents. Here's what we learned.

Not the technical lessons (those are in the docs). The philosophical ones — the ones that changed how we think about software, agents, and the relationship between humans and machines.

Lesson 1: Frameworks are scaffolding. Languages are foundations.

Every agent framework today is a library sitting on top of a language that was never designed for agents. Python wasn't designed for agents. TypeScript wasn't designed for agents. They're general-purpose languages with agent frameworks bolted on top.

This works the same way building a house on scaffolding works — temporarily. The scaffolding holds the structure up, but it's not the foundation. Eventually, you need to pour concrete.

A language is concrete. When agents, tools, memory, RAG, and flows are first-class language constructs — not imported classes — the compiler can check things that frameworks can't. Type safety on tool signatures. Flow stage validation. Agent capability verification. All at compile time, not runtime.

The lesson: when a domain gets complex enough, it needs its own language. SQL for data. HTML for web. Kubernetes YAML for infrastructure. And now, a DSL for agents.

Lesson 2: The compiler is your friend.

The biggest surprise: how much value the compiler provides. Not because the code generation is clever — because the type checking catches errors that would otherwise be runtime crashes.

In a framework, if you pass the wrong type to a tool, you discover it when the agent calls the tool and crashes. In a language with a compiler, you discover it before the agent ever runs.

This changes the development experience fundamentally. You're not debugging agent behavior — you're debugging agent definitions. The behavior follows from the definition. Get the definition right, and the behavior is correct by construction.

Lesson 3: Multi-target compilation changes the economics.

One of the biggest costs in agent development is the Python/TypeScript divide. Your backend is Python. Your frontend is TypeScript. Your agent needs to run on both. So you write it twice.

When the compiler targets both Python and TypeScript from the same source, you write it once. This isn't a convenience — it's an economic shift. Half the development cost, half the maintenance cost, zero inconsistency risk.

Lesson 4: Mock mode is essential.

The single most useful feature we built: --mock mode. Run any agent without calling an LLM. No API key, no cost, no latency.

Why is this essential? Because it changes who can try the language. A developer who doesn't have an OpenAI API key can still clone the repo, run the examples, and see the compiler work. A student can learn the syntax without spending money. A team can evaluate the language without procurement approval.

The lesson: reduce the activation energy to try your tool. Every step between "we heard about this" and "we tried it" is a step where people drop off.

Lesson 5: Stories matter more than specs.

We wrote a fairytale about the language. A 16-page storybook about a kingdom where agents fill forms and a developer who creates a language to free them.

The storybook got more engagement than the technical documentation. Not because the docs are bad — because stories are how humans understand new concepts.

We've known this for millennia. Every culture teaches through stories. Every religion uses parables. Every great teacher uses analogies. Yet in technology, we default to specifications.

The lesson: if you want people to understand your vision, tell a story. If you want them to evaluate your implementation, show them the specs. Do both. But start with the story.

Lesson 6: Open source is the only honest way to launch a language.

A programming language is a bet on the future. If you ask people to learn your language, you're asking them to invest time in something that might not exist in two years.

Open source is the only way to make that promise credible. MIT licensed — the code is free to read, study, use, and modify. No restrictions, no royalty, no strings. If we disappear, you still have the compiler.

The lesson: if you want people to trust your language, give them the compiler. No strings attached.