# AI use cases for Unlazy (Leonxlnx/unlazy) Repo: [Leonxlnx/unlazy](https://github.com/Leonxlnx/unlazy) | Use cases: 3 | Page: https://dedupedai.com/use-cases/leonxlnx-unlazy/ unlazy is an anti-laziness skill for AI agents that makes them write a checkable acceptance ledger, run runnable gates, and report only what the evidence supports. This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL. - Gate a solo refactor with a verified GATES.md ledger: https://dedupedai.com/use-cases/leonxlnx-unlazy/gate-a-solo-refactor-with-a-ledger/ - Split a large task into parallel agent leaves with scoped claims: https://dedupedai.com/use-cases/leonxlnx-unlazy/fan-out-independent-tasks-to-parallel-agents/ - Block Claude Code from ending a session with unmet gates: https://dedupedai.com/use-cases/leonxlnx-unlazy/keep-claude-code-from-stopping-early/ ## How to gate a solo refactor with a verified GATES.md ledger with Unlazy Repo: [Leonxlnx/unlazy](https://github.com/Leonxlnx/unlazy) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README Turn a substantial change into runnable gates and re-check them before claiming done. **Who it is for:** A developer or agent finishing a multi-step refactor who wants evidence, not a claim, that every outcome works. **The problem:** Agents often declare substantial work complete after a partial check, and nothing records which outcomes were actually verified. **The outcome:** A GATES.md ledger where each outcome has a command and expected output, and a re-run that confirms every gate passes. ### Steps 1. Run `npx skills add Leonxlnx/unlazy` to install the skill. 2. Copy templates/gates-leaf.md to GATES.md in the project root and replace every placeholder with a real outcome, CHECK command, and EXPECT string. 3. Run `node /scripts/gate-check.mjs --status GATES.md` to inspect the ledger without executing any command. (inferred, check the README) 4. Read every CHECK command and the scripts it calls, then run `node /scripts/gate-check.mjs --approve GATES.md`. (inferred, check the README) 5. Run `node /scripts/gate-check.mjs --reverify GATES.md` and treat only a passing re-run as completion. (inferred, check the README) ### Prompt to paste into your agent ```text Use the unlazy skill in the repo to refactor . Write GATES.md from templates/gates-leaf.md with one runnable gate per outcome, then run node /scripts/gate-check.mjs --reverify GATES.md. Report the gate results, and verify that every gate is marked met before you say the work is complete. ``` ### Caveat The checker only proves the shell command you declare, so a weak CHECK line can pass while the outcome is still broken. Risk, credentials: Checks run with ambient filesystem, environment, credential, and network access, so a gate command can touch secrets or external services. Dual-use notice: only use this on software, sites and systems you own or are authorized to test. Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/ URL: https://dedupedai.com/use-cases/leonxlnx-unlazy/gate-a-solo-refactor-with-a-ledger/ ## How to split a large task into parallel agent leaves with scoped claims with Unlazy Repo: [Leonxlnx/unlazy](https://github.com/Leonxlnx/unlazy) | Difficulty: Advanced | Time: 1 hour | Basis: From the README Run independent leaves in fresh agent contexts using scoped pipelines and ownership claims. **Who it is for:** A tech lead coordinating several agents on a large change where some subtasks touch separate parts of the codebase. **The problem:** Parallel agents can overwrite each other's files, and no shared record shows which subtask owns which paths. **The outcome:** A scoped pipeline under .unlazy/ with a PLAN, ledgers, and claimed leaves, and one reduced status for the whole scope. ### Steps 1. Create a scoped pipeline under .unlazy/ with PLAN.md, GATES.md, and gates/leaf-*.md files, and give each ready leaf complete, disjoint OWNS: paths. 2. Claim each ready leaf for its scope with `node /scripts/gate-check.mjs --scope api --leaf leaf-1.2.1 --claim`. (inferred, check the README) 3. Let each agent run only the gates for its claimed leaf, sequentially by default. 4. Run `node /scripts/gate-check.mjs --scope api` to reduce the ledgers and dispatch waves together. (inferred, check the README) 5. Treat the scope as finished only when the output prints ALL MET, since an abandoned wave is a HANDOFF REQUIRED outcome. ### Prompt to paste into your agent ```text Use the unlazy skill in the repo to split into scoped leaves with disjoint OWNS: paths. Claim each ready leaf, then run node /scripts/gate-check.mjs --scope and report the reduced result. Verify that the output says ALL MET before you report success. ``` ### Caveat Lease matching is a coordination guard, not write isolation, so parallel agents can still write to the same files outside the claimed paths. Dual-use notice: only use this on software, sites and systems you own or are authorized to test. Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/ URL: https://dedupedai.com/use-cases/leonxlnx-unlazy/fan-out-independent-tasks-to-parallel-agents/ ## How to block Claude Code from ending a session with unmet gates with Unlazy Repo: [Leonxlnx/unlazy](https://github.com/Leonxlnx/unlazy) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README Install an optional Stop hook that holds the session open while gates remain unmet. **Who it is for:** A Claude Code user running a long task who keeps seeing the agent stop before its own gates pass. **The problem:** The agent can end a session while gates are still unmet, and the user only learns this after reviewing the result. **The outcome:** A Stop hook in local Claude Code settings that returns a block decision while gates or launch waves are incomplete. ### Steps 1. Run `npx skills add Leonxlnx/unlazy` to install the skill, then confirm the ledger exists as GATES.md or under .unlazy/. 2. Run `node /scripts/install-hooks.mjs` to write the hook into .claude/settings.local.json, after you consent to the install. (inferred, check the README) 3. Add .claude/settings.local.json, .unlazy/, and .unlazy-hook-state.json to the project's ignore rules. 4. Run a Claude Code session on the task and confirm the hook blocks exit while a gate is unmet. 5. Run `node /scripts/install-hooks.mjs --uninstall` when the task is done to remove the hook. (inferred, check the README) ### Prompt to paste into your agent ```text Use the unlazy skill in the repo to keep this Claude Code session on until its gates pass. Run node /scripts/install-hooks.mjs, then run the session and report whether the Stop hook blocked exit while gates were unmet. Verify that .claude/settings.local.json is listed in the project's ignore rules. ``` ### Caveat The hook's progress guard releases after six consecutive blocks without gate progress, so it will not hold a session open indefinitely. Dual-use notice: only use this on software, sites and systems you own or are authorized to test. Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/ URL: https://dedupedai.com/use-cases/leonxlnx-unlazy/keep-claude-code-from-stopping-early/