Trying defuss-vae: making AI agents stop shipping slop

I've been using AI agents for coding for a while now, and I keep hitting the same problems: the agent says "done" but there's still a debug marker left behind, tests pass but nobody checks whether the docs actually match the code, or a commit goes through only for the same pattern we fixed before to creep back in.

Recently I got to try defuss-vae(vae.defuss.org), an extension for Claude Code, Codex and other agents. Its idea hits the mark for me, so I wanted to share what it's actually like.

What does it do?

In plain terms, it turns your repo's "quality standards" intodeterministic checks that actually run before a commit — not just tests, but verification, code review, and docs too. The important part: these checks are plain Python (standard library only), so they cost zero model tokens.

When a check fails, it holds the commit and hands the agent a clear next task — e.g. REMAINS: hygiene.probes with the exact file and line to fix. Once the agent fixes it and the gate goes green, the commit is allowed through.

My favorite part: lessons become permanent gates

This is the part I genuinely love — normally when an agent messes up and you correct it, it might forget next time. But defuss-vae'swrap command codifies that lesson into a new verifier rule or test, so every gate from then on checks for that pattern automatically.

Their paper describes a case where the verifier grew from 33 to 87 checks over the course of development — every new kind of slop makes the sieve denser. (It does have MEMORY.md and EPISODES.md for things no program can check, but memory is just the "second layer" — the verifier is the real deal.)

Who is it for?

• People who use coding agents seriously — if you only experiment occasionally it may feel like overhead, but if you commit often it's very worth it
• Repos with clear standards — the more rules you have (no mocks, docs required, must verify), the more value you get
• Teams that want to review only risky spots — the gate handles everything machine-checkable, so humans only read the diff that already passed

Things to know before using it

• You need your own Makefile verbs (build, test, verify) — it calls your existing tools rather than forcing a framework
• You'll write some rules in .vae/VERIFY.py yourself at first, though stack defaults are included
• If the gate keeps blocking commits, tune the rules to be reasonable — don't just turn them off, since the point is catching real slop

Summary

defuss-vae doesn't make AI write better code — it makes sureAI-written code passes the same quality gate every single time. For me, who relies on agents as my main workflow, it genuinely reduces slop — less with every commit, because each lesson becomes a permanent check. I'd recommend it if you commit often and want your repo to stay clean. It's MIT licensed too, so commercial use is fine.

Check it out at vae.defuss.organd the GitHub repo — if you try it and hit issues or want to share rules you've written, let me know in the comments.