Proof

The goal: software that keeps its promises.

AI-made changes, checked against your saved rules.

Working name · November 2026

A request you have probably made

"Make weekend shifts fairer."
The AI does it. Which way?

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.

Reading one: fewest hours first

Alex

Fewer hours, so the next shift goes to Alex.

Reading two: fewest weekend shifts first

Sam

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

AI writes code fast.
And quietly breaks what already worked.

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.

1 in 200 By the final stage of the benchmark, only about one attempt in two hundred passed every required check, old and new

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

  • You say what matters. It becomes examples a machine can check: 10am is booked, so a second 10am booking is refused.
  • Every change is checked before it is accepted. If a current saved example fails, the change is refused at the door.
  • Rule changes go on the record. The AI can change a rule too, and the change is stated and recorded for review.
  • Every change carries a record: what was expected, what was checked, what came out.

Passing these checks does not establish complete coverage.

Left: a brick husky rebuilt badly from memory with a self-approved sticky note. Right: the same husky built against a checklist, every item ticked.

What it looks like

A new feature can work while an old one breaks.

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.

Three real tasks from the test

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

What should stay the same as your app grows?

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.

Removing a rule did not make it disappear

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

You see the decision.
You decide if it is the one you meant.

  1. BeforeThe roster has a rule: two people can take a shift, and the one with fewer hours this week gets it.
  2. The request"Make weekend shifts fairer." That could mean using weekend count only to break an equal-hours tie, or putting weekend count ahead of hours. Those are different business decisions.
  3. The changeThe AI picks one, writes the new rule, and the code to match. Every other rule is re-checked. The change to the rulebook is stated, not slipped in.
  4. The recordThe old line, the new line, who changed it, and the checks that still pass. Anyone reviewing can read the old line beside the new one and catch 'that is not what I meant' early. Whether a sign-off is required is a setup choice.

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

Three questions. The engine answers one.

1

Did this saved example pass?

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.

2

Are the examples good enough?

A person judges. Good examples take work, and useful coverage may need more cases as the app and its uses develop.

3

Is this what the owner meant?

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

A shared direction. A specific contribution to test.

ToolWhat it does, from its public guides, Nov 2026
GitHub Spec KitRequirements, plans and tasks in documents, with agent-led checks for gaps.
AWS KiroRequirements linked to generated property tests that surface failing cases.
TesslSpec-linked tests, evaluations and configurable checks (an AI judge) that can block a merge.
UnClick ProofCurrent 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

Same AI. Same four tasks. Two ways of working.

32 of 32

UnClick Proof

Every one of its own checks passed. Same result on the repeat run.

21 of 27

Ordinary coding (plain git)

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.

2×

Did it again, same result

Run twice from the same start. Same score on every task both times, though the AI wrote different code each time.

0

Earlier passing checks lost

Neither side lost a check that passed earlier, in any run. The refusal examples elsewhere in this deck come from a separate engine test.

+⅓

About one-third more API cost

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

Less working memory exposed a weakness.

  • What happened: we made the AI summarise its work much sooner. UnClick Proof could not finish one task that ordinary coding completed; three checks on the next task also stayed failing.
  • More time did not fix it. Not counting summarising time against the clock (run C) did not help. Smaller reads (run D) cut the biggest read from 52,300 characters to 8,588, but the task still did not finish.
  • What the logs show: repeated summarising triggered the tool's own stop condition. The minimum working memory the method needs is not yet measured.

What did not happen

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

Anyone can copy the idea.
The road took eleven months.

1 · Rules a machine can check

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.

2 · Refusal at the door

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.

3 · A way to measure it

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.

4 · It sits on UnClick

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.

5 · The scar tissue

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.

6 · The receipts

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

If you change the software,
keep the evidence.

Dec 2026Updated EU liability rules explicitly cover software, and what counts as relevant evidence in a defective-product claim. National implementation deadline 9 Dec 2026.
Dec 2027AI Act, high-risk uses. Specified high-risk AI uses face documentation and oversight duties from 2 Dec 2027 (regulated-product systems from Aug 2028).
Dec 2027Cyber Resilience Act. Covered digital products face secure-development and vulnerability-handling duties from 11 Dec 2027; incident reporting from Sep 2026.

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

Four things we think agents will need by 2027.
UnClick already has them.

Memory

With UnClick, a connected assistant can retrieve context in later sessions, from other tools and devices.

The Boardroom

A room where AI seats hand work to each other, claim jobs, post decisions and blockers. Coordination you can read.

Receipts

Evidence with each claim: a link, an id, a test result, a hash. "Done" is something you can examine, not a feeling.

Proof is the capstone

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).

ChatGPT, Claude, Windsurf, Cursor, Copilot and a local model seated around one UnClick table

Where next

An encouraging result and a clear limit.
Where is this useful beyond our own setup?

Beachhead · now

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.

Possible later audiences

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

Eleven months.
One week of runs produced the result.

Jan to Feb 2026

UnClick starts

The idea; first build on Lovable in February. Memory, then the Boardroom, then receipts.

Jul 2026

Our own forge

Code moves to a self-hosted forge. AI agents help build, review and merge.

Sep 2026

The engine

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.

Oct 2026

The first real test

Eight tasks, both arms: git 8/8, UnClick 7/8. No win yet. Three fixes designed from what it showed.

Nov 2026

The result, twice

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

Let someone else check the result,
then put it in front of one platform.

  1. Someone else chooses what success meansAn outside reviewer designs one fresh task and one shared scoring suite, frozen before either builder starts. Same model, memory and limits. Both outcomes published. Proposed cap: US$50 of machine cost, plus reviewer time.
  2. Rescore the saved outputsHand the sealed files, tasks and scoring programs to someone outside; they rescore 32 of 32 against 21 of 27 without taking our word for it, scoring assumptions included. About a day.
  3. Rerun the buildersSame start, same tasks, and report whether the result repeats. A new AI run is a new experiment; the score is not guaranteed. Proposed cap: US$50.
  4. A second modelSame tasks, a non-Anthropic model on both sides. Roughly US$20, unconfirmed.

Then

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

The AI cannot quietly ship a change that breaks a promise.

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.

Take it with you

The context, in plain English.
One short file.

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

1 / 19
UnClick
← → move · F fullscreen · P print to PDF