unlazy
Anti-laziness skill for AI agents. Core: the Depth Tree method, which splits a task N layers deep and gives every leaf the full time budget of the whole task, so effort multiplies with depth. Grounded in 2025-2026 research on model laziness, underthinking and premature completion.
What is it?
What it is
unlazy is an anti‑laziness skill for AI agents that enforces task completion by structuring work into a depth‑tree, writing acceptance gates to files, running those gates as executable checks, and optionally blocking the agent from ending a turn until all gates are met. It works with Claude Code, OpenAI Codex, Cursor, and any agent that can read `SKILL.md`.
Why it exists
The skill was created to counter the measurable laziness of large language models—premature truncation, under‑thinking, and incomplete multi‑part responses—by providing a hierarchy of enforcement that turns prose instructions into concrete, runnable evidence. By making completion visible and auditable, it raises effort, catches hidden failures, and ensures reliable delivery.
Who should use it
Developers and engineering teams that use AI coding agents (Claude Code, Cursor, OpenAI Codex) and need structured, verifiable task decomposition and acceptance criteria. Users comfortable with Node.js scripts, markdown gate files, and willing to invest time in setting up checks and hooks.
Who should avoid it
Beginners or users seeking quick, lightweight prompts. Those without a Node environment or who do not work with AI agents. Teams that prefer to rely on model self‑reporting rather than enforced gates.
Stars over time
+16 stars in the last 1 day
How it works
A quick walkthrough in plain English
How unlazy works
Step 1 of 3
You interact with it
Open unlazy, send a request, or connect it to your stack.
Features
Advantages
- Increases effort 1.6-3.9x baseline and fixes 4-10 self-found defects pre-delivery
- Combats model laziness by preventing premature truncation and partial compliance
- Targets invisible failures: premature done reports and confidently wrong numbers in final summaries
- Hook costs zero tokens (only a file scan)
- Checks-as-commands save tokens by replacing thousands of tokens of model re-reading with a free subprocess
- Structured enforcement hierarchy: discipline -> gates files -> runnable checks -> parent re-verification -> Stop hook
- Fresh context per leaf in orchestrated mode avoids stall-at-80-percent (end-of-long-context disease)
- Discipline mode costs only a few hundred tokens and 1.5-4x baseline output (worth it for robustness sweeps)
- MIT license, open source
Disadvantages
- Orchestrated mode multiplies cost with leaf count, only worthwhile for real builds (roughly half an hour of work or more)
- For tasks under half an hour, solo mode is advised (orchestrated mode has overhead for small tasks)
- Hard enforcement (Stop hook) is Claude Code only; other agents only get discipline mode
- Requires Node 16+ for the scripts (gates checking and hook functionality)
- Requires writing gates files and CHECK commands, which involves setup and learning the method
- Tree decomposition requires specifying depth (tree N) and may have a learning curve
Installation
native
Install via the skills CLI (works with Claude Code, OpenAI Codex, Cursor, etc.): `npx skills add Leonxlnx/unlazy`. For Claude Code manually: `git clone https://github.com/Leonxlnx/unlazy ~/.claude/skills/unlazy`. For OpenAI Codex CLI manually: `git clone https://github.com/Leonxlnx/unlazy ~/.codex/skills/unlazy`. For any other agent, use the plain‑markdown `SKILL.md` as a system prompt, Cursor rule, or preamble – gates and scripts require only Node 16+.
FAQ
How do I install the unlazy skill for my agent?
Use the skills CLI: `npx skills add Leonxlnx/unlazy`. For Claude Code manually, clone into ~/.claude/skills/unlazy. For Codex CLI, clone into ~/.codex/skills/unlazy. For other agents, paste SKILL.md as a system prompt or rule. All scripts require Node 16+.
What does the tree N command do?
`tree N` decomposes a task into N layers of work. Leaves are real units of work (10+ minutes each), branches handle decomposition and integration. Use tree 2-3 for features or bug hunts, tree 4-5 for subsystems, and tree 6-7 for whole projects built leaf by leaf with fresh-context subagents.
How does hard enforcement work in Claude Code?
The Stop hook (scripts/stop-hook.mjs) mechanically blocks ending a turn while gates are unmet. Install it with `node scripts/install-hooks.mjs` (project) or `--global` (all projects). It's a zero-token file scan. If no gate progress occurs across six consecutive blocked stops, it releases with a warning. Add .unlazy-hook-state.json to .gitignore.
What are acceptance gates and how do they work?
Gates are acceptance criteria written to files (GATES.md, gates/*.md) before work starts. Each gate has a CHECK command, EXPECT result, and EVIDENCE field. The gate-check.mjs script runs CHECK commands, flips boxes only when EXPECT matches, and records evidence. Done means the ledger is full with all evidence verified.
What is the difference between v1 and v2?
v1 was instructions-only. v2 adds structural enforcement: gates in files, runnable checks as commands, and an optional Stop hook. The v2 method was tested showing 1.6-3.9x effort increase and 4-10 self-found defects fixed pre-delivery. Prose cannot enforce prose, so v2 moves enforcement to files and hooks.
When should I use orchestrated mode vs solo mode?
Solo mode (discipline alone) costs a few hundred tokens overhead and is suitable for tasks under half an hour. Orchestrated mode multiplies cost with leaf count and is worth it only for real builds (tree 4+). Below half an hour of work, stay solo.
Featured in Videos
YouTube tutorials and walkthroughs for unlazy
Alternatives
Similar projects ranked by category, topics, and text overlap.
