# 100 levels of working with agents

100 things people who are good with coding agents actually do, from pasting screenshots to adversarial reviewers. Paste one prompt: your agent checks which you do on your own machine and hands you a card.

- Page: https://www.prehistoriq.com/levels/
- Check your own level: paste `Read prehistoriq.com/levels/check.md and do what it says.` into your coding agent
- Data: https://www.prehistoriq.com/levels/levels.json · Season 1, checked 2026-10-21

Your level is how many of the 100 you do. The list is always 100: when a new level earns its place, one goes extinct.

Level 0: Copy code out of a chat tab. Everyone starts here. It doesn't count, and nobody's judging.

## Levels 1–10: Stone Age · First contact

It edits, it runs things, it answers. You stop copy-pasting.

### 1. Install a coding agent

One that reads your files and runs commands, not a chat tab.

- How it's checked: Any agent config folder exists: ~/.claude, ~/.codex, ~/.cursor, ~/.config/opencode, ~/.gemini, ~/.factory, ~/.pi. You're reading this from inside one, so: yes.
- Who does it: Mitchell Hashimoto: “To find value, you must use an agent.” (https://mitchellh.com/writing/my-ai-adoption-journey)

### 2. Let it edit the files

Stop pasting code between a chat window and your editor. It writes to disk; you read the diff.

- How it's checked: Its file-edit tool shows up in session logs (Edit, Write, apply_patch).

### 3. Ask before you change

"How does auth work here?" Ask it what you'd ask a senior engineer on day one.

- How it's checked: 5+ prompts that are questions about the code (how, why, where, what does).
- Who does it: Anthropic, Claude Code best practices: Ask it the questions you'd ask a senior engineer about the codebase. (https://code.claude.com/docs/en/best-practices)

### 4. Paste the whole error

The full stack trace or log, not your summary of it.

- How it's checked: 5+ prompts with pasted blocks or raw logs ([Pasted text …], stack traces).

### 5. Send it a screenshot

A picture of the broken layout beats a paragraph about it. "Fix this" + image is a whole prompt.

- How it's checked: 3+ prompts with an image attached ([Image #…]).
- Who does it: Peter Steinberger: Attaches a screenshot to a large share of his prompts; "fix padding" plus an image is enough. (https://steipete.me/posts/just-talk-to-it)

### 6. Interrupt it

Hit Esc the moment it heads the wrong way. Waiting for it to finish costs more.

- How it's checked: 5+ interrupted turns in session logs ("[Request interrupted by user]").
- Who does it: Peter Steinberger: “Don't be afraid of stopping models mid-way.” (https://steipete.me/posts/just-talk-to-it)

### 7. Point at the files

@-mention the file or paste the path, so it doesn't go hunting.

- How it's checked: 10+ prompts with @file mentions or explicit file paths.

### 8. Commit small and often

A clean git tree is the best undo button you have. Commit before you let it loose.

- How it's checked: It ran git commit 5+ times in your sessions, or you use checkpoints.

### 9. Start a fresh session

When it gets confused, /clear and ask again. Arguing with a polluted context never wins.

- How it's checked: /clear, /new or a fresh session after a failed attempt, 3+ times.
- Who does it: Anthropic, Claude Code best practices: After two failed corrections, /clear and write a better first prompt. (https://code.claude.com/docs/en/best-practices)

### 10. Use it for something that isn't code

Rename 400 photos, sort the receipts, untangle a spreadsheet. It's a computer that does chores.

- How it's checked: 1+ session in a folder that isn't a git repo (Downloads, Documents, home).

## Levels 11–20: Fire · Context

It knows what you know, because you told it.

### 11. Write a rules file

AGENTS.md or CLAUDE.md: how to build, test and run this repo, and what never to do.

- How it's checked: An AGENTS.md, CLAUDE.md, GEMINI.md or .cursor/rules in any repo you work in.
- Who does it: Lee Robinson: “I started with zero custom rules. I only added a rules file later after the model got a few things wrong” (https://leerob.com/pixo)

### 12. Write down how you like to work

One global file for every project: your taste, your tools, your pet peeves.

- How it's checked: ~/.claude/CLAUDE.md or ~/.codex/AGENTS.md exists and isn't empty.

### 13. Talk instead of type

Dictate. You'll give it three times the context you'd ever bother typing.

- How it's checked: A dictation app is installed (Wispr Flow, superwhisper, MacWhisper, VoiceInk, OpenWhispr, Aqua, Spokenly, Handy), or prompts read like speech (um, uh, long run-ons).
- Who does it: Dax Raad: “the thing that killed my editor for me was fast local voice models more than OpenCode” (https://x.com/thdxr/status/2078527322563449007)

### 14. Hand it the docs

Paste the URL of the API reference, the issue, the RFC. Let it read instead of guess.

- How it's checked: 10+ prompts with URLs, or web fetches in session logs.

### 15. Point at an example

"Do it like UserCard.tsx." One good example beats a paragraph of conventions.

- How it's checked: Prompts that name an existing file or project to copy ("like X", "same as Y", "follow Z").

### 16. Say what done looks like

What's wrong, where, and how you'll know it's fixed. "Fix login" isn't a task.

- How it's checked: Prompts that state a finish line ("done when", "until", "should show").
- Who does it: OpenAI, Codex best practices: Goal, Context, Constraints, Done when: their prompt template. (https://learn.chatgpt.com/guides/best-practices)

### 17. Ask for a plan first

Plan mode, or "don't write code yet". A plan is ten times shorter than the diff it saves you.

- How it's checked: Plan mode used, or 5+ prompts asking for a plan before code.
- Who does it: Lee Robinson: “Plan mode in Cursor is one of the most underrated features.” (https://leerob.com/pixo)
- Who disagrees: Peter Steinberger: Skips plan mode; asks for options and talks it through instead. (https://steipete.me/posts/just-talk-to-it)

### 18. Ask for three versions

Of the UI, the name, the approach. Pick one, or steal from all three. Variants are nearly free now.

- How it's checked: 5+ prompts asking for variants, options or versions.

### 19. Let it interview you

"Ask me questions until you understand what I want." Then it builds the right thing.

- How it's checked: Its ask-the-user tool used, a grill-me style skill installed, or prompts like "ask me" / "interview me".
- Who does it: Matt Pocock: grill-me (https://github.com/mattpocock/skills/blob/7a030a8b0dcaa601bb0dda9aaf174affb3d61145/README.md#L103)

### 20. Add a rule after every mistake

It did something dumb? It goes in the rules file, so it never does it twice.

- How it's checked: A rules file changed 3+ times, agent memory notes saved, or prompts like "add this to AGENTS.md".
- Who does it: Boris Cherny: “Anytime we see Claude do something incorrectly we add it to the CLAUDE.md” (https://x.com/bcherny/status/2007179840848597422)

## Levels 21–30: Wheel · Checks

It proves the thing works before it says done.

### 21. Give it a way to check its work

Tests, a build, a screenshot to compare. Then it fixes its own mistakes before you see them.

- How it's checked: 10+ prompts that ask it to verify, test, or make sure it works.
- Who does it: Boris Cherny: “give Claude a way to verify its work… 2-3x the quality” (https://x.com/bcherny/status/2044847858634064115)

### 22. Failing test first

Reproduce the bug in a test, watch it fail, then fix. Proof before the fix.

- How it's checked: Prompts about failing tests, TDD or red/green, or a TDD skill installed.
- Who does it: Steph Ango: “Verify the same fixture fails before the fix and passes afterward; do not change expectations to match buggy behavior.” (https://github.com/kepano/defuddle/blob/49d14ecc4089696565c2479b2f57db72be199adc/AGENTS.md#L17)

### 23. Let it drive a browser

Playwright, agent-browser, Chrome. It clicks through what it built instead of guessing.

- How it's checked: A browser MCP or skill installed, or 10+ browser-automation calls.

### 24. Ask for proof, not "done!"

The command it ran and the real output. A screenshot. A video of it working.

- How it's checked: 5+ prompts asking for proof, screenshots or recordings of the result.
- Who does it: Thorsten Ball: “give me irrefutable proof that this works. Dazzle me. Give me a video as proof, or something.” (https://registerspill.thorstenball.com/p/joy-and-curiosity-99)

### 25. Undo the conversation, not just the code

Rewind or a checkpoint takes you back to before it went wrong. Try risky things.

- How it's checked: /rewind or a checkpoint restore used by you at least once (typed, not just mentioned).

### 26. Teach it your CLIs

gh, aws, stripe, supabase. "Run foo --help" and it learns the rest.

- How it's checked: It ran 3+ different third-party CLIs (gh, aws, gcloud, vercel, netlify, stripe, supabase, wrangler, fly…).

### 27. Pre-approve the safe stuff

An allowlist for tests, lint and git status. Approval fatigue is how you end up clicking yes to everything.

- How it's checked: Permission allow rules, Codex rules, or auto mode configured.

### 28. Ask side questions without derailing

/btw, or a second session. The answer never pollutes the main context.

- How it's checked: /btw used, or a parallel throwaway session for a quick question.

### 29. Type the next message while it works

Queue follow-ups instead of waiting for it to finish.

- How it's checked: Queued prompts in your agent's stats or logs, 20+.

### 30. Get pinged when it's done

A hook, a sound, a push to your phone. Then go do something else.

- How it's checked: A hook or script that notifies you when it's done (sound, push, notification), or a rule telling it to.
- Who does it: Chris McCord: “when it's done work it runs a `notify msg` bash function I have” (https://x.com/chris_mccord/status/2016576023400181773)
- Who disagrees: Mitchell Hashimoto: Turns agent notifications off, so he decides when to switch context. (https://mitchellh.com/writing/my-ai-adoption-journey)

## Levels 31–40: Bronze Age · Tools

It reaches past the repo: CLIs, servers, your browser, your inbox.

### 31. Install a skill

Someone else's packaged know-how, loaded only when it's needed.

- How it's checked: 1+ skill folder in ~/.claude/skills, ~/.codex/skills, ~/.agents/skills or a repo's .claude/skills.

### 32. Connect a tool server

MCP for the things without a good CLI: Figma, Linear, your database.

- How it's checked: 1+ MCP server configured.
- Who disagrees: Peter Steinberger: Prefers CLIs: the GitHub MCP alone ate 23k tokens of context. (https://steipete.me/posts/just-talk-to-it)

### 33. Let it open the PR

Branch, commit, push, write the description. You review.

- How it's checked: It ran gh pr create (or similar) 3+ times.

### 34. Let it ship

Vercel, Netlify, Fly, a TestFlight build. You decide who presses the last button.

- How it's checked: It ran a deploy CLI 3+ times.

### 35. Save a prompt as a command

The thing you type every week, saved as /ship or /review.

- How it's checked: 1+ custom command in .claude/commands, or a user-invoked skill you wrote.

### 36. Turn the effort dial

Low for chores, high for the gnarly bug. Pick the model per job.

- How it's checked: /effort or /model switched 3+ times, or reasoning effort set in config.

### 37. Know what you burn

ccusage, CodexBar, /usage. Tokens are a budget; spend them on purpose.

- How it's checked: A usage tracker installed, or /usage, /stats, /cost used 3+ times.

### 38. Watch the context fill up

A status line with context used, model and cost. No more surprise compactions.

- How it's checked: A statusLine configured, or /context used 3+ times.

### 39. Two agents at once

One on the bug, one on the feature. Different folders, different problems.

- How it's checked: Two sessions active in the same 10 minutes, on 5+ occasions (from prompt timestamps).

### 40. Connect it to your messages

Gmail, Slack, Teams, calendar. "What did I promise people this week?"

- How it's checked: A mail, chat or calendar connector or MCP configured (names only).

## Levels 41–50: Iron Age · Your setup

Rules, skills, hooks and memory that you wrote yourself.

### 41. Write your own skill

The thing you keep explaining, written down once as a SKILL.md.

- How it's checked: A skill you wrote yourself: no upstream source or lockfile entry, or it lives in your own repo.

### 42. Use subagents

Send helpers to read and search, so your main context stays clean.

- How it's checked: 10+ subagent runs in session logs.
- Who does it: Alexander Embiricos: “Then, when I need anything new, I say "using a subagent in parallel, do X"” (https://x.com/embirico/status/2046033614106931414)

### 43. A hook that tidies every edit

Formatter or linter after each write. Deterministic beats "please run prettier" in a rules file.

- How it's checked: A post-edit hook that runs a formatter or linter.
- Who does it: Boris Cherny: “We use a PostToolUse hook to format Claude's code.” (https://x.com/bcherny/status/2007179852047335529)

### 44. A hook that says no

Block rm -rf, force pushes, pip when you use uv. Rules are advice; hooks are law.

- How it's checked: A pre-tool hook that blocks or guards commands.
- Who does it: Armin Ronacher: “Replaces the bash tool with a `uv`-aware version that injects Python command shims and blocks common non-`uv` workflows.” (https://github.com/mitsuhiko/agent-stuff/blob/0865c849befd2021490679f96a8dee58c84ac857/README.md#L63)

### 45. Let it keep notes

Memory, notes.md, PROGRESS.md. It shouldn't relearn your project every morning.

- How it's checked: 5+ memory notes, Codex memories on, or notes/progress files in your repos.
- Who does it: Simon Willison: “Create a notes.md file in that folder and append notes to it as you work, tracking what you tried and anything you learned along the way.” (https://github.com/simonw/research/blob/ba0cb97b42da153c13c465fb617f5c45f1f03b04/AGENTS.md#L3)

### 46. One rules file for every agent

Symlink CLAUDE.md to AGENTS.md. Same rules, whichever agent you open.

- How it's checked: A CLAUDE.md that is a symlink to, or imports, an AGENTS.md (or the other way round).
- Who does it: Peter Steinberger: “~/.codex/AGENTS.md -> ~/Projects/agent-scripts/AGENTS.MD
~/.claude/CLAUDE.md -> ~/Projects/agent-scripts/AGENTS.MD” (https://github.com/steipete/agent-scripts/blob/79150cfac4a6ba4df13cf30176bf2db85170ae6c/README.md#L65-L67)

### 47. Keep the rules file small

A map to your docs, not an encyclopedia. Would removing this line cause a mistake? No? Delete it.

- How it's checked: The rules file of the repo you work in most is under 150 lines and points to other docs for the rest.
- Who does it: Kent C. Dodds: “This file is included in full context for every agent conversation. Keep it tiny and stable.” (https://github.com/kentcdodds/kentcdodds.com/blob/b61c7ff4200c4aa0e35326d1a7baeb8a51d86673/AGENTS.md#L3-L4)

### 48. Spec first

Two paragraphs in, a SPEC.md out, and a fresh session builds from the spec.

- How it's checked: A SPEC.md, PLAN.md or plans/ folder in a repo you work in.
- Who does it: Alex Kladov: “I was providing structure, Claude was painting by the numbers.” (https://matklad.github.io/2026/01/20/vibecoding-2.html)

### 49. Write a handoff

Before the context fills, it writes down where it is. The next session picks up in one read.

- How it's checked: A PROGRESS.md, HANDOFF.md or todo.md, or a handoff skill.
- Who does it: Thomas Ptacek: “I should be able to tell a future agent "read PLAN.md and PROGRESS.md" and trust it's up to speed with this codebase.” (https://github.com/tqbf/swiftui-app/blob/3ca1cc4b8ffdbd3b628cc847574c9951b036fe12/CLAUDE.md#L5-L6)

### 50. One worktree per agent

Parallel agents in one checkout trip over each other. Worktrees don't.

- How it's checked: git worktree list shows 2+ in any repo.
- Who does it: Boris Cherny: “Worktrees are essential… dozens of Claudes” (https://x.com/bcherny/status/2038454353787519164)
- Who disagrees: Peter Steinberger (2025, he uses them now): “Why not worktrees? I run one dev server, as I evolve my project I click through it and test multiple changes at once.” (https://steipete.me/posts/just-talk-to-it)

## Levels 51–60: Steam · Second opinions

Another agent reads it before you do.

### 51. Have an agent review the diff

/code-review, Codex /review, a fresh session. Before you read it, not instead.

- How it's checked: A review command, review skill or review subagent used 3+ times.
- Who does it: Filippo Valsorda: “making a human review a change before an LLM is disrespectful.” (https://bsky.app/profile/filippo.abyssdomain.expert/post/3moq6sdq6xk2l)

### 52. Cross-model review

Claude writes, GPT reviews, or the other way round. Different models miss different things.

- How it's checked: One vendor's agent asked to review another's work (codex exec / claude -p review, or prompts that hand a diff across).
- Who does it: DHH: “Review this with claude” (https://x.com/dhh/status/2107882896195199116)

### 53. Fresh-eyes review

Same model, empty context: "read this as if you didn't write it".

- How it's checked: Reviews run in a fresh context (a new session or a subagent), not in the session that wrote the code.
- Who does it: Harper Reed: “carefully read over all of the new code you just wrote … with "fresh eyes," looking super carefully for any obvious bugs … Use a subagent.” (https://github.com/harperreed/dotfiles/blob/6db272a76a71b098272c7c8a26ae084d197a43ac/.claude/commands/careful-review.md#L1)

### 54. Make it quiz you on the diff

It explains the change, then asks you five questions. Merge only if you pass.

- How it's checked: An explain-diff or quiz skill, or prompts asking it to explain or quiz you on a change.
- Who does it: Thariq Shihipar: “I only merge after I pass the quiz perfectly.” (https://x.com/trq212/status/2073100352921215386)

### 55. Ask for a diagram

Architecture, data flow, the state machine. Pictures review faster than prose.

- How it's checked: 3+ prompts asking for a diagram, chart or visual explanation.
- Who does it: Dex Horthy: “/show-me prompts the agent to use concise visuals to explain what's happening, instead of walls of prose.” (https://www.humanlayer.dev/blog/show-me-skill)

### 56. Let it babysit the PR

It watches CI and the review bots, fixes, pushes, and repeats until it's green.

- How it's checked: It checked CI or PR status (gh pr checks, gh run) 5+ times.

### 57. Two agents, two jobs

Claude writes the code, Codex draws the images. Or one builds and the other reviews.

- How it's checked: One agent launched another (codex exec, claude -p, gemini -p) 3+ times.

### 58. Run it headless

claude -p, codex exec. Pipe logs in, get JSON out, put it in a script.

- How it's checked: 3+ headless runs in shell history or logs.

### 59. Have it make a video

A 30-second motion explainer of what you shipped, for the colleague who won't read the PR.

- How it's checked: Remotion, Hyperframes or ffmpeg renders from a session, or a video skill installed.

### 60. Skip the prompts, inside a box

Full autonomy in a container or a fresh VM with no prod keys. Not in your home folder.

- How it's checked: Permission prompts off AND a sandbox (devcontainer, Docker, VM, /sandbox). Prompts off without a box doesn't count.
- Who does it: David Crawshaw: “You have to turn off the sandbox, which means you have to provide your own sandbox. I have tried just about everything and I highly recommend: use a fresh VM.” (https://crawshaw.io/blog/eight-more-months-of-agents)

## Levels 61–70: Electric · Off the desk

It works while you sleep, sit on the couch, or close the laptop.

### 61. Schedule a prompt

For later, or every morning: /loop, /schedule, cron, launchd.

- How it's checked: A scheduled or recurring agent run (loop/cron tools, a launchd or cron entry that calls an agent).

### 62. Let it work while you sleep

Kick off a few tasks before bed, review them with coffee.

- How it's checked: Agent activity between 1am and 6am while you typed nothing.
- Who does it: Calvin French-Owen: “This is over-hyped on Twitter, but I do really try and kick off 3-4 tasks in Codex before going to bed, so they'll be ready for review in the morning.” (https://calv.info/agents-feb-2026)

### 63. Drive it from your phone

Remote Control, the Codex app, ssh + mosh + tmux. Unblock it from the couch.

- How it's checked: Remote control set up, a mobile session, or mosh/Tailscale used to reach your agent box.
- Who does it: Harper Reed: Claude Code is better on your phone (https://harper.blog/2026/01/05/claude-code-is-better-on-your-phone/)

### 64. Hand chores to a cloud agent

Codex cloud, Claude on the web, Cursor background agents, Devin. The boring stuff, no laptop needed.

- How it's checked: Cloud or remote agent tasks in your history.
- Who does it: Adam Wathan: “I feed this thing every little random tedious OSS task that I'd otherwise neglect on my TODO list” (https://x.com/adamwathan/status/2017616165455949851)

### 65. A finish line it can't fake

"Don't stop until the test passes and the screenshot matches." Then let it run.

- How it's checked: 3+ prompts like "don't stop until" / "keep going until", or a goal set with /goal.

### 66. Run it in a loop

Same prompt, fresh context, again and again until the spec is done.

- How it's checked: A shell loop or script that re-runs an agent, or /loop until a condition.
- Who does it: Geoffrey Huntley: “while :; do cat PROMPT.md | claude-code ; done” (https://ghuntley.com/ralph/)

### 67. Put an agent in CI

@claude on issues, Codex on every PR. It's a teammate with a GitHub login now.

- How it's checked: claude-code-action, codex action or similar in a .github/workflows file.

### 68. Run it four times, keep the best

Same task, parallel attempts, thirty seconds each to judge. Throwing work away is fine now.

- How it's checked: The same task run in 2+ parallel sessions or worktrees.
- Who does it: Alexander Embiricos: “So I might kind of throw throw codex at it but I might just do it four times in parallel instead.” (https://www.youtube.com/watch?v=xeZDHGjG5zM&t=1375)

### 69. Make two agents argue

One proposes, one attacks, until they agree or you see exactly why they can't. Nice.

- How it's checked: Multi-round back-and-forth between two agents (rounds of review and fix, or relayed replies).
- Who does it: Dex Horthy: “let sol and fable implement / review / argue over night” (https://x.com/dexhorthy/status/2092244659057909765)

### 70. An always-on machine

A box that keeps agents running when your laptop sleeps. A Mac mini, a VPS, a shed.

- How it's checked: Agents running on another machine you reach over ssh.
- Who does it: DHH: “all my agent and compile work now happens on an AI shed.” (https://x.com/dhh/status/2107463006552793231)

## Levels 71–80: Silicon · Orchestra

Many agents, one plan, and you still know who's doing what.

### 71. Five at once

Five agents, five problems, and you still know what each one is doing.

- How it's checked: 5+ sessions or background agents running at the same time.

### 72. A coordinator agent

One agent hands out the work, checks on the others, and reports to you.

- How it's checked: One agent messaging or steering others (agent teams, SendMessage, an orchestrator session).
- Who does it: Andreas Kling: “Tell coordinator to parallelize the work over 4 separate computers via SSH” (https://x.com/awesomekling/status/2102089363631059199)

### 73. Strong model plans, fast model builds

Pay for thinking where it matters. Different models for design, code and review.

- How it's checked: Per-agent model settings, or 3+ prompts assigning models to roles.
- Who does it: Steve Yegge: “Every implementation bead goes through this lifecycle: Fable design, Opus implementation, Fable review.” (https://yegge.ai/essays/the-shape-of-things-to-come/)

### 74. Give agents job titles

A security reviewer, a tester, a docs writer, each with its own tools and model.

- How it's checked: 2+ custom agent definitions (.claude/agents/*.md or equivalent).

### 75. Script the whole pipeline

A rerunnable multi-agent workflow, not a heroic one-off session.

- How it's checked: A workflow tool used, or a script that chains several agent runs.

### 76. Adversarial reviewers

Two refuters per builder, and points for every real bug they find.

- How it's checked: Reviews run by 2+ competing or adversarial agents.
- Who does it: Jesse Vincent: “Assign two subagents to review your work adversarially. Tell them that whoever finds the largest number of legitimate significant issues gets 5 points.” (https://github.com/obra/dotfiles/blob/6ebb5ba848526b2bfd5b5ab3cb30741ff32c4447/.claude/commands/par.md#L1)

### 77. Three bug hunters, one report

Run several reviewers, then have one agent rule out the false positives.

- How it's checked: Findings from 2+ review tools merged into one triaged list.
- Who does it: Nolan Lawson: “Run a Claude sub-agent, Codex, and Cursor Bugbot to find bugs in this PR ranked by critical/high/medium/low.” (https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/)

### 78. Every task makes the next one easier

After each job it writes the lesson into a skill or rule. Next time is cheaper.

- How it's checked: Rules, skills or memory edited by agent sessions 5+ times.
- Who does it: Kieran Klaassen: “Compound is still the most important step, because the whole point is that every feature should make the next feature easier.” (https://every.to/p/compound-engineering-gets-an-upgrade)

### 79. Turn rules into checks

Written "never do X" twice? Make it a lint rule or a type, so it can't happen.

- How it's checked: Custom lint rules, ast-grep rules or check scripts in a repo.
- Who does it: José Valim: “encode as many rules as possible into deterministic checks (first) and adversarial reviews (second), instead of relying exclusively on a bunch of AGENTS.md files to do the job.” (https://x.com/josevalim/status/2075221914549686774)

### 80. Build a tool for your agent

A small CLI made for it to call: --json output, good --help, no prompts.

- How it's checked: Your own scripts or CLIs that agents call regularly.

## Levels 81–90: Orbit · Harness

You build the system the agents work in.

### 81. Test your skills

Does it trigger when it should? Does it actually help? An eval tells you.

- How it's checked: Eval files for a skill or plugin, or a plugin eval run.

### 82. Publish your skills

A public repo of your skills, so your team (or strangers) can steal them.

- How it's checked: Your skills live in a git repo with a remote.
- Who does it: Peter Steinberger: agent-scripts (https://github.com/steipete/agent-scripts)

### 83. An agent in your team's chat

Tag it in Slack, it opens the PR. Your teammates use it without installing anything.

- How it's checked: A chat-integrated agent set up (Slack app, Claude Tag, Devin, a bot).
- Who does it: Cat Wu and Thariq Shihipar, via Simon Willison: Claude Tag lands 65% of the Claude Code team's product PRs. (https://simonwillison.net/2026/Jul/21/cat-and-thariq/)

### 84. Build on the Agent SDK

Your own agent product, with the same loop under the hood.

- How it's checked: An agent SDK in a project's dependencies (Claude Agent SDK, Codex SDK, OpenAI Agents).

### 85. A wiki about you, for your agents

How you think, what you've decided, what you can't stand. Loaded only when it's relevant.

- How it's checked: A personal context repo or folder that your agents load when relevant, through a rule or a skill.

### 86. Your agents talk to each other

No more "Codex says: [paste]". They pass findings directly while you do something else.

- How it's checked: Agents sending each other messages or reading each other's output, without you relaying it.

### 87. Sensors next to the agent

Lint, types, coverage, mutation score, always running, where it can read them.

- How it's checked: Watch-mode checks or a dashboard the agent reads while it works.
- Who does it: Birgitta Böckeler: Sensors for coding agents (https://martinfowler.com/articles/sensors-for-coding-agents.html)

### 88. A QA script it runs before release

Every release, the same long checklist, run by the agent, start to finish.

- How it's checked: A QA or release checklist file, or a release skill.
- Who does it: Salvatore Sanfilippo: QA_BEFORE_RELEASES.md (https://antirez.com/news/168)

### 89. Hardware in the loop

It flashes the board, reads the serial port, watches the LED. Or the Stream Deck.

- How it's checked: Device tools driven by an agent (serial, adb, simctl, esptool, arduino-cli…).
- Who does it: Linus Torvalds: “I started the day with "I want to connect two pedals together and have them validate each other", and ended the day with three pedals, a signal generator, and a USB MIDI dongle all connected together as a validation bench with automated checks.” (https://github.com/torvalds/GuitarPedal/commit/d1b95dc5e71e0a2d42912001c5fa4469bbc88766)

### 90. Your git log obeys your rules file

If the rules say "no AI trailers", the last 100 commits have none. If they say "tests pass", they did.

- How it's checked: Compare what your global rules demand with your last 100 commits (trailers, messages). They agree.
- Who does it: Mike McQuaid: “reject "has AI attribution; remove it and disclose AI use in the PR description."” (https://github.com/MikeMcQuaid/dotfiles/blob/a340d0ef58084694861946d587a0832a80782898/git-hooks/pre-push#L51)

## Levels 91–100: Stone, again · Full circle

Less config, more judgement. You read the 5% that matters.

### 91. Delete more config than you add

Prune the rules, skills and servers that don't earn their tokens anymore.

- How it's checked: A rules file that got shorter at least once in its git history.
- Who does it: Dax Raad: “when i see people with custom workflows and setups they're all addressing problems that don't exist anymore” (https://x.com/thdxr/status/2107260844400931156)

### 92. Start clean with each new model

Old prompts fight new models. Reset, then add back only what's missing.

- How it's checked: Your setup was trimmed or rewritten soon after a major model release.
- Who does it: Cat Wu: “I generally reset my configs for each new model” (https://x.com/_catwu/status/2102556970473709717)

### 93. Fewer agents, on purpose

You've run ten at once, and you know exactly why you run two now.

- How it's checked: You used to run more parallel agents than you do now, by choice.
- Who does it: Thariq Shihipar: “now like it's mostly one active Claude Code session and then a bunch of Claude Tag sessions.” (https://www.youtube.com/watch?v=aVO6E181cNU&t=1200s)

### 94. Write the skeleton yourself

Types, signatures, the hard 20%. It fills in the bodies.

- How it's checked: You write structure and interfaces by hand before handing over.
- Who does it: Alex Kladov: “I was providing structure, Claude was painting by the numbers.” (https://matklad.github.io/2026/01/20/vibecoding-2.html)

### 95. Review by risk, not by habit

A copy fix gets a glance. Auth, money and migrations get every line.

- How it's checked: Your rules or review setup name the paths that always get a human read.
- Who does it: Boris Cherny: “I read diffs when it's touching critical code, or code that's important to get right. I don't write the code.” (https://x.com/bcherny/status/2098210496109572123)

### 96. Cap what it writes per day

No more code than you can actually review. The bottleneck is you, so be the bottleneck on purpose.

- How it's checked: You hold back generation to what you can review.
- Who does it: Mario Zechner: “Set yourself limits on how much code you let the clanker generate per day, in line with your ability to actually review the code.” (https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down/)

### 97. Teach it to someone

Pair with a colleague, run a workshop, write the post. You don't know a trick until you've taught it.

- How it's checked: Only you know.

### 98. It knows when to stop and ask

Stuck agents ask instead of trying a ninth fix. You set that up.

- How it's checked: A rule or hook that makes it stop and report when stuck or out of scope.

### 99. Read all 3,000 lines, once

At least once, on something that mattered, you read every line it wrote. Then you know what to skip.

- How it's checked: Only you know.
- Who does it: Mitchell Hashimoto: “First, I reviewed the entire diff (yes, all ~3,000 lines of it). Then I reviewed it again. I re-read the entire diff by hand three or four times.” (https://mitchellh.com/writing/simdutf-no-libcxx)

### 100. Read the right 5%

Know which part of the diff can hurt you, and read that part properly. Every time.

- How it's checked: Only you know.

## Fossil record

- "You are a senior engineer with 20 years of experience." (extinct, 2023): Role-play preambles. Today's models don't need the pep talk; they need the context.
- "I'll tip you $200 for a perfect answer." (extinct, 2023): It sort of worked once. Nobody ever paid.
- "Take a deep breath and work on this step by step." (extinct, 2023): Reasoning models think before answering anyway.
- "Write the full code. No placeholders." (extinct, 2023–24): From the era of lazy models and "// rest of the code stays the same".
- .cursorrules (extinct, 2024): One file in the repo root. Replaced by rule folders and AGENTS.md, which every agent reads.
- Codex custom prompts (extinct, 2025): Deprecated in favour of skills.
- "ultrathink" (endangered, 2025–): Thinking keywords. Effort is a setting now, and reports disagree on whether the word still does anything.
- "How many r's are in strawberry?" (extinct, 2024): Retired as a benchmark. Still a good party trick.
