Last time we talked about the Think-Act-Observe loop — the skeleton of an AI coding assistant. A skeleton can’t work on its own; it needs muscle. In Claude Code, that muscle is tools. Without tools, the loop loses the Act between Think and Observe and degenerates into plain Q&A. With tools, the model can touch the real world: read your code, change your configs, run your tests.
If you dig through the Claude Code source, you will discover a counterintuitive fact: The core of the entire program is a while loop. Not a complex state machine, not an elaborate pipeline, not distributed coordination — just a plain while loop that does three things over and over: let the model think, let the model act, feed the results back. 1 2 3 4 5 6 7 8 9 while (user hasn't quit) { thinking = callLLM(conversation history + tool definitions) if (thinking.wants to call a tool) { result = executeTool(thinking.toolCall) conversationHistory.push(result) } else { output(thinking.reply) } } That’s it? The entire secret of an AI coding assistant lives in this loop?
The most annoying thing about coding with AI isn’t that it writes bugs — it’s that it writes them differently every time. Same requirement, three conversations, three implementations. The standards live in your head; the AI doesn’t know them. Trellis tries to solve this. It’s not yet another AI coding assistant — it’s a framework for injecting project standards into AI: the AI reads your standards before writing code, gets checked automatically after writing, and once the check is done, anything newly learned gets distilled back into the standards. The more you use it, the better the AI knows your project.
Packing multiple probabilistically sampled large language model instances into a single codebase or production pipeline is, fundamentally, constructing a distributed system over an unreliable network using stochastic state machines. The axiomatic foundations of classical distributed computing—deterministic state transitions, reproducible failure modes, Byzantine fault tolerance, and atomic commits—collapse almost entirely when applied to modern generative models. Tech social media abounds with utopian product demos: one agent searches documentation, another implements business logic, a third writes unit tests, and a fourth conducts code review, while an orchestrator agent glides over the process like an infallible engineering manager. Yet anyone who has pushed such topologies into a 500,000-line monolithic repository or a high-concurrency production environment knows the reality: the system rapidly degenerates into distributed chaos. Unsynchronized modifications cause silent overwrites and split-brain states; non-deterministic rollouts cause cognitive divergence; token consumption explodes in a positive-feedback avalanche; and parent and child processes lock each other in cognitive livelocks.
