i-have-adhd, ponytail, and 7 more skills that make your agent stop explaining itself

i-have-adhd is ten rules in one markdown file. It doesn't write code and it doesn't run anything. It tells your coding agent to put the answer first and stop talking. This week it sits at the top of GitHub, with the rest of this list right behind it. Almost everything developers are installing right now is a skill that makes the agent say less. I went through all nine. One of them is ours, and it takes the opposite bet.

By the end you'll know how four of these shorten what the agent gives back, in prose and in code. You'll know why context-mode says shortening the prose is the wrong half of the problem, with the benchmark it cites. And you'll know which one to install if you'd rather watch the answer than read it.

A skill is a folder with one markdown file in it. Your coding agent, Claude Code, Codex, Cursor or Gemini CLI, reads it at the start of a session and follows it like a house rule. One command installs it. That is the whole technology, and it is what every repo here ships.

First, i-have-adhd. It puts the answer first.

You ask why your login is failing. The stock agent opens with "Great question", tours the middleware, mentions your dependency versions, and closes with "Hope this helps". With the skill on, the first line is the command to run. Then three numbered steps. Then one next action: paste the first failing test line. Same fix, a third of the words.

The rules are ten short sentences. Lead with the next action. Number the steps. End with one concrete thing to do. Cap every list at five items, which is why the ten sit in two columns of five. And rule ten, the one people install it for: no preamble, no recap, no closing pleasantries.

The file opens with five facts about how ADHD changes reading. Working memory is small, so anything off the screen is gone. Vague time estimates all feel the same. Visible progress is what starts the next step. The author adapted them from a clinical ADHD toolkit, and says the subtitle out loud: no ADHD diagnosis needed. I'd say that is why it spread. Every one of those facts is true of a tired engineer at six in the evening.

The catch is in the frontmatter. Disable model invocation is set to true, so the agent never turns this on by itself. You type slash i-have-adhd once per session and it stays on until you say "stop adhd mode". Forget the slash command and you are back to "Great question".

ponytail. It writes the least code that works.

You know him. Long ponytail, oval glasses, at the company longer than version control. You show him fifty lines and he replaces them with one. Ponytail puts him inside your agent. Ask for a date picker and the stock agent installs flatpickr, writes a wrapper component, adds a stylesheet, and opens a discussion about timezones. With ponytail you get one line: an input of type date. The browser already has one.

Before it writes anything, the agent walks a ladder and stops at the first rung that holds. Does this need to exist at all? Is it already in this codebase? Does the standard library do it? Does the platform do it natively? Is there an installed dependency? Can it be one line? Only then, the minimum that works. It reads the code first; in Dietrich's words, lazy about the solution, never about the reading.

Dietrich measured it on a headless Claude Code session editing a full FastAPI and React template: twelve feature tickets, scored on the diff each run left behind. Against the same agent with no skill, ponytail produced 54 percent less code, 22 percent fewer tokens, 20 percent less cost, and finished 27 percent faster. The pink bars are ponytail, and every one sits below the baseline. The date picker went from 404 lines to 23.

Here is what that chart hides, and it is the catch for this whole episode. The orange bars are caveman, a skill that only makes the agent talk terse. Its code shrank 20 percent, and its tokens, cost and time all went up. Shorter prose cost more than it saved. Dietrich's earlier headline said 80 to 94 percent less code; a GitHub issue showed the baseline was padding its answers with prose, and he published the fair number instead. The rule, in his words, was never fewest tokens. Write only what the task needs, and never cut validation, error handling, security or accessibility. Slash ponytail-review applies the same rule to a diff you already have and hands back a delete list.

humanizer. It takes the AI tells out of your writing.

Humanizer rewrites text that sounds like a chatbot so it reads like the person who asked, and keeps every fact. The idea behind it is one sentence. A language model writes whatever is most likely to come next, so it picks what fits the widest audience. A person picks for one reader. Every tell is a symptom of that default. And it never invents a detail; a missing name, number or date gets asked for.

The list comes from Wikipedia's page on signs of AI writing. Twenty-five patterns in five groups. Staging instead of stating: "it's not X, it's Y". Rhythm by rule: forced triads, dashes everywhere. Inflation: "a pivotal moment", "experts believe". Formatting by rule: bold on every label. And leftovers from the chat: "Great question", "Hope this helps". It was 35 patterns until this month; the third rewrite cut it to 25 and dropped synonym cycling, because Wikipedia now lists that as a human habit.

