This New Skill Finally Solves Thinking For AI Agents

0:00 Claude Code, Codex, and pretty much every other agent you use all have one serious problem, and you run into it the moment you need one of them to actually make a decision. These models can think a problem through, but they never come up with anything new. And it doesn't matter which one you're using because all of them fall short the moment you need something creative. So, when you go to them for ideas, what comes back is the safe answer, and you end up asking again and again for the angles they should have found on their own. Until you hand them those angles yourself, they won't think creatively at all. But the fix for this, weirdly enough, is actually ADHD, which is when a person's attention jumps all over the place instead of staying on one thing. And it turns out ADHD's becomes a superpower when you're an AI agent, and that's basically what we're giving them now.

0:41 There's a tool trending these days that does exactly that. And if this is your first time here, we're a software company, and this is our channel AI Labs, where we show you how to optimize your processes with AI, just like we've optimized our own. So, in this video, we're going to go over how giving your agent ADHD actually helps. Now, before we get into the tool, you need to know why you need it in the first place. If you've worked with Claude Code, Codex, or any other agent, you already know they're good at breaking the big tasks you give them into small chunks. They hand those chunks to sub-agents, so each one works in its own context window without filling up the main session. You don't even have to ask for it. They create to-do's and delegate them wherever they can, so the work runs in parallel. But all of that splitting up only happens for the work itself. None of it happens when you ask them to ideate. And if you've tried brainstorming different angles of an idea with one of them, you'd already know this pain. You ask for variations, and what comes back sounds different when you read it, but all of them are just the same idea reworded differently.

1:40 So, ideation is the trickiest thing to hand off because finding genuinely different directions is not something agents are good at. Basically, it comes down to how these models are trained. An agent reaches for the pattern that showed up most often in the data it learned from because seeing the same answer repeated is what taught it that the answer is a good one. That doesn't make its answers wrong and what you get is usually fine, but there are other angles to the problem it never even looks at, which kind of defeats the whole point of brainstorming with it.

2:08 And the safe patterns are only half of it because it also never evaluates each idea on its own. Every possibility gets worked through in the same context window, so the ideas bleed into each other and the context fills up with noise. The thinking gets worse instead of better. That's why it can't evaluate anything clearly and it ends up handing you the same idea with different wording. The ADHD skill came out fairly recently and picked up a lot of stars within a few days. And the name fits because just like actual ADHD where the thoughts are scattered all over the place, it scatters the thinking instead of running it in one straight line. So it takes ideation or really any task with a lot of possible directions and splits it across separate agents as a tree of thought. A tree of thought is basically a structure where multiple branches of sub agents work in isolation on different ideas, the same way a tree's branches split apart. Then at the end, once each branch has settled on one possibility, it brings all those ideas back together and merges them into the final answer. So it spins up multiple agents that think in their own context windows and each one gets a different framing of the same problem. They're isolated, so they share zero context and none of them know what the others are working on. But the isolation here isn't about splitting up the work, it's about keeping each idea separate so they can't influence each other. The way it keeps them apart is with frames, which are basically different lenses to look at the problem through. It has a whole frame library inside it, which holds all the different directions the agents can go in and each agent picks the frame it's going to work through. So it gets that frame's prompt along with the system prompt and the problem itself.

3:41 Then a critic agent scores everything that comes back because something has to decide which of these ideas are worth keeping. It grades every idea on three things: novelty, which is how new and creative the idea actually is. Viability, which is whether you could realistically build it. And fit, which is how well it matches the problem you're trying to solve. This grading happens in an agent of its own, running a prompt that tells it to act as a skeptical senior engineer. So, its whole job is to be hard on everything it reads. And based on the score, it decides whether an idea survives or gets thrown out. At the end, the skill shortlist the strongest ideas and goes through the trap list, which is basically the problems each idea could cause if you actually went with it. Then it prioritizes those ideas that got flagged as non-obvious. Before we actually show you interesting ways this skill actually helps, it would be great if you subscribe to the channel and hit the hype button. This small gesture of support goes a long way for us. So, that's what it's doing under the hood.

4:38 Now, let's get it installed. You'll find the command for that on the project's GitHub repo. So, you copy it, open the terminal in whichever project you're working on, and run it. It then asks which AI coding agent you want it installed for, and it supports more than 45 of them. So, you can just pick whichever one you use. After that, it asks whether it should be available only inside the current project, which is project scope, or from anywhere, no matter which project you're in. If you only need it in one place, project scope is the one to pick. But once it's done, the skill lands in a folder called .agents. That's what a lot of other agents like Codex use for keeping their configuration, but Claude code only recognizes the.claud folder by default.

5:18 So, if that's what you're using, you rename that folder to.claud and it gets picked up. When you open it, you'll see the skill sitting in there. And it's just a single skill.md file that handles everything by itself with no reference files or dependencies next to it. The instructions also push the agent hard past its first three answers. The file straight up says those first three are the most common responses in the data these models learned from, and they're also the ones any senior agent could come up with immediately. The more interesting stuff a senior agent is actually capable of only starts after those. But spinning up this many agents burns a lot of tokens, so there's a pre-check step that decides whether this skill should run at all. If you call it with the slash command or you just ask for it directly, it fires straight away.

6:01 If you didn't mention it in your prompt to call the skill directly and your agent decides to auto invoke the skill, then it runs the problem through three questions that makes up the pre-check step. The first one is whether the problem is open-ended, which basically means would someone experienced have a few different answers that all work here or just one right answer? If there's only one right answer, then thinking from multiple angles is pointless and just wastes tokens, so it stops there.

