I-have-ADHD Open Source Project: Making AI State the Next Step Before Explaining Why

When Coding Agent Responses Become a Reading Obstacle

If you've used coding assistants like Claude Code or Codex, chances are you've encountered this scenario: you just asked it to fix a login error, but it responds with an overwhelming wall of text — background context at the top, a list of possible causes in the middle, and some tangential thoughts on cache optimization and test coverage tacked on at the end. By the time you finish reading, you still have to dig through all that text to figure out: what should I actually fix first?

Coding Agent Technical Background

Coding Agents are programming assistance tools built on large language models (LLMs), with notable products including Anthropic's Claude Code and OpenAI's Codex. These tools understand developer intent through natural language and generate code suggestions, debug errors, or explain technical concepts. But as model capabilities have grown, a contradiction has emerged: in an effort to demonstrate reasoning ability and provide comprehensive information, models tend to generate lengthy contextual preambles, multi-possibility analyses, and extended suggestions. This "over-explaining" actually increases cognitive load on developers. Especially in debugging scenarios where quick problem identification is needed, developers want "tell me what to do first, then explain why" — not the traditional academic paper structure of "background → analysis → conclusion."

According to a breakdown by a Bilibili creator, this is exactly the problem that an open source project called I have ADHD aims to solve. The project has already accumulated over 17,000 stars on GitHub, but what it does is surprisingly simple: it doesn't enhance model capabilities, it doesn't help you manage to-do lists, and despite having "ADHD" in its name, it doesn't diagnose whether you have an attention disorder.

ADHD and Information Processing Patterns

People with ADHD (Attention Deficit Hyperactivity Disorder) have unique information processing patterns: they're particularly sensitive to lengthy, loosely structured information and tend to lose focus during reading or need to backtrack repeatedly. But the project's name "I have ADHD" isn't actually about building a dedicated tool for people with ADHD — it borrows the concept to highlight a universal problem: in fast-paced work scenarios, everyone can exhibit similar "attention deficit" traits. When you're debugging a production issue, handling multiple parallel tasks, or reviewing code suggestions in fragmented time slots, the traditional "academic-style" response structure significantly reduces information extraction efficiency. The project essentially applies the "conclusion first" communication principle to AI interactions.

The only thing it does is change the order in which the model delivers its answers — making the AI state the next step first, then explain why.

How I-have-ADHD Restructures AI Responses

The project documentation provides a classic example: a login failure. In normal mode, the model would first analyze the authentication logic, then tack on several additional suggestions, while the actual files to modify and action steps are buried in the middle of a massive block of text, requiring you to dig them out yourself.

After enabling this Skill, the response structure changes completely: the first line tells you what needs to be added, then directly points out which file to modify. If it can be done in three steps, they're listed in order, and the response ends with an "immediate action you can take." You don't need to re-trace the model's reasoning because it has already front-loaded the most critical action items.

How the Skill Mechanism Works

In AI coding tools, a Skill is a system prompt enhancement mechanism. System prompts are hidden instructions injected into the model before the user conversation begins, used to constrain model behavior and output format. The I have ADHD project is essentially a carefully designed set of prompt rules that reshape the model's output patterns through explicit structural requirements (such as "the first sentence must be an actionable step" and "lists should not exceed 5 items"). Different tools support Skills in different ways: Claude Code loads them via startup scripts, Cursor can declare them in configuration files, and Codex supports global Skill registration. These rules don't modify model weights — they only guide the model to organize its existing knowledge in a specific format during inference, so they can be enabled or disabled at any time.

At its core, it doesn't make the model smarter — it just changes the expression order, forcefully injecting the "conclusion first" writing principle into every AI response.

Core Design Details in the Rules File

The heart of this project is really a set of readable, editable rules files, with several noteworthy details:

• Multi-step tasks must be numbered: If a task has more than one step, the model must number them in sequence to prevent you from having to figure out the order yourself.
• Resume conversations with a progress update: When continuing to the next round of conversation, it first states "where things left off," saving you from scrolling back through previous chat history.
• Rein in tangential digressions: When the model thinks of an extended topic, it holds back instead of expanding on it.
• No vague time references: It can't just say "soon" or "later" — it should give an approximate time in minutes whenever possible.

