# Tricks to pick from

From 94 engineers' real setups at https://www.prehistoriq.com/stacks/, each linked to where they said it.
Pick by `id`. Fit matters more than fame: match how the person works and how far along they are.

- `steipete`: **$autoreview**, before every commit. A review skill that must pass before anything lands. (Peter Steinberger, https://github.com/steipete/agent-scripts/blob/79150cfac4a6ba4df13cf30176bf2db85170ae6c/AGENTS.MD#L83)
- `simonw`: **Showboat**, agents demo their own work. A CLI he built so agents record the commands they ran and the real output, as proof the code works. (Simon Willison, https://simonwillison.net/2026/Feb/10/showboat-and-rodney/)
- `bcherny`: **/go**, test, /simplify, open PR. One skill at the end of most prompts puts his verify-first rule into practice. Claude tests its own work end to end before it opens a PR. (Boris Cherny, https://x.com/bcherny/status/2044847858634064115)
- `karpathy`: **autoresearch**, overnight agent research. He edits only program.md and agents run the experiments; round one found ~20 real gains. (Andrej Karpathy, https://github.com/karpathy/autoresearch/blob/e6d79c123441a53d91bb8df7adf4db45cf120bf1/README.md#L7)
- `mitchellh`: **Harness engineering**, after every agent mistake. He coined the term. Every bad agent behavior gets an AGENTS.md line or a script so it never happens again. (Mitchell Hashimoto, https://mitchellh.com/writing/my-ai-adoption-journey)
- `dhh`: **"Review this with claude"**, adversarial review from Codex. He drives from Codex and has Claude review the work, one agent checking the other. (DHH, https://x.com/dhh/status/2107882896195199116)
- `mitsuhiko`: **/answer**, in place of plan mode. He skips plan mode and lets the agent ask questions in plain prose, then a self-built extension turns those questions into a form he fills in. (Armin Ronacher, https://lucumr.pocoo.org/2026/1/31/pi/)
- `t3dotgg`: **T3 Code**, his own GUI over every agent. He built the app he works in: one window over Claude Code, Codex and the rest, and the repo expects most contributions to come from T3 Code itself. (Theo Browne, https://github.com/pingdotgg/t3code/blob/9bd1d8009a6b7c50f9dd9458e2bf27d481ff3b43/AGENTS.md#L41)
- `antirez`: **QA_BEFORE_RELEASES.md**, an agent QA pass per release. A 2,088-line release gate an agent works through, which he credits with raising quality. (Salvatore Sanfilippo (antirez), https://antirez.com/news/168)
- `theprimeagen`: **Field guide**, agent writes its own lessons. Every session is logged with commit hashes, then the agent turns it into a project guide it must read before touching code. (ThePrimeagen, https://x.com/ThePrimeagen/status/2081066227619836308)
- `steveyegge`: **Seats**, 18 long-lived Fable officers. Every agent boots into a named office with its own memory and authority, which he says saves tokens. (Steve Yegge, https://yegge.ai/essays/seats-and-sunsets/)
- `levelsio`: **tm**, a tmux session per site. A Claude-written script that drops him into a per-project tmux session with Claude Code, straight on the production server. (Pieter Levels, https://x.com/levelsio/status/2091987033367724309)
- `badlogic`: **Daily code limit**, sized to what he can review. He wrote his own agent and still rations how much code it writes in a day. (Mario Zechner, https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down/)
- `mrnugget`: **“Irrefutable proof”**, video proof, not line reads. Rather than read the diff, he asks the agent in its orb to prove the work end to end, often with a video. (Thorsten Ball, https://registerspill.thorstenball.com/p/joy-and-curiosity-99)
- `obra`: **/par**, rival reviewers, 5 points. His adversarial review command makes two subagents compete to find the most real issues, and inflated findings get a reviewer disqualified. (Jesse Vincent, https://github.com/obra/dotfiles/blob/6ebb5ba848526b2bfd5b5ab3cb30741ff32c4447/.claude/commands/par.md#L1)
- `harperreed`: **"fresh eyes" review**, a subagent rereads the code. His careful-review command sends a subagent back over new code with "fresh eyes". Jesse Vincent says he learned the trick from Harper. (Harper Reed, https://github.com/harperreed/dotfiles/blob/6db272a76a71b098272c7c8a26ae084d197a43ac/.claude/commands/careful-review.md#L1)
- `kentbeck`: **TCR skill**, red tests revert the code. His own Test && Commit || Revert discipline as an always-on agent rule, so a failing step is thrown away instead of patched. (Kent Beck, https://github.com/KentBeck/TCRSkill/blob/0132ef205b08ef0558cd493336420cce9dbbfa89/.cursor/rules/tcr-always.mdc#L2)
- `kieranklaassen`: **/ce-compound**, turns each fix into a lesson. The step his whole method is named for, writing every solved problem down so the next agent starts smarter. (Kieran Klaassen, https://every.to/p/compound-engineering-gets-an-upgrade)
- `mattpocock`: **/grill-me**, before every change. His most popular skill makes the agent interview him until the design is settled, before any code is written. (Matt Pocock, https://github.com/mattpocock/skills/blob/7a030a8b0dcaa601bb0dda9aaf174affb3d61145/README.md#L103)
- `indragiek`: **Claudescope**, transcript link in every PR. He built his own hook-driven tool so reviewers read the agent session and plan behind a PR instead of the generated diff. (Indragie Karunaratne, https://www.youtube.com/watch?v=IPBIB7Go6TY&t=463s)
- `addyosmani`: **/loop PR triage**, on Agent Skills, every day. Scheduled agent loops make the first pass on the PR queue of his 100k-star skills repo. (Addy Osmani, https://addyo.substack.com/p/practical-loop-engineering)
- `ghuntley`: **The Ralph loop**, an agent in a bash while loop. He invented it. One prompt file fed to an agent again and again until the work is done. (Geoffrey Huntley, https://ghuntley.com/ralph/)
- `sqs`: **"I'm feeling Pucky" button**, starts half their work. A Slack button that turns a bug report into an agent thread with one click, and he says about half the team's work starts there. (Quinn Slack, https://ampcode.com/podcast/season-02/episode-05)
- `thdxr`: **Voice prompting (Hex)**, instead of typing. He dictates prompts with fast local voice models and says voice, not OpenCode, is what replaced his editor. (Dax Raad, https://x.com/thdxr/status/2078527322563449007)
- `nickbaumann98`: **"Chief of staff" thread**, spawns every project thread. One persistent Codex thread runs his work. It starts each new project thread and checks in on them. (Nick Baumann, https://x.com/nickbaumann_/status/2060480729830789376)
- `adamwathan`: **Every tedious OSS task**, fed to cloud Claude Code. Since January 2026 he hands the Tailwind chores he would otherwise neglect to Claude Code on the web and keeps working; ten of his 2026 Tailwind commits carry its session links. (Adam Wathan, https://x.com/adamwathan/status/2017616165455949851)
- `antfu`: **antfubot**, agents ship PRs as a bot. His agents work under their own GitHub account and open PRs he reviews and merges, so agent work is always labelled. (Anthony Fu, https://github.com/antfubot)
- `awesomekling`: **Welfare checks**, on workers across 4 machines. The coordinator, not he, watches for stuck or crash-looping workers, so multi-day runs need no steering. (Andreas Kling, https://x.com/awesomekling/status/2102089363631059199)
- `bcantrill`: **This Old Repo**, reviving a 1990s game. He pointed Claude at BattleTris, a game he started in the mid-1990s that had not built in over 20 years. Claude found the 64-bit stack smash that kept it from running. It is his case for agents doing tedious, open-ended restoration nobody would finish by hand. (Bryan Cantrill, https://bcantrill.dtrace.org/2026/05/25/a-portentous-reunion/)
- `birgitta410`: **sensors check**, a sidecar the agent polls. She built a CLI that keeps linters, tests, coverage and mutation testing running beside the agent and hands it a short status with fix guidance, so it can self-correct before she reviews. (Birgitta Böckeler, https://martinfowler.com/articles/sensors-for-coding-agents.html)
- `burkeholland`: **A lead agent per project**, he just files issues. Each project gets a standing Copilot lead that triages, tests, merges and cleans up, so his input is the issue tracker. (Burke Holland, https://x.com/burkeholland/status/2105459495833063754)
- `burntsushi`: **"I wrote this PR with an LLM"**, flagged for careful review. He says up front which PRs an LLM wrote, reviews them as untrusted and pares them down himself. (Andrew Gallant, https://github.com/rust-lang/regex/pull/1364#issuecomment-4642193394)
- `calvinfo`: **/pr-pass**, loops until CI and bots pass. At the end of /implement-all it pushes, waits for CI, fixes what Bugbot and Codex flag, and goes round again, so review comments get handled without him. (Calvin French-Owen, https://calv.info/agents-feb-2026)
- `catherinewu`: **Fresh config per model**, reset at every model launch. She tests each new model on a clean slate instead of carrying old tweaks forward. (Cat Wu, https://x.com/_catwu/status/2102556970473709717)
- `chiphuyen`: **Cross-provider runner**, Codex, Claude spawn each other. She built her own runner so a strong model plans and reviews while Codex and Claude agents hand work to each other. (Chip Huyen, https://github.com/hugobowne/show-us-your-agent-skills/blob/2c1f52025a1a993a5ce58c744d6a6e987ff58c2e/episode-field-notes/ep-8/chip.md#L38)
- `chrismccord`: **`notify msg`**, in CLAUDE.md, not a hook. Instead of hooks, one line in his global CLAUDE.md makes Claude ping him when work is done. (Chris McCord, https://x.com/chris_mccord/status/2016576023400181773)
- `crawshaw`: **meat**, strips diffs to what matters. His own LLM tool that cuts imports, nil-checks and error handling out of a diff, so his review covers only the architecture. (David Crawshaw, https://github.com/boldsoftware/meat/blob/f39f41dfe7b5b37a12b35fdfbaecc7e779855bd3/README.md#L5-L10)
- `cvolawless`: **LGTM, the PR closer**, a bot that clears her PR queue. A bot she built that goes through her PRs every day, merges, closes, rebases and nudges, and hands fixes to Cursor agents. (Claire Vo, https://www.lennysnewsletter.com/p/grok-bot-vs-openclaw-how-i-replaced)
- `danluu`: **Named-persona review panels**, with contrarian personas. Instead of switching models, he has independent agents review as named engineers (and as himself) plus contrarians, which he says beat the same token budget spent otherwise. (Dan Luu, https://danluu.com/ai-coding/)
- `dbreunig`: **Plumb**, reviews decisions at commit. His own tool stops each commit, pulls the decisions out of the diff and agent transcripts, and makes him approve them, keeping spec, tests and code in sync. (Drew Breunig, https://www.dbreunig.com/2026/03/04/the-spec-driven-development-triangle.html)
- `dexhorthy`: **/show-me**, diagrams, not walls of prose. His own skill makes agents explain plans and diffs as trees, call stacks and diagrams, so he can review them fast. (Dex Horthy, https://www.humanlayer.dev/blog/show-me-skill)
- `dshipper`: **"Want me to compound?"**, asked after every sweep. His AGENTS.md makes the agent offer, after each run, to turn what it learned into a policy change he approves. (Dan Shipper, https://github.com/EveryInc/tend/blob/ba6ba0e614f5d1151b75032bd58951a0fcb75067/AGENTS.md#L24-L25)
- `embirico`: **"Using a subagent in parallel, do X"**, from one always-on thread. Instead of opening new threads, he keeps one thread alive and hands every new task to a subagent from it. (Alexander Embiricos, https://x.com/embirico/status/2046033614106931414)
- `ezyang`: **sl follow / sl adopt**, restack parallel agents. Two Sapling aliases let agents in several worktrees amend one shared stack without trampling each other. (Edward Z. Yang, https://blog.ezyang.com/2026/03/parallel-agents-heart-sapling/)
- `fabiensanglard`: **"Reload agent.md"**, when code quality drops. A one-line fix for context dilution, sent the moment the agent's style slips. (Fabien Sanglard, https://fabiensanglard.net/agent.md/index.html)
- `filosottile`: **filippo-agent**, agent's own GitHub account. His agent commits from a separate, low-privilege GitHub account so it never holds his maintainer keys. (Filippo Valsorda, https://bsky.app/profile/filippo.abyssdomain.expert/post/3mmjslkth422a)
- `garrytan`: **/plan-ceo-review**, finds the 10-star product. Before any code, an agent plays founder and challenges the scope of the request. That is the role at the centre of his setup of agents as a virtual company. (Garry Tan, https://github.com/garrytan/gstack/blob/c285d88b90d39116ccfa2b901f80ea0fce0b26eb/README.md#L250)
- `geerlingguy`: **AI Disclosure**, README names the exact model. Every Claude-built repo we found ends with a section saying which model wrote what, down to the effort level. (Jeff Geerling, https://github.com/geerlingguy/densitron-lcd/blob/645fa2cb29dc4e3c901b3cc2e3eed5cfd73ed26d/README.md#L41-L43)
- `geoffreylitt`: **/explain-diff**, with a quiz before he ships. Every agent change becomes a background-intuition-code explainer ending in five quiz questions, and he won't send code until he passes. (Geoffrey Litt, https://geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html)
- `geohot`: **(kimi) in the PR title**, names the model per PR. His tinygrad PRs carry the name of the model that helped, a public log of which model wrote what. (George Hotz, https://github.com/tinygrad/tinygrad/commit/9f6d3d882cfe0b8d5e98255b85d9c96dac2966b3)
- `jarred-sumner`: **Adversarial review**, 2 Claudes refute every change. Separate Claude reviewers who only see the diff and try to prove it wrong let him merge a million-line port. (Jarred Sumner, https://x.com/jarredsumner/status/2060050588574818763)
- `jessitron`: **Capability Owners**, standing agents per feature. Her create-owner skill appoints a standing Owner for each capability, a knowledge base plus instructions a fresh subagent follows, so 'everything else still works' has someone to check it. (Jessica Kerr, https://github.com/jessitron/tronijess-skills/blob/6a0c93bac3617baf3a60c64e10449c760d5a1922/README.md#L33-L36)
- `josevalim`: **Adversarial review agents**, on compiler & security work. He makes a second set of agents try to disprove a change before any human sees it. (José Valim, https://github.com/elixir-lang/elixir/blob/f6e177092eca20118eddf95d6a4e663f3d53d0c3/CONTRIBUTING.md#L221-L225)
- `jph00`: **claude-air**, nudges after 8 silent rounds. A hook that interrupts long silent tool runs and makes the agent stop, say what it found and check its own last call, so he stays in the loop instead of the agent drifting. (Jeremy Howard, https://github.com/AnswerDotAI/aai-coding/blob/bb010bf14189878ed1b2bb8db7158305c61696a3/SETUP.md#L140)
- `jxnl`: **$ultragoal**, goal kept in an editable file. Long Codex runs chase a goal kept in a file, so he can add scope while the loop is still running. (Jason Liu, https://ai.engineer/talks/il1c1a2FufU-full-workshop-setting-yourself-up-for-success-jason-liu-openai-codex)
- `kentcdodds`: **/ship-pr**, Bugbot loop, merge, Discord. A cloud agent babysits its own PR through Bugbot and CI, merges low-risk changes, then posts a summary with the billed agent cost to his Discord. (Kent C. Dodds, https://github.com/kentcdodds/kcd-skills/blob/ab6303e3b22fbbeec665f9a62ee654f379c8c600/skills/ship-pr/SKILL.md#L3-L5)
- `kentonv`: **plans/ in the repo**, checked in for code review. The agent-written plan is committed beside the code, so reviewers and later prompts work from the same document. (Kenton Varda, https://news.ycombinator.com/item?id=49191519)
- `kepano`: **Fail-first fixtures**, before every extraction fix. His rules make the agent prove a bug with a failing fixture before fixing it, and forbid editing expectations to fit. (Steph Ango, https://github.com/kepano/defuddle/blob/49d14ecc4089696565c2479b2f57db72be199adc/AGENTS.md#L17)
- `leerob`: **Plan mode**, before every long agent run. He plans each change with the model in Cursor, then hands it to a cloud agent and walks away. That is how he built a whole Rust library without writing code by hand. (Lee Robinson, https://leerob.com/pixo)
- `lethain`: **/linear-project-loop**, loops a project to its goal. A software-factory skill that audits a Linear project's RFC and metrics, files missing issues, then works the unblocked ones. (Will Larson, https://lethain.com/software-factory-experiment/)
- `maggieappleton`: **maggie-design**, her design taste, as a skill. She says design, not build time, is always her bottleneck, so she wrote her own design philosophy down for the agent. (Maggie Appleton, https://github.com/MaggieAppleton/maggieappleton.com-V3/blob/ca41b010e1910fb753529f0ec4f9be2e4089b576/.claude/skills/design-and-ui/maggie-design/SKILL.md#L8)
- `matklad`: **Hand-typed skeletons**, Claude fills in the bodies. He types the types and function signatures himself and has Claude complete only the bodies, so the code keeps his structure. (Alex Kladov, https://matklad.github.io/2026/01/20/vibecoding-2.html)
- `mckaywrigley`: **"You are AGI-pilled."**, in every agent's system prompt. One line he puts in every agent's system prompt, after two weeks of A/B tests, so agents stop acting as if the world stays static. (McKay Wrigley, https://x.com/mckaywrigley/status/2085078744486789248)
- `mikemcquaid`: **AgentIDE**, his own vibe-built agent IDE. He replaced Superset, Fork and Zed with a native app he built for sandboxed agents in parallel worktrees, now in Homebrew. (Mike McQuaid, https://mikemcquaid.com/vibe-coding-developer-productivity-tools/)
- `mikeyk`: **iOS Claude pings Android Claude**, to port each feature. He keeps an iOS and an Android version of a Labs app in step by having the agent on the iOS side message the agent on the Android side after each change. (Mike Krieger, https://podscripts.co/podcasts/big-technology-podcast/anthropics-labs-lead-on-fables-capabilities-building-ai-native-products-with-mike-krieger)
- `minimaxir`: **codex exec Luna subagents**, 7–12 cheap critics per pass. Instead of the harness's full-price subagent tool, his prompt makes the agent shell out to cheap read-only Codex runs that pitch ideas and then sign off on the result. (Max Woolf, https://minimaxir.com/2026/09/agentic-iteration/)
- `natolambert`: **/gemini-feedback**, Gemini critiques each diagram. Claude Code draws the textbook figures, then a skill sends each one to Gemini for a second model's review. (Nathan Lambert, https://github.com/natolambert/rlhf-book/blob/6063b3de36fff7cb57892e99519dbdd7d72f0225/CLAUDE.md#L36)
- `nedbat`: **Be introspective**, Claude fixes its own rules. When a workflow goes wrong, his CLAUDE.md has Claude work out why and propose changes to its own instructions. (Ned Batchelder, https://github.com/nedbat/dotfiles/blob/003ae2618eebc9877f69e7a01f610d43070bd92c/dot_config/claude/nedbat-main.md#L11-L13)
- `nolanlawson`: **code-review-turbo**, three-agent PR bug hunt. Claude, Codex and Cursor Bugbot each review the PR, then the main agent cross-checks their findings to drop hallucinated bugs. (Nolan Lawson, https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/)
- `orta`: **/commit**, human writes the headline. He types the first line of every commit himself and Claude only adds the body from the diff, so humans still write for humans. (Orta Therox, https://blog.puzzmo.com/posts/2026/07/03/twelve-months-of-claude/)
- `paulirish`: **paulirish-agent**, a GitHub account for agents. Agent commits land under their own GitHub identity, so his history shows what he wrote and what the agent wrote. (Paul Irish, https://github.com/paulirish-agent)
- `rasbt`: **Audit the agent first**, before installing any harness. Before trying a new coding agent he clones its repo and has a trusted agent audit it for egress and blast radius. (Sebastian Raschka, https://magazine.sebastianraschka.com/p/using-local-coding-agents)
- `rauchg`: **gdp-ts**, auth checks as type proofs. Instead of reviewing more agent code, he wrote a library, linter and skill that make the type checker reject missing authorization checks. (Guillermo Rauch, https://x.com/rauchg/status/2107119811444748555)
- `ry`: **Claw Patrol**, firewall between agents and prod. Rather than trust the agent, Deno routes its agents' production traffic through a gateway that parses SQL, Kubernetes and HTTP and enforces rules. (Ryan Dahl, https://deno.com/blog/clawpatrol)
- `sgoedecke`: **30-second triage**, rejects most agent attempts. He lets agents attempt every change, throws most away after a half-minute skim, and only reviews in depth the attempt worth keeping. (Sean Goedecke, https://www.seangoedecke.com/how-i-use-llms-in-2026/)
- `slavingia`: **Fourth-wall check**, enforced in CI on every PR. A hard rule, checked by a linter in CI, that prototype copy never calls itself a prototype or explains its changes. (Sahil Lavingia, https://github.com/slavingia/prototypes/blob/9c921329300d64ecb328e8fdb0fd633fc087d810/CONTRIBUTING.md#L17-L18)
- `snarktank`: **!land playbook**, refreshes skills on every PR. His Devin playbook for every merge starts a child session that updates skills and docs, so they never go stale. (Ryan Carson, https://x.com/ryancarson/status/2089719890097664413)
- `steveklabnik`: **rue-overnight-hunt**, bugs filed only with repros. An overnight workflow that fans out bug finders across one compiler subsystem and files only findings whose repro was actually run. (Steve Klabnik, https://github.com/rue-language/rue/blob/5200b119000163884fb28310fd49107c662761af/.claude/workflows/rue-overnight-hunt.js#L3)
- `swyxio`: **$cassandra-creator**, a standing dissent agent. Next to a CEO agent that runs a project, he sets up an independent agent whose job is to challenge it. (swyx, https://github.com/swyxio/skills/blob/038ef3441a4c7bfff16ae3241dc1730746a69a5b/cassandra-creator/SKILL.md#L8)
- `teorth`: **Five favorable conditions**, before handing code to an agent. He delegates all the coding only when the work is non-critical, stand-alone, sandboxed, off his core skills and not competing with humans. (Terence Tao, https://terrytao.wordpress.com/2026/07/16/two-more-apps-visualizing-the-zeta-process-and-the-motions-of-the-heavens/)
- `thariqs`: **Change quiz**, must pass before merging. Instead of trusting a diff, he has Claude explain the change in HTML and quiz him on it, and he merges only after a perfect score. (Thariq Shihipar, https://x.com/trq212/status/2073100352921215386)
- `tiangolo`: **AI Disclaimer**, names agent and model in PRs. Each agent-made PR states the agent, the exact model and that he reviewed it by hand. (Sebastián Ramírez, https://github.com/fastapi/sqlmodel/pull/2112)
- `tibo-openai`: **Random-file bug hunt**, automation, several times a day. A scheduled Codex automation literally runs Python random to pick a file, then finds and fixes a latent bug in it. (Thibault Sottiaux, https://every.to/podcast/transcript-how-openai-s-codex-team-uses-their-coding-agent)
- `tmcw`: **Pi on GLM 5.2**, as the security bug hunter. A cheap model that does not refuse security work, in a separate harness with Cloudflare's audit skill and a local OWASP cheatsheet checkout. (Tom MacWright, https://blog.val.town/security)
- `tobi`: **qmd**, local search, agents too. His own all-local search engine is the base layer under the tools he builds, and he points his agents at it too. (Tobi Lütke, https://x.com/tobi/status/2013217570912919575)
- `tonsky`: **Live nREPL for the agent**, instead of app restarts. His CLAUDE.md points the agent at a running nREPL so it evaluates and reloads code the way a Clojure programmer does. (Nikita Prokopov, https://github.com/tonsky/chillalert/blob/6bd46030dbbe911e60c2b0b6b04778b9dfba9db1/CLAUDE.md#L3)
- `torvalds`: **Pedals in a ring**, a bench that tests itself. He had Opus turn three pedals and a signal generator into an automated test bench, so agent changes get measured on real hardware instead of eyeballed on a scope. (Linus Torvalds, https://github.com/torvalds/GuitarPedal/commit/d1b95dc5e71e0a2d42912001c5fa4469bbc88766)
- `tqbf`: **swiftui-app template**, copied into every new app. One folder carries his rules, skills and no-Xcode build, so every app starts with cp -R and a sentence. (Thomas Ptacek, https://sockpuppet.org/blog/2026/08/20/stop-making-tuis/)
- `unclebob`: **uml-viewer**, colored by CRAP + mutation. Instead of reading agent code, he drills through a live UML diagram of the system, colored by CRAP and mutation scores, and tells a companion agent what to change. (Robert C. Martin, https://x.com/unclebobmartin/status/2100938985543446954)
- `walnutwaldo`: **Daily customer-report Devin**, escalates top feature asks. His favorite Devin job is not code at all, it reads every customer report each day and escalates the top requests to engineering. (Walden Yan, https://x.com/walden_yan/status/2090158861974163826)
- `wesbos`: **vite-plugin-killer-instincts**, hands the LLM a kill command. Rather than a rule the agent can ignore, he ships a deterministic Vite plugin whose error tells the agent which process holds the port and how to kill it. (Wes Bos, https://github.com/wesbos/vite-plugin-killer-instincts/blob/26b8105bd6008565fc107ba799ef706d38711adc/README.md#L34)
- `wesm`: **roborev**, reviews every agent commit. He built a background reviewer that a second model runs on every commit his agents make, and will not code without it. (Wes McKinney, https://wesmckinney.com/transcripts/2026-02-10-rill-data-podcast.html)
- `xe`: **Assisted-by: footer**, model + tool on every commit. Her global rules make every agent sign its commits with the model and tool, so her git log is an honest record of who wrote what. (Xe Iaso, https://github.com/Xe/x/blob/de9b63d24e5216518495966b5816156cfdde1c56/pkgs/claude-code-cfg/CLAUDE.md#L7-L10)
- `zachlloyd`: **Scorer + self-improvement agents**, agents that fix agents. Scorer agents grade every agent run, and other agents turn low scores into PRs that fix the factory's skills. (Zach Lloyd, https://x.com/zachlloydtweets/status/2105659008577060915)