The goal: software that keeps its promises.
AI-made changes, checked against your saved rules.
Chris Byrne · Melbourne · chris@unclick.world
Working name · November 2026A request you have probably made
Alex has worked 10 hours this week and 3 weekend shifts this month. Sam has worked 20 hours and 1 weekend shift. Both can take the next shift.
Fewer hours, so the next shift goes to Alex.
Fewer weekend shifts, so the next shift goes to Sam.
Both fit the request. They give the shift to different people. Which one did the AI build into your app? You should be able to see that decision, and know the rest of the roster still works.
An illustration, not a screen; names and numbers are made up. UnClick Proof records the rule the AI changed and re-checks every rule it did not. Deciding whether the change matches what you meant still needs a person.
The problem
A new feature can pass while an older feature stops working. If the checks miss it, the customer may find it first.
Teams already have checks for what works today. The open question is how well AI agents keep passing them as a project keeps changing, and who is measuring that.
A 2026 study (SlopCodeBench, March version: 20 problems, 93 stages) had AI agents keep adding features to their own code, tests hidden. A stage counted as solved only if the new feature worked and every earlier test still passed. Final-stage strict pass rate: 0.5%.
The study measured other agents under its own conditions. It says nothing about UnClick Proof; it says the problem is real. Its decline mixes earlier checks failing with harder new checks, and the paper says so.
Change the code. Show when the rules change.
The goal, in one line
The AI cannot quietly ship a change that breaks a promise.
What it does today
Passing these checks does not establish complete coverage.
What it looks like
Your booking app must never accept two appointments for the same time. You ask an AI to add reminder emails. The emails work. Did the double-booking rule survive?
With UnClick Proof the question is asked for you, before the change is accepted: the saved checks for the new feature and for double-booking must both pass. If one fails, the change is refused.
The booking app is an illustration. The three tasks on the right are real.
7 Nov 2026 UTC (8 Nov in Melbourne)
Show the job's owner on the board. UnClick Proof went from 4 of 8 hidden checks passing to 8 of 8, wrote four new rules, and kept all 78 earlier checks.
Reorganise the stage words into one table. A pure tidy-up: 248 rules, none changed, 94 earlier checks still passing.
Add a "latest evidence" date to the pipeline. Both sides passed their own checks. UnClick Proof extended a rule to cover the new field and shipped with every rule green.
Check the rulebook as well as the code
Some decisions should outlive today's code: who gets the shift, what a title may look like, when a booking is refused. Keep them separate from the code, so the work of understanding your business still counts when the code changes.
Tests already check code. UnClick Proof also examines changes to the rules used to judge that code. Sometimes a rule should change. You should be able to see that it changed.
Internal engine test, 1 Nov 2026: a rule and its setup were removed, which was allowed and recorded. The comparison still reran the saved case and found that the proposed code left out a field the old code returned. The proposed change was refused through all three tested routes (by hand, by change, by import).
Scope: one controlled engine test and a four-task run, not a universal guarantee. Deliberate rule changes are allowed when declared, and an operator can set the reply-shape comparison to advise only; a change that fails a saved check is still refused. Would this catch something your current checks miss? That is the comparison we want to run next.
What a rule change looks like
An illustration of what a reviewer needs to see, not a screenshot of an existing screen. The system makes the decision visible; it cannot choose the owner's intention for them.
What the engine answers, and what stays yours
The engine runs the current saved examples before it accepts a code change, and records the results. It also examines and records rule changes, and can compare cases from removed rules.
A person judges. Good examples take work, and useful coverage may need more cases as the app and its uses develop.
A person judges. The record makes the decision visible so the question can be asked early; it cannot choose the intention.
You still decide what matters. Writing and reviewing useful examples may need technical help. The test's AI costs (US$5.66 and US$4.72 for four tasks, 7 to 8 Nov 2026) do not measure the human effort of adopting this way of working.
Where this sits
| Tool | What it does, from its public guides, Nov 2026 |
|---|---|
| GitHub Spec Kit | Requirements, plans and tasks in documents, with agent-led checks for gaps. |
| AWS Kiro | Requirements linked to generated property tests that surface failing cases. |
| Tessl | Spec-linked tests, evaluations and configurable checks (an AI judge) that can block a merge. |
| UnClick Proof | Current saved checks run before a change is accepted, rule changes are recorded, and cases from removed rules can enter the old-versus-new comparison, in a tested engine. |
"Write the rules first" is a real direction in 2026 and several products help teams write and check requirements; we are part of it. We have not compared them directly. Our next proof is whether this method holds up across more tasks, models and projects.
The test · 7 to 8 November 2026
Every one of its own checks passed. Same result on the repeat run.
Six of its own checks failed. Same score on the repeat run.
Two check suites, one written for each way of working, so these are two results, not one race.
Run twice from the same start. Same score on every task both times, though the AI wrote different code each time.
Neither side lost a check that passed earlier, in any run. The refusal examples elsewhere in this deck come from a separate engine test.
US$5.66 against US$4.12 the first time, US$4.72 against US$3.76 on the repeat. API cost was higher in both rounds; we have not isolated the reason.
Same AI model on both sides (Claude Sonnet 5). Four real changes to UnClick's own jobs board. Checks written before any run and never shown to the AI: 32 for UnClick Proof, 27 for plain git, same requirements in each side's own form. We wrote them ourselves, so this is an internal result from two rounds, not independent proof; wider testing is needed. Scores cover the assigned tasks; failures that existed elsewhere before the runs stayed as they were.
The honest limit
No previously passing check was lost, on either side, in any of these runs. At the normal memory setting, UnClick Proof passed all its assigned checks in both rounds.
Internal tests, 8 to 9 Nov 2026. "Less memory" here means a tighter summarisation threshold, not half the model's capacity.
From the AI's own logs: UnClick Proof's summaries were 16.3k to 19.4k tokens in run D on 9 Nov 2026. Plain git's were 9.4k to 14.9k in run C on 8 Nov 2026. Both used the same task and the same summarisation threshold (55,842 tokens). Run D tested UnClick Proof alone, after the smaller-read change.
Why this is hard to copy
Each rule says: start here, do this, expect that. A machine can check it; a person can still write it, with judgement about which cases matter. Getting both at once took most of the year.
A change that fails a current saved check is refused. Rule changes are recorded, and cases from removed rules can stay in the comparison. That friction is deliberate: it costs the demo, it buys the record.
Hidden checks, a plain-git comparison, sealed starting points, a score for what stayed working. The starting points, tasks, scoring programs and results are saved so a reviewer can examine the work.
Cross-session memory, the Boardroom where agents coordinate, tools for recording evidence, 669 apps and 1,599 actions (9 Nov 2026) through one connection. This experiment concerned our own jobs board.
Eleven months, roughly US$10,000 of AI compute in R&D, more than 1,300 merged pull requests by September 2026, and AI agents that helped build and review it.
Every result is sealed with a digital fingerprint. Anyone can rescore the saved outputs without taking our word for it; the scoring assumptions are theirs to examine. A fresh run is a new experiment.
Why now
Our opportunity: make clear what was required, what changed and what was checked, for every change. Those records can support a review. They do not certify compliance.
Sources: European Commission pages on the Product Liability Directive (2024/2853, Articles 9 and 10), the AI Act and the CRA, read 10 Nov 2026. Coverage and exclusions vary by product; this is not legal advice.
Why UnClick as a whole matters more now
With UnClick, a connected assistant can retrieve context in later sessions, from other tools and devices.
A room where AI seats hand work to each other, claim jobs, post decisions and blockers. Coordination you can read.
Evidence with each claim: a link, an id, a test result, a hash. "Done" is something you can examine, not a feeling.
Memory holds the rules, the Boardroom runs the work, receipts let it be examined, and the gate refuses a change that fails a saved check. Underneath: 669 apps and 1,599 actions (9 Nov 2026).
Where next
Agent platforms and AI-native teams. Our hypothesis: teams already running agents unattended feel the quiet break, and they can test this themselves. One partner, one unfamiliar task, the same agreed checks for both approaches.
Deal shape, if it holds: a licence.
Regulated and critical software. Finance, health, infrastructure, government, legal, science. Where a quiet regression costs more than the software, and a stated rule with a record is a procurement question. A hypothesis until a regulated buyer says so.
Reached through the platforms, not around them.
Also watching: the benchmark community. We want to publish our experiment so others can examine what it measures and what it misses.
How we got here
The idea; first build on Lovable in February. Memory, then the Boardroom, then receipts.
Code moves to a self-hosted forge. AI agents help build, review and merge.
The rules-first engine is built. A demo runs 893 automatic checks end to end. Our own jobs board is rebuilt from 416 written rules.
Eight tasks, both arms: git 8/8, UnClick 7/8. No win yet. Three fixes designed from what it showed.
Fixes built and pinned. Four tasks, both arms, twice: 32 of 32 on its own checks against 21 of 27 on theirs. Then a tighter-memory failure recorded and investigated.
Roughly US$10,000 of AI compute across the eleven months. The lesson we keep: run cheap, look, then harden only what wins.
What happens next
A two-page write-up naming the checks passed and failed, what changed, and what was not tested.
One agent platform as a pilot partner. One outside reviewer.
Questions for the pilot: whether any saved decision proved useful in a later change, how much effort the examples took to write and review, and what the reader would do next after reading a record.
Proposed: two weeks, under US$200.
UnClick Proof · the goal, in one line
You keep the rules. The AI writes the code. Every accepted change leaves a record. Let's find out what this adds to your checks.
Chris Byrne · Melbourne · chris@unclick.world · unclick.world
Take it with you
The problem, how it works, the November result, its limits and what happens next. Read it in five minutes, or give it to your AI assistant and ask it anything.
Written 18 Nov 2026. It carries the result and its limits together. A longer technical pack, with every run task by task, is available on request: chris@unclick.world