• Lists capped at five items: Usually no more than five items, to avoid information overload.
• Clear completion and error reporting: When a task is done, it clearly states what was completed; when encountering an error, it directly describes the symptoms and the next troubleshooting direction, without starting with a long apologetic preamble.

Stacked together, these rules noticeably reduce repetitive summaries, pleasantries, and tangential extensions.

Installation and Activation: Configuration Methods for Different Tools

After installing the Skill, you still need to manually enable it once in your current session. You might not have noticed that Claude Code and Codex use different invocation syntax. Once enabled, the rules persist throughout the current session; if you want to switch back to normal responses, just tell it to "restore normal mode."

The project also provides auto-loading methods: Claude Code can load these rules at startup, Codex can put them in global configuration, and Gemini CLI, Cursor, OpenCode, and other tools that support the Skill mechanism all have corresponding entry points.

However, the content creator offers a pragmatic suggestion: try manually enabling it a few times before considering auto-loading. Some rules, when enforced too rigidly, can actually cause information to be missed.

Pitfalls Worth Watching Out For

Though simple, this project isn't without controversy, and the creator honestly pointed out several issues:

The hard limit of five list items can lose information. The rules require lists to retain at most five items, but if the sixth item is also important, the model might simply drop it. People in the repository have already proposed changing this rule to "show the five most important items first, with remaining content expandable on demand" — a more reasonable compromise.

Technical Trade-offs in Rule Enforcement

There's inherent tension in forcefully applying natural language rules to probabilistic models. LLMs fundamentally generate token sequences based on probability distributions, and hard rules like "lists of at most 5 items" or "must state the conclusion first" need to impose constraints during the sampling phase. When rules conflict with the model's natural output tendencies, two problems can emerge: information truncation (e.g., the 6th important reason gets dropped) or forced padding (the model fabricates an explanation to satisfy a "must state the reason" requirement). This is why the community suggests converting hard rules into priority guidelines — "prioritize showing the 5 most important items" fits real-world scenarios better than "only 5 items allowed." An ideal rule set should be heuristic rather than mandatory, leaving the model room to flexibly adjust based on context.

Forcing error explanations can lead to guessing. Another rule requires the model to explain the cause of errors and how to fix them, but when the model doesn't have enough evidence, it might "guess a plausible-sounding reason." This concern has also been raised in the project's issues.

Windows users need to be extra careful. Claude Code's persistent scripts use Unix-like environment syntax, and there are known open issues on Windows; manual activation uses a different entry point and is relatively safer. The project also has known compatibility issues with testing on Windows.

Cross-Platform Compatibility Challenges

Cross-platform support for open source AI tools often lags behind core feature development. Claude Code's startup scripts use Bash shell and Unix-like path conventions (such as ~/.config), which work well on macOS and Linux, but Windows' PowerShell and CMD have different syntax rules, environment variable mechanisms, and path separators. While WSL (Windows Subsystem for Linux) can mitigate some issues, many Windows developers don't have WSL installed. The "known issues" mentioned by the project typically refer to scripts failing to correctly parse paths, permission settings failing, or process management anomalies. Manual activation is relatively safer because it bypasses the startup script and injects rules directly at runtime via API. For open source project maintainers, complete cross-platform support requires writing test cases and conditional execution logic for each OS — something commonly deferred in early stages.

Additionally, while the repository includes evaluation scripts, complete before-and-after comparison data hasn't been finalized, and the project doesn't yet have official version tags. In other words, it's still in a fairly early stage.

A Set of AI Response Habits You Can Customize

Taking this project apart, there's no complex program logic — the main content is just a set of response habits you can adjust yourself. If you feel five list items aren't enough, or you don't want the model estimating timeframes, you can go directly into the rules file and modify it.

This is exactly where its value lies: as large models become increasingly powerful yet increasingly verbose, many pain points aren't about "the model not being smart enough" but about "the model not knowing how to deliver answers to humans." I have ADHD uses the lightest possible approach to remind us — sometimes optimizing the AI interaction experience doesn't require changing the model, just changing the order in which it speaks.

The recommended approach is simple: find one of those long AI responses you least want to read, apply this Skill and ask again, then compare the experience. If any rule feels too rigid, just edit it directly.

Key Takeaways