The README's example is a Lisbon travel post. Before: "this city completely stole my heart", "a vibrant testament to Portugal's enduring spirit". After: "I spent five days in Lisbon last October and still have mixed feelings about it. Beautiful, yes. Also harder on the knees than anyone warned me." It could say October and Alfama because the writer supplied notes. Without notes, humanizer asks instead of inventing. It is one markdown file, so it runs in any agent that reads skills.

no-ai-slop. It deletes the slop and keeps your voice.

Peter Yang's skill covers the same ground with a narrower promise: twenty-plus slop patterns removed without flattening the vocabulary, cadence and humor that make writing sound like you, plus a list of what it changed. Ask "is this slop?" and it quotes every pattern it found without guessing whether a model wrote the text. Ask for a slop post about anything and it writes the most cringe version it can, as satire. It is also a plugin inside ChatGPT, the one place on this list a non-developer can reach.

The two lists overlap on the big ones: binary contrasts, throat-clearing openers, fake-profound endings, chatbot residue. They split on one. no-ai-slop still cuts synonym cycling, "the agent handles your email, the assistant drafts replies", and humanizer dropped it this month. I'd pick by that. If you write in one register and want it back, Peter's. If you want the Wikipedia list enforced, blader's.

Four repos in, and I'll give you my answer now rather than hold it. i-have-adhd and ponytail earn their install: one changes the shape of the answer, the other the amount of code, and both show you a before and after. Humanizer and no-ai-slop are editors; run one on anything you are about to send. But every one of these makes the answer shorter so you read less. The next repo asks a different question: what if you didn't read it at all?

presenter. This one's ours.

You ask your agent for a briefing on a repo, or a walkthrough of the pull request it just opened. Instead of a wall of text, it writes slides and a script, your own machine turns the script into speech, and you get a link that plays in any browser, on your phone, on a TV, with the narration in sync. Free and unlimited. Nothing is billed per word, so you can send one to a teammate without thinking about it.

Three skills ship in the repo. Present makes it. Watch reads anyone's published presentation back as text, so an agent can answer questions from it. Video renders any of them to an MP4, landscape for YouTube or vertical for a Short, and that half is Mac only. It runs in Claude Code, Codex and Gemini CLI, the first run downloads a speech model to your machine, and a GitHub Action adds an explainer to every release you publish. One line installs it: npx skills add bisque-cloud/presenter. Now the pushback.

context-mode. It keeps tool output out of the context window.

Context Mode calls itself the other half of the context problem, and its README opens with a measurement. One Playwright snapshot costs 56 kilobytes of the agent's context. Twenty GitHub issues, 59 kilobytes. One access log, 45. After thirty minutes, forty percent of the window is gone, and the maintainer's point is where it went: to tool output, with the agent's prose a distant second.

So it runs the tool in a sandbox instead. The agent writes a small script, the script reads the files, and only what it prints comes back. The README's own example: 47 reads of source files, 700 kilobytes, becomes one execute call and 3.6 kilobytes. Think in code, it says: the model should program the analysis, not compute it. Twelve language runtimes, each in its own subprocess. Across its benchmark, a session's 315 kilobytes of raw output becomes 5.4, and the maintainer's claim is a session that runs three hours before compacting instead of thirty minutes.

Point four of the README is aimed at the first half of this episode. No prose-style enforcement. Context Mode keeps data out of the window but never dictates how the model writes its final answer, because, and it links the evidence, aggressive brevity prompts have been shown to degrade coding and reasoning benchmarks. The link is Moonshot AI's own report on kimi-k2.5. So in this maintainer's view, the four skills before this one spend model quality to save your scrolling. Ponytail's caveman arm says the same thing from the other side.

Two catches. It is licensed under Elastic License 2, source available: fork it, modify it, ship it inside your product, but you cannot sell it as a hosted service. And the 98 percent needs hooks, which let a plugin intercept a tool call before it runs. On an agent without them, Zed and the Antigravity IDE today, the routing is a text instruction the model follows about sixty percent of the time, and one unrouted curl puts 56 kilobytes straight back into the window.