6:27 The second one is whether the stakes are actually high, which means would it genuinely cost you something if the obvious answer turned out to be the wrong one. And the third one is how you asked. If you used words like quick or standard, you're clearly after the straightforward answer, so it stops there instead of using the skill. Aside from the pre-step, you've got all the phases of the loop along with the table of frames, which become the different directions that get handed to each agent. It also lists the patterns the agents are explicitly told to avoid. But before we dive into interesting ways you can use it, let's have a word by our sponsor, TopView. If you make AI videos, you already know the pain. Every model lives on a different platform and you generate one clip at a time. TopView fixes that. It's the world's first all-in-one AI video skill and it lives right inside your coding agent, Claude, Code, Cursor, Codex. It aggregates every top model in one place, VEO, Kling, SeaDance, Nano Banana, and more. No switching platforms, no juggling subscriptions. So we tried it. We gave our agent one command, "Generate 10 variations of a 15-second TikTok ad from this product image." Seconds later, we had 10 finished ads ready to post. This is the real shift. TopView turns your agent into a video production line. You describe what you want once and it batch generates dozens of videos across different models, styles, and aspect ratios in a single session. It even auto selects the right model for the job. You go from one line of text to finished videos without ever leaving your agent.

7:51 Try TopView skill at the link in the description. So, that's it set up. Now, let's get into where this actually pays off. One place it really pays off is test-driven development, which is also called TDD, where you have the agent write the tests first. Then, it builds the app piece by piece until all of those tests pass. And writing the tests before you write the code matters like we've talked about in our previous videos. Because when all of your requirements are strictly written out as code, any change that breaks the app gets caught by the tests. The agent is forced to comply with them. And writing tests is a really good problem to hand to the skill because this is exactly where agents lack off. They don't cover all the cases they should because like we just said, they fall back on the same common answers and only write tests around those. They never look at the other paths someone could take through the app, which need to be covered, too.

8:37 You can hand one a detailed prompt on how to write tests, and you can build a specialized test author agent whose only job is writing them. But, they still fall back to the same patterns. Before you run it though, the agent needs to know what you're building before it writes anything. For that, you need to write down what needs to be built like a PRD, which is basically the document that lays out what the app is supposed to do and the problem it solves along with the goals you want to hit and who it's for. And alongside that, you should also give it a technical specification document, which locks in the technical details so you're not repeatedly telling it which tools to use. You link both of those inside your claw.md file, so it picks up that context from the very start. Then, you invoke the skill with its {slash} command, give it a prompt describing the app you're building, and ask it to write test cases using a TDD approach. Because you called it explicitly, it skips the pre-check and spins up five agents straight away. Each one goes off in its own direction of thinking using the frame that best matches the problem, and they come back with different approaches for writing the tests. Then it scores each one against the criteria we went through earlier, picks the top three, and explores those in more depth. And once all of those agents have finished, you get a detailed report of the testing directions along with their scores. The scores are written in shorthand. So, N9 means the idea scored a nine on novelty, V8 means it scored an eight on viability, and F10 means it got a perfect score on fit. Each idea also comes with a sketch of how it would be built, the risks involved, and the first steps for getting started on it. But the ideas that come back look nothing like a normal set of tests. Usually, the tests an agent writes only check that the app works correctly. But the ideas the skill gave went after way more of the edge cases, and they catch performance issues, too. So, you end up with a much stronger test suite split across three deeply explored branches, and each one is testing a different path through the application. One thing to be clear about here, though, the skill plans the tests, it doesn't actually write them. What you get back is the strategy. So, from there, you just tell the agent which direction you want, and it goes and implements that one. You can take a single direction if that's all you need, or have it implement all three. If performance is critical for what you're building, you'd want all three, but that takes a while because the agent has to work through the paths one at a time.

10:52 Once it's done, though, you can clearly see the tests are way more detailed than they would have been otherwise because the whole testing strategy got planned out in depth before a single test was written. So, this works really well before you start building since it covers most of the ground up front and cuts down the chances of breaking the app later on. But that's all for before you build. The other way to use this is as a step right before you ship. You run the skill on the app you're about to launch and ask it to evaluate the user experience. Then it flags anything that could trip people up while they're navigating the site or using the product, and anything that could push them to churn, which is basically when people stop using your product after they've already started. And churn happens a lot once your site is out there with real people using it, especially if it's a paid one. They like it at first and then leave because one feature didn't work the way they expected, so they want their money back.

11:40 And a lot of the time, it's something small that got overlooked while the app was being built, made its way into the live version, and caused problems down the line. We ran this on our own community website, and we were actually in the middle of launching a new feature. We already have a lot of members in there, so anything new has to be checked really carefully because we don't want to ship something that breaks the experience for people who are already there. So, we invoked it with the slash command, gave it the feature, and asked it to work out where people might churn and what could give them a bad experience. It started by going through the application in depth to gather context, then spun up its agents the same way, and surfaced around 30 different ideas. From those, it picked the top three and explored them further.

12:20 And once that was done, it gave us every finding graded on novelty, viability, and fit. And it caught gaps that had gone completely undetected, like features that were promised in the PRD but never actually got built, so we'd have shipped something that didn't match what we said it would do, along with a bunch of other findings. And for every one of them, it suggested a fix and listed out the traps and risks that came with it. And it works the same way as the tests here. It's not fixing anything itself, so you just hand the findings you want back to the agent and it goes and implements them. So, you get to deal with all of that before the launch instead of after it, which puts your app in a way better state by the time it actually goes public. Now, all the skills, workflows, and resources we show you in our videos are available in AI Labs Pro, which is our community. So, if you found value in what we do and want to support the channel, this is the best way to do it. The link's in the description. That brings us to the end of this video. If you'd like to support the channel and help us keep making videos like this, you can do so by using the Super Thanks button below. As always, thank you for watching, and I'll see you in the next one.