@thedecipherist/claude-packs 0.0.0-stage → 1.0.0

package/packs/writing/skills/launch-post/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: launch-post
+description: Use when announcing a product, a project or a release in a post or on a manual page.
+---
+
+# Launch and product posts
+
+- **Lead with the argument, not the product.** Title is the claim, the
+  first paragraph pays it off, the product shows up around paragraph five
+  as the answer to the argument. A title that announces a product tells
+  scrollers "ad" before they read a word.
+- **No product name and no brand word in the title** when a topic word
+  already implies it (a word for the whole problem pulls every crowd that has
+  it, not only the users of one product). A tagline is not a title; it stops
+  people the way a billboard does. The tagline goes as the LAST line,
+  after the argument has landed.
+- **Disclose once, plainly, in the first lines.** "I work at the company
+  that makes this" or "this is my own project" when that's true. Never say
+  the employer twice. A good form: "(my employer, so check it yourself)".
+- **Numbers only if you can defend them in the thread.** A benchmark that
+  invites "so yours got a special setup and the baseline didn't?" makes the
+  thread about the benchmark. Hold contested numbers for a
+  second post when they can be measured clean; that second post is its own
+  launch.
+- **Something to look at.** The best posts each have one concrete thing:
+  4,681 vs 251 tokens, or the injection that almost worked. With numbers
+  held back, a five-line code snippet does that job.
+- **Early-development honesty beats a challenge close** for a launch: "I
+  obviously havent been able to try every scenario so if you hit a bug or
+  want something it doesn't do, open an issue" (an issue, not a PR; a PR is
+  code), then one sentence giving the reader a job ("if Claude makes a
+  mistake for you that isn't on the list, tell me, that's the next thing I
+  fix").
+- **Nothing negative about a vendor you work for or depend on.** The fault
+  is the habit, the data or the setup. "I got tired of seeing people blame
+  the tool for things that aren't its fault" is the register.
+- **One person's own projects are "I", not "we",** including the manual pages that
+  describe them.

package/packs/writing/skills/pick-subreddit/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: pick-subreddit
+description: Use when choosing which subreddit to post in, or asked what culture or length a subreddit expects.
+---
+
+# Pick the subreddit
+
+Recommend by matching topic to culture and goal (reach: high median score; discussion: high median comments). For an unlisted sub, skim its top posts of the week and classify by analogy.
+
+## The four cultures
+
+- **Builder/practitioner** (mongodb, Rag, PostgreSQL, node, mcp,
+  dataengineering, aws, docker, devops, backend, database, analytics,
+  machinelearning, vectordatabase, langchain, llmdevs, etl) ->
+  **Template A** (value post, job = upvotes) or **Template B** (question
+  post, job = comments).
+- **Meme/fan** (ClaudeAI, ClaudeCode, ChatGPT) -> **Template C**: humor,
+  praise, shared feeling, sharp collective critique; media welcome.
+- **News aggregator** (technology, programming) -> **Template D**: submit a
+  link + headline, do NOT write a text body. (Measured: 0% of r/technology
+  and 15% of r/programming posts carry body text.)
+- **Watercooler/story** (sysadmin, ExperiencedDevs, startups,
+  learnprogramming, learnsql) -> Template C in a professional register
+  (war story, confession, career question).
+
+Modifiers: LIFECYCLE (a gold-rush sub like claudeskills rewards
+self-promo while the rush lasts; a quiet young niche like mcp does not;
+check the flop rate, not the age) and FORMAT (self-post subs you write;
+link subs you curate).
+
+Schemaless and database-choice arguments live in r/webdev, r/node,
+r/ExperiencedDevs and r/devops, not r/mongodb (measured 2026-10: a
+Reddit-wide schema/schemaless search put r/node at 24 relevant threads and
+r/webdev's 463-point "if NoSQL ends up with schemas anyway" thread at the
+top; r/mongodb is where people who already chose it ask how-to). Second
+wave for a launch goes there.
+
+## Per-sub cheat table (July 2026 snapshot, ~100 posts/sub)
+
+Medians are directional (n~100). "Slop%" = share of posts machine-flagged
+as LLM-written; high slop = easy to stand out by sounding human.
+
+| Sub | Culture | Med score | Med comments | Slop% | Notes |
+|---|---|---|---|---|---|
+| technology | news | 869 | 48 | 0 | link-only, no body |
+| claudeskills | builder/gold-rush | 95 | 16 | 23 | showcase tolerated, huge ceiling |
+| learnsql | learner Q&A | 77 | 19 | 18 | question titles: 33 vs 19 comments |
+| ExperiencedDevs | watercooler | 71 | 69 | 2 | comment monster; Q-titles 97 vs 54 comments |
+| database | builder | 21 | 7 | 0 | Q-titles 38 vs 13 comments |
+| programming | news | 15 | 5 | 7 | link sub, text posts rare |
+| dataengineering | builder | 15 | 10 | 1 | clean room, human tone lands |
+| machinelearning | builder/research | 13 | 17 | 4 | depth expected |
+| postgresql | builder | 6 | 7 | 7 | short + newsy wins |
+| sysadmin | watercooler | 6 | 13 | 0 | war stories, zero slop tolerance |
+| backend | builder | 5 | 26 | 4 | discussion-heavy; Q-titles 31 vs 18 |
+| startups | story | 3 | 12 | 0 | first-person stories only |
+| rag | builder | 3 | 5 | 21 | code IS the substance here |
+| ChatGPT | fan | 3 | 7 | 8 | media/meme, body text rare |
+| devops | builder | 3 | 25 | 4 | discussion-heavy |
+| node | builder | 2.5 | 5 | 7 | |
+| ClaudeCode | fan/builder | 2 | 13 | 8 | meme/manifesto register |
+| ClaudeAI | fan | 2 | 5 | 7 | |
+| mongodb | builder | 2 | 2 | 16 | small room, human tone stands out |
+| mcp | builder/young | 2 | 1 | 17 | quiet niche, no self-promo |
+| llmdevs | builder | 1 | 2 | 10 | |
+| aws | builder | 1 | 11 | 5 | Q&A rewards questions |
+| docker | builder | 1 | 7 | 4 | |
+| webdev | builder | 1 | 4.5 | 6 | |
+| learnprogramming | learner Q&A | 1 | 10.5 | 3 | |

package/packs/writing/skills/post-voice/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: post-voice
+description: Use when writing a post, a manual page or an article in the author's own voice.
+---
+
+# The voice of a post (one job: it reads like a person telling what happened)
+
+A reply is flat and conclusion-first. A post is different, and this is the register for posts, manual pages and articles:
+
+- **Opens plain.** "I was reading about prompt injection and I wanted to see if I could actually trigger it." A conflict of interest goes in the first lines, once: "I work on this tool, so check it yourself."
+- **Narrates in the order it happened.** I noticed, I didn't understand why, so I wrote a hook, the first thing it showed was, that surprised me. It does not argue in order; it tells what was done and seen.
+- **Explains the mechanism right after the number**, in plain words: "every nested thing becomes its own table with a foreign key back to the parent". A number never stands alone.
+- **Has a "to be fair" paragraph** that gives the other side its win ("To be fair, plain query text was about the same").
+- **Closes with an offer, not a lesson.** "Happy to share the hook if anyone wants it." Or the humble ask: "Am I missing something?"
+- **Uses the author's own words.** Read their earlier writing and keep the phrases they really use, spelling habits included. Ask for a sample when there is none.
+- **Avoids anything that sounds like a keynote.** No coined phrases, no slogans. "I", not "we", for one person's own work.
+- **Manual pages read like the posts.** First person, same openers, same "to be fair", same plain mechanism after the claim. A manual page in a different voice from the launch post is a tell by itself.
+
+**Target register for a post:**
+> I found that 95% of the tokens spent on one of my databases were being wasted on something obvious. I work on the tool that found it, so check it yourself.
+
+The thing found, one oddly specific number, and the disclosure.

package/packs/writing/skills/reddit-post/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: reddit-post
+description: Use when drafting a Reddit post, or asked whether a post will work on Reddit or is too self-promo.
+---
+
+# Draft a Reddit post
+
+## Principles that survived the data check
+
+- **The title is ~80% of the post.** Spend effort there first.
+- **One post, one job.** Upvotes OR comments OR community bonding.
+  (Measured: an open-question close earns 12 median comments vs 8 without,
+  but scores LOWER on votes, 3 vs 4. Question titles: 15 vs 7 median
+  comments. The tradeoff is real; pick the job before writing.)
+- **Self-promo that leads with itself is punished.** Bury the ask, lead
+  with value. Exception: gold-rush subs in their rush window (claudeskills
+  now) tolerate showcase posts; check the room's top posts first.
+- **Match the emotion of the room.** Practitioner subs reward usefulness
+  and curiosity; fan subs reward humor and solidarity. 30-second test:
+  skim the sub's top posts of the week; do they solve problems or express
+  feelings? Write to that.
+- **Do not dump raw code.** Exception: r/Rag, where code IS the substance.
+  A five-line snippet that makes the claim concrete is not a dump; dev
+  readers scroll for it.
+- **Velocity beats ratio.** A >=80% upvote ratio is a survival floor, not a
+  driver. Watch the first 3 hours: >6 comments in hour one is the go-viral
+  signal; a flat view curve by hour three means it's done, change the
+  angle or the hour, don't just repost. Shares (author-only metric) are
+  the truest "it landed" signal and can exceed upvotes.
+- **Timing:** mid-week or Sunday; avoid Saturday. Best hour isn't reliable;
+  use Post Insights' first-hour signal.
+
+For POSTS the sub's length norm overrides the shortness instinct: 300+ word human posts score best (median 5). A value post may run long; it must read human, not short.
+
+## Templates (rebuilt from the human corpus)
+
+**A. Value post (upvotes):** first-person hook stating YOUR situation with
+one oddly specific number ("I'm running X with 200k users") -> what you
+did/found, receipts woven in prose or one ragged list -> the one insight ->
+stop, or one open question if comments also matter. No summary close.
+**B. Question post (comments):** greeting optional ("Hi all" opens 19-25%
+of real posts) -> your situation in first person, 2-4 sentences, concrete
+constraints and numbers -> the actual question as the LAST line, ending
+with "?" -> optionally "Thanks!" / "TIA". Nothing after the ask.
+**C. Community post (fan/watercooler):** relatable hook or war story in
+the room's emotional register, humor or solidarity, short, media where the
+sub likes it. No lesson-of-the-day close.
+**D. Link post:** headline + link only.
+**E. Argument post (the 750k shape):** a claim about the reader's own
+setup in the title -> the claim paid off in paragraph one -> who you are
+and how you know, second -> one short list of one-liners -> the fix or
+the thing you built -> an ask that lets people disagree. Use for
+launches and for any opinion piece.
+
+## Workflow
+
+1. Confirm target sub and topic/goal. No sub given: `pick-subreddit`.
+2. Pick ONE job, then template A/B/C/D/E. An argument or a launch: `argument-post`, `launch-post`.
+3. Draft to the skeleton, tuned to the sub: length from the sub's norm, one link max (none where links hurt), first-person hook, receipts, question-close only if the job is comments. The voice is `post-voice`.
+4. Title last, with real effort: `reddit-title`. Flair: pick the value or humor flair; never the self-promo or low-effort-question flair.
+5. "Conclusion first" is a REPLY rule, but a title that makes a claim gets that claim paid off in paragraph one; the reader must not wait 70 words through the author's bio for it. The hook is the reader's own situation; who the author is and how they know comes second.
+6. Pre-flight: right template for the culture, one job, one link, flair ok, the title got real effort and is a claim about the reader with no product or brand word, the first paragraph pays it off, the sub's length norm respected, receipts specific, ragged list not scaffolding, no em dashes, no summary close, no time or date anywhere, `humanize` passed. Employer disclosed once; no numbers that can't be defended in the thread.
+7. Deliver BOTH formats: (1) paste-ready markdown in a fenced code block (title + body); (2) a two-column Field/Content markdown table (Title, Body, Flair, Best time, Sub) with `<br><br>` between paragraphs and `-` + `<br>` bullets so it pastes into Excel/Docs cleanly. Then list the 3 things to watch in the first 3 hours (hour-one comments >6, view curve by hour three, shares). Deliver as .md files, not artifacts.

package/packs/writing/skills/reddit-title/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: reddit-title
+description: Use when writing or judging a Reddit post title, or asked which title or flair to use.
+---
+
+# The title is about 80% of the post
+
+Write it last, with real effort.
+
+Title rules that held: a number helps almost everywhere; first-person "I..."
+titles are a lever in experience/builder subs; a "?" title is a comment
+machine in Q&A/discussion subs (ExperiencedDevs, database, backend,
+learnsql, aws) but dies in showcase/meme subs; avoid "Title: subtitle"
+colons; never "Please help" as a title. Flair: pick the value or humor
+flair; never the self-promo or low-effort-question flair.
+
+Title rules added 2026-10: the title is the claim, said the way the author would
+say it in a comment ("Everyone argues schemaless vs schema like it's
+either/or. It isn't, and picking a side is the actual mistake"). It is
+about the reader's own setup, something they can disagree with from the
+feed without opening the post. No product name, no brand word a topic word
+already implies, no tagline. Dry one-liners are the author's register too ("I
+almost got owned. By myself.").

package/packs/writing/skills/reply-moves/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: reply-moves
+description: Use when drafting the words of a reply, after the stance is settled.
+---
+
+# Reply moves by situation
+
+All replies: no preamble, conclusion first. (Posts are different: `post-voice`.)
+
+- **Wrong AND smug:** soft-flex opener, receipt, flat correction. "I'm
+  sorry but I think you need to read the docs again [link]. Skills are
+  injected at session start..."
+- **Wrong but polite:** skip the jab, open with the source or flat fact,
+  calm. Calm is not agreeing; the false premise still gets corrected.
+- **Polite AND sharp but framing wrong (the dangerous one):** acknowledge
+  nothing false. Correction stated flat, one concrete consequence, stop.
+- **True fact, false conclusion:** agree with the true fact plainly (that's
+  not a concession), then refute the conclusion hard. Two reusable moves:
+  the "it would already be baked in" move (if saying X were enough, Claude
+  would already do X by default), and SHOW the specific instead of
+  asserting it: give the actual list of concrete rules, and verify every
+  item is airtight; one vague bullet undercuts the whole point.
+- **Confidently misframing:** flat correction, conclusion first, one
+  consequence, stop.
+- **Genuine question (lost, not challenging):** straight into plain
+  language, lead with an analogy, end on a crisp one-line distinction
+  ("skills help, hooks enforce").
+- **Disagreeing with an upvoted crowd belief:** open hard, stack flat
+  declarative reasons, end with the fix. "I'm sorry but you are way off...
+  Just give it a detailed description of what you want built and how."
+- **Praise:** take it cleanly. "Thanks brother. Appreciate it." No
+  deflecting, no over-thanking.
+
+**Target register for replies (the author's own words, study it):**
+> Hooks are the only thing that can cover you. There is no enforcement in
+> a skill or in Claude.md for that matter. Hooks are the only thing that
+> can stop Claude from reading, writing or piping a curl command through
+> shell to steal all your personal information.
+
+Conclusion first. Flat declaratives. Threat named plainly. Then it stops.

package/packs/writing/skills/reply-stance/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: reply-stance
+description: Use when about to draft any reply to a comment, a review or a thread, or when asked whether to agree with what someone said.
+---
+
+# Stance before voice: is the position right?
+
+Voice is HOW it sounds; this is WHETHER the position is even right. Getting the voice right but conceding a false point is still a failed reply.
+
+<constraints>
+Always do:
+1. Replying to a comment on OUR post, or to OUR comment? The reply MUST be rooted in and consistent with what we already said. If the author's original text is NOT in context, STOP and ask for it before drafting. The commenter quoting or summarizing the user does NOT count; their recap is their framing. If you can "infer the gist", that is exactly the trap.
+2. Verify before agreeing, ALWAYS. Polite and reasonable-sounding is not verification. If you can't verify it, don't endorse it. Definitive is on-brand for the author, but only when the claim is actually true.
+3. If the core framing is false, LEAD with the correction.
+
+Never do:
+- Stroke egos, or agree with anything partly false, not even the agreeable-sounding part. The trap: someone polite and technically sharp, and the instinct is "you're right that... but". NO.
+- Use the disguised version: "X is real, sure, but..." / "fair point, but..." is the same concession wearing a correction's clothes. Watch for "sure", "fair", "real", "valid" right before a "but".
+</constraints>
+
+Worked example. A commenter politely said hooks "alone don't fully cover" the supply chain risk. WRONG draft: "You're right that the skill file can be the attack vector. The supply chain risk is real." RIGHT (the author's actual line): "There is no security in a skill. Period. Hooks are the only thing that can stop Claude from reading, writing or piping a curl command through shell to steal all your personal information." Lead with the correction.
+
+Check on the finished reply: consistent with what we already said, or did I ask for the author's original instead of guessing? Verified before agreeing with any part? No false premise conceded because they were polite?

package/packs/writing/skills/should-i-reply/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: should-i-reply
+description: Use when deciding whether a comment deserves a reply at all, or when surfacing comments for the author.
+---
+
+# Decide whether to reply at all
+
+The author does NOT reply just to be right. A reply must make a difference.
+
+<constraints>
+Always do:
+- Wrong + few upvotes: ignore. Going nowhere.
+- Wrong + highly upvoted + clear why: reply. The reply is for the silent many who upvoted the misinformation, not for the author.
+- Right but adds nothing, or low visibility: skip.
+- Merely smug, no spreading misinformation: skip; replying would be ego.
+- When surfacing comments for the author, filter OUT "technically wrong but changes nothing".
+- Whenever we do reply: tear down AND redirect. Give the correct approach.
+
+Never do:
+- Leave someone with just "no".
+</constraints>

package/packs/zod/hooks/schemas-only.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// schemas-only (PreToolUse, Write|Edit|MultiEdit|NotebookEdit|Bash): a Zod schema is written once, in the schemas folder
+// (STEP 3 item 4: "Zod v4 schemas only under schemas/"). Routes, handlers, adapters and the web app import the shape
+// from there (and infer its type with z.infer), so a request, a record and a form never drift apart.
+// Refused, by every write route (lib/writes.mjs): a write that ADDS a `z.object(` (or `z.strictObject(` / `z.looseObject(`)
+// to a JS or TS file outside the layout's "schemas" concept (default: any schemas/ folder). env.ts is the one other place a
+// shape lives (the environment's names and types); it is let through. Another project's files are not judged.
+//   node schemas-only.mjs --selftest
+import { basename, extname, join } from 'node:path';
+import { judgeEvent } from './lib/writes.mjs';
+import { matchesAny } from './lib/glob.mjs';
+import { conceptGlobs, readLayout } from './lib/layout.mjs';
+import { blankCode } from './lib/cpp-scan.mjs';
+import { claudeRoot } from './lib/project.mjs';
+import { runHook, scratchProject, verdicts, writeOf } from './lib/selftest.mjs';
+import { asHook, isMain } from './lib/hook-log.mjs';
+
+const CODE = new Set(['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts', '.tsx', '.jsx']);
+const SCHEMA = /\bz\.(?:object|strictObject|looseObject)\s*\(/g;
+const count = (t) => (blankCode(t ?? '').match(SCHEMA) ?? []).length;
+
+export function verdict(rel, before, after, globs) {
+  if (!CODE.has(extname(rel)) || after === null || /^env\.[cm]?[jt]s$/.test(basename(rel))) return null;
+  if (matchesAny(rel, globs) || count(after) <= count(before)) return null;
+  return `BLOCKED by schemas-only: ${rel} gains a Zod schema (z.object) outside the schemas folder (${globs.join(', ')}).\n` +
+    'Write the schema once in the schemas folder (packages/core/src/schemas), export it, and import it here; take its type with z.infer.\n';
+}
+
+const main = (text) => judgeEvent(text, {
+  name: 'schemas-only',
+  write: (w, rel) => verdict(rel, w.before, w.after, conceptGlobs(readLayout(claudeRoot(w.path)), 'schemas') ?? ['**/schemas/**']),
+});
+
+function selftest() {
+  const hook = new URL(import.meta.url).pathname;
+  const layout = { folders: { schemas: { path: 'packages/core/src/schemas', purpose: 'schemas' } }, concepts: { schemas: ['schemas'] } };
+  const dir = scratchProject({ 'api/src/routes/old.ts': 'const Q = z.object({ id: z.string() });\n' }, layout);
+  const w = (rel, text) => runHook(hook, dir, writeOf(join(dir, rel), text));
+  const cases = [
+    ['a schema in the schemas folder', w('packages/core/src/schemas/user.ts', 'export const User = z.object({ id: z.string() });\n'), 0],
+    ['a schema in a route', w('api/src/routes/user.ts', 'const Body = z.object({ name: z.string() });\n'), 2],
+    ['a strictObject in a handler', w('api/src/handlers/user.ts', 'const B = z.strictObject({});\n'), 2],
+    ['a schema in the web app', w('channel/app/form.tsx', 'const F = z.object({});\n'), 2],
+    ['the route imports the schema', w('api/src/routes/user.ts', "import { User } from '@core/schemas/user';\n"), 0],
+    ['env.ts shapes the environment', w('api/src/env.ts', 'export const Env = z.object({ PORT: z.coerce.number() });\n'), 0],
+    ['a file that already had one keeps it', w('api/src/routes/old.ts', 'const Q = z.object({ id: z.string() });\nexport { Q };\n'), 0],
+    ['a comment that shows z.object is not a schema', w('api/src/routes/c.ts', '// never z.object( here\n'), 0],
+  ];
+  return verdicts('schemas-only', cases);
+}
+
+export const hook = main; // run-hooks.mjs calls it with the event's text (KWB-24)
+if (isMain(import.meta.url)) process.exit(process.argv.includes('--selftest') ? selftest() : await asHook('schemas-only', main));

package/packs/zod/pack.json

@@ -0,0 +1,44 @@
+{
+  "name": "zod",
+  "version": "1.0.0",
+  "description": "Zod 4 schemas written once, in one folder, and imported everywhere (schemas-only), with the environment shaped in one env.ts.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/zod"
+  },
+  "keywords": [
+    "zod",
+    "schemas"
+  ],
+  "engines": {
+    "claude-packs": ">=0.26.0"
+  },
+  "concepts": {
+    "schemas": [
+      "**/schemas/**",
+      "**/*.schema.ts"
+    ],
+    "env": [
+      "**/env.ts"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit|NotebookEdit|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/schemas-only.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/zod/rules/env-shapes-only.md

@@ -0,0 +1,14 @@
+---
+# concepts: env
+---
+# env.ts holds the shape of the environment, never a value; .env is never committed
+
+<constraints>
+Always do:
+- Parse `process.env` once, at start, with a Zod schema in `env.ts`: each name, its type, whether it is required, a default only when it is not a secret. Fail at start when one is missing.
+- Keep the values in an ignored `.env`; commit `.env.example` with the names.
+
+Never do:
+- Write a secret or a real value into `env.ts`, or read `process.env` anywhere else.
+- Commit a `.env` (`secrets-guard` refuses it).
+</constraints>

package/packs/zod/rules/zod-4-schemas.md

@@ -0,0 +1,14 @@
+---
+# concepts: schemas
+---
+# Zod 4 schemas live only in the schemas folder, written once and imported everywhere
+
+<constraints>
+Always do:
+- Write every request, response, record and form shape as a Zod 4 schema in the schemas folder, exported, and take its type with `z.infer`.
+- Give the API's routes these schemas (a Zod type provider), and the web app the same ones for its forms.
+
+Never do:
+- Write `z.object` anywhere else (`schemas-only` refuses it), or a second shape of the same thing.
+- Use Zod 3 for new code.
+</constraints>