# Re-checking 413 web pages with Jev: 23 needed a full read

How affiliateprogramterms.com keeps its terms current: one Jev yes/no request per page, $0.04 a refresh, and a test against Claude Haiku and Opus on 66 pages.

Published 2026-10-21 by dave8172. Page: https://quirkyagents.com/wizard/blog/jev-recheck-web-pages-affiliate-terms/

Video summary (no sound): https://pub-21da2bddd9cf4685b4374f3e9115db36.r2.dev/jev-recheck-web-pages-affiliate-terms/jev-scan-demo.mp4

[affiliateprogramterms.com](https://affiliateprogramterms.com) is my directory of affiliate
programme terms for developer and SaaS tools: commission, cookie window, minimum payout, and
whether the commission repeats. It lists 479 programmes as of 21 October 2026. Every figure was
read off the vendor's own page, and every record shows that page and the date it was checked.

Vendors change their terms, so every page has to be checked again. Checking means reading. This
post is about how **Jev cut the reading** down to the few pages that changed, and what that does
to time and cost.

## Before Jev: read every page

The pipeline has two parts. **Code** finds and fetches the pages. After the first few sweeps,
code knew where programme pages usually live: `/affiliate` led to a programme page 144 times in
1,300 tries, `/partners` 90 times, `/affiliates` 85. So code tries those paths first and fetches the page.

**A careful reader** then reads each page and writes the record. For this directory that reader
is Claude Opus in a coding session, and it reads slowly on purpose: it quotes each figure and
checks it against the fetched page. Then I check what it wrote. In one sweep on 14 September it read 181 pages to write 99
records.

That is fine for new records. For a refresh it is waste. Most pages have not changed, and the
careful reader still has to read all of them to find the few that have.

## What Jev does here

Jev is a decision model from TypeSafe. It reads text, makes the decision you ask for, and says how
sure it is. Here each decision is a yes or a no about the page.
For a refresh, code takes the record and asks Jev about the page it just fetched:

- Does the page state that the attribution window is **30 days (1 month)**?
- Does it state that an affiliate earns **30%** on a referral?
- Does it state that the minimum payout is **$50**?
- Does it say commission repeats on renewals? And, in the same request, does it say it is paid
  only once?

All questions about one page go in **one request**, and Jev charges for the page once per request,
however many questions it carries. If every answer is yes, the record keeps its figures and gets
today's date. If an answer is no or unsure, the record is flagged and the careful reader reads the
page. Jev never writes a figure. It only
decides which pages a reader looks at.

## The refresh: 23 pages of 413

A free check in code runs first: is each figure still somewhere in the page text? Then Jev asks
its questions. Here is what reached the careful reader in the last two full refreshes:

With Jev checking first, the careful reader read 52 pages on 21 September and 23 on 24 September, instead of every page.

Pages the careful reader had to read:

| Tool | Pages the careful reader had to read | Details |
|---|---|---|
| Without Jev | 413 | Every record's page, read again |
| With Jev, 21 Sept | 52 | 417 records: 332 passed, 52 flagged, 27 unconfirmed (they keep their old date), 6 pages did not load |
| With Jev, 24 Sept | 23 | 413 records: 373 passed, 23 flagged, 15 unconfirmed (they keep their old date), 2 pages did not load |

That is **8 to 18 times fewer pages to read**. The flags were worth reading: of the 23 on 24
September, 6 were real changes, such as Descript's programme, which was moving
to a new affiliate network.

The Jev part of a full refresh with every question costs **$0.04** (947,000 tokens). The whole
run takes about five minutes, and most of that is fetching pages, with a pause between requests to the same site.

## Finding new programmes: 49 pages of 161

New candidates come from sweeps, and most fetched pages are not what code hoped for. Jev asks two
questions about each: is this the vendor's own affiliate programme page, and does it state at
least one term? On a backlog of 161 pages:

Of 161 fetched pages, Jev sent 49 to the careful reader.

Where Jev's two questions sent each page:

|  |  |
|---|---|
| 61 | not a programme page: dropped |
| 46 | a programme page that states no terms |
| 27 | states terms: read and write a record |
| 22 | unsure: read anyway |
| 5 | could not read the page |

Of the 16 dropped pages that did state terms, 14 were blog posts about affiliate marketing. Jev's verdicts on that backlog cost **$0.017**.

## Could a small LLM do the same job?

Any model that answers yes or no could sit in front of the careful reader. So I gave the same
questions to Jev, Claude Haiku 5.5 and Claude Opus 5.5, on 66 programme pages whose figures a
person had already checked. Each page had questions whose right answer was yes (the record's own
figures), and questions whose right answer was no: a figure that is on the page but is not the
term. Notion's page, for example, gives a 180-day window and says the reward can be taken
back on a refund within the first 2 months, so one question asked whether the window is 60 days. 382 questions in all.

Jev answered 371 of 382 right, Opus 366, Haiku 351.

Right answers, of 382:

| Tool | Right answers, of 382 | Details |
|---|---|---|
| Jev 1.13 | 371 | 11 misses, all a no to a true figure: 9 pages sent to the reader for nothing. It said yes to none of the 83 wrong claims |
| Claude Opus 5.5 | 366 | 15 no's to true figures (15 pages to the reader for nothing) and 1 yes to a planted cookie window |
| Claude Haiku 5.5 | 351 | 29 no's to true figures (21 pages to the reader for nothing) and 2 yes's to wrong claims |

The kind of mistake matters more than the count. A **no to a true figure** costs one extra read.
A **yes to a wrong claim** lets a wrong term stay on the site with a new date on it. On this test
Jev made only the first kind.

Then speed and cost. Both are per page, with every question for that page in one request:

Jev answered in 0.31 s per page, Haiku in 1.6 s, Opus in 2.1 s.

Median seconds per page, network included:

| Tool | Median seconds per page, network included |
|---|---|
| Jev 1.13 | 0.31 s |
| Claude Haiku 5.5 | 1.6 s |
| Claude Opus 5.5 | 2.1 s |

Per 1,000 pages: Jev $0.10, Haiku $0.39, Opus $15.35.

Cost per 1,000 pages (log scale):

| Tool | Cost per 1,000 pages (log scale) | Details |
|---|---|---|
| Jev 1.13 | $0.10 | $0.042 per million input tokens; answers are free |
| Claude Haiku 5.5 | $0.39 | $0.10 per million input tokens, $0.50 per million output tokens |
| Claude Opus 5.5 | $15.35 | $4 per million input tokens, $20 per million output tokens |

So on this job Jev was **4 times cheaper and 5 times faster than Haiku**, and 158 times cheaper
and 7 times faster than Opus, with the fewest wrong answers. Two things make this a home game for
Jev, and you should know them:

- **The question wording was tuned on Jev, on these same pages**, when I built the refresh in
  September. Claude got the same words. Words tuned for Claude might close some of the gap.
- **Claude ran at low effort**, which suits a yes/no job. Higher effort may be more accurate, and
  costs more.

## What stays in code

Jev does not make the slow part faster. In a count of the sweeps on 21 September, 79% of 23,166
requests were path probes that came back "not found": there is no page there for any model to read. Code also does the unit
conversion ("6 months" is 180 days), the dates, and the free figure check. Every figure in a
record is still written by the careful reader from the page, and checked by me. Jev decides which pages that reader
sees.

The general lesson: **if most of the pages you re-check have not changed, put a cheap yes/no check
in front of the expensive read.** Ask about the figures you already hold, all in one request per
page, and send every no or unsure to the reader.

<details class="tech">
<summary>Technical details: how I measured</summary>

- **Refresh and triage numbers** come from the reports the refresh and triage tools saved on 21
  and 24 September 2026 (`jev-1.13.0`). "Flagged" is drift + review + "a field recorded as not
  stated now appears stated". Unconfirmed records (Jev saw neither direction of a yes/no) were
  not read and kept their old date.
- **Head-to-head, 21 October 2026:** the 66 cached pages whose figures a person had read, run once.
  Questions are the production strings: the two triage questions, one per stated field, and the
  opposite recurring question. Wrong figures were planted from other durations and amounts on the
  same page (cookie window and payout); planted commissions were left out because many are real
  earnings, such as a tier or a bonus. Expected: yes for the triage questions and the record's
  figures, no for planted figures and the opposite recurring question.
- **Jev:** `jev-1.13.0`, the version the directory pins because its thresholds were measured on it
  (Jev 1.14 is out; I did not test it here). Noul questions, one request per page, yes at p ≥ 0.5. Page text cut at
  40,000 characters. 152,058 input tokens.
- **Claude:** `claude-haiku-5-5` and `claude-opus-5-5`, effort low, structured output with one
  true/false field per question, same page text and question words (with each question's yes and
  no criteria written out). 231,651 input tokens each; output 5,080 (Haiku) and 4,307 (Opus).
- **Time** is wall time per request from one cloud server, network included, six requests in
  parallel. Prices are list prices on 21 October 2026. The run cost $1.05, almost all of it
  Opus.

</details>