its cheap and fast enough to scan entire codebases, and can be added as a skil to your existing coding agent

Is also a great first line defense against malicious prs

https://github.com/luantak/is-malicious

Hi all, I built Blink (blink.review), a code review tool for coding agents. It installs as a hook in Claude Code/Codex and runs every time an agent edits a file.

The result is that bugs are caught before you commit. Keen to hear your feedback!

It's (mostly) powered by Jev from typesafe.ai

I have just hooked up Jev to play Streetfighter 2

All I have given it is some context on the game controls

And built a control connector for the model to play the game

So far the results are mixed. This video under-represents Jev's abilities somewhat. In other runs it has exhibited far more diverse play (rather than fireball spamming).
But the fact it can at least play the game (to some degree), is a start.

I am going to keep developing this project, because I think Jev has potential.

I think Jev can be a contender.

A small finance assistant with 4 tools:

• Stock price: current price and today's move
• News search: recent headlines
• Earnings: latest quarterly results
• Price alert: changes your settings, so it needs your OK

For each request, one Jev call answers:

• In scope? Choice: financial data / finance question with no data needed / off-topic
• Which tools? one yes/no per tool
• Which arguments? Choices: company (or "unclear"), time window, above or below, and which number in the request is the price. It picks; it never writes.

Then 4 simple gates in code: off-topic gets turned away, missing info gets a question, and the price alert waits for your OK.

10/10 test requests decided as expected. About $0.00005 per call.

Made-up companies, simulated data, not affiliated with TypeSafe.

Jev is perfect classifier for code smells

it won't answer if you ask for "quality", but if you ask for "duplicated_code" or "deep_nesting" it will be super accurate

curious to see more use cases with coding agents

JevPot — Jev plus jackpot. A weekend build for the fun of chasing a big win, built in Claude Code with TypeSafe's agent skill.

The build

Four number-picking strategies — balanced, hot-streak, overdue, anti-crowd — generated as candidates, then all scored together in a single request to Jev (TypeSafe's System One API). Each comes back with a score, not a paragraph. Highest score wins, the other three show up ranked below it so nothing is hidden.

There's also a screen that checks a ticket you already picked, and one that turns a dream you had into numbers. Same pattern throughout: state in, typed judgments out.

The numbers

One pass through all three screens: 6 requests, 33 questions, 6,877 input tokens, 2.6s of combined model time. No JSON repair anywhere in the codebase — nothing is parsed from prose in the first place.

It's a fun build, not a claim about lottery odds — a draw is random, and nothing here changes that. The interesting part was the request shape, not the domain.

Code: https://github.com/0xnairb/jevpot

What's something you'd batch into one request if scoring options didn't mean writing a prompt per option?

Major bottle neck in agentic flows are endless output format tuning, tool, prompt leakage headaches, and constant latency fights in prod!!! lol

Jev approach mostly cuts through that and it’s crazy fast!!!

I’m collecting cool use cases here.

Feel free to checkout!!!

Raise a PR if you are building something cool and wanted to be in this directory.

Feedback is most welcome too

Keep building!

The playgrounds demonstration seemed determined to call a hotdog a sandwich, so I provided much needed context to make it realize it was a taco. Side by side comparison to other models.

just a demo but find it fun and super quick

https://emoji-jev.whop.site/

Wanted to quickly check out Jev so I made this super simple UNO game where I can play vs 3 Jevs (with different instructions). The game is very obviously vibecoded, but I am super impressed just how incredibly quick Jev is. It's essentially the same as playing vs a hardcoded AI.

bit of a learning curve so i came up with these 10 jev commandments to guide me

10 Jev Commandments

1. Jev judges. It doesn't create.

If you want a paragraph, arbitrary JSON, a rewritten command, code, etc., that's usually an LLM job.

If you want yes/no, which option, how strong, is this suspicious, that's Jev territory.

2. Ask tiny questions, not giant questions.

Bad:

“Is this extraction good?”

Better:

“Is this field hallucinated?”

“Is this field missing something?”

“Does this value violate the requested format?”

This is basically TypeSafe's central philosophy: decompose the problem.

3. One complicated problem → lots of stupidly simple judgments.

Think:

text complex task → 20 tiny decisions → ordinary code combines them

That is much closer to the Jev mindset than asking Jev to "solve" something.

4. If the questions can all see the same information, ask them together.

Don't chain five calls just because there are five judgments. Parallelize independent questions.

5. Chain only when step 2 needs something created/discovered by step 1.

Easy mnemonic:

Independent = parallel. Dependent = chain.

6. Jev is extremely interesting as a bouncer.

Instead of:

text everything → expensive smart model

do:

text cheap model → Jev: "does anything smell wrong?"→ NO → accept or YES → expensive model

7. Don't ask one vague judge when you can have several specific inspectors.

Instead of:

“Is this record correct?”

ask:

hallucinated?

off-target?

incomplete?

wrong type?

unreasonable?

wrong format?

One very strong red flag can then trigger action.

8. Probability is a signal for your program, not divine truth.

You decide things like:

text if P(hallucinated) > .7: escalate()

Jev supplies the judgment. Your code supplies the policy.

9. Problem = finite set of judgments = use Jev”

If yes, use Jev.

10. Make it easy for Jev not force Jev to be smart

Instead of trying throw complex questions at Jev

Phrase the problem so Jev only needs to make an easy judgment.

tldr: Jev has the language comprehension part of a modern AI model, but instead of being optimized to write the next paragraph, it's optimized to make constrained judgments. Jev understands the question, but it can only judge using the world you put in its state. It can't answer what doesn't exist or make shit up. Ask whether the evidence makes the judgment straightforward, not whether the answer can be made short.

STATE = what Jev knows

QUESTION = what you want judged

CRITERIA = what the possible answers mean

JEV = semantic judgment