Can Jev write your CV? No — here's what it does

Can Jev actually write your CV?

No. Jev can't write your CV, and that isn't a quality judgment — it's architecture. TypeSafe AI's model is transformer-based, but it isn't a language model in the sense you're used to. It never generates text token by token. You hand it some state — a CV, a job ad, a support ticket — plus questions you've defined in code, and it hands back typed answers with a confidence number attached: a yes/no probability, one choice from a set of up to 255 options, or a score on a rubric you specify. There's no paragraph at the other end. No explanation, no refusal, no bullet point. Asking Jev to rewrite your summary is like asking a thermometer for directions.

The confusion is understandable, because the headlines have been loud. Vercel's AI Gateway data, published on 15 October 2026, made Jev the fastest-adopted model in the gateway's history: roughly 13% of paid teams on day one — twice the GPT-5.6 family and six times Fable 5.1 — then about 35% within two weeks, nearly double the next most-used model, Sonnet 5.5. TypeSafe closed an $870M Series A at a $7.5B valuation on 9 October, barely three weeks after the model came out of stealth on 15 September. Vercel itself swapped in Jev to classify harmful commands. So you read "fastest-adopted model ever" and reach for your CV. Reasonable instinct, wrong tool.

One claim about Jev deserves a closer look, because you'll see it repeated everywhere: that it can't hallucinate. That's a schema guarantee, not a truth guarantee. Jev can't return a malformed or undeclared value, so the code calling it never breaks on bad output. It can absolutely pick the wrong valid answer, and when it does you get no rationale, because there's no text surface for it to explain itself on. Add the hard limits — text input only, no images or PDFs, a 32K-token context window — and the picture sharpens. My honest take: Jev reframes the question job seekers should be asking. It isn't "can this model write my CV." It's "what is this model going to decide about my CV."

So what is Jev doing in hiring right now?

Resume screening — it's one of Jev's canonical use cases. TypeSafe's own documentation reaches for a CV example to explain the model, because deciding whether a candidate clears a bar is a decision, not an essay. The pattern that has emerged in production is remarkably consistent. A full language model reads the job ad once and turns it into six to eight atomic questions: has shipped production Python, has managed a team of three or more, holds a current nursing license, has worked in a regulated environment. A decision model then answers those same questions for every CV in the pile. The expensive, creative step happens once per role. The cheap step happens once per applicant, forever.

The economics are what made this spread so fast. Jev charges roughly $0.042 per million input tokens and nothing at all for output, because there is no output text to bill. Open-source screeners built on it already do the obvious thing: paste in a job description, upload a batch of CVs, get a yes/no fit verdict and a 0–100 score for each candidate, plus a pick for best fit. Developers running these have reported 150 CVs turned into roughly 1,800 separate decisions in a few seconds for well under two cents, with responses landing in the 70–500 millisecond range. Screening every applicant properly is now cheaper than the crude keyword filter it replaces.

One design detail matters more to you than any benchmark. In the better implementations, the model doesn't write out its evidence — it selects the line from your CV that supports each answer. That's deliberate: a quote that's chosen rather than generated can't be fabricated. The practical consequence is blunt. Every claim you want credited has to sit on one locatable line, in plain language, where a machine can point at it. A skill that appears nowhere except implicitly, inside a three-line paragraph about "cross-functional delivery," has no evidence line. The answer comes back false, with high confidence, and the sentence you were proudest of never gets read by anyone.

Which AI should you use to write your CV in 2026?

Use a text-generating frontier model for the writing, and treat decision models as the audience rather than the author. For drafting and tailoring, the credible options right now are GPT-6 Astra, released on 3 September 2026 with a 1.05-million-token context window, Fable 5.1, and Sonnet 5.5. All three will restructure a bullet, compress a flabby three-line paragraph, or rewrite your experience against a job ad you've pasted in. If you want a fourth opinion, how Mistral Large 4 handles the same four CV jobs is worth a read. Jev belongs on the other side of the desk entirely — it's the thing that scores what you produce, so write for it, not with it.

