@stupify/cli 0.1.0 → 0.2.0

package/.review/CORPUS.md

@@ -1,73 +1,44 @@
-# Good-code reference — YOUR curated exemplars (template)
+# Good-code reference — taste packs
 
-> This is a template. **Replace it with 3–6 files from your own codebase that you'd point a new hire at** —
-> the code you wish all your code looked like. The reviewer treats these as the standard and measures every
-> diff against them. Taste can't be auto-extracted: hand-pick these, and say *why* each is good. A vague
-> corpus produces vague reviews; a sharp one produces sharp ones.
-
-How to write an entry:
-- **Name the file** (a real path in this repo) and **one sentence on what makes it good** — the principle it
-  embodies (e.g. "complexity tamed by decomposition", "type makes illegal states unrepresentable",
-  "fail-fast at the boundary"). The reviewer opens the live file; the excerpt just shows the shape.
-- Keep a short code excerpt that captures the pattern. The point is the *principle*, not the lines.
-- Group loosely (e.g. "complex but readable", "clean service boundary") so the reviewer can cite the right one.
-
-Pick principles you actually care about. Common ones worth encoding:
-**dependency injection** (collaborators injected, never `new`d inline; config read only at a composition root),
-**type-system-first invariants** (`satisfies`, discriminated unions, schemas at boundaries — illegal states
-hard to represent), **fail fast and loud** (no silent fallback), **small single-responsibility units**,
-**declarative over imperative**, **readable signatures** (≤3 positional params → options object).
+Judge every diff against the standards below. When you flag slop, name the principle (or the linked file) the change should have followed. The links are commit-pinned exemplars — open them when you need detail.
 
 ---
 
-## A. Complex, kept readable
-
-### 1. `src/path/to/your-exemplar.ts` — one line on why it's good
-`src/path/to/your-exemplar.ts`
-
-Say what makes it the standard — e.g. the complexity (optimistic UI, retries, sync) is tamed by decomposition:
-the orchestrator only *coordinates*; every concern is a small focused unit, and every operation is the same
-shape, so N of them read like one.
+## Code like Sindre Sorhus (@sindresorhus) · one file, one job
 
-```ts
-// a short excerpt that shows the pattern — the shape, not the whole file
-export function handle(input: Input): Result {
-  const state = read()
-  const ops = compute(state, input)   // pure
-  return apply(ops)                   // effectful shell
-}
-```
+Radical minimalism: each module does exactly one thing and is small enough to read in five minutes. A function
+where a class would do; no surprise dependencies; inputs validated eagerly at the top so failures are loud and
+early. Tiny public surface, deep comments on the *why*. If it can't be read top-to-bottom in one sitting, it's
+too big.
 
