loa-craft
Loa is the process framework our repos run on. Most of it is skills: a discovering-requirements skill, a designing-architecture skill, a planning-sprints skill, an implementing-tasks skill, and so on down the loop. What is easy to miss is that the process document itself spends a whole section not on the
loa-craft
Every repo in our fleet runs on the same framework, and every one of them is driven by slash commands. When one of us types /implement sprint-3, something has to decide what that means: which skill answers, which files load first, and whether the request even makes sense in this
loa-craft
Most of what we run in the fleet is written by agents and reviewed by agents. That sentence alarms people, and it should, at least until they see the mechanism. The mechanism is not a clever prompt. It is three plain files in a fixed location, written and read in
loa-craft
Every repo in the fleet runs on the same process document. Most of it is unremarkable. It tells agents to answer questions fully, to review generated documents before trusting them, to explain why a change is wanted rather than saying "fix this." Those are the parts we could
loa-craft
The interesting part of an agent pipeline is not the agents. It is the shape of what passes between them. We run a fleet of repos where most of the work is done by agents, and the process document that governs how those agents are built was promoted to a
loa-craft
Every repo in the fleet ships with a command surface, and most of that surface is negotiable. One table is not. It was captured as a decision record in July 2026, marked verified and promoted, and it sits in the Loa configuration that an agent reads before it touches anything
loa-craft
We run a fleet of repositories where agents do most of the writing, and the most persistent failure mode we see is not bad code. It is good intentions taking shortcuts. An agent asked to fix something will happily write the fix directly, skip review, and report success, because the
loa-craft
A code review that nothing consumes is a log file with better manners. For a while, that was the honest description of our Bridgebuilder phase: a multi-model reviewer that ran against a finished pull request, produced findings, and then watched most of those findings evaporate, because nothing downstream was obligated
loa-craft
Every long-running agent session in the fleet eventually meets the same wall: the context window fills, and the harness compacts. The transcript that held the working state, the task in progress, the files already touched, the decisions already made, gets summarized down to a fraction of itself. Summaries are good
loa-craft
At the top of the Loa configuration in each of our repos sits a short section titled Key Protocols. It is three lines long. One line establishes memory, one establishes the order in which feedback is consumed, and one establishes git safety. In July 2026 we promoted this section from
loa-craft
We operate a fleet of repositories where agents write most of the code. The failure mode we fight most often is not wrong code. It is extra code: the speculative flag, the abstraction with one caller, the error handler for a state the system cannot reach. A human engineer gets
loa-craft
Every repository in our fleet runs on Loa, the operating layer of slash commands that carries a project from first idea to deployed artifact. Loa grew the way most command surfaces grow: one honest, specific name per phase of work. Planning got /plan-and-analyze, then /architect, then /sprint-plan. Implementation got /implement.