Namer

Namer

Generate, evaluate, and validate names across linguistic, technical, and platform dimensions. Produces ranked options with availability matrices and actionable next steps.

Not for domain registration, branding strategy, or logo design. Not for reviewing naming conventions in existing code.

Dispatch

Gallery (Empty Arguments)

Pick a number, describe what you're naming, or type "guide me".

Guided Intake

If the user types "guide me", ask three questions:

1. What are you naming? "A CLI tool, a SaaS product, an OSS library, a startup, a brand, or something else?"
2. What does it do? "Describe it in one sentence."
3. What vibe? "Playful, serious, technical, warm, edgy, minimal, or describe your own."

Dynamic Context Classification

Auto-detect from the user's description. Adjusts both platform priority AND scoring weights.

Scoring presets — each context uses different intrinsic/extrinsic dimension weights AND a different intrinsic/extrinsic split ratio. See references/scoring-rubric.md § Context Presets for the full weight tables. Key differences:

• CLI Tool: 30/70 intrinsic/extrinsic split — typeability (30%) and registry (35%) dominate extrinsic
• Brand: 50/50 split — phonetics (30%) and domain (35%) are top priorities
• Side Project: 25/75 split — availability-first; typeability (40%) and registry (20%) lead extrinsic

Present the classification and preset to the user. User can override with --style or adjust weights manually.

Core Workflow (6 Phases)

Phase -1: Memory Load (runs once per session)

!uv run python scripts/memory.py load

If memory exists, integrate into session:

• Archetype affinities → bias Phase 1 generation distribution (e.g., 35% evocative if user favors it)
• Phonetic likes/dislikes → add to Phase 1 hard filters (dislikes) and soft scoring boosts (likes)
• Length preferences → adjust length constraints in Phase 1
• Weight overrides → pre-fill Phase 3 scoring weights
• Context defaults → suggest context in Phase 0 Brief ("Last time you named a CLI tool — same context?")
• Inspirations → reference in Phase 1 generation as stylistic anchors
• Past selections → avoid regenerating names the user already picked

If no memory exists, proceed normally. Memory is additive — never block a phase on missing memory.

Phase 0: Brief (sequential, interactive)

1. Parse what's being named, context, constraints
2. Auto-classify naming context → select preset
3. Present classification + adjusted weights to user
4. Accept overrides: --style, --thorough, manual weight adjustment
5. Accept inspirations: "I like names like Vercel, Stripe, Neon"

Phase 1: Generate & Filter (inline, single-pass)

Load references/naming-strategies.md for archetype details and sound symbolism guide.

Generate 40-60 candidates across 6 naming archetypes:

Hard filters (binary pass/fail, run BEFORE availability checking):

Run !uv run python scripts/generate.py filter --input candidates.json for automated filters, then apply AI-only filters inline:

1. Profanity/vulgarity in English (script: generate.py filter)
2. Offensive meaning in top 10 world languages (AI-only: use brave_web_search)
3. Exact collision with top-1000 brand in same category (AI-only: use brave_web_search)
4. Exceeds length limit (15 chars product, 8 chars CLI, 12 chars library) (script: generate.py filter)
5. Unpronounceable consonant clusters (script: generate.py filter)
6. Reserved word in major programming languages (script: generate.py filter)
7. Contains hyphens/special chars (for package names) (script: generate.py filter)

Score intrinsic dimensions (phonetics, semantics, memorability, morphological flexibility, visual quality). Use !uv run python scripts/generate.py analyze <name> for phonetic breakdown to inform phonetic quality scoring. Select top 20-25 for availability checking.

--thorough mode: Run multiple generation passes with varied prompting for more diversity.

Phase 2: Availability Sweep (parallel subagents)

Load references/platform-checks.md for per-platform check methods.

Dispatch 4 parallel subagents, each checking ALL candidates in its category:

Subagent A — Domain Checker:

• .com/.net via RDAP: GET https://rdap.verisign.com/com/v1/domain/{name}.com → 404 = available
• .dev/.io/.ai/.app via brave_web_search
• Pricing: brave_web_search for top 5 candidates

Subagent B — Dev Registry Checker (Direct API):

• GitHub: GET https://api.github.com/users/{name} → 404 = available
• npm: GET https://registry.npmjs.org/{name} → 404 = available
• PyPI: GET https://pypi.org/pypi/{name}/json → 404 = available
• Crates: GET https://crates.io/api/v1/crates/{name} → 404 = available