-### 2. `src/path/to/another.ts` — composition + named pieces
-`src/path/to/another.ts`
+- [`p-limit/index.js`](https://github.com/sindresorhus/p-limit/blob/42599ebbbb1228a5bdab381fcf8f4ac20eb8d551/index.js) — a whole concurrency limiter in one short, obvious file.
+- [`execa/options.js`](https://github.com/sindresorhus/execa/blob/f3a2e8481a1e9138de3895827895c834078b9456/lib/arguments/options.js) — careful, explicit input normalization before anything runs.
+- [`chalk/index.js`](https://github.com/sindresorhus/chalk/blob/aa06bb5ac3f14df9fda8cfb54274dfc165ddfdef/source/index.js) — a clean, composable API with a minimal surface.
 
-e.g. pure composition — each piece a named small component, conditions become named type-guards, not inline
-boolean soup.
-
-```ts
-function hasMeasuredWidth(width: number | undefined): width is number {
-  return width !== undefined && width > 0
-}
-```
 
 ---
 
-## B. Clean boundary / DI
+## Code like Anton Kropp (@devshorts) · DI + branded types
 
-### `src/path/to/service.ts` — injected collaborator + composition-root factory
-`src/path/to/service.ts`
+The Startup Architecture house style: every domain concept gets its own tiny wrapper type (a `QueueName`,
+never a raw `String`), so a primitive never leaks across a boundary. Dependencies are wired through small,
+single-purpose DI modules listed explicitly at one auditable composition root. Interfaces are single-method
+contracts. `Clock` is injected so tests can move time. Fail fast and loud; no silent fallbacks.
 
-e.g. constructor injection — the collaborator is never `new`d inline; a small factory is the composition root;
-the method parses input at the boundary, logs with structured context, and **fails loud** (catch → log → rethrow).
+- [`QueueName.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/model/src/main/java/io/paradoxical/cassieq/model/QueueName.java) — a branded value type: a raw string can't masquerade as a `QueueName`.
+- [`DefaultApplicationModules.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/DefaultApplicationModules.java) — the composition root: one explicit list of named DI modules, no magic scanning.
+- [`ClockModule.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/ClockModule.java) — one module, one concern (binds `Clock`), trivially swapped in tests.
 
-```ts
-export function createService() {
-  const scope = container.createChildContainer()
-  scope.register(CLIENT, { useValue: makeClient() })
-  return scope.resolve(Service)
-}
-```
 
 ---
 
-> Add a "Fine — do NOT flag" set of your own here too, if there are patterns reviewers keep wrongly dinging.
+## Code like Colin McDonnell (@colinhacks) · parse, don't validate
+
+Data never enters the system as an unvalidated primitive — it's parsed at the boundary and the parsed type
+guarantees its shape. Schemas are immutable values (methods return new instances). Errors are discriminated
+unions with a `code`, so every branch is exhaustive and typed. `parse` throws (fail fast); `safeParse` returns
+a typed result for callers that want to branch. Composable validators replace hand-rolled type guards.
+
+- [`parse.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/parse.ts) — symmetric `parse`/`safeParse` with the sync/async boundary enforced; the error class is injected, not hardcoded.
+- [`errors.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/errors.ts) — a discriminated-union error type, every field `readonly`, a `path[]` for nested location.
+- [`schemas.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/schemas.ts) — distinct compile-time types per schema kind: illegal states are unrepresentable.

package/.review/CORPUS.template.md

@@ -0,0 +1,73 @@
+# Good-code reference — YOUR curated exemplars (template)
+
+> This is a template. **Replace it with 3–6 files from your own codebase that you'd point a new hire at** —
+> the code you wish all your code looked like. The reviewer treats these as the standard and measures every
+> diff against them. Taste can't be auto-extracted: hand-pick these, and say *why* each is good. A vague
+> corpus produces vague reviews; a sharp one produces sharp ones.
+
+How to write an entry:
+- **Name the file** (a real path in this repo) and **one sentence on what makes it good** — the principle it
+  embodies (e.g. "complexity tamed by decomposition", "type makes illegal states unrepresentable",
+  "fail-fast at the boundary"). The reviewer opens the live file; the excerpt just shows the shape.
+- Keep a short code excerpt that captures the pattern. The point is the *principle*, not the lines.
+- Group loosely (e.g. "complex but readable", "clean service boundary") so the reviewer can cite the right one.
+
+Pick principles you actually care about. Common ones worth encoding:
+**dependency injection** (collaborators injected, never `new`d inline; config read only at a composition root),
+**type-system-first invariants** (`satisfies`, discriminated unions, schemas at boundaries — illegal states
+hard to represent), **fail fast and loud** (no silent fallback), **small single-responsibility units**,
+**declarative over imperative**, **readable signatures** (≤3 positional params → options object).
+
+---
+
+## A. Complex, kept readable
+
+### 1. `src/path/to/your-exemplar.ts` — one line on why it's good
+`src/path/to/your-exemplar.ts`
+
+Say what makes it the standard — e.g. the complexity (optimistic UI, retries, sync) is tamed by decomposition:
+the orchestrator only *coordinates*; every concern is a small focused unit, and every operation is the same
+shape, so N of them read like one.
+
+```ts
+// a short excerpt that shows the pattern — the shape, not the whole file
+export function handle(input: Input): Result {
+  const state = read()
+  const ops = compute(state, input)   // pure
+  return apply(ops)                   // effectful shell
+}
+```
+
+### 2. `src/path/to/another.ts` — composition + named pieces
+`src/path/to/another.ts`
+
+e.g. pure composition — each piece a named small component, conditions become named type-guards, not inline
+boolean soup.
+
+```ts
+function hasMeasuredWidth(width: number | undefined): width is number {
+  return width !== undefined && width > 0
+}
+```
+
+---
+
+## B. Clean boundary / DI
+
+### `src/path/to/service.ts` — injected collaborator + composition-root factory
+`src/path/to/service.ts`
+
+e.g. constructor injection — the collaborator is never `new`d inline; a small factory is the composition root;
+the method parses input at the boundary, logs with structured context, and **fails loud** (catch → log → rethrow).
+
+```ts
+export function createService() {
+  const scope = container.createChildContainer()
+  scope.register(CLIENT, { useValue: makeClient() })
+  return scope.resolve(Service)
+}
+```
+
+---
+
+> Add a "Fine — do NOT flag" set of your own here too, if there are patterns reviewers keep wrongly dinging.

package/README.md

@@ -1,32 +1,67 @@
+> Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as
+> cleverly as possible, you are, by definition, not smart enough to debug it.
+>
+> — **Kernighan's Law**
+
 # stupify
 
+Tired of [wasting your time](https://github.com/thesysdev/openui/issues/517) reviewing [AI](https://github.com/RsyncProject/rsync/issues/929) [slop](https://github.com/anthropics/claudes-c-compiler/issues/1)?
+
+[![npm](https://img.shields.io/npm/v/@stupify/cli?color=cb3837&label=%40stupify%2Fcli)](https://www.npmjs.com/package/@stupify/cli)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 **A code reviewer that talks like an idiot and catches real bugs.**
 
-> uhhhh ummm a couple things 👇
+Kernighan was right: the clever code is the code you can't debug. stupify drags your code back toward boring —
+at **both ends** of the loop:
+
+- **before you code** — [`stupify prime`](#prime-your-agent-instant-local-no-servers) seeds every Claude Code session with your taste, so the agent writes to your standard from line one.
+- **after you PR** — the reviewer reads every PR on [Codex](https://github.com/openai/codex) against that *same* taste and flags what drifted.
+
+You encode your taste once — a `CORPUS.md` of files you already think are good (or a [taste pack](#taste-packs)) — and stupify enforces it going in and coming out. Not some model's idea of "best practice." So it catches the stuff that actually bugs *you*: premature abstractions, cute one-liners with a bug hiding in them, helpers someone reinvented. Then it points at the boring thing they should've used.
+
+Most AI reviewers carpet-bomb your PR with `consider renaming this`. stupify stays quiet until it finds
+something real, says it in one sentence, and shuts up.
+
+> uhhhh ummm this cleanup got a little cleanup-y:
 >
-> 🔴 **`src/checkout/session.ts:88`** · footgun · conf 0.9
-> if `stripe.retrieve()` throws, the `catch` returns an empty cart — a transient blip looks like an empty order.
-> **→ Fix:** rethrow with context, like the fail-loud boundary in `payment-service.ts`.
+> 🟠 **`server/checkout.ts:40`** · slop · conf 0.82
+> you inlined `validateCart` and `applyDiscounts` into the handler, so it's branch soup with two mutable `let`s now, instead of validate → price → charge. those weren't throwaway wrappers, they were the steps.
+> **→ Fix:** put the named steps back. the handler should orchestrate, not do all of it.
+>
+> 🟡 **`server/checkout.ts:12`** · slop · conf 0.7
+> `order?.total ?? order.cart.total` — `order` is required here, so the `?.` never fires and the fallback is dead code cosplaying as safety. it's `order.total`.
+> **→ Fix:** drop the `?.` and the `??`. if order's actually optional, fix the type, don't paper over it.
 >
 > _— stupify, against the good-code corpus_
 
-Reviews your PRs on [Codex](https://github.com/openai/codex), against a corpus of code **you** picked:
+### What you get
 
-- 🎯 **Your taste.** Hand-pick your best files into `CORPUS.md`; it judges diffs against *that*, and cites them.
-- 🧹 **Anti-slop.** `RUBRIC.md` defines slop for your team, and it right-sizes the fix to the owner.
-- 🧠 **Remembers + converges.** Fed the PR's thread, so it won't re-raise what you fixed or declined — and posts `no new blocking issues ✅` and stops.
-- 😂 **A personality.** `oof, yeah this'll break:` … then gets to the point. (Tunable.)
+- **Your taste, not the model's.** Everything is judged against a `CORPUS.md` — a [taste pack](#taste-packs) ("code like dtolnay / DHH / antirez …") or your own best files. Nothing to write to start.
+- **Slop, named.** `RUBRIC.md` is your list of what counts as slop: reinvented primitives, speculative abstraction, fallbacks the types already guarantee. It keeps the fix small.
+- **Both ends of the loop.** The *same* `.review/` primes the agent before it writes (prevention) and reviews the PR after (detection). The best review is the one you didn't need.
+- **It remembers.** Reads the PR thread, won't re-raise what you fixed or waved off, posts `no new blocking issues ✅` when there's nothing left.
+- **It's funny.** `oof, yeah this'll break:`. Turn it off if you hate joy.
 
-A finder, not a gatekeeper — it comments, it doesn't block merges.
+## Prime your agent (instant, local, no servers)
 
-## Quickstart
+The best slop is the slop never written. `prime` wires a Claude Code [SessionStart hook](https://docs.claude.com/en/docs/claude-code/hooks) that injects your taste into every session — so the agent holds your standard *before* it touches a line. Pure file read, ~30ms, no model call.
 
-Stupify runs on an always-on box, so it rides [exe.dev](https://exe.dev). From your laptop, **one command provisions everything** — it detects your repo, wires the GitHub integration, and spins up a VM that installs itself. No keys, no tokens, you never SSH anywhere:
+```bash
+bunx @stupify/cli taste --pack sindre-sorhus,zod   # pick the code yours should look like
+bunx @stupify/cli prime --install                  # every Claude Code session now opens knowing it
+```
+
+That's it. Open Claude Code in any repo and it's already primed. A repo's own `.review/` wins; otherwise it
+falls back to the taste you assembled. `bunx @stupify/cli prime --uninstall` removes the hook cleanly.
+
+## Add the reviewer (rides exe.dev — no keys, no servers *you* run)
+
+From your laptop, **one command** provisions a VM that reviews your repo's PRs. No API keys, no tokens — you
+never even SSH anywhere.
 
 ```bash
-bunx github:Octember/stupif.ai
+bunx @stupify/cli
 ```
 
 ```
@@ -36,25 +71,46 @@ bunx github:Octember/stupif.ai
 └  stupify is provisioned for acme/widgets 👀
 ```
 
-First time on exe.dev? `ssh exe.dev` to onboard, link GitHub at [exe.dev/integrations](https://exe.dev/integrations). Then give it your taste — copy [`.review/`](.review) into your repo and point `CORPUS.md` at your best files. Label a PR `codex-review` (or add [`autolabel.yml`](.github/workflows/autolabel.yml)) → a review in ~60s.
+New to [exe.dev](https://exe.dev)? `ssh exe.dev` to onboard and link GitHub at
+[exe.dev/integrations](https://exe.dev/integrations) — both one-time, both painless. Then just **open a PR** —
+stupify reviews every non-draft, non-bot PR in ~60s, no labels or workflows to wire up. (Want manual control?
+`SCOPE=label` flips it to opt-in: only PRs you tag get reviewed.)
 
 ```bash
-bunx github:Octember/stupif.ai <owner/repo>   # provision for a specific repo
-ssh exe.dev rm stupify-<owner>-<repo>         # tear it down
-bunx github:Octember/stupif.ai setup          # install on this machine instead of a VM
+bunx @stupify/cli <owner/repo>          # provision for a specific repo
+bunx @stupify/cli setup                 # run the reviewer on this machine instead of a VM
+ssh exe.dev rm stupify-<owner>-<repo>   # tear it down
 ```
 
+## Taste packs
+
+Don't have a corpus yet? Borrow one. Pick a programmer whose code you'd point a new hire at and review (and
+write) like them — or compose several:
+
+[dtolnay](packs/dtolnay.md) · [DHH](packs/dhh.md) · [antirez](packs/antirez.md) ·
+[Sindre Sorhus](packs/sindre-sorhus.md) · [Rich Harris](packs/rich-harris.md) ·
+[zod](packs/zod.md) · [Mitchell Hashimoto](packs/mitchell-hashimoto.md) ·
+[Tanner Linsley](packs/tanner-linsley.md) · [Simon Willison](packs/simon-willison.md) ·
+[Anton Kropp](packs/anton-kropp.md) · [the perf pack](packs/jarred-sumner.md) · [browse all →](packs)
+
+Each pack is concrete principles plus commit-pinned exemplar files. Or bring your own: drop a
+[`.review/`](.review) in your repo and point `CORPUS.md` at the files you *wish* all your code looked like (it
+always wins over a pack). stupify dogfoods this — its own [`.review/CORPUS.md`](.review/CORPUS.md) is real.
+
 ## How it works
 
 ```
-cron (~60s) → review-sweep.ts → codex exec → gh pr comment
-  refresh checkout · list labelled PRs · skip already-reviewed heads
-  feed the PR's thread back as memory · review against .review/* · post
+prime   Claude Code SessionStart hook → bun ~/.stupify/prime.ts → inject .review/ (rubric + corpus)
+review  cron (~60s) → review-sweep.ts → codex exec → gh pr comment
+          refresh checkout · list open PRs (skip drafts/bots) · skip already-reviewed heads
+          feed the PR's thread back as memory · review against .review/* · post
 ```
 
-The CLI (`src/cli.ts`) provisions; the engine (`src/review-sweep.ts`, dependency-free Bun) sweeps; the taste
-(`.review/`) lives in the repo it judges. Details in [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md).
+Both halves read the same `.review/` (a repo's own wins; else the pack taste you assembled). The CLI
+(`src/cli.ts`) sets things up; the engines (`src/prime.ts` and `src/review-sweep.ts`) are dependency-free Bun.
+The whole design — including why it *remembers* instead of debouncing — is in
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md).
 
 ## License
 
-[MIT](LICENSE) © Noah Lindner. `stupif.ai` — read it "stupify".
+[MIT](LICENSE) © Noah Lindner. Built by the team at [Bevyl](https://bevyl.ai). `stupif.ai` — read it "stupify". PRs welcome — it'll review them 😈

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stupify/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A code reviewer that talks like an idiot and catches real bugs — corpus-grounded, anti-slop, runs on Codex.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "src",
     ".review",
+    "packs",
     "README.md",
     "LICENSE"
   ],
@@ -16,10 +17,10 @@
   "homepage": "https://stupif.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Octember/stupif.ai.git"
+    "url": "git+https://github.com/Octember/stupify.git"
   },
   "bugs": {
-    "url": "https://github.com/Octember/stupif.ai/issues"
+    "url": "https://github.com/Octember/stupify/issues"
   },
   "keywords": [
     "code-review",
@@ -38,6 +39,7 @@
   },
   "scripts": {
     "typecheck": "tsc -p tsconfig.json",
+    "test": "bun test",
     "cli": "bun src/cli.ts"
   },
   "dependencies": {

package/packs/antirez.md

@@ -0,0 +1,10 @@
+## Code like Salvatore Sanfilippo / antirez (@antirez) · comments that earn their keep
+
+Readable C, of all things — because the comments do real work. ASCII-art diagrams of the data structure sit
+above the code that implements it. Banner section dividers read like chapters. Every function comment states
+the contract, the error return, and the ownership of any pointer it touches. Nothing non-obvious goes
+unexplained; nothing obvious gets a comment.
+
+- [`rax.h`](https://github.com/antirez/rax/blob/1927550cb218ec3c3dda8b39d82d1d019bf0476d/rax.h) — the radix tree drawn in ASCII before a line of it is implemented.
+- [`rax.c`](https://github.com/antirez/rax/blob/1927550cb218ec3c3dda8b39d82d1d019bf0476d/rax.c) — banner-divided sections; each function comment states its contract and pointer ownership.
+- [`sds.h`](https://github.com/antirez/sds/blob/5347739b1581fcba74fd5cab1fc21d2aef317d71/sds.h) — a string library whose header comments are the spec.

package/packs/anton-kropp.md

@@ -0,0 +1,10 @@
+## Code like Anton Kropp (@devshorts) · DI + branded types
+
+The Startup Architecture house style: every domain concept gets its own tiny wrapper type (a `QueueName`,
+never a raw `String`), so a primitive never leaks across a boundary. Dependencies are wired through small,
+single-purpose DI modules listed explicitly at one auditable composition root. Interfaces are single-method
+contracts. `Clock` is injected so tests can move time. Fail fast and loud; no silent fallbacks.
+
+- [`QueueName.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/model/src/main/java/io/paradoxical/cassieq/model/QueueName.java) — a branded value type: a raw string can't masquerade as a `QueueName`.
+- [`DefaultApplicationModules.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/DefaultApplicationModules.java) — the composition root: one explicit list of named DI modules, no magic scanning.
+- [`ClockModule.java`](https://github.com/paradoxical-io/cassieq/blob/3856962f13e5f7d84893a2ef274d08016b2c828b/core/src/main/java/io/paradoxical/cassieq/modules/ClockModule.java) — one module, one concern (binds `Clock`), trivially swapped in tests.

package/packs/dhh.md

@@ -0,0 +1,10 @@
+## Code like DHH (@dhh) · controllers that tell the story
+
+Conventions used so consistently that a new file is predictable. Controllers fit on one screen: actions are a
+few lines, all setup pushed into `before_action` filters with self-documenting names (`set_room`,
+`ensure_can_administer`). Cross-cutting behavior is extracted into named concerns (`Authentication`,
+`Authorization`), not sprinkled inline. The code reads like the product, top to bottom.
+
+- [`messages_controller.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/controllers/messages_controller.rb) — a controller you can read in one screen; the actions tell the story.
+- [`authentication.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/controllers/concerns/authentication.rb) — a named policy extracted as a concern, reused everywhere.
+- [`message.rb`](https://github.com/basecamp/once-campfire/blob/8d3c2bbd2be070008a275330efbee1001fd202dc/app/models/message.rb) — a fat-but-organized model with the domain rules where they belong.

package/packs/dtolnay.md

@@ -0,0 +1,10 @@
+## Code like David Tolnay (@dtolnay) · the API that disappears
+
+The gold standard of idiomatic Rust. Every public type earns its existence; the API surface collapses to the
+minimum, and correct usage is the *only* usage. Errors carry context without leaking internals. Derive macros
+vanish into your types and leave no fingerprint. Trait impls over free functions. Expose the smallest thing
+that works.
+
+- [`thiserror/lib.rs`](https://github.com/dtolnay/thiserror/blob/7214e0e8331d76afbea7173d8a14997512ac8713/src/lib.rs) — a tiny public surface that generates exactly the error impls you'd hand-write.
+- [`thiserror/expand.rs`](https://github.com/dtolnay/thiserror/blob/7214e0e8331d76afbea7173d8a14997512ac8713/impl/src/expand.rs) — the macro internals: precise, readable codegen with no fingerprint left behind.
+- [`anyhow/context.rs`](https://github.com/dtolnay/anyhow/blob/841522b2aa09732fecee40804440d2c35c68c480/src/context.rs) — errors with context attached, internals never leaked.

package/packs/jarred-sumner.md

@@ -0,0 +1,9 @@
+## Code like Jarred Sumner (@Jarred-Sumner) · perf as a correctness concern
+
+The perf pack. Performance decided *structurally*, not by micro-tweaking later: stack-fallback allocators
+before the heap, atomic counters instead of mutexes, `comptime` conditionals that delete dead paths at zero
+runtime cost. Names encode invariants. The root module is a curated namespace, not a junk drawer. Fast because
+the *shape* is fast — and still readable.
+
+- [`bun.zig`](https://github.com/oven-sh/bun/blob/454e3b2884c2bfabfa424ebecc3e9a1a9ee32773/src/bun.zig) — the root namespace, deliberately curated so the fast path is the obvious one.
+- [`AsyncHTTP.zig`](https://github.com/oven-sh/bun/blob/454e3b2884c2bfabfa424ebecc3e9a1a9ee32773/src/http/AsyncHTTP.zig) — concurrency built from atomics and explicit state, not locks bolted on.

package/packs/mitchell-hashimoto.md

@@ -0,0 +1,10 @@
+## Code like Mitchell Hashimoto (@mitchellh) · documented tradeoffs
+
+State machines as exhaustive tagged unions, so every case is handled or it won't compile. Data structures that
+document their own tradeoffs inline. Comments explain the *why* and the tradeoff taken, never the *what*.
+Explicit `MAX_*` constants with the empirical reason next to them. When something is non-obvious, it says so
+candidly instead of pretending it's clean.
+
+- [`Parser.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/terminal/Parser.zig) — a real state machine as an exhaustive enum; no `default:` swallowing the unknown.
+- [`circ_buf.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/datastruct/circ_buf.zig) — a data structure whose comments justify the layout and its costs.
+- [`Config.zig`](https://github.com/mitchellh/ghostty/blob/49a9181560707936c587ae121656d2d762d27849/src/config/Config.zig) — config as typed data with the constraints stated, not scattered through the code.

package/packs/rich-harris.md

@@ -0,0 +1,10 @@
+## Code like Rich Harris (@Rich-Harris) · compiler-grade precision
+
+Library code written with a compiler author's discipline: small named classes with one responsibility,
+immutable sentinel constants (`BLANK`, `EMPTY_SET`) instead of re-allocating, errors that carry a `code` and a
+docs URL. No defensive fallbacks — methods throw immediately with a precise message rather than papering over a
+bad state.
+
+- [`magic-string/Chunk.js`](https://github.com/Rich-Harris/magic-string/blob/410fd4d080d8bf0b5be900c16c8ba11276fd8749/src/Chunk.js) — a focused, mutation-careful data structure.
+- [`rollup/blank.ts`](https://github.com/rollup/rollup/blob/5e0066d92defee0097f10fb814e63f60b2a7b612/src/utils/blank.ts) — shared sentinel objects, named and reused instead of re-allocated.
+- [`rollup/getOrCreate.ts`](https://github.com/rollup/rollup/blob/5e0066d92defee0097f10fb814e63f60b2a7b612/src/utils/getOrCreate.ts) — a one-job helper extracted and reused, not inlined everywhere.

package/packs/simon-willison.md

@@ -0,0 +1,10 @@
+## Code like Simon Willison (@simonw) · one concept per file
+
+(Yes — the person who coined "slop".) Plugin-first design: every extension point is a named hookspec, declared
+before it's implemented. One concept per file (`recipes.py`, `events.py`, `hookspecs.py`). Dataclasses for
+typed events and data. Sentinel values over magic booleans. Docstrings explain the contract, not the
+implementation. Small, obvious, testable seams.
+
+- [`recipes.py`](https://github.com/simonw/sqlite-utils/blob/8f0c06e1889513ed0f01cb57783ddf07c442d4be/sqlite_utils/recipes.py) — one concept per module: small, composable transforms.
+- [`hookspecs.py`](https://github.com/simonw/sqlite-utils/blob/8f0c06e1889513ed0f01cb57783ddf07c442d4be/sqlite_utils/hookspecs.py) — plugin seams declared up front, before any implementation.
+- [`events.py`](https://github.com/simonw/datasette/blob/dfd5b95ec8adc425b683df22148cb1c14bb01128/datasette/events.py) — typed dataclass events instead of loose dicts.

package/packs/sindre-sorhus.md

@@ -0,0 +1,10 @@
+## Code like Sindre Sorhus (@sindresorhus) · one file, one job
+
+Radical minimalism: each module does exactly one thing and is small enough to read in five minutes. A function
+where a class would do; no surprise dependencies; inputs validated eagerly at the top so failures are loud and
+early. Tiny public surface, deep comments on the *why*. If it can't be read top-to-bottom in one sitting, it's
+too big.
+
+- [`p-limit/index.js`](https://github.com/sindresorhus/p-limit/blob/42599ebbbb1228a5bdab381fcf8f4ac20eb8d551/index.js) — a whole concurrency limiter in one short, obvious file.
+- [`execa/options.js`](https://github.com/sindresorhus/execa/blob/f3a2e8481a1e9138de3895827895c834078b9456/lib/arguments/options.js) — careful, explicit input normalization before anything runs.
+- [`chalk/index.js`](https://github.com/sindresorhus/chalk/blob/aa06bb5ac3f14df9fda8cfb54274dfc165ddfdef/source/index.js) — a clean, composable API with a minimal surface.

package/packs/tanner-linsley.md

@@ -0,0 +1,10 @@
+## Code like Tanner Linsley (@tannerlinsley) · types that forbid bad states
+
+Private class fields (`#field`) for real encapsulation. Types do the enforcing: `Updater<T> = T | ((old: T) =>
+T)`, recursion-guarded `DeepKeys<T>`, tuple utilities — illegal states are structurally unrepresentable, caught
+at compile time, not asserted at runtime. Big interfaces are assembled from small feature slices rather than
+written as one god-type.
+
+- [`query/subscribable.ts`](https://github.com/TanStack/query/blob/0bed37a91efa1b6e84b192ca3629d6e0c6cfcb73/packages/query-core/src/subscribable.ts) — a tiny single-purpose unit with truly private state.
+- [`query/focusManager.ts`](https://github.com/TanStack/query/blob/0bed37a91efa1b6e84b192ca3629d6e0c6cfcb73/packages/query-core/src/focusManager.ts) — one concern, encapsulated, testable.
+- [`table/type-utils.ts`](https://github.com/TanStack/table/blob/ed814260e0a863861f8387087e72feef1b75cd37/packages/table-core/src/types/type-utils.ts) — type-algebra that makes the wrong shape a compile error.

package/packs/zod.md

@@ -0,0 +1,10 @@
+## Code like Colin McDonnell (@colinhacks) · parse, don't validate
+
+Data never enters the system as an unvalidated primitive — it's parsed at the boundary and the parsed type
+guarantees its shape. Schemas are immutable values (methods return new instances). Errors are discriminated
+unions with a `code`, so every branch is exhaustive and typed. `parse` throws (fail fast); `safeParse` returns
+a typed result for callers that want to branch. Composable validators replace hand-rolled type guards.
+
+- [`parse.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/parse.ts) — symmetric `parse`/`safeParse` with the sync/async boundary enforced; the error class is injected, not hardcoded.
+- [`errors.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/errors.ts) — a discriminated-union error type, every field `readonly`, a `path[]` for nested location.
+- [`schemas.ts`](https://github.com/colinhacks/zod/blob/912f0f51b0ced654d0069741e7160834dca742ee/packages/zod/src/v4/core/schemas.ts) — distinct compile-time types per schema kind: illegal states are unrepresentable.