i-have-adhd & Ponytail: 2 Trending Agent Skills (2026)

"i-have-adhd" (ayghri/i-have-adhd) and "ponytail" (DietrichGebert/ponytail) are Agent Skills you install on top of coding agents such as Claude Code, Codex, and Cursor, and as of September 2026 both have been trending heavily on GitHub's weekly charts. i-have-adhd reshapes the agent's output structure: instead of burying the answer under a preamble and background explanation, it forces the agent to lead with the next action, number multi-step work, and restate progress. Ponytail instead reshapes the agent's coding judgment: under the instruction to "think like the laziest senior developer in the room," it makes the agent first question whether a feature is even needed, prefer reusing existing patterns and standard libraries, and suppress unnecessary code additions. Neither swaps out the underlying model — both change behavior purely through instructions (a Markdown behavior-rules file the agent reads).

By GitHub Trending's weekly star-gain metric, i-have-adhd added +16,740 stars and ponytail added +8,444 stars in a single week; as of September 14, 2026 their cumulative totals stand at roughly 44,300 and 137,300 respectively (measured via the GitHub API; both repos are MIT-licensed). i-have-adhd's repo was created on May 13, 2026 and ponytail's on June 12, 2026 — both reaching this scale in under six months. The backdrop is that as coding agents increasingly run long, autonomous tasks, two complaints surfaced at once: "I can't tell what I'm actually supposed to do next" and "it wrote code I never asked for." The two skills gained traction as targeted fixes for each complaint respectively.

i-have-adhd is an Agent Skill focused specifically on not letting the agent bury its answer. Its README and SKILL.md lay out five premises drawn from ADHD-related cognitive traits: (1) working memory is small, so anything off-screen gets forgotten; (2) there's friction between knowing what to do and actually doing it, and that friction is what kills follow-through; (3) starting requires an obvious, small first step; (4) vague time estimates ('some work') feel indistinguishable from each other; and (5) since dopamine is scarce, visible progress matters.

- Put the answer on the very first line — conclusion, command, or path up front
- Number multi-step work, with exactly one bounded action per step
- Restate current state every turn ("3 of 5 steps done")
- Give concrete time estimates ("15 minutes"), never vague ones
- Make wins visibly concrete (countering dopamine scarcity)
- State errors matter-of-factly — cause and fix, no alarm language
- Cap lists at 5 items; group the rest and expand only on request
- Cut intent-announcing preambles and "let me know if anything else" closers

Ponytail is an Agent Skill built around making the agent "think like the laziest senior dev in the room." The repo's own tagline is: "The best code is the code you never wrote." It triggers on words like "ponytail," "be lazy," "lazy mode," "simplest solution," "YAGNI," and "do less," and applies only to coding tasks — writing, refactoring, fixing, reviewing, or designing code. Before writing anything, it works down a 7-rung decision ladder, stopping as soon as a higher rung resolves the need.

Ponytail exposes three intensity levels. "Lite" builds what was asked but suggests a lazier alternative alongside it. The default "full" applies the decision ladder strictly and aims for the smallest diff. "Ultra" is YAGNI-extremist and questions the requirement itself. Default intensity is configurable via the PONYTAIL_DEFAULT_MODE environment variable or the defaultMode field in ~/.config/ponytail/config.json. At every intensity, though, the skill spells out non-negotiables it will never simplify: input validation, error handling, security, accessibility, explicitly requested features, and domain-specific tuning (e.g., hardware calibration). Deliberate shortcuts must be flagged with a ponytail: comment naming the ceiling it hit.

Both are distributed through the Agent Skills mechanism: a Markdown behavior-rules file (SKILL.md) the agent loads and activates via an explicit command (i-have-adhd: /i-have-adhd) or trigger word (ponytail: "be lazy," etc.), with no fine-tuning of the underlying model involved. i-have-adhd's SKILL.md is organized around "10 core rules" plus a pre-send checklist that instructs the agent to delete intent-announcing preambles, "anything else?" closers, hedging adverbs, and figurative language before sending a reply. Ponytail's SKILL.md, beyond the 7-rung ladder, explicitly bars unrequested abstractions (single-implementation interfaces, unnecessary config options), states that deletion beats addition, and insists on root-cause fixes over symptom patches.

Both skills support Claude Code's plugin mechanism, Codex's plugin mechanism, and the generic npx skills CLI. Representative commands (as of Sep 2026, per each repo's INSTALL.md/README.md):

Ponytail's README documents install steps for 20+ agents and harnesses (OpenCode, Gemini CLI, Grok Build, Devin CLI, and more), plus a rules-file fallback for editors with no plugin system. i-have-adhd has its own per-client paths too — a "create skill from URL" flow for Zed, qwen extensions install for Qwen Code, and so on. In both cases, installing the skill alone does not change behavior — it still needs the explicit command or trigger word to activate.

- i-have-adhd: long interactive pair-programming sessions where you want to skim the agent's output for just what's needed right now
- i-have-adhd: multi-step migrations or debugging sessions where you don't want to lose track of how far you've gotten
- i-have-adhd: review or investigation requests where you want the conclusion first, with detail still available to reference afterward (the checklist enforces "conclusion, then detail")
- ponytail: new feature work where the agent tends to add config options or abstraction layers beyond what was requested
- ponytail: small-to-mid-size projects where you want to avoid adding dependencies and prefer reusing standard libraries or existing code
- ponytail: as a pre-review pass to get a minimal-diff implementation before a human review (it also ships subcommands like /ponytail-review)

Agent Skills for coding agents have proliferated through 2026, and we've previously covered grill-me (Matt Pocock's skill that interrogates you with questions before implementation to get full alignment) and archify (a skill that compiles a JSON intermediate representation into diagrams). i-have-adhd and ponytail target different axes — output readability versus implementation minimalism — so their role differs from both.

Because i-have-adhd compresses output, it can be a poor fit for learning-oriented exchanges that need detailed background explanation — the checklist's instruction to strip hedging language and figurative phrasing can cost nuance you actually wanted. Ponytail's "ultra" intensity questions the requirement itself, so for work where you need the spec followed exactly, staying at "lite" or "full" — or explicitly telling it not to simplify a requested feature — is safer. Both are relatively young projects launched in May–June 2026, and the contents of their SKILL.md files are likely to keep changing.

i-have-adhd addresses "the answer is buried" through instruction-based output reshaping, while ponytail addresses "it wrote code nobody asked for" through an instruction-based decision ladder. Neither requires swapping models — installing the skill and activating it is enough — and both run across Claude Code, Codex, and a wide range of other agent platforms. They pull in the opposite direction from a skill like grill-me, which adds dialogue to raise accuracy rather than compressing output, and the two families can be combined depending on what you need.

- What Is Context Mode? — The MCP Server That Cuts AI Agent Tool Output by 98%
- What Is archify? — The Agent Skill That Makes Diagrams Verifiable via JSON IR