Over the past month, a tiny GitHub repository with just over 1,100 stars has quietly reshaped how I write Solidity with Claude. It's not a new model, not a plugin that extends Claude's reasoning, nor a clever chain-of-thought hack. It's a set of ten rules—a system prompt template—called 'i-have-adhd.' And its existence tells me something uncomfortable about the state of AI-assisted blockchain development: we have been optimizing the wrong layer.
I stumbled upon it while debugging a lending protocol's liquidation logic. I had asked Claude to review a batch of _getCurrentDebt calculations, and it gave me back a 500-word essay with a polite greeting, a summary of what it was about to do, and then the actual analysis buried under two layers of formality. I found myself scrolling, impatient, wishing it would just give me the code diff and the risk score. That's when a colleague sent me the link to the skill. "Try this," he said. "It'll change how you talk to the machine." He was right.
Context: What Is 'i-have-adhd'?
The skill is a Claude Code Skill—essentially a system prompt that modifies Claude's default output behavior. Its ten rules are simple: start every response with an action, never apologize, never rephrase what the user already said, avoid transitional phrases like "great question," eliminate repetitive summaries, limit lists to five items, show only the information needed for the current step, use specific numbers over vague terms, cut all greetings, and keep everything concise enough to fit a single screen. The developer, a pseudonymous user on GitHub, created it because they found Claude's default verbosity incompatible with rapid task execution. It's not a fine-tune; it's pure prompt engineering.
In the chaos of consensus, I seek the quiet truth. The quiet truth here is that this skill reveals a gap between what large language models were trained to do—be helpful, thorough, and polite—and what developers in a bear market need: speed, precision, and minimal cognitive overhead. When you're auditing a smart contract that could drain a million dollars in a flash, you don't want a soft introduction; you want the vulnerability list, the fix, and the gas impact. You want the machine to shut up and serve.
Core: The Structural Integrity of Output
Let me walk through each rule through the lens of a Solidity developer. Rule one: "Start with the action." When I ask Claude to generate a ReentrancyGuard modifier, I want it to dump the code block first, then optionally explain. That rule alone shaves 30 seconds off every interaction—seconds that accumulate into hours over a week. Rule two: "Never apologize." Apologies are noise. In a market where time-to-deploy matters, every wasted word is gas. Rule three: "Don't repeat what I said." The most infuriating habit of AI is paraphrasing my own prompt back to me. It adds no information. Rule four: "Use specific numbers." Instead of "the risk is high," say "the liquidation threshold is 85%." That's the difference between poetry and a contract.
Rule five: "Limit lists to five." Miller's Law—human working memory holds about seven items. For a developer scanning a require statement chain, five is plenty. Rule six: "Only show current-step info." When I'm deploying a contract, I don't need the tokenomic explanation from three conversations ago. Rule seven: "No transitions." "Moreover" and "furthermore" are for essays, not code. Rule eight: "Cut all greetings." "Hi, I'm Claude, I can help with that..." wastes 15 tokens every time. Rule nine: "One screen." If the output doesn't fit on a single terminal window, it's too long. Rule ten: "Be direct." The entire philosophy in one word.
From my years auditing DAO governance structures, I've learned that clarity is trust. Code is the new covenant, but trust is the ink. And this skill redefines the ink—it prints sharp, clean lines instead of fuzzy paragraphs. I've applied it to my own Claude Code setup for the past two weeks. I run a small bot that generates test suites for Solidity contracts. Previously, each test generation came with a preamble explaining the test strategy. Now it spits out the .sol file and a single line: "Test coverage: 93% branch, 87% condition." That's it. I can read it, paste it, and move on.
The deeper insight is that this skill isn't just about brevity; it's about reducing the cognitive load of reading AI output. When you're under pressure—say, during a hackathon or a last-minute audit—your brain's executive function is already taxed. Every extraneous word is a tiny tax. The skill is effectively a tax cut. It aligns the output format with the user's mental model of execution: do, then explain. Not explain, then do.
But the most interesting hidden signal is what this says about Claude's default behavior. The popularity of 'i-have-adhd' is a vote of no confidence in Anthropic's default output design. It tells them that developers—their most valuable user segment—find the baseline too polite, too wordy, too slow. This is not a bug report; it's a feature request. And Anthropic would be wise to listen. I suspect that within six months, Claude's official System Prompt will incorporate half of these rules natively. The third-party skill will be obsoleted by the platform itself. That's the life of a prompt template.
Contrarian: The Risk of Over-Simplification
Yet I must pause. There is a counter-argument that this skill, for all its elegance, introduces a dangerous blind spot. Smart contract development is not always a sprint; sometimes it is a detailed archaeological dig into opaque logic. When I ask Claude to explain a complex proxy pattern like EIP-2535, I need the verbose walkthrough. I need the historical context, the trade-offs, the known vulnerabilities. A one-screen output might truncate critical reasoning. In fact, I tested it: I asked the skill-enabled Claude to analyze a delegatecall inside a fallback function for reentrancy risk. It gave me three bullet points and a code block. The analysis was correct, but it missed a subtle edge case involving storage collisions—because it cut the explanation short before it had room to explore the cross-contract storage layout. The deficiency was not in reasoning but in output scope.
This is the risk: forcing conciseness can force shallow analysis. For routine tasks like writing a simple ERC-20, it's perfect. For security-critical code, it might mask complexity. The original developer even noted that the skill does not enhance Claude's reasoning; it only changes the output. But output constraints indirectly constrain reasoning if the model, in its eagerness to comply, truncates its own chain-of-thought. We've seen similar issues with context window limits—cutting off before the full conclusion. The skill's rigid rules could amplify that problem.
Moreover, the name 'i-have-adhd' is a brilliant metaphorical hook, but it risks trivializing a real condition. That's an ethical nuance the blockchain community often brushes aside. In a space that prides itself on inclusivity, using a diagnostic label as a feature name is tone-deaf. It might alienate users who actually have ADHD and feel their condition is being used as a product descriptor. I don't think the developer meant harm, but the name could become a liability if the skill gains mainstream adoption. I would advocate renaming it to something like 'concise-mode' or 'execution-first' before it becomes a controversy.
Takeaway: The Next Layer of Interaction Design
The 'i-have-adhd' skill is more than a convenience. It is a signal that the next frontier in blockchain tooling is not better AI models but better ways to communicate with them. We are entering an era where the interface between human intent and machine execution is the bottleneck. Prompt engineering is the new UX layer. As a protocol PM, I spend half my time thinking about how to make decentralized systems accessible to normal people. This skill taught me that sometimes the unlock is subtractive: removing the AI's noise reveals the signal. Ownership is not a receipt; it is a soul. And the soul of this skill is that it respects the user's attention as a scarce resource.
In a bear market, attention is more valuable than yield. Every second you save on code generation is a second you can spend on risk assessment or community building. I've already incorporated the ten rules into my team's internal style guide for Claude. We now write system prompts for each protocol we audit. The effect is measurable: our average time to fix a reported vulnerability dropped by 18% in the first week. That's not magic; it's discipline.
The quiet truth I leave you with is this: the best innovation in crypto this month is not a new L2 or a new stablecoin. It's a 200-line prompt that tells an AI to shut up and do its job. That should scare you—not because it's bad, but because it reveals how far we have to go in making these tools truly serve human needs. The code writes itself, but the conversation we have with the code—that is where the next covenant is forged.
