Intent-assurance-lab’s design was finished, independently reviewed, and parked. What it had never done was touch a real task. The obvious next step, with the framework sitting idle, was to pick a real not-yet-started piece of work somewhere in the factory and write a real intent for it by hand, with no tooling, just the schema and a checklist. The obvious candidate ruled itself out within a minute of git status.
What I tried
Another lab had an in-flight phase that looked like exactly the kind of change this framework targets: judgment-heavy, worth specifying before building. Before writing anything, the plan was to confirm it was genuinely unstarted. It was not. git status showed real, uncommitted files already on a live branch: a judge-chain module and its tests, mid-build in a concurrent session. Writing “before implementation” intent against work already underway would have been exactly the failure mode the framework itself was designed to catch: an intent document that reverse-engineers the code that already exists and calls it a specification, which proves nothing except that a human is good at describing what they can already see.
That target was dropped, no argument needed once the evidence was in.
What worked
A second lab had a phase that was genuinely clean: git status empty on main, well-specified in an existing plan document, and security-relevant enough to be a meaningful mid-tier example. An intent record was written by hand against the schema: what would be true after the change, the evidence that would establish it, the proposed review tier. Then the Layer A critique checklist was run against it, also by hand, no automation. Result: pass, zero failing checks, tier T2.
The reusable pattern
A pilot proves what it claims to prove only if the target was actually unstarted, and “actually unstarted” is a checkable fact, not an assumption carried over from memory or from what the plan document says should be true. The rule that came out of this: verify the target with a live-branch check before writing a word of intent, every time, even when a candidate looks obviously idle. If every candidate on hand turns out to be already underway, the correct move is to wait, not to lower the bar and write intent for code that already exists.
What next
This trial proves the schema and checklist are usable by hand to produce a specific, falsifiable record for genuinely unstarted work, and that doing the exercise honestly surfaces real judgment calls (the tier, the explicit non-goals) worth recording before code exists. It does not prove the framework changes review behavior, because the implementation this intent describes had not been built yet when this was written, so no reviewer had anything to be usefully focused by. That test stays open.
What Next
Teach the Engine to Decline
Next: what it looks like when the engine itself, not just the human reviewer, is allowed to say a change isn't good enough yet.