Why the standard has to bind both sides.
I built all of this because I couldn’t trust a machine’s word that it got something right. But the honest version of that distrust includes me. I am a moving idea and a brainstormer; left alone, I fragment, I call things done on a feeling, I drift past the edges I set. So the same discipline I asked of the tools, I have to ask of myself — otherwise I’ve just built a system that’s accountable in one direction and trusts its operator without ever checking, which is the exact failure I started from.
The frame is deliberately not about worth. It never asks whether you are good enough — only about the action: is this finished, is this verified, is this in scope. A failing check is information, not a verdict on the person. That separation — judge the action, never the worth — is what lets the critic be relentless without being cruel: not a higher bar to feel unworthy against, but a fair one anyone can keep meeting by simply wanting to prove themselves wrong. (Why I think that separation matters is its own longer argument.)
It leans on evidence the other tools already produce — the witness, the gate, the receipt — and adds the one thing they couldn’t: the questions aimed at me.Where it really is — said plainly.
Because this page is about turning an honest standard on myself, it would be a strange place to overstate what exists. So: this is a published reference framework and one working reference script, not a finished system. The script — the critic — runs. It scans the repositories for work left unmerged, reads a project’s declared state for unfinished edges and unverified claims, and prints four standing questions: finish, focus, verify, scope. Answer one and it adds your answer to a running log that only ever grows — nothing is removed. That much is real and you can run it today.
What is not built here is the rest of the machinery the idea describes — the inward evidence-receipts that would judge the work itself. That half isn’t vapour; it already runs in the other organs (the gate, the witness, the loop) — but it is not yet wired into this one, and a version that runs outside my own command-line setup is still open work. I’m publishing it now to stake the idea and its date, not to claim it’s done.
The one piece that runs. Here it is, asking me.
No grand demo — that would be its own kind of dishonesty. Just the reference script doing the single thing it really does: standing in front of the work and asking the questions out loud.
$ ./critic.ps1 === critic - the substrate's questions for YOU === [FINISH] keystone - sprawl check clean - everything is merged. [FOCUS] one unit, one branch open edges in STATE: none listed Q: are you finishing the claimed unit, or fragmenting onto a new front? [VERIFY] receipt, not vibe no unverified markers flagged in STATE. [SCOPE] GATE - answer before proceeding Q: does the current work touch your declared out-of-scope boundary? - authorization in place? - in scope, or out by construction? - the work you intend, or drift away from it? Answer any: ./critic.ps1 -For FINISH -Record "<your call>" # -> DECISIONS.md
Run here against an empty state, it honestly reports “clean / none listed” — it has nothing to interrogate until there’s real work in front of it. Pointed at a live project, the same four questions land with teeth.
The whole engine is one ~100-line PowerShell script, critic.ps1, plus a coordination template and the framework write-up — github.com/HarperZ9/accountable-engine. Honest limit: the critic is shallow on purpose for now — it reads git state and a declared-state file and asks from a fixed set of questions; it doesn’t reason about your decisions yet. It’s a reference for the shape of the thing, not the finished interrogator. The code is MIT-licensed — read it, run it, build on it — though this is still published to stake the idea, with the build ahead of it.
A thesis with a working seed, not a product.
Accountable Engine is the idea I most want to be held to: a system that earns the right to check a machine by first agreeing to be checked itself. Today that idea ships as a written framework, a protocol template, and a single reference script that runs. No version number, no test suite, one platform — I’m not going to dress that up, on this page least of all.
If I’d rather you not see the rough edges, I haven’t earned the standard I’m selling.
So here is the line, drawn by the same hand that drew it for the machine: the concept is real and, I think, load-bearing for the whole project; the one script does what it says; and everything else — the evidence-driven critic, the version that runs outside my own command-line setup, the tests — is owed. When it’s built, it’ll be here, witnessed like the rest. Until then it’s forming, and calling it forming is the most accountable thing the page can do.