ECC. It installs an entire engineering system.

ECC goes the other way. Where ponytail is one rule ladder, ECC is 68 agents, 292 skills and 94 commands, plus hooks, memory, and a security scanner that treats the agent's own configuration as an attack surface. The pitch is a loop: plan, test, implement, review, verify, remember, improve. Install that process once instead of typing it into every prompt.

Which raises the obvious question: doesn't 292 skills bury the context window this whole episode is trying to protect? ECC's answer is a table. Skills load only when the task needs them. Agents run in their own context. Hooks run outside the model entirely. Only rules are always loaded, so you install those selectively. Its motto is optimize the context window, persist everything else.

The catch is in its own support matrix. Claude Code is the stable primary. Codex is a supported plugin. Cursor and OpenCode are beta. GitHub Copilot is instruction-only, and Gemini, Zed, Antigravity and six others are experimental. The README asks you to read those as capability statements, not marketing tiers. The maintainer is one person; the core is MIT, and a hosted GitHub app for private repos starts at 19 dollars a seat a month.

superpowers. It makes your agent plan before it codes.

Superpowers is Jesse Vincent's methodology, and at first it makes the agent say more. Ask it to build something and it stops, asks what you are trying to do, and shows you a spec in chunks short enough to read. Then it writes a plan pitched, in its own words, at an enthusiastic junior engineer with poor taste and no project context. Then a fresh subagent takes each task, a reviewer checks it, and the README says a run goes for a couple of hours without drifting.

Fourteen skills, deep on the inner loop. Test-driven development that deletes code written before its test. Systematic debugging. Git worktrees for parallel branches. And writing-skills, which applies test-driven development to the skills themselves. It is in the official Claude and Codex marketplaces, and installs into Cursor, Gemini, Copilot CLI, Kimi, Devin, Pi and Hermes. One catch from the bottom of the README: the brainstorming skill's visual companion loads the Prime Radiant logo from their site with your version attached, which is how they count users, and one environment variable turns it off.

Last, the two catalogs: openai/skills and Addy Osmani's agent-skills.

openai/skills is on the board this week, and its README opens with a deprecation notice. The catalog moved to openai/plugins, which is on the same board. Codex now ships five skills built in, including a skill installer and a skill creator, and 39 curated ones stay in the old repo. If you are starring this repo, read the notice first.

Addy Osmani's agent-skills is 25 skills mapped to a lifecycle: spec, plan, build, test, review, ship, each behind a slash command. Every skill carries a table of the excuses an agent makes to skip a step, "I'll add tests later", with the rebuttal written next to it. And it is the only repo on this list with an evaluation suite in the repo that checks the skills route to the right task.

Addy's docs compare his pack to superpowers and to Matt Pocock's skills, and say who each is for: agent-skills for driving a feature through every phase with a human checkpoint, superpowers for long autonomous runs, Pocock's for one expert's daily loop. They link one head-to-head, same model, same repo, same prompt: agent-skills reached code in about eight minutes to superpowers' twelve and ran seven validation passes to five; superpowers did more design up front. One developer, one task.

So, the limit on my own argument. Say less is the shape of the week, and two of the biggest repos on it, superpowers and ECC, make the agent do more, and one, context-mode, argues that shrinking the prose costs you reasoning. What all nine agree on is where the fix lives: a markdown file the agent reads, installed in one command, portable across Claude Code, Codex, Cursor and Gemini.

Should you install any of it? If your agent's answers make you scroll, i-have-adhd, today, and remember to turn it on. If it over-builds, ponytail, and run ponytail-review on your next diff. If tool results are what eat your session, context-mode, with hooks on. If you want a process, pick one of superpowers, ECC or agent-skills, and read Addy's comparison page first. And if the answer is going to someone else, a teammate, a manager, a reviewer, presenter, so they can watch it.

Every one of them is a single command; the READMEs list the Codex, Cursor and Gemini equivalents.

Open your last session and look at the thing you scrolled past. Was it the agent's prose, or a tool result? Your answer picks between i-have-adhd and context-mode, and I'd like to hear which one it was. That was i-have-adhd, ponytail, and seven more skills that make your agent stop explaining itself. New repo tomorrow.