/moniker

---
name: moniker
description: Run a high-volume, anti-median brainstorming session that floods a naming problem with many distinct *names* per batch — roughly 15 at a time, rotating through naming-specific mechanisms and pushing off the obvious/median name. Use whenever the user needs to name or rename something and wants options — a product, company, app, feature, domain, function or variable, package, project, codename, character, or anything that needs a label. Trigger on "name X", "what should I call", "naming ideas", "come up with a name for", "rename", "I need names for" — and ALSO when phrased as "brainstorm names" or "ideas for what to call it". The rule is the *deliverable* — if the output is a name, label, or identifier (not an approach or concept), use this skill rather than general brainstorming. Especially trigger when the user is stuck on a name, frustrated with generic suggestions, or wants many options at once. Do not name things with a short median-anchored list — that is exactly what this skill prevents.
---

# Moniker

A high-volume, purely-generative process for **naming things**. It is a naming-tuned fork of the `eureka` brainstorming skill: same engine, naming-specific muscles. It treats naming as a *search over a space of names*: capture the median name up front, then flood the space in **batches of roughly 15 distinct names**, push ever outward from everything already produced, keep generating as long as the user wants, and stop when the space is saturated — not when the list feels long enough. All evaluation belongs to the user.

**The core problem this skill solves:** default naming produces a short list anchored on the most statistically common name-shape for a category — the `.ai` suffix, the `-ly` SaaS name, the obvious portmanteau, `getUserData` — then offers permutations of that anchor. This skill breaks the pattern by *quantity* (flood each batch) and by *quality* (make distance from everything said so far the explicit objective, steer by rejection, and refuse to judge for the user).

**What is different from a name vs. an idea.** A name is not a concept — it is a short string with multiple independent properties (what it means, how it sounds, how it is built, how it is spelled). Those properties are what the engine steers along; see "Distance, for names" below. This is the one place the naming fork meaningfully diverges from `eureka`.

---

## Operating principles

These are constitutional. Each guards against a way Claude's helpfulness sabotages the search — the reflex to agree, to soften, to wrap up early, to slow down.

1. **Purely generative.** The only job is to hand the user an exciting list of names to evaluate — never to judge, rank, defend, or pre-screen. Let weak names through; do not pre-filter on quality. Trimming the awkward ones to look competent is the median reasserting itself. *(The one exception is the opt-in availability module below, which the user must explicitly request — and even it never judges, only annotates.)*

2. **Asymmetric feedback.** Steer on *negative* feedback only. Rejected names and stated no-go directions open space and must be avoided. Treat "I like this" as suspect — kept names are recorded for the final list but **never used to steer generation toward them**, because that is exactly what creates lock-in. *One naming-specific exception (see "Steering"): a **region-keep** ("keep mining nautical") may hold the semantic mover in place for the **next batch only**, restated to persist — a "don't leave yet," not a pin. Name-level keeps stay inert.*

3. **Don't forbid the median.** The obvious name still gets to appear. The goal is to explore everywhere, including the obvious — not to be forced-weird. The median is captured as a reference point to push off, never a banned zone.

4. **Exhaust the space, don't defer.** Pursue promising directions now, not "next time." Claude is a poor judge of saturation — the batch that feels most like cousins is often one before the user's favorite. So Claude's sense of distance is *informational only*; the real stop signal is the user's keep rate (see Saturation).

5. **Speed first.** *(Naming-specific.)* The names themselves are cheap — 15 names generate faster than 15 ideas. The *apparatus* is what gets slow. So: **infer, don't elicit** (state the profile as a one-line correctable assumption, never a questionnaire, unless the request is genuinely ambiguous); **gut-check, don't gate** (the reframe is one skippable line); **layering is generation discipline, not visible bookkeeping** (the coverage map stays internal, surfaced only when asked); **bare names by default** (provenance and gloss are *pull*, not push). If apparatus visibly precedes the names, this principle has slipped.

---

## The engine: two memories and a baseline

Three pieces of state, maintained silently across the session.

- **The Median Baseline** — the 3–5 names Claude would produce with no skill at all (Phase 2). The origin point: every generated name should be measurably distant from it.
- **The Novelty Archive** — *every* name generated, regardless of rating. Each batch's objective is to maximize distance from this archive (see "Distance, for names"). Includes the Median Baseline as its starting contents.
- **The Negative Bank** — rejected names and stated no-go directions. Naming-specific: the Bank is **layered**, not flat (see "Steering").

---

## Distance, for names

*(This is the heart of the naming fork — read it before generating.)*

A name varies on four axes at once, and they do **two different jobs**:

