Done means done done.

I build software with coding agents every day, and they kept handing back something other than what I designed and planned.

First you build it. Then you find out whether it works. You are done when both are true, and Runtime is two components, one for each job.

You can watch an agent work. Watching is not knowing.

// the first done

Did it get built the way you intended?

Design, plan, code, compile, test, push. You lead the design session. After that Meero takes over, the agentic sidekick that stands in for you, and drives the board itself: every card sits in the stage it has actually earned, and Meero moves it as the work clears each one. You can see where the build stands without interrupting a session to ask, and without hoping a checkbox in a markdown file was ticked correctly.

Open a card and the testable exit criteria are there, written at design time, before there was any code to grade them against.

The pipeline. A gate at every stage, what each gate checks, and a refusal that goes back into the work carrying its reason.

The Runtime board, with cards held across design, plan, code, compile, test and push. — The board. Where every card in the build is right now, moved by Meero as each stage is earned.

The route inside a card, running from plan into code. Under PLAN, marked all in: research, runtime-reuse, plan written, first phase todo written, then the plan and its first phase reviewed together by a fresh session, which passed and filed a receipt. Meero spawns a session and reports back before the next leg begins. Under CODE, fourteen not done yet: worker assigned, the plan read, the phase card read, code written, attest, rule set and the code oracle, each not filed yet, then code-review and simplify, which each filed findings from a fresh context. — Inside one card. The route from plan into code. Every step files a receipt or shows as not filed, Meero spawns the next session, and a fresh reader reviews what the builder wrote.

// the second done

Does it function the way you intended?

The observer opens the running application in a real browser and exercises it, then checks the exit criteria from the card against what the software actually did. It watches three layers while it drives, and puts them on one timeline.

A green test tells you a test passed. This tells you what happened.

It also shows what got left behind: code nothing ever reaches, and the branches and worktrees where an agent stalled or a session closed early. That work is still out there, and it is easy to lose track of how much.

// what it is made of

One process on your machine.

It installs as a plugin, and the plugin brings its MCP server, hooks and skills with it, so it attaches to the session you already use. Nothing you build leaves the machine it was built on.

// what happens next

It is being packaged for open source release.

Runtime grew inside my own development environment, as the tooling I needed to keep the work moving, and it is wired into that workflow. Pulling it out is the work now: refactoring it to stand on its own, and packaging it as a plugin for the Claude and OpenAI marketplaces.

The modules go out one at a time as each one comes free, with the skills that drive them, and the field notes written on the way.

Done means done done.

Did it get built the way you intended?

Does it function the way you intended?

One process on your machine.

It is being packaged for open source release.

If any of this sounds like your week, let’s talk.