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.

21 Oct 2026

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:

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

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:

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.

← All writing