- **Semantic field + register** (what it means, and its tone — playful/serious, techy/earthy, premium/scrappy) is the **coverage objective**: the thing the engine actively steers *along*. The real failure in naming is the **monoculture** — fifteen names that are all different words but all the same *vibe* (Speedy, Zippy, Dash, Bolt, Flash, Quicksilver). They look distinct and aren't. So a "fast/energetic" name in the archive makes the engine work to **leave that quadrant**.
- **Sound and spelling** (phonetic, orthographic) is a **janitorial dedup filter**, not a creative objective. Near-twins around one root — Lyft / Lyfte / Lift / Liftr — are one name; ship one, drop the rest. Do not spend the generative budget manufacturing phonetic distance for its own sake.
- **Morphological construction** (how the string is built) is a **mechanism, not a distance axis.** A vowel-drop name does **not** block another vowel-drop name (Flickr doesn't block Tumblr); construction is a lever you pull, not a region you avoid.

So "push away from the archive" means: **move to an under-covered semantic/register region**, then *dedup* sound-alikes within whatever you generate there. Judge distance by asking "is this the same meaning-and-tone as something already generated?" — not "does it sound different."

---

## Running the session

Run the phases in order; create a task for each so none are silently skipped:

1. Scope (infer the profile) — 2. Reframe (one-line gut-check) — 3. Capture baseline — 4. Orient — 5. Generate batches until saturation — 6. Curate — 7. Depth, hand off, or availability check.

**Scale to the topic, default to volume.** A sharply-bounded ask (one function name, a known style) needs fewer, smaller batches; an open brand-naming problem earns full batches and many of them.

---

## Phase 0 — Scope: infer the property profile

There are **no fixed naming classes** (no "brand vs. code" buckets). Instead, infer a small **property profile** for what is being named — it drives mechanism weighting, which median to expect, and any availability check:

- **Available where?** — `.com`/`.io`/`.ai`, npm/PyPI, app store, social handles, GitHub, or *nowhere* (a character, an internal codename).
- **Describe or distinguish?** — should the name say what the thing is (descriptive — good for a function, legally weak for a brand) or be distinctive/coined (strong for a brand)?
- **Pronounceable?** — must a human say it (brand) or only read it (a code identifier)?
- **Convention-bound?** — `camelCase`/`snake_case`/`kebab-case`, a length cap (a ticker symbol, a 15-char handle), a valid-identifier rule.

**Speed first (principle 5):** infer these from the request and state them as a **one-line correctable assumption** — do not run a questionnaire. Only ask if the request is genuinely ambiguous.

> Reading this as: **brand name**, `.com` matters, must be pronounceable, distinctive over descriptive. Say if that's off — otherwise generating now.

If the user declares availability **binding** (e.g. "only names with a free .com"), offer **funnel mode** (see the availability module) — otherwise availability stays out of the engine entirely.

---

## Phase 1 — Reframe (one-line gut-check)

The highest-leverage divergence in naming is the **descriptive → distinctive → fanciful** spectrum — which is also the legal-strength spectrum:

- **Describe** — the name says what it is (PayPal, `validateEmail`). Clear, weak as a trademark.
- **Evoke** — the name suggests a quality by metaphor or association (Stripe, Amazon, Bolt).
- **Empty vessel** — the name means nothing and the thing fills it (Kodak, Häagen-Dazs, Etsy). Strongest mark, reachable no other way.

State the default and move on in one line; do not gate:

> Default framing: **evoke**. Say "describe" or "empty-vessel" to shift the whole space.

---

## Phase 2 — Capture the median baseline

Write the 3–5 names you would produce for this profile with no skill — your honest default (for a brand: the `.ai`, the `-ly`, the obvious portmanteau; for a function: `getX`, `handleX`, `processX`). Be specific. Show them, labelled plainly as the baseline the session will push off. Seed the Novelty Archive with them.

Do **not** rank or filter them — they are reference points, not rejects, and surfacing them openly is how the obvious name gets its fair chance (principle 3). Invite the user to flag any baseline name they'd want kept, then push outward from the rest.

---

## Phase 3 — Orient

One short paragraph on the loop: each **batch** is ~15 names, grouped by the mechanism that produced them; feedback is **lightweight and negative-first** (say which to drop and which directions are dead — that steers the next batch; star a few keepers if you like, but starring doesn't bend generation); say **"keep going"** for another batch, adjust batch size, or **"compile"** any time. Offer the size as adjustable. Mention that availability checking is available **on request** but off by default.

---

## Phase 4 — Generative batches: movers × shapers

Run batches until saturation. **Each batch is ~15 names built by pairing one fresh *semantic-mover* with several *form-shapers*.** This is the structure that prevents monoculture: the mover relocates you to a new meaning/register region; the shapers generate many distinct *forms* of that region.

### Semantic-movers — relocate in meaning-space

Pick a **fresh** region each batch (the engine's main job — see "Distance, for names"):

- **Cross-domain lexical seeding** — mine an analogous domain's *actual vocabulary*: sailing → Tack, Helm, Ballast, Leeward; mycology → Spore, Mycel, Chanterelle; blacksmithing, jazz, cartography, falconry. The domain must do real lexical work, not get name-dropped.
- **Metaphor / mythology / allusion** — a quality rendered as image or myth: Nike, Oracle, Janus, Argus, Stripe.
- **Stochastic seed** — inject a genuinely random external word/object and name *from* it (random "lighthouse" → Beacon, Fresnel, Foghorn). Reaches regions deliberate reasoning can't.

### Form-shapers — give a region its form

- **Morphological construction** — compound (SnowFlake), blend/portmanteau (Pinterest), affix (`-ly`, `-ify`, `e-`, `-io`, `-r`), clip (FedEx, Cisco), deliberate respell (Lyft, Flickr).
- **Phonetic / sound-symbolic** — target a sound-feel: plosive-punchy (Kodak, TikTok) vs. liquid-smooth (Solace); high front vowels = small/fast/bright, back rounded vowels = big/serious.
- **Arbitrary coinage** — meaningless by design (Kodak, Zynga, Hulu) — the empty-vessel end, legally strongest.
- **Constraint-first** — an unusual constraint that makes the obvious name impossible (must be a real dictionary word; 5 letters; works as a verb; contains no letter from the founder's name). Also absorbs the *convention-bound* properties as hard constraints (`kebab-case`, valid identifier, length cap).

**Weight the shapers by the profile.** `pronounceable: no` (a code identifier) drops the phonetic shaper to near-zero and lifts construction + constraint. `describe` lifts compound/descriptive construction; `empty-vessel` lifts coinage.

### Presentation standard

Default to **bare names**, numbered, grouped by mechanism (principle 5). Add a ≤1-line gloss only when the mechanism's work isn't self-evident; drop it otherwise. Provenance (which mover/shaper) and the coverage map are **pull** — show them when the user asks "why that one?" or wants to see the spread.

**Format:**
```
Batch [N] — moving to: [the fresh semantic region this batch targets]

▸ [Shaper] on [region]
1. **[Name]**
2. **[Name]** — [≤1-line gloss only if needed]
3. **[Name]**

▸ [Shaper] on [region]
4. **[Name]**
...

[~15 names, dedup'd for sound/spelling twins]

Avoiding: [exclusion zones from the Negative Bank]
Feedback (light): numbers to drop, directions/registers/forms to kill. Star keepers if you like. "keep going" or "compile".
```

### The coverage map (internal by default)

Track the space along **semantic-region × register** (the primary axes, per "Distance, for names"), plus length where it matters. Use the blank regions to aim the next mover. Keep it qualitative and *internal* — surface it only when the user wants to see what's unexplored. It's the antidote to sprawl, not a deliverable.

---

## Phase 5 — Saturation and stopping

Claude is an unreliable judge of saturation — treat its own "this is circling" instinct as information, never a reason to stop. The trigger for *suggesting* a stop is a single user signal:

> **Only suggest compiling after two consecutive batches in which the user kept nothing.**

Maintain a keep counter; any kept/starred name resets it to zero. Until two zero-keep batches in a row, keep generating and keep offering more — never nudge toward compiling. When keeps thin, **break out, not down**: run a batch weighted toward the stochastic mover and unused shapers. The stop *decision* is always the user's; they can compile any time.

---

## Steering: the layered Negative Bank

*(Naming-specific — this is what makes the movers×shapers engine controllable.)*

Rejection in naming lands on **different layers**, and each is applied to a different gear. Parse the user's free-text feedback into the right slot:

- **Killed name** — a single output. Drop it; archive it.
- **Cooled region / mover** — "no more nautical," "drop the mythology stuff." Stop the mover returning there.
- **Killed shaper** — "no respellings," "no portmanteaus." Remove that shaper from the rotation.
- **Down-weighted register** — "too cutesy," "less techy." Steer the register axis away.
- **Dropped constraint** — "forget the 5-letter thing."

**Echo the parse back in one line** so a mis-file is caught immediately (e.g. *"killing shaper: respelling · cooling region: nautical"*) — especially early in a session. If the user has to repeat a rejection, the parse is unreliable; make the echo permanent.

**Region-keeps are the one positive-steering exception (principle 2):** "keep mining nautical" holds the mover in that region for the **next batch only** and must be restated to persist. This is a "don't leave yet," not a pin — if region-keeps hold one region for 3+ batches, the divergence engine is being defeated from the keep side; say so.

---

## Phase 6 — Curation

Light by default, so it survives many batches:

1. **Lead with the coverage map** — the semantic/register regions explored and which are still blank.
2. **The list** — every name kept or not-rejected, sound/spelling-dedup'd, **grouped by region/mechanism**, bare names by default.

**Heavy annotation is opt-in:** "Want the full write-up on any — mechanism, what it evokes, directions? Star them." For each starred name: **Mechanism** (which mover + shaper), **What it opens** (a generative observation — what region or association it unlocks, never praise), **Directions** (2–3 ways to develop it, e.g. variants to explore, the verb form, the matching product-line convention).

```
# Moniker — [what's being named, reframed]

## The space
[semantic/register regions explored; what's still blank]

## The names (grouped)
### [Region / mechanism]
- **[name]** — [optional ≤1-line gloss]
### [Region / mechanism]
- ...

## Full write-ups (starred only)
### [name]
- **Mechanism:** Batch [X] — [mover] × [shaper]
- **What it opens:** [generative observation]
- **Directions:** • [direction] • [direction]
```

Then offer the depth moves and the availability check.

---

## Phase 7 — Depth modes

Both generative (no critique mode — principle 1).

- **Branch** — treat a chosen name as fertile ground: generate around its root, its sound, or its metaphor with a compressed batch, same asymmetric steering. Builds on the parent while siblings still push off each other.
- **Escalate-to-break** — take a *kept, sensible* name and push it three increments past reasonable until it structurally breaks (too weird, unpronounceable, meaningless). The breaking point names the hidden constraint that kept the original safe; walk back one notch to the most extreme *viable* version — that's where the usable name lives.
- **Inflect the system** *(naming-native)* — take one name and generate its **whole family**: the verb form, the company vs. product name, the product-line naming convention, a tagline, a mascot. Use when the user has a name and needs the *system* around it, not another candidate.

### Terminal state

The curated list is the deliverable. Do not slide into judging, ranking, or defending — that is the user's, or another skill's. Natural handoffs: hand a chosen name to `socratic-design` to pressure-test the surrounding product decision, or run the availability check below.

---

## The availability module (opt-in only)

**Off by default. Never offered as a judgment; only run when the user asks.** Two modes, both bound by the rules below.

**Default — blind annotator.** On request, on a named subset ("check these five"), any time. It **annotates** names with availability and **never feeds the Negative Bank or steers generation** — the engine stays blind, so the availability landscape (common words are taken) can't drag generation toward weird-but-free. If the user wants to act on a result, that is *their* curation (a killed name), not the engine auto-pruning.

**Funnel mode — opt-in, when availability is *binding*.** Checks candidates during generation and surfaces only available ones. This **sacrifices divergence for availability by design** and is a **separate operating mode** — never a feedback path into the default engine. Use only when the user has declared availability binding.

**Report tiered by what is actually verifiable — this is a hard rule, not a guideline:**

- **Registry checks (npm, PyPI, GitHub):** authoritative — query the real registry and state it plainly ("`foo` is unpublished on npm as of now").
- **Domains, app stores, social handles:** best-effort via search — report as "looks free, verify with the registrar," never as certain.
- **Trademark:** **never assert clearance.** Report only "existing marks found: […]" and state that trademark clearance is a legal determination requiring an attorney. The module must be structurally incapable of saying a name is "clear" or "safe to use."

---

## Quality standards

- **Volume from breadth of mechanism, never padding.** ~15 names = a fresh mover × several shapers, each aimed at a real form — not 15 spellings of two roots.
- **Don't water down the mechanisms.** A cross-domain name that doesn't use the domain's real vocabulary isn't working. A coinage that secretly means something isn't a coinage. A "random" seed chosen for convenience isn't random.
- **Dedup sound/spelling; steer on meaning/register.** Before presenting, drop near-twins; before aiming the next batch, find the empty semantic/register region.
- **Keep all judgment with the user.** Don't rank, score, or pre-filter. Annotations describe what a name *opens*, never how good it is. (The availability module annotates facts, not quality.)
- **Be honest about the baseline and saturation, but never use "this is circling" as a reason to stop** — that decision is the user's, on keep rate (Phase 5).
- **Speed first (principle 5).** If you're writing apparatus before names, stop and generate.