How to Use Jev With Claude to Fix Your Website

TypeSafe's System One page describes these models as “a class of AI models built to make fast, structured decisions that software can use directly,” and says plainly that they “do not write replies, produce code, or generate explanations of their reasoning.” So Jev gives you a number your code can act on, and Claude gives you the sentence that replaces the weak one. If the model itself is new to you, the overview of what Jev is and what it returns covers the answer types before you start wiring anything together.

The split matters for cost and for time. Asking a chat model to read 300 pages and write a report on each one is a long, expensive job, and you'd still have to read 300 reports. Jev answers the same few questions across all 300 pages for a few cents, which is the arithmetic further down, and you pay a writing model only for the handful of pages that turn out to need new copy.

Start with a list you trust. Pull the URLs from your sitemap.xml file, export them from your CMS, or run a small crawler across your own domain. For each URL, store the title, the headings and the body text a visitor actually reads. Leave out the menu, the cookie banner and the footer, because those repeat on every page and they drag the answers around.

TypeSafe's models page puts Jev's context at “64k tokens per request; 32k tokens for state plus the longest question,” so a very long page needs trimming before you send it. The same page lists input as “Text only. String, JSON object, or array of text values. No image, audio, or video input,” which means a page that carries its message in a picture will look thin to the model. That's worth remembering before you read a low score and blame the page.

Sending one page to Jev is a single POST request. TypeSafe's API reference documents POST https://api.typesafe.ai/v1/systemone with an Authorization: Bearer header and a body carrying state (“The content to evaluate.”), model, and questions, described as “A map of typed Question objects.” The answers come back under the keys you chose, alongside a usage object counting input and output tokens.

Three question types cover most page checks. The primitives page frames Choice as “Which of these options?”, Score as “Which level?” and Noul as “Is this true?”, which returns a value from 0 to 1. A Score needs at least two levels and the API accepts up to 10. Keep every instruction to one judgment a knowledgeable person could make in a second. Here's a request that asks three questions about a single page.

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "state": "Roof Replacement in Carmel, Indiana ... full visible text of one page ...",
  "model": "jev-latest",
  "questions": {
    "names_service_and_area": {
      "type": "noul",
      "instructions": "Does this page name both the service offered and the town or area where it is offered?"
    },
    "has_contact_path": {
      "type": "noul",
      "instructions": "Does this page give the reader a way to make contact, such as a phone number or a form?"
    },
    "clarity": {
      "type": "score",
      "instructions": "How clearly does this page tell a first time reader what the business does and what to do next?",
      "criteria": [
        "Unclear; the reader would have to guess",
        "Partly clear; the service is named, the next step is vague",
        "Clear; the service, the area and the next step are all stated"
      ]
    }
  }
}

Every question in that request shares the same state, so you pay for the page text once however many questions you attach. On thresholds, TypeSafe's Noul page says to “Use 0.5 when yes and no are equally easy to act on,” and to raise the bar when acting on a false yes is expensive. Here a false yes only puts a page on your rewrite list, so 0.5 is a reasonable place to start.

Jev hands back numbers, and your code decides what they mean. The jaggedness page for Jev 1.13 is blunt about this: “Jev is not a calculator. We strongly recommend implementing any mathematical logic in code.” Ranking and threshold checks belong in the script that made the requests. Write the results to a spreadsheet with one row per URL and read them next to the live pages.

Sort ascending by the clarity score, then lift any page that failed either yes or no question to the top. On most small business sites that top slice is short and predictable: old service pages written before you changed what you sell, a location page for a town you stopped driving to, and blog posts that never name a service at all. For the pages that land in the middle, the guide to deciding what to refresh, merge or leave alone is the better tool.

Give Claude three things: the current page text, the Jev answers for that page, and the facts the page has to state. That last part is the one people skip. Write down the services you sell, the towns you cover, your phone number, your hours and the proof you can actually back up, then ask for a rewrite that keeps every true claim, names the service and the area in the first paragraph, and closes with a clear next step. Guidance on adding proof without inflating claims is a useful checklist for that fact sheet.

Keep the volume honest while you're at it. Google's page on creating helpful, reliable, people first content puts it this way: “If the 'why' is that you're primarily making content to attract search engine visits, that's not aligned with what our systems seek to reward.” Using a model to fix a page a customer will read is editing. Using one to spin out hundreds of near identical pages is the behavior that guidance warns about, and the comparison of AI SEO and automated content production walks through where the line sits. A page that states its facts plainly also reads better to assistants, which is the argument in agent ready service pages.

Once the rewrites are live, send the new page text through the same request with the same questions and the same thresholds. Keep a small table with the URL, the date, the answers before and the answers after, so the change is visible to somebody who wasn't in the room. Pages that moved from 0.1 to 0.9 on a yes or no question tell you the rewrite landed.

A page that still fails after a careful rewrite usually means the question was wrong. The jaggedness page explains why: “A question will be answered based on the words written in the instruction, whereas a person might have read the intent.” Reword the instruction, run the batch again and compare. Each pass costs so little that rewording a question and running the batch again is an easy call.

Here's the arithmetic with every assumption labeled, so you can swap in your own numbers. Say your site has 300 pages. Say the text you send for each page, plus the three questions above, comes to 2,000 input tokens. That second number is an assumption you should check against the usage object in your first few responses, since a long page can run well past it.

300 pages at 2,000 tokens each is 600,000 input tokens, which is 0.6 million. TypeSafe's models page publishes Jev at “$42 / $0.042” per billion and per million tokens, “Charged per input token. Output tokens are free.” So 0.6 times $0.042 works out to about $0.025, roughly two and a half cents for the whole site. Checking the rewrites runs the same questions a second time, so call it five cents for the before pass and the after pass together. That page also publishes rate limits of “250,000 tokens per second / 1,200 requests per minute” and says those limits can change without notice, so read them again before you plan a large run. The real spend in this workflow is the writing model and the person reading the drafts, and both of those scale with the pages you actually change.

• Send the page and leave out the furniture. The jaggedness page warns that “Accuracy falls as the state grows with content unrelated to the decision,” so site menus, cookie notices and long footers work against you.
• Keep arithmetic in code. Word counts, averages, rankings and anything involving a threshold belong in your script, since TypeSafe tells you to implement any mathematical logic in code.
• Skip date questions. The same page says Jev “reads dates as text,” so comparing a published date against today's date is work for code.
• Ask Claude for the words. Jev 1.13 “is not trained to generate text,” so every sentence that reaches a customer comes from the writing model and then from your editor.
• A person signs off. Every page a customer sees gets read by somebody who knows the business and can catch a claim the rewrite invented.

That last guardrail carries the most weight. The typed model narrows the list and the writing model drafts the fix, while the owner still owns whatever the page promises a customer. Build the review step into the workflow from the first run, because neither model has any way of knowing that you stopped offering a service last spring.

Most owners don't need 300 pages scored on day one. Run the three questions above against your ten busiest pages, read the answers next to the pages themselves, and see whether the model agrees with what you already suspected. When the scores match your gut, widen the run. When they don't, the instruction usually needs rewording before the pages do.

If you'd like a second set of eyes on that list before you rewrite anything, the free site audit covers the same ground by hand and comes back with the pages worth fixing first.