Tari Ibaba

This Skill is a game changer for Claude Code.

The I Have ADHD Skill massively upgrades the quality and clarity of Claude’s responses by encouraging it to communicate in a much more direct, structured, and action-oriented way.

It removes all the fluff and goes straight to the point — saving you so much token costs and improving your mental model of the task at hand — which let’s you move faster and get things done.

The crucial problem it’s here to solve

AI coding assistants often answer simple questions with long explanations before getting to the solution.

That style can be useful for learning — but when you’re debugging, shipping features, or reviewing code, it creates unnecessary friction.

The “I Have ADHD” skill solves that by encouraging Claude to prioritize the next action instead of lengthy context.

How the Skill works

The skill dramatically changes how Claude structures its responses.

Instead of long introductions, it’s encouraged to:

• Start with the immediate next step.
• Break work into numbered tasks.
• Remove unnecessary filler.
• Show progress throughout a task.
• Finish with one clear next action.

You end up getting an AI that isn’t just intelligent, but also extremely easy to work with.

Why so many developers love it

The project quickly gained over 10,000 stars on GitHub within days of launch.

Because it addresses a frustration many developers have long had with AI assistants: too much explanation and not enough execution.

Whether you’re debugging, refactoring, or navigating a new codebase, concise responses reduce cognitive load and help you stay focused.

How to get started with the I Have ADHD skill

Install it easily with these commands:

JavaScriptCopied!

claude plugin marketplace add ayghri/i-have-adhd

claude plugin install i-have-adhd@i-have-adhd

Then type /i-have-adhd in a Claude Code session to activate it — all the responses will be structured according to the rules of the skill for the rest of the session:

How to use it to transform your workflow (5 practical use cases)

1. Debugging production issues

Without the skill

Plain textCopied!

There are several reasons your API could be returning a 500 error. Let's begin by understanding how Express middleware works before we explore possible causes...

With the skill

Plain textCopied!

1. Check server logs.

2. Verify DATABASE_URL.

3. Run:

   curl http://localhost:3000/health

4. Report the output.

Why it matters: When production is down, you need the next action — not a lesson.

2. Refactoring legacy code

Without the skill

Plain textCopied!

There are multiple approaches to refactoring this codebase. Before making changes, let's discuss architecture, design patterns, and technical debt...

With the skill

Plain textCopied!

Plan:

✓ Identify dead code

✓ Extract duplicate logic

□ Add tests

□ Rename interfaces

Current step:

Extract duplicate validation logic.

Why it matters: Breaking work into milestones makes large refactors feel manageable.

3. Building large features

Without the skill

Plain textCopied!

Let's build a complete authentication system. First, here's the architecture...

[Hundreds of lines covering models, JWTs, middleware, RBAC, testing, deployment, and security.]

With the skill

Plain textCopied!

Phase 1

✓ User model

✓ Login endpoint

Phase 2

□ JWT middleware

□ Refresh tokens

Phase 3

□ Role middleware

□ Permissions

Why it matters: You stay focused on one phase instead of being overwhelmed by the entire implementation.

4. Learning an unfamiliar codebase

Without the skill

Plain textCopied!

This project uses a layered architecture with controllers, services, repositories, middleware, utilities, shared modules, and configuration files...

Let's walk through every directory.

With the skill

Read these first:

Plain textCopied!

1. routes.ts

2. auth.ts

3. middleware.ts

Ignore everything else for now.

Why it matters: You can understand the project faster by focusing only on the files that matter.

5. Reviewing pull requests

Without the skill

Plain textCopied!

Overall this is a solid pull request. I noticed a few issues of varying importance, so let's review each one in detail...

With the skill

Plain textCopied!

Critical

- SQL injection risk

Important

- Missing null check

Minor

- Rename variable

Approve after fixing the first two.

Why it matters: Prioritized feedback makes reviews quicker to understand and easier to act on.

Final thoughts

You don’t just need a smarter assistant — you need an assistant that helps you get things done faster.

Sometimes the biggest productivity improvement isn’t giving an AI more knowledge. It’s simply teaching it to get to the point.

This Claude Code command is amazing.

It’s somehow like the multi-agent teams feature — but much simpler and more straightforward.

It’s perfect for those large-scale changes that can easily be broken down into smaller tasks — like mass refactoring and codebase migration.

It spins up multiple AI agents to work simultaneously across the codebase — giving you an immense boost in productivity.

