My Median Prompt Is 56 Characters

My Median Prompt Is 56 Characters

Andrej Karpathy posted a week ago that when he needs an LLM to understand something complicated, he switches to voice and rambles for ten minutes — total mess, full stream of consciousness — because the model reconstructs the tangle better than he could have written it. Three and a half million views. Within a day it was everywhere: type to humans, talk to AI. Ramble first, clean second, execute third.

The advice is correct. I've been working that way for months.

It is also, as stated, missing the half that actually does the work — and I can prove it, because I have 34 days of receipts.

Claude Code keeps a complete transcript of every session on disk in ~/.claude/projects/**/*.jsonl. Not just what you typed: every tool call, every subagent dispatch, every model that answered. I pointed Claude at mine and asked it to read all of it.

5,244 prompts I typed. 9,715 prompts my setup typed on my behalf. 359 sessions. 34 days.

The second number is the story.

---

Finding 01 — My prompts are bimodal, and there is nothing in the middle

Here is the distribution of everything I typed:

Median: 56 characters. Not 56 words. Fifty-eight percent of everything I type at Claude is shorter than this sentence.

The most frequent things I say, verbatim, counted:

continue          189×
do it              65×
yes                55×
get it done        46×
status?            27×
gap analysis       22×
close the gaps     13×
commit and push    10×

That is not a prompt library. That's a steering wheel.

But look at the other end. That 5.9% of prompts over a thousand characters carries 78.4% of every character I typed in the entire window.

Six percent of the prompts hold seventy-eight percent of the information.

There is almost nothing in between. Two tools that happen to share a text box.

---

Finding 02 — The long ones really are rambles, typos and all

I was suspicious of my own result here. A "1,000+ character prompt" could just be me pasting a stack trace. So I checked what those 312 long prompts actually are.

71% are prose. Not logs, not JSON, not pasted errors — sentences. And 31% of those contain uncorrected typos. Sentence-enders run at 0.082 per word, above normal written prose, because a ramble is a burst of short declaratives, not constructed paragraphs.

My longest prose prompt in the window is 14,585 characters and opens like this:

"how can we really mkae computer generated graphics and take them to the enxt level? i want to make the game more interactive, more physics, more procedurally gernated characters beyond just stable diffusion..."

mkae. enxt. gernated. All left in.

Not because I'm sloppy. Because fixing mkae costs me the next three ideas. The bottleneck in that moment is how fast I can get what's in my head into the machine, and every keystroke spent on polish is a keystroke not spent on detail. The model was never confused for a second.

Typos are free. Unproven claims are not. That asymmetry is the whole personality of my setup.

So: Karpathy is right. Ramble. That part is real and my data supports it completely.

Now the part nobody is posting about.

---

Finding 03 — The precision didn't disappear. It moved.

In those same 34 days, my setup generated 9,715 prompts of its own — rules files, skill definitions, and subagent dispatches written by the harness rather than by me. That's 1.85 machine-written prompts for every one I typed. Their median length is 2,986 characters.

Here is what's in mine versus what's in theirs:

Ninety percent of the prompts my machine writes name a specific file. Six percent of mine do.

And the single most damning number in the whole dataset:

"Don't assume" or "don't guess" appears in 1 of my 5,244 prompts.

One. 0.0%.

Anyone who has watched me work would tell you I am completely obsessive about this — I do not accept "it should work," I don't accept green tests as proof, I want the live round-trip or it isn't done. And I type that requirement approximately never.

Because it's written once, in a rules file, and after that it is simply true forever.

You don't type your standards. You install them.

---

What this actually means

Prompt engineering is dead. Everyone saying that is right.

But it didn't die because models got smart enough to read your mind. It died because the careful prompt got demoted from a human craft to a build artifact.

Something still has to produce three thousand characters of specification before real work happens — the file paths, the expected shapes, the constraints, the "prove it live." That never stopped being necessary. In a mature setup, that something is your harness.

Karpathy's ramble moves context from your head into the model — manually, brilliantly, and again every single session.

The harness moves context from your head into the system — once — so it's there every session, in every dispatch, whether you remembered it or not.

They're the same insight applied at two different time horizons. The ramble is how you load what's new. The harness is how you stop re-loading what isn't.