Where these models genuinely earn their keep is compression and translation. Hand one a bloated bullet that already contains real numbers and it'll tighten it properly, usually better than you will at 11pm. Paste a job ad beside your experience and it'll surface the vocabulary mismatch you couldn't see on your own — that you wrote "client management" where the whole sector says "stakeholder management," or "fixed bugs" where the ad says "incident response." Where they all fail is identical and predictable. They invent metrics you never gave them. They produce summaries so generic they'd fit four hundred other candidates. And they cannot see your layout — a model reading extracted text has no idea your two-column template buried half your career.

Three prompts are worth keeping on hand. First: "Here's my CV and here's the job ad. List every requirement in the ad that my CV does not currently evidence on a single specific line. Don't rewrite anything yet." That mirrors how screening actually works. Second: "Rewrite these six bullets using only the numbers I've given you. If a bullet has no number, say so instead of estimating." That second sentence is what stops the fabrication. Third: "Turn this job ad into eight yes/no questions a screener would ask, then answer each from my CV with the exact line that proves it." If you only run one, run that one — it shows you your own file the way a decision model sees it.

How do you write a CV that survives a decision model?

Write in atomic, evidence-bearing lines. A CV that survives automated screening states one checkable fact per line, in the words the job ad uses, with the number attached. "Managed a team of six engineers across two time zones; cut release cycle from three weeks to five days" answers three separate screening questions in a single line. "Experienced leader with a track record of driving operational excellence" answers none of them, and a scored rubric will actively mark it down rather than politely ignore it. Seniority, team size, licenses, tools, years of experience and budget scope are the fields these systems ask about most often, so put each one somewhere it can be read without inference.

Then fix the part no model will warn you about: extraction. Screening pipelines take text input only, which means something upstream has already converted your PDF into a plain string — and that step is where good CVs quietly die. Two-column layouts interleave unrelated lines. Icons replace the words "email" and "phone," so your contact details disappear. Dates inside text boxes vanish. Tables scramble the order of your roles. Skills drawn as little graphic bars extract as nothing whatsoever. If you built your CV in a design tool and it looks gorgeous, open the PDF, select all, copy, and paste it into a plain text editor. What you see there is the only version being judged — so build it in a format that extracts cleanly from the start.

The third failure mode is tone, and it's newer. Reviewers have gotten fast at spotting CVs that read as machine-written: every bullet opening with the same verb, "spearheaded" and "orchestrated" three times on one page, percentages suspiciously rounded to tens, and a summary that describes a category of professional rather than a person. There's a lot of anxiety about invisible watermarking exposing AI-assisted text, and why that invisible mark won't flag your CV is worth understanding before you panic about it. The real giveaway is style, not forensics. Use AI to compress and sharpen your own sentences, then put your own vocabulary back in before you hit send.

What should you check before you send it?

Check the extracted text, then get the file scored against the specific job you're applying for. Those are two different checks, and skipping either one is how a genuinely strong candidate gets filtered out in under a second. The extraction check takes thirty seconds with copy and paste. The scoring check is harder, because you can't read your own CV the way a rubric does — you know what you meant, so you see evidence that isn't actually on the page. That gap between a fluent AI rewrite and a CV that clears an automated first filter is the entire problem, and no chat model closes it for you, however good its prose is.

That's the job HRLens does. Upload your CV for a free analysis — PDF, Word, or even a photo, with Hebrew OCR if you're applying in Israel — and the free tier returns an overall score out of 100 rated Weak, Decent, Strong or Excellent, plus five category scores covering experience, tech stack, impact and ownership, clarity and structure, and ATS compatibility. You also get your strengths and a visual layout analysis showing what your design is doing to the text. Paste the job description in as well (copy the text for LinkedIn and Indeed, which block fetching) and the analysis lists the missing skills. The $3.99 Full Analysis adds the fix list, likely rejection reasons, blind spots, hiring probability and a salary estimate.

So, the verdict in one line: Jev is the wrong tool for writing your CV and the right lens for understanding how it gets read. The workflow I'd run this month has three steps. Draft and tighten with a text model, supplying every number yourself and refusing to let it estimate. Export to a single-column file and verify the extracted text with your own eyes. Then score that file against the actual job ad before you apply, and fix what the score surfaces rather than what merely feels weak to you. New models will keep landing — jev-1.14.0 arrived on 14 October with its biggest gains in multilingual handling, which matters if you apply in both Hebrew and English. The checks don't change.

Frequently asked questions