Let’s look at the key features that make it so invaluable when working with Claude Code — from autonomous testing and pull requests, to how it combines brilliantly with other Claude Code commands to build a comprehensive engineering workflow.

1. Multi-agent task decomposition: ship large-scale code changes faster

The foundation of /batch is its ability to break large requests into smaller, independent units of work.

When you invoke /batch, Claude Code:

• Analyzes the repository.
• Understands the requested objective.
• Identifies logical boundaries within the codebase.
• Decomposes the work into 5–30 independent work units.

Rather than editing files sequentially, Claude distributes work across multiple agents that can operate in parallel.

For example, a framework migration might be divided into:

• Shared UI components
• Authentication modules
• Routing logic
• API integrations
• Testing infrastructure

By separating work into distinct scopes, /batch can scale far beyond the limitations of a traditional single-agent workflow.

2. The /batch and /simplify power combo

One of the more interesting aspects of /batch is how it complements Claude Code’s /simplify command.

While /simplify focuses on reducing complexity and unnecessary abstractions, /batch can coordinate improvements across an entire codebase.

The combination gives us several advantages:

• Identifies overly complex patterns at scale.
• Reduces unnecessary abstractions and indirection.
• Improves code readability and maintainability.
• Creates greater consistency across modules.
• Eliminates repetitive manual refactoring work.

Instead of simplifying files one by one, you can use /batch to coordinate the effort across dozens of components simultaneously. This makes large-scale codebase cleanup and standardization significantly faster and more manageable.

3. Git worktree isolation: parallelize without conflicts

A key feature of /batch is its use of Git worktrees.

Every subagent receives its own isolated worktree instead of sharing a single working directory.

This enables:

• Concurrent development
• Independent validation
• Isolated dependency management
• Reduced merge conflicts

Because each worker operates in its own environment, changes made by one agent do not interfere with another.

A component migration can run in one worktree while another agent updates tests or refactors utilities elsewhere in the repository.

This isolation is what makes large-scale parallel execution practical and reliable.

4. Autonomous testing and pull requests

/batch is more than a code-editing tool.

Each subagent behaves like an autonomous developer responsible for its assigned scope.

Subagents can:

• Implement code changes
• Run test suites
• Detect failures
• Fix localized issues
• Validate completed work
• Create commits or pull requests

Instead of producing one massive repository-wide change, /batch generates smaller, self-contained outputs that are easier to review and merge.

The result is less manual coordination and a cleaner development workflow.

5. Plan-first execution

Before making any changes, /batch generates a structured execution plan.

The plan outlines:

• How the task was divided
• Which files or directories belong to each work unit
• The responsibilities assigned to each subagent
• The proposed transformation for each area of the codebase

Developers review and approve the plan before execution begins.

This approval stage:

• Provides visibility into the process
• Prevents unexpected repository-wide changes
• Keeps humans in control of major modifications

Rather than blindly applying edits, /batch follows a plan-first approach designed for large-scale engineering work.

Final thoughts

Claude Code’s /batch command represents the broader shift single-agent coding assistance to coordinated multi-agent software engineering.

With key features like:

• Intelligent task decomposition
• Parallel AI execution
• Git worktree isolation
• Autonomous testing
• Pull request generation
• Human approval checkpoints

It enables repository-wide transformations at a scale that would traditionally require significant manual effort.

Software is no longer being built by a single AI agent, but now by a coordinated systems of specialized agents working together toward a common objective.

Hooks are a powerful way to add deterministic control over an AI agent.

As you know these agents can be unpredictable at times.

That’s why hooks exist — they make AI agents more predictable and reliable by enforcing critical behavior with code, instead of relying on prompts.

Hooks are scripts that run automatically at key points in Claude’s workflow — like before an external tool runs or after Claude changes a file.

Instead of relying on prompts Claude might follow or ignore — hooks let you control these things at the system level.

You can automate repetitive work that needs to happen only when the agent does something — or give Claude extra instructions only when it needs them.

Let’s look at the various ways hooks upgrade coding agents to help you build faster as a developer.

1. Dynamic context injection — give Claude the right information at the right time

Big system prompts get messy fast.

You add coding rules. Architecture docs. Security requirements. Then instructions for one small part of your codebase.

Soon Claude carries lots of context it doesn’t need at all times.

Hooks give you another option — inject information only when it becomes useful.

Say Claude starts changing /src/payments.

A PreToolUse hook could give Claude your payment security rules before it makes the change.

If Claude works on database migrations you can load your migration rules instead.

A SessionStart hook could also load GitHub issues or Jira tickets when Claude starts.

