GitHub's #1 Trending Author's New Claude Skill Is Insane
AAI LABS
Computing/SoftwareInternet Technology
Transcript
00:00:00There's a fundamental problem with AI models. Whenever you give them tasks, they never take
00:00:04ownership of that task. And this is why we always have to review the agent's output because we
00:00:09cannot trust it. But this laziness problem just got solved. So GitHub's number one trending author
00:00:15has a solution for this. And this is the person who also made the design taste skill, which is
00:00:20one of the most popular design skills out right now. He has built a new skill called Unlazy that
00:00:25solves this exact problem in AI agents. The workflow behind Unlazy is really creative. But
00:00:31after running it ourselves, we came across a huge problem with how slow it was and we found a way to
00:00:36fix that as well. Now, if you're new here, then welcome. We're a software company and this is AI
00:00:41Labs. In this video, we're going over what Unlazy is, how it actually works, the problem it has and
00:00:46the change we made to fix it. Now, laziness is a problem that basically shows up no matter which
00:00:51model you're using, even the most powerful ones like Opus and GPT 5.6. It just becomes easier to
00:00:57notice in the smaller models because they have far fewer capabilities and their limitations become
00:01:02obvious much faster. And Unlazy is built to fix exactly that. This skill forces the agent to stop
00:01:08being lazy with its inbuilt mechanism and deliver what you actually need. And the main idea behind it
00:01:13is that it doesn't tell you the agent is done, it proves it. It checks the work against a ledger,
00:01:18which is basically a checklist where every item has to have proof that it's actually done. So instead
00:01:23of just telling you the work is complete, it shows you the proof for every part of it. And it works
00:01:28with all the popular agents like Claude Code, Codex and more. But to understand why this skill matters,
00:01:34you need to know what happens without it and how adding this one solves that problem. But before we
00:01:39go deeper into it, it would be great if you subscribe to the channel and hit the hype button. This small
00:01:44gesture of support goes a long way for us. Now before actually exploring the skill, we need to
00:01:48understand why the agents get lazy in the first place. Now on a fresh context window, you might not
00:01:54notice that at all. There's barely anything in there yet, which is why the model can focus way better
00:01:59on the task you gave it. But it will be more visible as the context fills up. Now these models don't have
00:02:04any inbuilt memory, so they actually don't know what happened in the previous message you sent. So how does it
00:02:09know what happened before? These agents send all of the previous messages along with your new prompt, so the model
00:02:14knows what has already happened. But as you send more and more messages, that pile keeps growing, and there's a lot
00:02:20more for the model to pay attention to at one time. And this is exactly why the agents aren't able to focus as
00:02:26clearly on each part of the task, and just slack off while they're working through it. And this laziness happens in two
00:02:31different ways. The first is that the agent tells you it's done when it isn't. There's been many times when you ask Claude
00:02:37code to work through many files, it just opens a few instead of actually looking at all of them and reports that
00:02:42it went through everything. And that's the part that actually costs you. A model that stops early with
00:02:47clearly unfinished work is acceptable, but when it stops early and tells you it finished everything, that's where
00:02:52it becomes a problem. You don't actually know if it's completed until you verify it yourself. So if you
00:02:57don't, and you build more on top of that unfinished work, you're going to run into problems in the long run.
00:03:02And the second is that it shrinks the job without telling you. So for example, you ask for something
00:03:06that has five parts to it, and one of those parts is difficult. It builds the four easy ones and skips
00:03:12the hard one. And the summary you get at the end never mentions anything's missing. Now you might be
00:03:16thinking this isn't a new problem, and you'd be right, because these problems have always been there
00:03:21with these agents, and people have been building fixes for them for a long time. You probably already know
00:03:26about the Ralph loop. That one keeps sending the agent back the same prompt again and again until an indicator in its output
00:03:33says the task is done. And there's also Claude's goal command, which uses another model as a judge. And we've built
00:03:39loops like this ourselves too, where a task list held the checks that every task had to pass. But all of these have a
00:03:44limit to them. With Ralph, that finish line is just a bit of text the agent writes while it's working, but a lot of tasks
00:03:50can't be judged by a finish line. There's no single word that tells you a feature is actually built properly.
00:03:56And the goal command uses a smaller model that reads through the conversation to decide whether the work
00:04:02is finished. So it's judging by what the conversation says instead of the work itself, and it can drift from
00:04:07what you actually needed. And with our own loops, those checks were real, but it was the agent itself that
00:04:12graded them, so it was still the agent deciding whether it was done. And they can all work really well
00:04:17when your context window is fresh. But once you're deep into real work, they start to falter. And that's
00:04:22exactly the point where you need them to hold. But before we show the whole workflow that fixes these
00:04:26problems, let's have a word by our sponsor. Data for SEO. If you've vibe-coded an SEO tool or marketing
00:04:33dashboard, you know it's only as good as the data behind it. And real SEO data usually means an expensive
00:04:39monthly subscription before you've even shipped. Data for SEO fixes that. It's one of the top SEO data
00:04:45providers in the world, with over 10 APIs covering everything from keywords and backlinks to competitor
00:04:51reports and AI search visibility. In their dashboard, there's an API playground. We typed in a keyword
00:04:56and fired off one request, and seconds later had the search volume and top-ranking pages in front of us.
00:05:02Then it handed us the code we plugged into the app, and our dashboard was pulling live ranking in under
00:05:06a minute. Setup took under five minutes. The pricing is where it really wins. There's no subscription,
00:05:11and you pay as you go per request, so cost scale as you grow. Plus real human support around the clock,
00:05:17not a bot. Normally you'd start with a $1 trial, using our link bumps that up to $5 in free credits.
00:05:23Go build with it the links in the pinned comment. Now before we show you how to set this up, let's look
00:05:27at what's actually going on underneath, and how that solves the problem. So when you give this skill a large
00:05:33task, it doesn't start working on it. It breaks that task into smaller tasks first, and then it takes each
00:05:38one of those and breaks it into smaller tasks again. So the whole thing branches out, one task turning
00:05:44into a few, and each of those turning into a few more. And that's why it's called a tree. And once it
00:05:49stops splitting, every small task at the end gets handed off to its own sub-agent. And you're the one
00:05:54who controls how many times that happens. So when you write your prompt, you say you want to use the
00:05:58skill, and you give it a number along with it. That number is the depth of the tree. So if you say
00:06:035, the task gets broken down 5 times over and no further. And if you don't give it a number at all,
00:06:09it picks the smallest one that fits what you asked for. Now the reason it does any of this goes straight
00:06:14back to that attention problem we just mentioned. When the work is broken up like this, each task has
00:06:19one clear goal, and the agent working on it isn't carrying the rest of the job around with it. But those
00:06:24tasks can't be too small either. The rule the skill gives is that each one should be worth at least 10
00:06:29minutes of real work, because it has to be a proper piece of the job that an agent can pick up and
00:06:34finish on its own. So if you set that number too high, and the tasks come out smaller than the 10
00:06:39minutes of work, the skill lowers the split task to the default number which is 3. And that number also
00:06:45decides how the work runs. 3 or under is what the skill calls solo mode, and that's the default.
00:06:51Everything stays in one session, and the same agent works through all of it. But 4 and up switches it
00:06:56into orchestrated mode, and that's where it writes a lot more of it down. It writes a plan file that
00:07:02holds the whole breakdown, and then a separate checklist for every single task in it. And the
00:07:06reason it writes that down in a file comes from how the previous version of this skill failed. That one
00:07:11tried to fix laziness by telling the agent to be thorough. But an instruction is the first thing to
00:07:16get lost in a long session, which is the exact problem it was trying to fix. So this version
00:07:21stopped asking and started putting it in a file before any work begins. That file is the gates
00:07:26file, and it's the ledger we mentioned at the start. And every item in that file is called a gate. So
00:07:32each gate is a checkbox with an outcome written next to it, which is one thing that has to be true
00:07:37before the task counts as done. And underneath that outcome there are three lines. The first is the
00:07:42command that proves that outcome has been achieved. The second is the exact words that command has to
00:07:47give back. And the third is the evidence, which starts out just saying pending. Then the skill
00:07:52comes with a checker, and when you run it, it goes down that file and runs every one of those commands
00:07:57itself. If the answer that comes back has the words the gate was expecting, it ticks the box and it
00:08:02replaces that pending line with the bit of the answer that decided it. And that evidence line is what
00:08:07closes the hole in every fix we listed earlier. A ticked box with pending still under it, it means
00:08:12the agent ticked that box itself, which is just the agent telling you it's done all over again. So it
00:08:17counts as unmet, and the skill treats that as worse than an empty box, because an empty box is at least
00:08:23honest about where the work actually got to. And that same rule is what keeps the bigger runs honest.
00:08:28In orchestrated mode, it hands one task to a fresh agent, which only gets the plan and its own
00:08:33gates file, nothing about the rest of the job. But when that agent comes back saying it's finished,
00:08:38the main one doesn't take its word for it and runs that task's checks again itself. And only then
00:08:43does it write a line into the plan file and hand out the next task. And there's an honest way out,
00:08:48because sometimes a task turns out to be impossible. So instead of the agent dropping it and saying
00:08:53nothing, it writes a line giving up on that gate by name with the reason and that goes into the report
00:08:58you get at the end. So unlazy is a whole system rather than a single check at the end. And at no
00:09:03point in it does the agent get to decide whether the work is done. Now to actually use the skill,
00:09:08you need to install it first. So you go to their official GitHub page and look for the install
00:09:13section and that's where you copy the command from. You can get the link from the description below.
00:09:17After that, you open the terminal inside the project you're working on and run it. And once you run it,
00:09:22the installer starts and the first thing it asks is which agent you're using. If you're on Codex,
00:09:27you don't need to change anything there because it installs into the .agents folder that Codex already
00:09:33reads from. But if you're on Cloud Code, you select it from the menu that opens and you can pick as many
00:09:38of the others as you want at the same time. Then it asks you to choose the scope, which is basically
00:09:43whether this skill should only work inside the project you're in right now or whether you want
00:09:47it available in everything you build. We went with the project scope because we wanted to test it
00:09:52against one specific project first. After that, you go with the recommended options and that's the
00:09:57install done. So when you open that project in VS Code, you'll see two new folders, one called .agents
00:10:02and one called .clawed and they're not two separate copies of it. The skill itself actually lives in
00:10:08the .agents folder and the .clawed one is just a shortcut to it so that Claude Codex can
00:10:12also recognize it and use it without having duplicates in the same project. Now inside that
00:10:17folder, the skill file is the one holding all the guidance for the agent on how to use this.
00:10:23And once that's done, the skill is installed and you're ready to start using it. But before you do,
00:10:28there's one thing you need to know. If you run this skill exactly as it is, it takes a really long
00:10:33time to get anything meaningful built. We found that out testing it on an app. That session ran for
00:10:37around three to four hours straight. And when we checked the progress, there was just a login page and
00:10:42nothing else. Since we went through the skill, we found that the problem was in its instructions.
00:10:47Both Claude Code and Codex can run several agents at the same time and each sub-agent can work in
00:10:52parallel on a different task. But this skill hands out one task, waits for it to complete and only then
00:10:57hands out the next one. So even though it was running agents, it was not using these agents
00:11:02capabilities to full extent and that's where all those hours went. So we opened the project back
00:11:06up and changed the skill itself. And you can pause here and copy the prompt we used if you want to
00:11:11change it yourself. What it does is get the skill to actually use the fact that these tools can run
00:11:16several agents at once. Then to run it, you type the skill name, then the depth of the tree,
00:11:21and then you write out everything you want built. Since we were building this demo app from scratch,
00:11:25we went with five. But you pick that number based on the size of your own task. If you want to work
00:11:30on a feature rather than a whole app in one go, two or three would be enough for you. And you don't have
00:11:35to worry about selecting the wrong option because if you picked higher than needed, it will automatically
00:11:40lower the depth for you. And the first thing it does before it builds anything is writing the plan.md
00:11:45file and then the gates.md file. In the plan.md, it also mentions which task is to work with which
00:11:51file so that if two agents are working at the same time, they don't overwrite each other's work. Then
00:11:56it lays the foundation and starts handing the work out to the agents all running at the same time. And
00:12:01with those fixes in, 10 agents were working at once, each on different parts of it. That run went for nearly two
00:12:06hours. At the end, we got the first version of our demo app running with all the features working
00:12:11exactly as we wanted. And if you're building at this kind of scale, you can also pair this with
00:12:16a model router skill. That's basically one that sends each task to the right model for it. So the
00:12:21simple mechanical work goes to a cheaper model and the hard parts go to the strong one so that it
00:12:26doesn't hit your limits soon. Now this skill we used here was built through multiple rounds of testing
00:12:31and refining. If you want this skill, you can get that in AI Labs Pro, which is our community.
00:12:36So if you found value in what we do and want to support the channel, this is the right way to do
00:12:40it. The link's in description. That brings us to the end of this video. If you'd like to support
00:12:44the channel and help us keep making videos like this, you can do so by using the super thanks
00:12:49button below. As always, thank you for watching and I'll see you in the next one.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video