Subagent C — Social & Handle Checker:

• Reddit: GET https://www.reddit.com/api/username_available.json?user={name}
• Bluesky: AT Protocol handle resolution
• X/Twitter, YouTube, Instagram, LinkedIn: brave_web_search with site: prefix

Subagent D — Conflict & Distinctiveness:

• Search collision volume: brave_web_search '"{name}" software'
• Trademark (--thorough): brave_web_search "USPTO TESS {name}"

Or run deterministic checks via script: !uv run python scripts/availability.py check-all candidate1 candidate2 ...

Scaling:

• ≤10 candidates: 4 parallel subagents
• 11-25 candidates: Pre-filter with quick .com RDAP, full check top 10-15
• --thorough: All social + trademark + Wikipedia checks

Phase 2.5: Variant Generation (conditional)

For top 5 intrinsic-scored candidates that FAILED availability:

• Generate 3-5 variants each: prefix (go-, un-), suffix (-kit, -lab, -ify), vowel dropping (namr), respelling (nomer), scoped (@scope/name)
• Run availability checks on variants (same subagent pattern, smaller batch)

Phase 3: Score & Rank (inline)

Load references/scoring-rubric.md for detailed criteria.

10 scoring dimensions (0-10 scale, context-weighted):

Composite: (0.4 × intrinsic_avg) + (0.6 × extrinsic_avg) — user can adjust split.

Run !uv run python scripts/score.py score --input candidates.json for deterministic scoring. Input JSON must have {"candidates": [{"name": "...", "intrinsic": {...}, "availability": {...}}], "preset": "cli-tool"}.

Phase 4: Present (inline)

Load references/output-formats.md for templates.

Three ranked views:

1. Best Names — ranked by intrinsic quality (availability shown but not factored)
2. Best Available — ranked by composite score (default recommendation)
3. Best with Variants — top intrinsic names with available modifications

Each view: ranked table with availability matrix (✅ ❌ ⚠️ ❓), scores, rationale.

Detailed cards for top 3 per view: full scoring breakdown, strengths, risks, next steps.

Actionable next steps: "Register neon.dev at $12/yr", "Claim @neon on GitHub", "npm init neon"

Interactive refinement: "more like #3", "shorter", "more technical", "avoid X sounds"

Dashboard: After all views and cards are produced, assemble the full session into the JSON schema from references/output-formats.md § Structured Output Schema. Read templates/dashboard.html, replace {} in <script id="data" type="application/json">{}</script> with the JSON, and write the result to ~/.{gemini|copilot|codex|claude}/namer/{session-slug}-dashboard.html. Print the open command: open ~/.{gemini|copilot|codex|claude}/namer/{slug}-dashboard.html

Save Session

Save to ~/.{gemini|copilot|codex|claude}/namer/{YYYY-MM-DD}-{context}-{slug}.md with YAML frontmatter after Phase 1 (candidates), Phase 2 (availability), Phase 4 (ranking). Supports resume.

Memory Save Triggers

Save memories at natural decision points. NEVER slow down a phase for a memory write — always save AFTER delivering primary output.

Batch multiple saves in a SINGLE message when a session produces several memories. All memory.py commands are prefixed with !uv run python scripts/.

Canonical Vocabulary

Reference File Index

Load ONE reference at a time per the "Read When" column.

Critical Rules

1. Never skip availability checking — unchecked names are worthless recommendations
2. Always present scoring rubric transparently — no black-box rankings
3. Never fabricate availability data — if a check fails, mark "❓ unknown", never "✅ available"
4. Always run hard filters before availability checks — don't waste API calls on disqualified names
5. Maximum 25 candidates through full availability pipeline — budget tool calls
6. Always surface trademark/conflict risks — legal issues trump name quality
7. Never modify user files — namer is read-only except session journals in ~/.{gemini|copilot|codex|claude}/namer/
8. Always produce all three output views — Best Names, Best Available, Best with Variants
9. Always provide actionable next steps — "register X at Y for $Z" not just "X is available"
10. Generation must use multiple archetypes — never produce candidates from only one strategy
11. Context classification before generation — weights and platforms depend on it
12. Intrinsic and extrinsic scores shown separately — user needs to see the trade-off
13. Load user memory before Phase 0 (Phase -1). Save memories AFTER delivering primary output — never block a phase for a memory write