GitHub's #1 Trending Author's New Claude Skill Is Insane

Unlazy: Solving AI Agent Laziness Through Verified Task Ledgers

This video from AI Labs examines a critical flaw in AI coding agents—their tendency to "slack off" on complex tasks—and presents a solution called Unlazy, a skill developed by GitHub's #1 trending author (also known for the popular "Design Taste" skill). The video explains why agents become lazy, why previous fixes fail, how Unlazy's verification system works, and includes the creators' own testing experience, including a performance bottleneck they discovered and fixed.

The Root Cause: Context Overload and Agent Laziness

The video begins by diagnosing why AI agents become unreliable on longer tasks. On a fresh context window, models perform well because there's little competing information. However, as conversations grow, the agent must process all previous messages alongside new prompts. This growing pile of context dilutes the model's attention, leading to two distinct failure modes:

• False completion: The agent claims it finished all files when it only opened a few. This is especially dangerous because unfinished work becomes the foundation for future builds, creating cascading problems.
• Silent scope reduction: When a task has multiple parts, the agent completes the easy ones and skips the difficult one—without ever mentioning the omission in its summary.

"A model that stops early with clearly unfinished work is acceptable, but when it stops early and tells you it finished everything, that's where it becomes a problem."

Why Previous Fixes Fall Short

The video reviews existing solutions and explains their structural limitations:

• The Ralph loop: Repeatedly sends the agent the same prompt until an output indicator signals completion. The flaw: the "finish line" is just text the agent writes itself—there's no objective verification.
• Claude's gold command: Uses a separate model as a judge. The flaw: the judge reads the conversation rather than the actual work, so it can drift from what was genuinely needed.
• Custom task-list loops: The creators admit their own loops had real checks, but the agent itself graded them—meaning the agent still decided when it was done.

All these approaches work in fresh contexts but falter exactly when they're needed most: deep into real work.

How Unlazy Works: The Tree and the Gates

Unlazy's core innovation is that it doesn't tell you the work is done—it proves it. The workflow operates in two stages:

1. Task Decomposition (The Tree)

When given a large task, Unlazy doesn't start working. Instead, it:

• Breaks the task into smaller tasks, then breaks each of those down again, creating a branching tree structure.
• Uses a depth number (provided by the user) to control how many times tasks split. If no number is given, it picks the smallest depth that fits.
• Enforces a rule: each leaf task must be worth at least 10 minutes of real work—small enough for focus, large enough to be meaningful. If the user's depth produces tasks smaller than this, it defaults to depth 3.

Depth also determines execution mode:

• Solo mode (depth ≤ 3): Everything runs in one session with the same agent.
• Orchestrated mode (depth ≥ 4): The skill writes a plan file with the full breakdown and a separate checklist for every task.

2. The Gates File (The Ledger)

The critical piece is the gates file, written before any work begins. This addresses a failure in the skill's previous version, which relied on instructing the agent to "be thorough"—an instruction that gets lost in long sessions. The new version stops asking and starts documenting.

Each item in the gates file is a gate, containing:

• An outcome (one thing that must be true for the task to count as done).
• A command that proves the outcome was achieved.
• The exact expected output that command must return.
• An evidence line, initially marked "pending."

The Checker: Closing the Trust Gap

The skill includes a checker that runs each command itself. If the output matches the expected text, the box is ticked and the "pending" line is replaced with the actual evidence. This closes the hole in every previous fix:

"A tick box with pending still under it means the agent ticked that box itself—which is just the agent telling you it's done all over again. So it counts as unmet, and the skill treats that as worse than an empty box, because an empty box is at least honest about where the work actually got to."

In orchestrated mode, each task goes to a fresh agent that only sees its own plan and gates file. When that agent claims completion, the main agent doesn't take its word—it runs the task's checks itself before writing a line into the plan file and handing out the next task. There's also an honest escape hatch: if a task proves impossible, the agent writes a "giving up on gate" line with the reason, which appears in the final report.

Installation and Setup

The installation process is straightforward:

1. Copy the install command from the official GitHub page.
2. Run it in the terminal within your project.
3. Select your agent (Codex needs no changes; Claude Code requires selection from a menu—multiple agents can be selected at once).
4. Choose scope: project-only or global availability.
5. Accept recommended options.

After installation, two folders appear: .agents (where the skill actually lives) and .claude (a shortcut so Claude Code can use it without duplication).

The Performance Problem and the Fix

The creators tested Unlazy on a demo app and hit a serious issue: the session ran 3–4 hours and produced only a login page. The culprit was in the skill's instructions. Both Claude Code and Codex can run multiple agents in parallel, but Unlazy's original design handed out one task at a time, waiting for completion before assigning the next. It was using agents sequentially, ignoring their parallel capabilities.

The fix: the creators modified the skill to leverage parallel execution. After the change:

• 10 agents worked simultaneously, each on a different part of the app.
• The run completed in ~2 hours with all features working as intended.
• The plan file now notes which task works with which file, preventing agents from overwriting each other's work.

For large-scale builds, the video also recommends pairing Unlazy with a model router skill, which sends simple mechanical work to cheaper models and hard parts to stronger ones, conserving API limits.

Key Takeaway

Unlazy represents a meaningful shift in how we handle AI agent reliability. Instead of trusting the agent's self-report or relying on a judge model reading the conversation, it externalizes verification into a machine-checkable ledger. The gates file with its commands, expected outputs, and evidence lines means the agent can never be the final arbiter of its own completion. The skill's design philosophy—breaking work into focused sub-tasks, documenting gates before work begins, and verifying with independent commands—directly addresses the context-overload problem that causes laziness in the first place. However, the creators' testing also reveals an important practical lesson: even well-designed verification systems need to be adapted to the parallel capabilities of modern agent tools to be practically useful. For developers working with Claude Code or Codex on multi-file projects, Unlazy offers a structured path from "trust but verify" to "verify, then trust."