A running record of the design sessions between Robert and Claude for a new programming language built for the AI era. Updated at checkpoints during discussion. Mode: exploration. Nothing is decided yet. We are collecting ideas, doing research, and comparing existing languages first; decisions come later. Ideas Robert has reacted well to are listed under Directions we like; open questions sit in Open questions. Last updated: 12 Sep 2026, ~1am — session 2 in progress, Q1–Q10 answered
Status at a glance
- Phase: Discovery / exploration (no decisions yet, by design). Session 1 complete.
- Next session starts with: Robert reviews the Open Questions & Recommendations page (Q1–Q16 with Claude’s picks) and answers in / no / counter for each.
- Working name: Mo (folder is
mo-lang; origin of the name not yet discussed) - Current leaning: A language that AI writes ~100% of, humans read only at the spec altitude, with an agent-capability model baked in
- Guiding lens: take old, proven ideas (Tiger Style, NASA Power of 10) and rethink them AI-first instead of human-first
Directions we like (not decisions)
- Agents write nearly 100% of the code. Humans no longer write or closely review code. Mo is designed for that world. This is Robert’s founding premise.
- Human-readable, but at a higher altitude. Mo stays readable by humans because it is the shared language of understanding, but humans read intent, contracts, and effects, not bodies.
- The source carries its own evidence. Since review is gone, trust comes from what the compiler can check: contracts, effects, tests bound to requirements, proofs.
- Style rules become laws, possibly with no escape hatch. Everything Tiger Style and Power of 10 enforce socially, Mo’s compiler enforces. Robert likes the no-override version; to be weighed later against which programs it rules out.
- Old ideas, rethought AI-first. Much of what works is decades old (Tiger Style, Power of 10, contracts, simulation testing). The job is to translate it for a world where agents write the code.
- Never OOP. No classes. Functional and procedural style. (Robert, strongly held)
- Elixir-flavored functional, not Haskell-pure. Pragmatic functional style.
- BEAM qualities without the BEAM. Compile to a single static binary, memory-efficient like Rust or Go. A small runtime linked into the binary (like Go’s scheduler) is acceptable; a separate VM is not.
- Primary inspirations: Rust, Go, Elixir/BEAM, Elm, plus anything else worth stealing.
- Immutable data by default. Gives agents locality of reasoning: to understand a function you need only the function. Perceus-style in-place reuse keeps it fast without a GC.
- Statically typed. Inferred inside bodies, required at every function boundary. The one thing not taken from Elixir. (Claude’s stated opinion, not yet debated)
- Concurrency at the edges, like Go. Most code is plain functions on immutable data; isolated processes are a tool for concurrency and fault isolation, not the primary program structure. (Robert)
- Local
varwith mutable value semantics, plusinoutparameters. In. Avarcan never be aliased, never escapes its function, and is semantically just rebinding that reaches inside a value. (Robert, after Claude’s unpacking) - Processes are the only identity, and each is an Elm-shaped state machine. State + message type + pure
updatereturning new state and effect commands. No globals, statics, mutexes, or singletons. Shared things (config, caches, pools) are a process or a platform-provided capability. (Robert: “that sits with me”) - Effects via capabilities, no effect type system. A function is pure unless it takes a capability parameter. The signature is the purity proof. (Robert: matches)
- Direct-style I/O with runtime interception.
fs.read(path)reads like Go and blocks like Erlang, but compiles to “suspend, hand a command to the runtime, resume with result.” The runtime is the single interception point for capability checks, replay logging, and fault injection. Green threads, noasynckeyword, no function coloring. (Robert: matches) - Every effectful call carries a mandatory deadline. Bounded waits, extending Power of Ten’s bounded loops. Timeout is an ordinary
Errvariant the exhaustiveness checker forces you to handle. (Robert: matches) - Two kinds of failure, two mechanisms, never crossing. Expected failure (“rain”) is an
Errvalue, exhaustive, in the signature, handled by the caller. A bug (“broken roof”: contract or invariant violated) crashes the process. No try-catch anywhere in the language. A crash can only be restarted by a supervisor, logged, and handed to an agent with seed + message log. Agents can never convert a bug into a handled outcome. (Robert: “definitely in”) - Negative space is the human-agent contract. Humans write nothing, not even the spec. Humans speak constraints in conversation (“never double-charge”), agents write them as
neverclauses, humans read them. Theneverset is the part of the spec altitude a person can judge instantly. The agent has full freedom inside the shape; the shape is what the human agreed to. - A human is pulled in when the shape changes. Agents add, rewrite, and refactor freely. The moment a change removes or weakens a
never, a person sees that diff. That is the precise answer to “when does the human look.” - Production crashes are fully autonomous. A tripped
neveror contract crashes the process, the supervisor restarts it, and the agent takes the crash as a task and fixes it with no human involvement. (Robert) Consequence: the runtime must emit a complete bug report (seed, message log, state snapshot, the violated clause and its contract chain), and a fix is acceptable only if it passes all tests and contracts and weakens nonever. If the fix requires changing the shape, item 20 applies and a human is pulled in. That closes the loop: the human is involved only when the shape changes, never when it is merely enforced. - Type system: Rust-plus-refinements from day one. Traits (without the deep solver machinery), enums with data, generics with bounds, exhaustive matching, plus refinement types on primitives (
Money where value >= 0) discharged statically when provable and at runtime otherwise. This is whereneverclauses can become types. Dependent types rejected: models write them at ~27% success vs ~82% for contract-style. (Robert) - Compile speed is a first-class requirement. The compile time is the latency of the agent’s loop; a slow teacher gets ignored. Rust’s slowness is the anti-pattern. (Robert, strongly held)
- Compilation target: C via the Zig toolchain for release, own fast backend for the edit loop. Zig toolchain as the only dependency (Tiger Style), trivial cross-compilation and static linking. LLVM deferred until performance demands it. Compile-to-Rust rejected as a trap (semantics mismatch). WASM deferred. Own VM off the table. (Robert agrees with Claude’s recommendation, with the speed requirement added)
- Fast path is an interpreter, never shipped. Build order: (1) bytecode interpreter for the edit loop, also the executable reference semantics and the host for the simulator, replay, fault injection, and crash reports; (2) C via Zig for release, differential-tested against the interpreter; (3) own native backend only if a real program proves the first two insufficient. Precedent: OCaml’s
ocamlc/ocamloptpairing. The interpreter is a dev tool and is never inside the release binary. (Robert: in) - Optimize for developer happiness AND agent happiness. Robert’s favorite language to read and write is Ruby (Matz’s “developer happiness”). Mo’s syntax must be enjoyable to read. A Rust/Gleam-shaped brace syntax was rejected on sight. Direction: Ruby’s look with Go’s discipline. Precedents: Crystal (Ruby syntax + static types + native binaries) and Elixir (Ruby’s feel on the BEAM). One way to write each thing, resolved by the formatter: Ruby’s look, not Ruby’s freedom.
- Design principle (Robert’s words): the language needs to be as simple as possible and elegant like Ruby and Python. Borrow all the things he likes, keep out the things he doesn’t. Every syntax proposal is held to this.
- Nothing is final until it is measured. (Robert, session 2) Every decision here — especially the performance-shaped ones — stands only until a benchmark, eval, or test says otherwise. Compile-time performance is of paramount importance, and runtime speed close behind, but both are measurable, so neither is settled by argument. Consequences: the project carries a benchmark suite and an eval suite from early on; every performance claim in this journal is a hypothesis with a named way to check it; a decision that measurement contradicts gets reopened without ceremony. This applies to the overflow-check cost, the interpreter-vs-native split, the incremental-rebuild targets, the C-via-Zig backend choice, and any law number.
- Agents edit by declaration ID, not by text position. (Robert: in, session 2, “fascinating”) Every declaration gets a stable ID in a toolchain-owned
.mo.idssidecar; source stays plain text and is the truth.mo edit <id>,mo rename <id>,mo insert,mo delete, plus a few named sub-targets. Edits are parsed before applying, carry--expect hash:for optimistic concurrency, and share the ID with diagnostics as the join key. Replaces grep-and-replace for essentially all agent edits. See the section below. - Supply-chain security is a first-class design goal. (Robert, session 2, very important) AI has made package-ecosystem attacks (npm, PyPI, and the rest) massive and unlike anything before. Mo and its ecosystem are designed to mitigate this from the start: a Go-sized-or-larger stdlib so most programs have zero dependencies, and a package system where a dependency can only do what it is handed a capability for. Capabilities become the permission system for packages, visible at install time. No install scripts, macros, or build-time code execution. Full question and sub-questions: Open Questions Q17.
ID-addressed editing (unpacked, session 2)
The problem: agent editing tools today use str_replace (fails on non-unique or already-changed text), line ranges (wrong the moment anything above moves), or whole-file regeneration (burns context, hides the real diff). Root cause: the edit is addressed by text position, but the agent thinks in declarations.
The move: the unit of edit is the unit of meaning. mo edit m7q2k --with refund.new.mo replaces one declaration. Sounds coarse, but the 40-line function law makes a declaration always fit one edit and one screen; the laws and the editing model reinforce each other.
What string editing cannot give:
- Atomic and parsed. The new declaration is parsed before the file is touched; a broken edit is rejected whole. A file is never left half-broken.
- Optimistic concurrency.
--expect hash:9f31…→ rejected if another agent changed it since. Parallel agents on one module without locks. - Semantic rename. Definition, every call site,
uselines, and test references across files in one step. No grep false positives. - Same address as diagnostics. A Q9
fixnamesid + line; it lands on the right declaration even after other edits. Granularity: the whole declaration, plus a small fixed set of named sub-targets matching the spec-altitude blocks:<id>.contracts,<id>.state,<id>.update;insert --after <id>;delete <id>(fails if referenced). Nothing finer — needing a one-line edit means the function is too big. What stays text: the.mofile. Humans read text on phones (Unison’s store is where people bounce off); git/diff/grep/editors work for free; text editing remains as a never-wrong fallback. Costs:.mo.idsis committed and can conflict only when two agents add declarations at once (mo ids rebuildresolves; existing IDs never move); agents must learn the tool exists (they learn it from diagnostics, since every fix names an ID); whole-declaration edits cost more tokens than a one-line replace, bounded by the 40-line cap.
Open questions (for Robert)
Who writes it?Answered: agents, ~100%. See Decisions. 1b.Laws with no escape hatch?Liked, parked. Revisit once we know the target domain.- First real program? Web service, CLI, data pipeline, agent harness, game? A language without a target domain dies. Deferred: Robert wants to explore language attributes first and let the domain fall out.
2b.
MutabilityAnswered: immutable data is great (typo in the original). Immutable by default. 2c. Processes as Elm-shaped state machines? Is “a process = state + message type + pure update returning new state and effect commands, and that is the only place state lives” right, or too restrictive? Liked. Processes are the only identity. See Directions we like, item 14. - Runtime appetite. Native via LLVM, WebAssembly, transpile to Rust/Go, or the BEAM (like Gleam)? Transpiling to Rust gets verification tooling and an ecosystem for free.
- How radical on syntax? Familiar Python/TypeScript feel to exploit model priors, or willing to look strange if it buys correctness?
- Verification dial. From “strong types + exhaustive matching” up to “Dafny-style proofs the agent must discharge.” Suggested start: runtime-checked contracts with an optional SMT path.
- The name. Is “Mo” decided? What’s the story?
- Type system spectrum considered: Go-level (small, boring, repetitive) / Rust-level (traits, generics, enums with data) / refinement types (values in types, SMT-backed) / dependent types (Lean, Idris). Answered: Rust + refinements.
The fork in the road
“A language for AI” means three different products:
- A language AI writes and humans review. Optimized for verification and review, not typing. Contracts, effects, exhaustive errors, no hidden control flow, structured compiler diagnostics that act as the agent’s teacher. Claude leans here.
- A language for orchestrating agents. LLM calls, tool capabilities, budgets, retries, structured concurrency as primitives. Pel lives here. Smaller, DSL-shaped bet.
- A spec language where the AI is the compiler. Humans write intent, model generates a verified implementation, code is an invisible intermediate. Boldest, mostly a research project. Recommendation: option 1, with the capability model from option 2 baked in, since agents will also be the ones running the code.
Two altitudes in one language (proposed, awaiting Robert’s reaction)
- Spec altitude (what humans read): module and function signatures, contracts (
requires/ensures), effect declarations, anintentstatement per unit, and a visible verification level (verified by tests, contractsvsproof). Semantically binding, not comments. Reads like a design doc. - Implementation altitude (what agents write): function bodies, checked against the spec altitude, collapsed by default. Sketch:
module payments.refund
intent "Refund a captured charge, at most once, within 90 days of capture."
fn refund(charge: Charge, amount: Money) -> Result<Refund, RefundError>
requires amount <= charge.captured_amount
requires charge.captured_at within 90.days
ensures result.ok implies ledger.balance == old(ledger.balance) - amount
effects db.write(ledger), net.call(stripe)
verified by tests, contractsTiger Style + Power of 10, rethought AI-first
Key move: both documents are style guides enforced socially by review. Review is gone. So every style rule becomes a language rule enforced by the compiler. Become laws of Mo (compiler-enforced):
- No unbounded loops. No
while true. Loops iterate finite collections or carry an explicit bound in the signature. - No general recursion. Only structural recursion the compiler proves terminates. Totality by default.
- Hard function length limit (number TBD). Also a context-window-sized unit of agent work.
- Minimum contract density: a function with no
requires/ensuresdoes not compile. - No compound asserts. A failure always names one property.
- Exhaustive error handling. Every result consumed. No exceptions.
- No default parameters. All options explicit at call site.
- No warnings, only errors.
- Explicitly sized types only.
- Positive and negative space tests are part of the unit; compiler checks both exist per precondition. Die (served human eyes): column limits, indent width, symmetric name lengths, file order, brace style. Canonical formatter, no choices. Promoted into bigger features:
- “Motivate decisions” → structured provenance field linking to requirement and conversation.
- “Performance sketching” → declared resource budgets in the signature (latency, memory, allocations), checked by compiler/simulator.
- “Paired assertions” → type invariants auto-checked at every boundary (create, serialize, deserialize).
- Deterministic simulation testing → default runtime model. Every program deterministic under a seed. Failing assertion + seed = complete, reproducible bug report for an agent.
- Static allocation after startup → powerful but domain-constraining; parked until first-program decision. Sources: Tiger Style, The Power of Ten
State model (deep dive, 12 Sep 2026)
Why state hurts, precisely
Not mutation itself. Three things OOP maximized:
- Aliasing plus mutation. Two names for one memory, one changes it.
- Hidden state. A call changes something invisible from the call site; the signature lies.
- Time. “What is x” has no answer without “when.” For an agent reasoning over a context window, each one means “you must read code that isn’t in front of you.”
Options weighed
| Option | Pros | Cons |
| 1. Shared mutable (imperative default) | Fast to write, matches machine | All three pains. Off the table. |
| 2. Pure functional, explicit threading (State monad, Elixir passing) | Total honesty, trivially testable | Monad ceremony, awkward accumulators, humans reject it |
| 3. Mutable value semantics (Swift, Hylo) | Natural loops, C-level perf, no borrow checker; no aliasing so pains 1 and 3 vanish | Needs a story for large shared structures; less familiar to models |
| 4. Ownership + borrowing (Rust) | Strongest guarantees, full expressiveness | Lifetimes: the #1 failure for humans and agents. Too expensive given option 3 |
| 5. State only in actors (Erlang, Elm) | Time explicit as message sequence, replay free, isolation free, supervision | Shared things become round-trips; god-process blobs; giant update fns |
| 6. Value/identity split (Clojure atoms, refs, STM) | Philosophically right | STM hard natively; reintroduces shared mutable identity |
| 7. State as algebraic effect (Koka) | Signature tells the truth; swap handler for test/replay | Unfamiliar, can get abstract |
| 8. Event sourcing (state = fold over log) | Log is truth; replay/audit built in; perfect for agent repro | Log growth, snapshots, schema evolution; overkill for a counter |
| 9. Relational / Datalog (Eve, Rel) | Very verifiable | Too far from what models know. Shelved |
| Property | How Mo gets it |
| Purity | No capability parameter = provably pure. Signature is the proof. |
| Interception | Runtime performs every command: capability check, replay log entry, simulator hook in one place. |
| No blocking | Green threads. 10k blocked processes cost 10k small stacks. |
| Visibility | Replay log = sequence of commands and results per process; spec altitude shows effects via capability params. |
| Expected failure | Bug | |
| Looks like | `Err(FileNotFound)` returned | `requires` / `ensures` / invariant fails |
| Who handles | Caller, via exhaustive `match` or `?` | Nobody. Process dies. |
| Next | Program continues by design | Supervisor restarts process from clean state |
| Who learns | Whoever handled it | An agent: crash + seed + message log = fix task |
| Own machine-code backend (Zig-style) | Interpreter (OCaml-style) | |
| Build effort | Hardest thing on the project: regalloc, calling conventions, debug info, green-thread stack switching, per architecture. Zig took years. | Weeks. Portable everywhere for free. |
| Compile latency | Low | Near zero (no codegen) |
| Runtime speed | Near release | 10-50x slower |
| Simulation / replay / fault injection / crash reports | Must be compiled into machine code | Hooks in the interpreter loop; interpreter-native |
| Semantics | One implementation | Two, but the interpreter is the executable spec and the C backend is differential-tested against it |
| Ships? | Yes | Never. Release is native via C. |
intent “Refund a captured charge, at most once, within 90 days of capture.”
never “a refund exceeds its charge” for r in Refund.all, c in Charge.all if r.charge == c.id r.amount > c.captured_amount end
struct Charge id: ChargeId captured_amount: Money captured_at: Time refunded: Bool end
enum RefundError AlreadyRefunded(id: ChargeId) WindowExpired(captured_at: Time, now: Time) Timeout end
fn apply_refund(charge: Charge, amount: Money) : Result(Charge, RefundError) requires amount <= charge.captured_amount
return Error(AlreadyRefunded(charge.id)) if charge.refunded?
var updated = charge updated.refunded = true Ok(updated) end
fn refund(db: Ledger, clock: Clock, id: ChargeId, amount: Money) : Result(Refund, RefundError) requires amount > 0
now = clock.now charge = try db.find_charge(id, within: 200.ms)
if !within_window?(charge, now) return Error(WindowExpired(captured_at: charge.captured_at, now: now)) end
updated = try apply_refund(charge, amount) try db.save_charge(updated, within: 200.ms)
Ok(Refund(charge: id, amount: amount, at: now)) end
process Counter state count: UInt32 end
message Increment message Reset
fn update(state, message) case message Increment: state.count += 1 Reset: state.count = 0 end end end
test “second refund is rejected” charge = Charge.fixture(refunded: true) assert apply_refund(charge, 1_00) == Error(AlreadyRefunded(charge.id)) end
*The older Ruby-shaped draft below is superseded by the base above.*
### Draft example (Ruby-shaped)
```ruby
module Payments::Refund
intent "Refund a captured charge, at most once, within 90 days of capture."
never refund.amount > charge.captured_amount
never a charge is refunded twice
never card.number reaches log
type Money = UInt64 where value <= 10_000_000_00
struct Charge
id : ChargeId
captured_amount : Money
captured_at : Time
refunded : Bool
end
enum RefundError
ChargeNotFound(id : ChargeId)
AlreadyRefunded(id : ChargeId)
WindowExpired(captured_at : Time, now : Time)
Timeout
end
def within_window?(charge : Charge, now : Time) : Bool
requires now >= charge.captured_at
now - charge.captured_at <= 90.days
end
def apply_refund(charge : Charge, amount : Money) : Result(Charge, RefundError)
requires amount <= charge.captured_amount
ensures ok(c) implies c.refunded?
return error AlreadyRefunded(charge.id) if charge.refunded?
ok charge.with(refunded: true)
end
def refund(db : Ledger, clock : Clock, id : ChargeId, amount : Money) : Result(Refund, RefundError)
requires amount > 0
ensures ok(r) implies r.amount == amount
now = clock.now
charge = try db.find_charge(id, within: 200.ms)
unless within_window?(charge, now)
return error WindowExpired(captured_at: charge.captured_at, now: now)
end
updated = try apply_refund(charge, amount)
try db.save_charge(updated, within: 200.ms)
ok Refund.new(charge: id, amount: amount, at: now)
end
process RefundQueue
state
pending : List(RefundRequest) where size <= 1_000
done : UInt32
end
invariant done >= 0
message Enqueue(request : RefundRequest)
message Drain
def update(state, message, db : Ledger, clock : Clock)
case message
when Enqueue(request)
state.with(pending: state.pending.push(request))
when Drain
var done = state.done
state.pending.each do |request|
case refund(db, clock, request.id, request.amount)
when Ok(_) then done += 1
when Error(e) then log.warn(e)
end
end
state.with(pending: [], done: done)
end
end
end
test "refund within window succeeds"
charge = Charge.fixture(captured_at: t0, captured_amount: 5_00)
assert apply_refund(charge, 5_00) == ok(charge.with(refunded: true))
end
test "second refund is rejected"
charge = Charge.fixture(refunded: true)
assert apply_refund(charge, 1_00) == error(AlreadyRefunded(charge.id))
end
test rejects "amount above captured violates requires"
charge = Charge.fixture(captured_amount: 5_00)
apply_refund(charge, 9_99)
end
verified by contracts, tests, simulation(runs: 1_000)
end
Steal list: what to take from other languages
Framing: Go ships a scheduler and GC inside every binary and nobody calls it a VM. Inko and Pony prove Erlang-style isolated processes and message passing work natively in one binary. Mo can have a small linked-in runtime and still meet the single-binary bar. What we lose without the BEAM: hot code loading and the mature distribution layer. Probably fine.
From Ruby (and Crystal)
- Steal: the reading experience.
def/end,case/when, blocks withdo |x|,unless, trailing conditionals, predicate methods ending in?, keyword arguments, everything is an expression. - Steal from Crystal: proof that Ruby’s syntax survives static types and native single binaries.
name : Typeannotations. - Leave: five ways to write everything, optional parens as a choice, monkey patching, metaprogramming, dynamic typing, exceptions.
From Elixir / BEAM
- Steal: processes as the unit of isolation, message passing as the only sharing, supervision trees, let-it-crash. AI-first twist: a crashed process + seed + message log is a contained, reproducible task for an agent. Failure becomes a unit of work.
- Steal: pattern matching everywhere, tagged results (
ok/error), the pipe operator. - Adapt: immutable data with structural sharing, implemented via Perceus-style reference counting with in-place reuse rather than per-process GC.
- Leave: dynamic typing, hot reload, Erlang term format, the VM.
From Rust
- Steal: enums with data, exhaustive matching, Result/Option, no null, no exceptions, traits not classes, “if it compiles it works.”
- Steal: compiler-as-teacher diagnostics, then go further: structured, machine-consumable errors with suggested fixes.
- Adapt: ownership guarantees (no aliasing+mutation, no data races) without the full borrow checker. Lifetimes are the biggest failure source for humans and agents alike; Hylo/Inko get the safety via value semantics and single ownership.
- Leave: lifetimes, macros, async coloring, trait-solver complexity, unsafe.
From Go
- Steal: single static binary, one-flag cross-compilation, fast builds, one formatter with zero options, one build tool, batteries-included stdlib so most programs need no deps.
- Steal: small language (~25 keywords). Simplicity is the AI-first feature.
- Adapt: ceiling on abstraction. Go says no by omission; Mo says no by law.
- Leave: nil, GC,
if err != nil, implicit interfaces.
From Elm
- Steal: zero runtime exceptions as a guarantee, not a goal. Proof that no-escape-hatch is achievable in a real language.
- Steal: effects as data. Pure functions return effect descriptions (
Cmd); the runtime performs them. Inspectable, testable without mocks, and the natural hook for capabilities: the runtime refuses commands the process was not granted. - Steal: compiler-as-patient-friend error messages (the origin of Rust’s). AI-first version adds a structured form: category, location, likely cause, candidate fix.
- Steal: enforced semantic versioning by API diff. Mo can go further: a changed contract forces a version bump, not just a changed signature.
- Steal: the discipline of no. No custom operators, no user-level FFI (ports only), unchanged since 2019. A stable target is a feature for a language models must learn.
- Steal: replay/time-travel falls out of state + message log. Same destination as deterministic simulation.
- Leave: web-only, slow BDFL cadence, no abstraction over types (real boilerplate; Mo needs traits or similar).
Unification spotted: The Elm Architecture, an OTP GenServer, and a Redux reducer are the same shape: state + message + pure
updatereturning new state and effects. Proposal: Mo has exactly one stateful construct, the process, and it is Elm-shaped. Everything inside is pure. Let-it-crash, replay, and agent testing (feed messages, check states) all fall out.
From languages nobody is looking at
- Austral: capabilities as linear values. No filesystem access without an unforgeable, consumable token. Cleanest foundation for agent permissions. Shares our anti-magic, small-enough-for-one-head philosophy. austral-lang.org
- Koka: effect types with handlers; Perceus compiles to plain C with no GC. Effects in the signature = how the spec altitude declares what a function touches. Possibly the single most AI-first feature. koka-lang
- Pony: reference capabilities: the type says who may read and who may write, so mutable data moves between actors with no copies and no locks. Six caps is too many; the core idea is gold. Pony reference capabilities
- Hylo: mutable value semantics. Mutate locals in place, but no two names ever alias the same memory. Feels functional, runs like C. Possible resolution of functional-vs-mutable. hylo-lang.org
- Roc: the platform concept. The language has no I/O; a platform provides it. Same language for embedded, server, or agent sandbox. Unsafe parts live in the platform, not the language, which supports no-escape-hatch laws. roc-lang.org
- Inko: existence proof of Erlang-style processes + deterministic memory + single ownership, natively, one binary. inko-lang.org
Idea backlog (Claude’s proposals, awaiting reaction)
- Stable semantic IDs on every declaration so agents edit by ID instead of fragile text diffs.
- Intent blocks that bind a natural-language requirement to a function and its tests, so provenance is part of the source.
- Capabilities as values with lifetimes. A function cannot touch the network unless handed the network. Distinguish “what you may do” from “what you actually did.”
- Structured, fix-suggesting compiler errors so an agent that starts wrong converges in two or three loops. The compiler is the agent’s teacher.
- One canonical formatting, no options, ever.
- Tiny grammar, surface syntax close to something models already know, so knowledge transfers and the zero-training-data problem is softened.
- Exhaustive result types, no exceptions from nowhere, no hidden control flow.
- Effect tracking so every function declares what it touches (I/O, mutation, DB, network).
- The language’s value lives in what it checks, not how it looks.
Research summary (Sep 2026)
Headline
Nobody has built this yet. Mojo hit 1.0 in Aug 2026 but is “for AI” in the sense of running AI workloads. Pel is a Lisp-ish agent-orchestration language. The closest real design is a blog sketch (PACT-Lang) that stayed a sketch. The space is open.
Three findings that shape everything
- Training-data gravity is real. Dan Luu benchmarked agents building a full zstd decoder and modifying Pandoc across many languages. Obscure languages did badly even when denser. Popularity correlated with correctness. A new language starts with zero corpus: our single biggest risk.
- Strictness helps models converge. Go-for-agents debate, Dafny vericoding (verification success 68% → 97% in one year), verified Rust via Verus and Aeneas. Agents thrive when the compiler rejects wrong programs loudly and there is one way to do things.
- The ideal AI language is one humans keep rejecting. Explicit effects, exhaustive result types, contracts, totality. Friction for a human typist, a gift for an agent that iterates in a loop and never tires of annotations.
Smaller things worth stealing
- Token efficiency matters less than people think at scale (Dan Luu). Don’t contort syntax for it.
- “Lingering Authority” paper: revocable, time-bounded capabilities for coding agents; separate permission from actual effect. Fits an effect system perfectly.
- Research trend toward compilers emitting structured diagnostics (category, cause, suggested fix) for agent feedback loops.
Sources
- AkitaOnRails: Best programming language for LLMs
- Dan Luu: token efficiency and correctness by language
- Do programming languages still matter to your AI coding agent teammate?
- Lingering Authority: Revocable Resource-and-Effect Capabilities for Coding Agents
- A benchmark for vericoding (POPL 2026)
- Pel: A Programming Language for Orchestrating AI Agents
- A case for Go as the best language for AI agents (HN)
- Mojo hits 1.0
- Aeneas: Bridging Rust to Lean
- Token Sugar (ASE 2025)
- AI Coders Are Among Us: Rethinking Grammar
Next session
All remaining questions now live on the Open Questions & Recommendations page, each with options, a recommendation, and why, plus the full example regenerated in the current style and the proposed path after alignment. The list below is kept for reference. Remaining syntax pieces (small):
- Literals, strings, interpolation, comments, numbers with units (
200.ms,90.days,5_00money). Optionand the absence of nil; howOptionis matched and combined.- The
verified by ...line: what levels exist and who writes it. - Regenerate the full example in the final style and read it end to end on the phone. Bigger topics still open:
- The verification dial in practice: what runs at runtime vs what the SMT pass proves, and how the verification level is displayed.
- Compiler diagnostics as the agent’s teacher: the structured error format.
- Semantic IDs and how agents edit Mo (by ID vs by text).
- The platform concept (Roc-style): what the standard platform provides, and the standard library policy (batteries-included, zero deps).
- First real program (deferred from Q2; attributes are now mostly known, so the domain can fall out).
- The name: is “Mo” decided, and the story.
- Then: compare the design against existing languages, and decide what to lock.
Session log
- 12 Sep 2026, session 1 (cont). Negative space programming: Claude laid out five levels and proposed
neverclauses as the human-facing surface. Robert: humans shouldn’t write any of it. Revised to speak/write/read split; humans pulled in when the shape changes. Robert: none, the agent takes the crash and fixes it. Type system: Robert chose Rust-plus-refinements from day one. Compilation target: Robert agreed with C-via-Zig then LLVM, and added compile speed as a hard requirement; Claude researched Zig/Roc/Unison and laid out the speed levers. Fast path: interpreter, then C, native backend only if proven necessary. Robert: in. Syntax: Claude proposed Rust/Gleam-shaped and showed an example; Robert rejected it, Ruby is his favorite language and the code must be enjoyable to read. Claude rewrote the example Ruby/Crystal-shaped. Robert: closer, but wants to pick piece by piece. Pieces 14 (modules) and 15 (dot-call sugar, traits,wheregenerics) in. Session closed at ~1am Robert’s time. Piece 13 (root-only capabilities, no log statements, typed events) in. Pieces 11 (loops,fn(x) ... end) and 12 (in-file tests,rejects,property) in. Robert intrigued by in-file tests; Claude cited Zig, Pyret, D, Rust, Elixir, Unison. Piece 10 (process) confused Robert; clarified with a counter. Robert dropped.withfor plainstate.count = 0, then wrote his own version ofapply_refund:fn ... endblocks, no braces,name: Type, contracts flowing into the body. That is now the base. Pieces 1-9 originally chosen: braces (not def/end, not indentation),fn+ Crystal types, bare=bindings,ifrules,casewith arrows,try+ predicate?, call-style construction +.with, contracts above the brace,module Payments.Refunddot paths +neversentence-and-block. - 12 Sep 2026, session 1 (cont). Errors and failure: rain vs broken roof, no try-catch, crash-only bugs with supervisor restart. Robert: definitely in. Robert queued negative space programming for discussion next.
- 12 Sep 2026, session 1 (cont). Effects and capabilities: Claude laid out effect types vs commands vs capabilities, then the direct-vs-command I/O fork. Conclusion: capabilities as parameters, direct-style I/O with runtime interception, green threads, mandatory deadlines. Robert: matches, capture it.
- 12 Sep 2026, session 1 (cont). State deep dive: Claude mapped nine state models with pros/cons and proposed a layered synthesis. Robert asked for
var/inoutunpacked, then said: in, capture it. - 12 Sep 2026, session 1 (cont). Immutability confirmed. Robert: processes at the edges like Go. Robert raised Elm; Claude extracted lessons and proposed the process = Elm-shaped state machine unification. Open: is that too restrictive?
- 12 Sep 2026, session 1 (cont). Robert switched to exploration mode: no decisions yet. Stated attributes: never OOP, Elixir-style functional, loves the BEAM but wants a single memory-efficient binary. Claude researched Roc, Koka, Hylo, Austral, Pony, Inko and produced the steal list. Open: what “mutable data is great” means.
- 12 Sep 2026, session 1 (cont). Q1 answered: agents write ~100%, humans read at a high altitude. Claude proposed the two-altitude model. Robert pointed to Tiger Style and NASA’s Power of 10 as old ideas to rethink AI-first; Claude mapped them into laws / dead rules / promoted features. Open: laws with no escape hatch?
- 12 Sep 2026, session 1. Kickoff. Robert: 10+ yrs SWE, first language, motivated by AI. Claude ran a research pass on the 2026 landscape and laid out the three-way fork plus six interview questions. Awaiting answers.