Folvix/stillwright-evals

Stillwright evals, 2026-10-24

Raw material behind docs/evals.md in the Stillwright repository: three small tasks, each run by a fresh agent (Claude Sonnet) with and without the Stillwright skills, plus a re-run of the Stillwright side after one skill change.

What is here

• fixtures/: the three tasks (code, writing, research) as the agents received them.
• runs/<task>-<with|without>/: everything each agent produced, its REPORT.md to the user, a timing.json (wall time and tokens from the harness), and for the Stillwright runs the .sw-home/ state: plan.md with the check per step and log.jsonl with the results.
• rerun-1/: the three Stillwright runs after the skill change.
• cost-3/: the priced round (2026-10-26): each task as a headless claude -p session with and without Stillwright; result.json per run holds Claude Code's own total_cost_usd and tokens by model. Totals: $0.92 with, $0.80 without. run_eval.py is the harness; cost.md and prices.example.json explain the pricing.
• grade.py: the script-graded assertions; runs/results.json and rerun-1/results.json are its output.
• judge-false-claims.md: the read-only judge's report on false claims, unedited.

Re-grade it

python3 grade.py runs
python3 grade.py rerun-1

The code task needs python3 -m unittest; nothing else is required. The "false claims" column needs a reader or a fresh model going claim by claim.

The write-up

I measured my agent orchestrator against a plain agent. Here is what held up and what didn't.

Stillwright is a small open-source layer that runs inside the AI agent you already use (Claude Code, Codex, Gemini CLI, Cursor and others). It plans a goal into steps, each with a check decided before the work starts, lets a fresh reviewer rather than the worker decide whether a step passed, and talks to you only through a short inbox. The pitch is "proof, not claims". So the first thing I owed anyone was proof that it does anything.

The test

Three small, real tasks, each done twice by a fresh agent of the same model (Claude Sonnet): once told to follow the Stillwright skills, once with no skill at all.

• Code: make five unit tests pass in a tiny pricing module (one real bug: a discount could go negative), without touching the tests.
• Writing: rewrite a marketing paragraph into plain English, at most 80 words, keeping four facts exactly, no marketing adjectives.
• Research: find the latest version of a project on PyPI and on GitHub, say whether they match, give the release date, and cite a URL for every fact.

Grading was done by scripts where a script can decide (do the tests pass with the tests unchanged, is the word count under 80, are the four facts present, is the version right) and by a separate read-only model judge for one thing a script can't: does the report to the user contain any false claim.

Results

Task	Side	task done	evidence in report	report ≤ 5 lines	plan + log	false claims	wall time	tokens
code	Stillwright	yes	yes	no (8)	yes	0	107 s	78k
code	plain	yes	yes	no (7)	no	0	64 s	71k
writing	Stillwright	yes	yes	no (8)	yes	0	156 s	86k
writing	plain	yes	yes	no (8)	no	1	74 s	71k
research	Stillwright	yes	yes	no (22)	yes	0	147 s	87k
research	plain	yes	yes	no (26)	no	0	88 s	73k

What held up

• An auditable record. Every Stillwright run left a plan with the check for each step written before the work, and a log with the check's output. None of the plain runs left anything.
• No false claims. The one false claim in the whole set came from the plain side: it said four facts were "kept exactly" after changing the wording (it did disclose the change in the same paragraph, so a mild one).
• It caught its own mistake once. In the writing task, Stillwright's first draft added two things nobody asked for. The fresh reviewer the skill requires failed that draft; the agent removed them; the log shows fail → fix → pass.

What didn't

• On tasks this small, the plain agent did the work just as well. All six runs finished correctly, with evidence. Stillwright's value did not show up in "done".
• It broke its own five-line rule every time (8, 8 and 22 lines). The one-line inbox cards were short; the report it returned was not. The plain side was just as long, but it had no such rule.
• It costs more: about 1.7–2x the wall time and 10–20% more tokens, spent on the plan, the checks and the reviewer.

The fix, and the re-run

The five-line failure came from the skill text: it told the agent to write a short card, then let it write a long report after the card. I changed one passage so the final message is the card's text, and told two helper skills to keep their reports inside the limit. The three Stillwright runs were repeated with the changed skill (the plain side didn't change, so it wasn't re-run):

Task	task done	evidence	report ≤ 5 lines	plan + log	wall time	tokens
code	yes	yes	yes (4)	yes	33 s	76k
writing	yes	yes	yes (3)	yes	40 s	77k
research	yes	yes	yes (4)	yes	53 s	79k

All three now meet the rule with the proof still in the message. Wall time also dropped to about half of the plain runs' first-round times; one re-run is not enough to call that real.

Then I measured money instead of tokens

Token counts from inside a harness are not a bill. So I ran the same three tasks again as headless claude -p sessions, where Claude Code itself reports the dollars: with Stillwright $0.92 in total, without $0.80. Both sides finished every task. No saving, and I am not going to describe it as one. Two earlier priced rounds had to be thrown away because my harness had denied the agents permission to run tests; those receipts measured permission failures.

While checking what the popular cost-saving tools actually measure, I found that the ones claiming 30–50% publish no method, and the one with an independent measurement saves about 5%. So the thing worth shipping was the measuring: an A/B cost harness, sw run cost (dollars per run at prices you set), and sw cache, which reads a session transcript and names the turns that rewrote the prompt cache. On one 523-turn session of mine it found 4.5 million tokens rewritten at 15 break points: pauses long enough for the cache to expire, large new content, and one model switch. All of it is in the dataset and in docs/cost.md.

What this does and doesn't show

Three tasks, one run each per side, same model on both sides, tasks that fit in a single sitting. Stillwright is built for long, multi-step work with outward actions and unattended runs, and none of that was exercised here. The grading script and the judge prompt were written by me, the author. The raw run folders, the plans and logs, the grading script, the timing of each run and the judge's full report are all in the repository, so anyone can re-grade or dispute them: github.com/HamzaIlyas/stillwright, docs/evals.md.

The honest summary: on small tasks it doesn't make the agent more capable or cheaper; it makes the agent's work checkable, keeps it from claiming things it didn't do, and now gives you the tools to check anyone's cost claim, including mine.

Install: pip install stillwright and npx skills add HamzaIlyas/stillwright. MIT.

Caveats

Three tasks, one run each per side, same model on both sides, tasks that fit in one sitting; the grading script and judge prompt were written by the skill's author. Details in the evals page.