Less noise — more useful context.

2. Hard security guardrails — stop dangerous actions before they happen

❌ “don’t run dangerous commands”

❌ “don’t expose secrets”

These are not things you should put in prompts.

Use hooks.

A prompt tells Claude what you want it to do — a hook can control what it actually can do in the real world.

A PreToolUse hook can inspect an action before Claude runs it. If the action looks unsafe according to your specifications, the hook can block it.

You can block commands like rm -rf or force-pushing to main. You can also protect .env files and API keys.

You don’t need to trust Claude to remember the rule every time — your system enforces it.

3. Enforce engineering standards — catch bad code before you review it

Claude can write code quickly.

But you don’t want to keep saying “run the tests” or “check the linter.”

Hooks can do that work automatically.

A PostToolUse hook can run your tests whenever Claude changes source code.

If something fails the hook can send the error back to Claude — Claude sees what broke and can try to fix it.

The workflow becomes:

Claude changes code → tests run → something fails → Claude fixes it.

You can use this for testing, linting, type checking and other quality checks.

You define the rule once — Claude follows it automatically.

4. Automatic code formatting — don’t waste AI time on formatting

Formatting is another job you probably shouldn’t give to the model.

You don’t need Claude thinking about spaces and indentation when tools already handle that well.

A PostToolUse hook can run Prettier, Black, or gofmt whenever Claude changes a file.

That means cleaner Git diffs and fewer formatting problems during review.

It also saves prompts — you don’t need to keep asking Claude to fix imports or indentation.

Claude solves the engineering problem — your formatter handles formatting.

5. External tool orchestration — connect Claude to the rest of your workflow

Hooks can run normal system commands.

So they can connect Claude to other tools you already use.

Say Claude spends 20 minutes working on a task — you don’t need to watch the terminal.

A hook could send you a Slack or Discord message when it finishes.

You could also use hooks for voice updates, human approvals, audit logs and cost monitoring.

You can even track token use and stop a session when it reaches a set limit.

Claude does the work — hooks handle what happens around it.

Hooks mean less failure and more reliable automation

Claude Code hooks let you move important rules out of prompts and into your development environment.

Security rules can block actions. Tests can run themselves. Context can appear only when Claude needs it.

Formatters can clean up files. Other tools can react when Claude finishes work.

Instead of constantly telling Claude what to do — you build a system that keeps it on track.

That means less babysitting. Fewer repetitive prompts. Faster feedback.

And much more predictable AI-assisted development.

grill-me has been one of the most transformative skills in the AI coding ecosystem.

It’s a powerful skill that turns Claude Code into an interviewer to poke holes in your assumptions and find flaws in your thinking.

It reveals blind spots, catches subtle problems and helps you make better technical decisions.

It gives you a deeper understanding of your overall development process, and improves the overall quality of your code.

Let’s look at the key features that makes it such a valuable part of your workflow.

1. Inverted roles — find blind spots before you build

There is a problem with asking AI to review your work — you still need to know what to ask.

If you forgot about concurrency then you may never ask about concurrency.

/grill-me solves this by taking control of the questions.

Say you tell it that users upload files before you add a processing job to a queue. It might ask:

What stops the same upload from being processed twice?

This is an important edge case you might have never thought of.

Your answer gives it somewhere new to dig.

Which parts of the processing pipeline are actually idempotent?

You are no longer asking AI to confirm your design. You are defending it — which can expose crucial missing requirements before you spend hours building the wrong thing.

2. Socratic pressure testing — catch problems before production

A good grill does more than run through a checklist. It questions the assumptions behind your answers.

It looks for the parts of a design that seem obvious but have not been fully thought through.

This can uncover race conditions and security risks. It can also find weak retry logic or scaling limits that normal AI conversations may miss.

The benefit is clear — you find failure cases during design instead of finding them at 2 a.m. in production.

3. Dynamic pressure testing — make better technical decisions

/grill-me doesn’t follow a fixed list of questions. It changes direction based on your answers.

A strong answer can move the conversation forward. A vague answer gives the AI a reason to dig deeper — especially when your reasoning depends on an assumption you haven’t proved.

This pushes developers to turn vague ideas into clear technical decisions.

It also makes those decisions easier to explain later. You have already had to think through the tradeoffs and defend why your approach works.

4. Customizable personas — get expert review on demand

You don’t always need the same kind of review.

A friendly grill can act like a senior engineer helping you spot things you missed. A tougher one can challenge every weak assumption you make.

