Name Audition

Name: Name Audition
Author: glebis

glebis/claude-skills

52 installs
339 repo stars
Updated August 4, 2026
glebis/claude-skills

Audition candidate product or brand names with authoritative domain checks, collision research, a light trademark read, and a ranked casting report.

About

Generates candidate names then screens them via a domain-availability script and web collision research across SaaS, GitHub, packages, and the adjacent vertical, producing a ranked risk table. A developer uses it to pressure-test a naming shortlist before committing, catching adjacent-domain collisions a domain check alone misses.

Separates brandability, availability, and adjacent-domain collision
check_domains.sh WHOIS/NS table plus interactive casting report

Name Audition by the numbers

52 all-time installs (skills.sh)
Ranked #1,316 of 1,879 Marketing & SEO skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/glebis/claude-skills --skill name-audition

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/glebis/claude-skills/name-audition.svg)](https://skillselion.com/skills/glebis/claude-skills/name-audition)

Installs	52
repo stars	★ 339
Last updated	August 4, 2026
Repository	glebis/claude-skills ↗

What it does

Audition candidate product or brand names with authoritative domain checks, collision research, a light trademark read, and a ranked casting report.

Files

SKILL.mdMarkdownGitHub ↗

Name Audition — «Кастинг имён»

Audition candidate names before you cast one. Brandability is not availability, and a free domain is not a safe name — the audition separates the three. Candidates try out; the best one gets cast; the rest simply don't make the cut.

The core lesson this skill encodes

A name can sound perfect, score well, have every domain free — and still be the wrong choice. Three ways a candidate fails its screen test, worst first:

1. Adjacent-domain collision is the worst kind. A product already operating in the target vertical means a name doesn't make the cut even when the string is free to register — confusion and SEO dilution are fatal in the same space. 2. Descriptive / generic names are domain-free but weak. Easy to register, hard to own — bad for trademark, bad for SEO, easy for competitors to crowd. 3. Search visibility ≠ availability. "I didn't see it in results" is not proof a name is free. Verify with authoritative sources before casting.

Workflow — the casting call

Run these stages in order. Stages 3a and 3b run together.

1. Brief. Establish: (a) what is being named (product / app / company / feature / benchmark), (b) scope + one-line description, (c) the adjacent domain — the vertical it lives in (healthcare, coaching, privacy/security, dev tooling); the user supplies this, (d) tone / vibe, (e) which TLDs matter (default .com .org .ai .io .app .co). If (a)–(c) is missing, ask first — the adjacent domain is what makes collision research meaningful. 2. The audition. Generate 4–8 candidate names matching the tone. Favor short, pronounceable, ownable coinages over descriptive compounds. Note for each what it means / why it fits. 3. The screen test (run 3a and 3b together):

3a — Domains (authoritative). Run scripts/check_domains.sh NAME [NAME ...] -- com ai io ...

for a name × TLD availability table. WHOIS no-match + no NS = registrable; Creation Date / Registrar / NS present = taken; ambiguous = verify by hand. Authoritative for registration, never for trademark.

3b — Collision research. For each candidate, use the firecrawl skill or web search

(never beautifulsoup) to check the sources below. 4. Callbacks. Build a per-candidate risk table and rank by safety + ownability. 5. Casting report. Use the present skill to build an interactive HTML deck — one slide per finalist plus a ranked comparison and a "cast it?" slide. 6. Branding (optional, gated). Only if the user wants it: draft a wordmark/logo per finalist with nano-banana or gpt-image-2 (draft quality), embed in the slides. 7. Cast → user decides. Give a clear top pick with reasoning; the user makes the final call. Names that fail "didn't make the cut" — never "killed".

Stage 3b — collision research checklist

For each candidate, search these surfaces and record URLs:

SaaS / AI / startups — Crunchbase, Product Hunt, a plain web search of "<name>" + vertical.
Code namespace — GitHub repos literally named it; PyPI and npm packages with that exact name.
The adjacent domain (most important) — "<name>" + the user's vertical. A same-vertical hit

is the one that ends an audition.

Privacy / security tooling — relevant if the thing touches data handling.
Trademark + ownability — a light USPTO / EUIPO look for live marks in the relevant classes,

plus a judgment call on descriptiveness: distinctive enough to own, or a generic compound a competitor can crowd?

Benchmark names — if naming a benchmark, the decisive check is the literature, not domains:

is the name already a published dataset/benchmark (arXiv / ACL / Papers with Code)? Citation clash, not a domain, is what matters there.

Output table:

Name	Notable existing uses (URLs)	Adjacent-domain clash?	Trademark / ownability	Verdict
Acme	github.com/x, acme.io (logistics)	No	Distinctive, no live marks	Callback

Verdict is Callback (advances) / Cut (out) / Cast (the pick). Apply the Decision rules.

Decision rules

Adjacent-domain collision → Cut. Even if every domain is free. A competing product in the

same vertical poisons the name.

Descriptive / generic compound → weak. Domains may be free, but hard to trademark and bad for

SEO. Flag the ownability risk even when registrable.

Domains-free ≠ safe. Availability is necessary, not sufficient. A name earns the part only

when it is both registrable and clear of adjacent-domain and trademark collisions.

Verify before casting. Confirm domains with check_domains.sh and trademark with a registry

lookup, not with "I didn't find anything."

Rank by safety first, then ownability, then aesthetics.

Example (a real audition)

Naming a privacy-focused de-id toolkit + benchmark for the mental-health / coaching vertical. Audition: Praxio, Dyad, Sessio, ClientPII, CONFIDE.

Name	Screen test	Verdict
Praxio	Sounded great, but Praxis EMR is a mental-health EHR — adjacent-domain collision in the exact vertical.	Cut
Dyad	Clean, meaningful, but `dyad.sh` is a local-AI dev tool and `dyad.ai` is a healthcare company — collisions in both tech and the vertical.	Cut
Sessio	Nice, but `sessio.base44.app` is a same-vertical product for therapists.	Cut
ClientPII	All TLDs free — but a generic descriptive compound, weak to trademark, bad SEO.	Didn't make the cut (as a brand)
CONFIDE	Domains all taken (bad product brand) — but as a benchmark name, citation-collision is low.	Cast (as the benchmark name)

One line: domains-free ≠ safe, and brandable ≠ available. Most names that look good fail on adjacent-domain collisions a domain check alone would never catch.

scripts/check_domains.sh

scripts/check_domains.sh praxio dyad sessio          # default TLDs (.com .org .ai .io .app .co)
scripts/check_domains.sh praxio dyad -- com ai io     # custom TLDs after a --
TLDS="com org ai" scripts/check_domains.sh praxio     # or via env

Per domain it runs whois (following the IANA registry referral when needed) plus dig +short NS, printing a name × TLD table of free / taken / ?. ? = verify by hand (WHOIS rate-limit or .ai flakiness). Needs whois and dig on PATH (ship with macOS; apt install whois dnsutils).

Referenced skills

`firecrawl` — collision / literature research (stage 3b). Never beautifulsoup.
`present` — interactive HTML casting report (stage 5). Pass it the comparison + per-name slides.
`nano-banana` or `gpt-image-2` — optional draft branding (stage 6). Draft quality by default.

Safety & limits

WHOIS is authoritative for registration, not trademark. A free domain can still infringe a

live mark. Always do the separate trademark read.

`.ai` WHOIS is flaky. Treat ? as "check the registrar's search," not "free."
The script proves registrability, not legal clearance — no trademarks, social handles, or

app-store conflicts. For a name you'll build a business on, get an attorney's clearance.

Branding is optional and gated — generate logos only when the user asks; draft quality unless

told otherwise.

The user casts. The skill recommends; it does not commit.

Install

Portable across Claude Code and Codex — plain-prose workflow, one bash script, no Claude-only tools.

cp -R name-audition ~/.claude/skills/   # Claude Code
cp -R name-audition ~/.agents/skills/   # Codex

#!/usr/bin/env bash
# check_domains.sh — authoritative domain-availability check via WHOIS + DNS NS.
#
# Usage:
#   check_domains.sh NAME [NAME ...] [-- TLD ...]
#   check_domains.sh praxio dyad sessio
#   check_domains.sh praxio dyad -- com ai io
#   TLDS="com org ai" check_domains.sh praxio
#
# Defaults: TLDs = com org ai io app co  (override via -- args or $TLDS).
#
# Availability heuristic (authoritative for REGISTRATION, not trademark):
#   - WHOIS says "No match / NOT FOUND / Domain not found / No Data Found"
#     AND `dig +short NS` returns nothing  => AVAILABLE
#   - Creation Date / Registrar / NS present                => TAKEN
#   - Anything ambiguous (rate-limited, .ai flakiness, etc.) => UNKNOWN (verify by hand)
#
# WHOIS is authoritative for whether a domain is REGISTERED. It says nothing about
# trademarks. `.ai` whois is often rate-limited or terse — treat UNKNOWN as "check manually".

set -u

# --- parse args: names before `--`, TLDs after (or from $TLDS env) ---
NAMES=()
TLD_ARGS=()
after_sep=0
for arg in "$@"; do
  if [ "$arg" = "--" ]; then after_sep=1; continue; fi
  if [ "$after_sep" -eq 1 ]; then TLD_ARGS+=("$arg"); else NAMES+=("$arg"); fi
done

if [ "${#NAMES[@]}" -eq 0 ]; then
  echo "usage: check_domains.sh NAME [NAME ...] [-- TLD ...]" >&2
  exit 64
fi

if [ "${#TLD_ARGS[@]}" -gt 0 ]; then
  TLDS_LIST=("${TLD_ARGS[@]}")
elif [ -n "${TLDS:-}" ]; then
  # shellcheck disable=SC2206
  TLDS_LIST=(${TLDS})
else
  TLDS_LIST=(com org ai io app co)
fi

command -v whois >/dev/null 2>&1 || { echo "error: 'whois' not found" >&2; exit 69; }
command -v dig   >/dev/null 2>&1 || { echo "error: 'dig' not found"   >&2; exit 69; }

# Patterns that indicate "not registered" in WHOIS output across registries.
AVAIL_RE='no match|not found|no data found|no entries found|status: *available|domain not found|not been registered|no object found'
# Patterns that indicate "registered".
TAKEN_RE='creation date|registrar:|registry domain id|name server|nserver|domain status: *(active|ok|client)'

# Run whois and follow an IANA TLD referral if the bare query returned the
# registry-object instead of the domain record (common on macOS whois).
do_whois() {
  local domain="$1" out refer
  out="$(whois "$domain" 2>/dev/null)"
  # IANA referral object: contains "refer:" and a "domain: <TLD>" object, not our domain.
  if printf '%s' "$out" | grep -qi '^refer:' && \
     ! printf '%s' "$out" | grep -qi "domain name: *$domain"; then
    refer="$(printf '%s' "$out" | grep -i '^refer:' | head -n1 | awk '{print $2}')"
    if [ -n "$refer" ]; then
      out="$(whois -h "$refer" "$domain" 2>/dev/null)"
    fi
  fi
  printf '%s' "$out"
}

classify() {
  local domain="$1" who ns who_lc
  # NS lookup first (fast, authoritative signal of an active registration).
  ns="$(dig +short NS "$domain" 2>/dev/null | head -n1)"
  # WHOIS (follows IANA referral when needed).
  who="$(do_whois "$domain")"
  who_lc="$(printf '%s' "$who" | tr '[:upper:]' '[:lower:]')"

  local has_ns=0 says_avail=0 says_taken=0
  [ -n "$ns" ] && has_ns=1
  printf '%s' "$who_lc" | grep -Eq "$AVAIL_RE" && says_avail=1
  printf '%s' "$who_lc" | grep -Eq "$TAKEN_RE" && says_taken=1

  if [ "$has_ns" -eq 0 ] && [ "$says_avail" -eq 1 ] && [ "$says_taken" -eq 0 ]; then
    echo "AVAILABLE"
  elif [ "$has_ns" -eq 1 ] || [ "$says_taken" -eq 1 ]; then
    echo "TAKEN"
  else
    echo "UNKNOWN"
  fi
}

# --- header ---
printf '%-16s' "name"
for t in "${TLDS_LIST[@]}"; do printf '%-12s' ".$t"; done
printf '\n'
total_cols=$(( 16 + 12 * ${#TLDS_LIST[@]} ))
printf '%*s\n' "$total_cols" '' | tr ' ' '-'

# --- rows ---
for name in "${NAMES[@]}"; do
  lname="$(printf '%s' "$name" | tr '[:upper:]' '[:lower:]')"
  printf '%-16s' "$lname"
  for t in "${TLDS_LIST[@]}"; do
    domain="${lname}.${t}"
    status="$(classify "$domain")"
    case "$status" in
      AVAILABLE) printf '%-12s' "free" ;;
      TAKEN)     printf '%-12s' "taken" ;;
      *)         printf '%-12s' "?" ;;
    esac
  done
  printf '\n'
done

echo
echo "Legend: free = WHOIS no-match + no NS (registrable). taken = registered. ? = verify by hand (rate-limit / .ai flakiness)."
echo "NOTE: WHOIS is authoritative for REGISTRATION only — NOT for trademark. Always run a separate trademark check."