---

The three modes

RAMBLE — unbounded, unedited — when loading new intent. Talk at the speed of thought. Leave the typos. Include what you already tried, what you're worried about, what "good" looks like, what you refuse to do, and the tangent you're not sure is relevant — the tangent is usually the load-bearing part. Then end with the one line that turns a mess into a spec:

"Reflect that back as a clean brief, tell me what's missing and what you'd have gotten wrong, and ask clarifying questions before touching anything."

POKE — under sixty characters — for everything after that. continue. do it. close the gaps. If your steering prompts are still long, that's a harness bug, not a prompting habit. Every requirement you retype is one you failed to install.

THE ANTI-MODE — and this is the one nearly everyone actually does — is the 200-to-800-character tidied-up, professional-sounding request. Too polished to carry your real intent, too short to carry a real spec, and aimed at a system that doesn't know your standards. It is the worst of all three and it's what most people type all day, every day.

Look at your own last twenty prompts. I'd bet nearly all of them are in that band.

---

The catcher

Here's the caveat that the viral version of this advice does not include, and it is the difference between this working and this being actively harmful.

A ramble into a bare chat window gets you a plausible wrong thing, very fast.

The rambling works because something catches it. In my case the catcher is 964 memory entries, 8 rules files, 19 hooks, 22 skills and 32 agent definitions. That's what expands "get it done" into three thousand characters of specification with a gate that can fail.

Build that first, in this order — each one is close to useless without the one before:

1. A rules file the agent reads every session. Your standards, written once. This is where "don't guess" lives so you never type it again. Keep it short; it competes for context.
2. Persistent memory with an index. One line per fact, linking to detail. Traps get a severity marker. Disproven theories get marked REFUTED rather than deleted — the refutation is the valuable part when the symptom comes back.
3. A gate that can fail. Lint, a test, a live round-trip, a stop hook. Without this, the ramble compounds errors instead of correcting them, and the whole method is strictly worse than writing careful prompts.
4. A skill for anything you've asked for twice. A repeated request is a missing skill. That's the entire rule.
5. Delegation for fan-out. The 1.85:1 ratio isn't overhead. It's the machine writing the careful prompts you stopped writing.

Do steps 1–3 before you let yourself enjoy step 0.

---

Honest limits

This is one operator, one 34-day window, one domain — infrastructure and agent platforms. The bimodality is a strong signal. The exact percentages are not a law of nature.

It's also survivorship-shaped: these numbers come from a setup that already had rules, memory, gates and delegation. Ramble-then-poke on a fresh install mostly produces confident garbage at speed.

The typo tolerance is a personal choice, not a finding. What the data shows is that typos didn't degrade outcomes in this corpus. Nobody ran the control that would show polish never helps.

And rambling costs real money. Seventy-eight percent of my characters sit in six percent of my prompts, and those get re-read on every subsequent turn until compaction. That's a bill.

One thing that isn't a limit: I measured this window against an earlier, completely disjoint 210-day window of 27,939 prompts. That one reported a median of 58 characters. This one says 56. Two separate measurements, months apart, landing two characters from each other.

---

Your telemetry is already on disk

You don't have to take my numbers. You have your own.

Every prompt you've ever typed at Claude Code is sitting in ~/.claude/projects/**/*.jsonl with a timestamp and a session id. Ten minutes of work will tell you your own median, your own distribution, and whether you're living in the anti-mode.

Two filters matter, and skipping them is the single most common mistake — I made it myself on the first pass and reported a median of 1,863 characters, off by a factor of thirty-three. First, drop any type: "user" record whose content holds a tool_result block; those are tool outputs wearing your name. Second, separate real project directories from subagent and workflow transcript directories — the latter is your harness prompting itself, and mixing the two makes machine-written dispatches look like things you typed.

I've open-sourced the whole doctrine — thirteen measured rules, the extraction method, and every caveat above — as two MIT-licensed skills, ramble-driven-development and code-like-david, in the free skills pack at github.com/Aitherium/awskills:

git clone https://github.com/Aitherium/awskills
cd awskills && bash scripts/install-awskills.sh

Then tell your agent: "use the code-like-david skill."

Ramble to load. Poke to steer. Put the precision in the harness.

And never type a standard twice.