You can also change who is doing the grilling.

Ask for a security engineer and the questions can focus on authentication or trust boundaries. Ask for an SRE and the focus can move to outages and recovery. A database expert can dig into indexes and transactions.

It gives developers another set of eyes without waiting for the right expert to become free.

5. Context-aware scrutiny — get feedback on your actual code

Generic architecture questions only go so far.

/grill-me becomes much more useful when it can read the project itself. It can use your code and specs to understand how the system really works.

That makes its questions specific to your project rather than based on textbook problems.

It also saves developers from explaining everything from scratch. The AI can find facts in the project — while the developer focuses on explaining and defending the decisions behind them.

A sparring partner — ship with fewer surprises

AI has made writing code much faster.

It has not made bad assumptions cheaper.

In fact AI agents can turn one bad assumption into thousands of lines of convincing code very quickly.

/grill-me adds friction before that happens — the useful kind.

Attack the idea before implementing it. Find the failure cases before users do. Question the assumptions before they turn into technical debt.

AI coding agents are great — until they go down the wrong path.

Maybe Claude Code changed five files before you noticed the problem. Maybe the first idea was wrong — and every prompt after that made things worse.

You could use Git to clean things up…

But Claude Code has a much faster option for this kind of trial and error: /rewind.

It lets you return to an earlier checkpoint quickly. But it does a lot more than just undo code.

1. Multiple restore options let you keep the exact parts that worked

When you run /rewind and pick a checkpoint, Claude Code gives you three restore options.

Restore Code and Conversation takes both your files and chat back to that point.

Use this when the whole attempt went wrong. You can throw away the bad code and the reasoning that led to it.

Restore Code Only is more interesting.

Claude puts the files back but keeps the current conversation. So Claude can still know what it learned during the failed attempt — even though the code itself is gone.

Maybe it found an edge case. Maybe it learned that an API works differently than expected.

You can keep that knowledge and try a better approach.

Restore Conversation Only does the opposite.

Your changed files stay in place. But Claude’s conversation goes back to the earlier checkpoint.

This works well when you like the code but the chat has become messy. You get a cleaner starting point without losing the work already sitting in your files.

So /rewind isn’t just undo — it lets you choose which state you want to keep.

2. Context summaries keep long coding sessions useful

The /rewind menu isn’t only about undoing things.

It also has “Summarize from here” and “Summarize up to here” for when the context gets long.

These options don’t change your files.

Instead they compress parts of your conversation into a shorter summary. This helps when a long coding session starts filling Claude’s context window.

Maybe you spent 30 minutes debugging an approach that didn’t work.

Claude doesn’t need every message from that process. It may only need to know what you discovered.

You can summarize that section and keep moving.

So /rewind is also a context management tool — not just a recovery tool.

3. Restored prompts make it faster to fix a bad instruction

Claude Code also saves you from retyping your prompt.

When you restore conversation state, it puts the original prompt from that checkpoint back into the input box.

Claude Code restores the original prompt on rewind:

Say you originally wrote:

Refactor the payment service so retries happen at the transport layer.

Claude tries it. You inspect the result and realize your prompt was too vague.

Rewind and the prompt comes back. Now you can edit it with clearer rules and try again.

The workflow becomes simple:

Prompt → Try → Inspect → Rewind → Edit → Try Again

It’s a small feature — but it makes experimenting much smoother.

4. Automatic checkpoints let you experiment without managing Git

Claude Code creates checkpoints as it edits files.

This works separately from Git. You don’t need to make a commit before every experiment or create temporary branches just so you have somewhere to return to.

You can ask Claude to try something.

Don’t like it? Rewind.

Then try something else.

This doesn’t replace Git. Git still gives you long-term project history and branches.

/rewind solves a smaller problem — quickly recovering from Claude’s changes while you’re working.

5. Key limitation to be aware of

There is one big limit.

/rewind tracks changes made through Claude’s file editing tools. It can’t reliably undo side effects from shell commands.

Think about commands like:

ShellCopied!

rm file.txt

mv old/ new/

npm install

The same warning applies to database migrations and deployments.

If Claude runs a migration that changes your database, /rewind can’t magically return that database to its old state.

So don’t treat checkpoints as a full backup system.

They are a safety net for Claude’s tracked edits.

And that’s what makes /rewind useful.

You can try an idea. Keep what Claude learned. Throw away what didn’t work — then take another shot.

As coding agents make bigger changes to our projects, being able to recover quickly may matter almost as much as getting the first attempt right.