Have you ever asked an AI agent to build something, watched it spit out a wall of code, and thought "looks done" — only to find edge cases skipped, error handling missing, and a TODO sitting right on the critical path?
Then you ask "is it done?" and it says "yes" with full confidence. You push back, and it suddenly "remembers" everything it skipped.
This isn't your model being dumb. It's a known failure mode of large models: laziness and premature completion. Models are optimized to produce efficiently, and "efficient production" often stops well before "actually done".
unlazy (2.9k stars, MIT, JavaScript) exists to fix exactly this. Its tagline: completion discipline for substantial AI-agent work, backed by runnable gates.
Don't trust the report. Verify it.
The core idea is refreshingly blunt: don't believe the agent's "done" — make it prove it with runnable checks.
unlazy asks the agent to write an acceptance ledger (GATES.md) before it starts working. Each gate is an observable, verifiable outcome — not a "completed" checkbox. Each runnable gate carries a CHECK: command and an EXPECT: expectation:
node <skill-dir>/scripts/gate-check.mjs --status GATES.md
node <skill-dir>/scripts/gate-check.mjs --approve GATES.md
node <skill-dir>/scripts/gate-check.mjs --reverify GATES.md
When the work is done, the agent doesn't say it's done — it runs the checks and lets the output speak. Its founding principle: prove results against the ledger, not against a confident completion report.
The Depth Tree
The part I like most is the Depth Tree method — unlazy's answer to "underthinking".
A normal agent takes a task and does it shallowly, once. The Depth Tree splits the task N layers deep and gives every leaf the full time budget of the whole task. Effort multiplies with depth instead of thinning out.
The result: the agent can't coast. Every leaf has its own acceptance gate; if any leaf is unfinished, the whole tree isn't done.
Why this matters now
Generation is no longer the bottleneck — every model can emit code. The bottleneck has become verification: how do you know what it emitted is correct?
unlazy turns verification from "human intuition" into "runnable gates". You don't read every line of the agent's code; you check whether the gates passed and the evidence chain is intact. For teams, that's an auditable trail for AI output — which is exactly what enterprises need before they'll trust AI-assisted development.
It pairs perfectly with loop-engineering (which I covered recently): loop-engineering designs the loop that runs the agent; unlazy designs the discipline that verifies it finished.
Get started
npx skills add Leonxlnx/unlazy
/unlazy tree 5 refactor the payment module and verify every migration path
I've localized the README, SKILL.md, and core docs to Chinese: https://github.com/yangshun2005/unlazy-cn
If you find this project useful, a star on the original repo supports the author's ongoing maintenance.
Top comments (0)