by andrew_da_miz | 2026-02-17 06:55:51+00:00
Twelve days ago, I had an empty directory. Today, I have a compiled programming language with a distributed actor runtime, a PostgreSQL driver written from scratch, a full ORM, and a SaaS backend written in the language itself. 111,000 lines of Rust. I didn't write most of it. Claude Opus 4.6 did.

WHAT IS MESH?

Imagine Elixir and Rust had a kid raised by OCaml. Statically typed, Hindley-Milner inference, do/end blocks, pattern matching, actors as primitives. Compiles to native code via LLVM. Ships as a single binary.

A working HTTP server with a stateful actor:

service Counter do
fn init(n :: Int) -> Int do n end
call Increment() :: Int do |count|
(count + 1, count + 1)
end
end

fn handle_count(request) do
let count = Counter.increment(Process.whereis("counter"))
HTTP.response(200, "Count: ${count}")
end

fn main() do
let _ = Process.register("counter", Counter.start(0))
HTTP.serve((HTTP.router()
|> HTTP.on_get("/count", handle_count)), 8080)
end

The service block defines a stateful actor. call returns (new_state, reply). Routes compose through the pipe operator. No type annotations on the handlers because the compiler infers them.

THE WORKFLOW

Opus 4.6 didn't figure this out on its own. If I'd opened a chat and typed "build me a programming language," I'd have gotten a toy lexer and a lot of apologies.

What made it work was GSD (github.com/gsd-build/get-shit-done), a spec-driven development system. Three files traveled with the project: PROJECT.md (tech stack, constraints), ROADMAP.md (every milestone and phase), and STATE.md (updated after every single commit, telling the AI exactly where we are and what's next). STATE.md was the leash. Without it, the model constantly tried to jump ahead.

Every feature followed: Milestone -> Phase -> Plan -> Atomic Commit. 300 tests ran after every plan. The build never broke.

TWELVE DAYS

Days 1-2: Lexer, parser, Algorithm W type inference, LLVM codegen. It could add two numbers.

Days 3-4: Green threads via corosensei, mark-and-sweep GC, and a pure Rust PostgreSQL wire-protocol driver (implemented the wire protocol from scratch instead of binding libpq).

Days 5-7: Distributed actors. WebSocket + TLS, a custom binary serialization format (Snow Term Format, because JSON was a bottleneck), and location-transparent PIDs. A PID is a PID whether the actor is local or remote.

Days 8-9: Docs site, associated types on traits, lazy iterators, From/Into conversion traits, Collect.

Day 10: Install scripts, TextMate grammar, LSP server with completions, VS Code extension.

Days 10-11: Mesher, a multi-tenant event monitoring platform built entirely in Mesh. 4,020 lines. Auth, event ingestion, real-time WebSocket alerts, background processing, alert rules engine. Zero Rust escape hatches.

Days 11-12: Ecto-inspired ORM. deriving(Schema) generates metadata from structs, queries compose through pipes, Repo pattern for CRUD, changesets for validation, relationships with batch preloading, migration system. Integrating it into Mesher surfaced 47 compilation errors and an ABI segfault. Fixed all of them.

WHAT I LEARNED

1,399 commits. 311 plans. 105 phases. 21 milestones. The same workflow scaled from "emit correct LLVM IR for integer addition" to "implement a multi-tenant event ingestion pipeline with real-time WebSocket alerting."

The discourse around AI coding focuses on the model. After this, I'm convinced the tooling around the model matters just as much. GSD is lightweight: a few markdown files, a command structure, some commit conventions. But it was the difference between "neat demo" and "111,000 lines of working Rust."

Mesh: https://meshlang.dev
GSD: https://github.com/gsd-build/get-shit-done