A fuzzy linter for coding agents.

Your team has rules no linter can check.

There's no regex for "this effect only derives state". So rules like these wait for code review, by a human or an agent, and every miss costs a round trip.

Here's that loop, start to finish.

40 seconds, from mistake to fix.

The editor scene is an illustrative session; the numbers are measured. Sound on.

Under the hood, it's small on purpose.

One hook. One call. Two tiers.

1. after every edit

   The hook sends only the new code.

   A PostToolUse hook in Claude Code or Codex sends the code the agent just added to TypeSafe Jev, a fast judgment model: one yes/no question per rule, in one call. A keyword gate skips rules that can't apply.

2. about 0.3 s later

   Findings go straight back.

   p ≥ 0.8 likely violations: fix these

   0.5–0.8 possible: double-check

3. never in the way

   It fails open.

   On a timeout, an API error or an unknown file type it exits silently and the edit goes through. It complements linters, type checkers and review; it doesn't replace them.

Does it work? We measured it in real agent runs.

Agents act on it.

Rule violations left in the final code, per task, with the hook off and on.

With every pack on, the drop holds: −43% (2.71 → 1.54); that baseline is higher because more rules are checked. All three drops are statistically significant. Measured 26–27 Sep 2026; method and caveats in the experiment notebook.

Fewer comments for the reviewer to send back.

With the hook on, review comments that one of our rules covers fell from 1.33 to 0.79 per task. Each is a comment the agent never has to read, work out how to fix, fix, and send back for another review.

With human reviewers the saving is direct: they never see these problems at all.

Reviews still find logic and design issues that no rule covers (about 3.6 comments per task in our tests), so the review doesn't go away; it gets smaller and cleaner. Review comments: all 170 rules, 48 Claude Code runs, 95% CI of the change −1.08 to −0.04 per task. Costs measured on our agent runs, 26–27 Sep 2026 (notebook Entries 5–7).

Fast enough that the agent never waits.

What it checks on day one.

Opinionated out of the box.

On held-out edits each pack scored 91–100% precision per language, and flagged 0–4% of clean edits. 110 of 117 new candidate rules passed; 12 of 12 new security rules passed. The rest stay candidates the hook doesn't ask. Every rule, with a good and a bad example →

test("returns 404 for an unknown user", async () => {
  const res = await app.request("/users/does-not-exist");
  expect(res.status).toBe(200);
  expect(await res.json()).toEqual({ user: null });
});

Your rules, not just ours.

• Defaults, not dogma. Turn any pack or rule off, scope it to some folders, or add rules for your team in .jev-lint/. They live in your repo, so the whole team shares them.
• Onboards itself. A skill reads your agent instructions, docs, skills and linter configs, then proposes rules for you to approve. Nothing a linter already checks.
• Learns what agents get wrong. Every check is logged. The learning skill finds the mistakes agents keep making, proposes a few targeted fixes, and measures whether they worked.

Try it on your repo.

One paste. Your agent does the rest.

Needs bun and a TypeSafe API key. Paste this into your agent from the repo you want checked.

Set up jev-lint for me: https://github.com/ckorhonen/jev-lint
Clone it to ~/Repos/jev-lint if it isn't there, then follow its jev-lint-setup skill
(.agents/skills/jev-lint-setup/SKILL.md): check my TypeSafe key, show me the dry run, install
the hook once I confirm, and run the smoke test. Then use its jev-lint-rules skill on this
repo: read all of our agent instructions, skills, docs and linter configs, and propose rules
for me to approve before writing anything.
I'm using Claude Code, so install the hook for Claude Code (--claude-only).