agentleFS
soulmachinesoulmachine/skills/affix-domains/SKILL.md

affix-domains

Skill3 starsChanged yesterdayMITView on GitHub

Attach popular brand prefixes/suffixes to a seed word and check availability against the authoritative registry. Starts at `.com`; if the seed word's own `.com` is taken, escalates the whole sweep to .com/.net/.org/.ai/.io/.co/.app/.cc. Use when the user names a word and asks for prefix/suffix domain variants, or wants domains generated by adding endings like -labs/-ify/-ly or beginnings like deep-/open-/get-. It also makes spelling variants of the bare seed (digg, noom, zillow and flickr patterns). Every candidate is also checked as a GitHub org name and an X (Twitter) handle, all in parallel lanes, so the domain, the org and the handle can be taken together. A domain the registry left unresolved (rate limit, timeout) is re-checked on Cloudflare's public domain search in a local real browser. Catalogs are ranked by 2025–26 hot-AI-startup evidence; scan and surface in rank order.

The file

We split this skill into the rules it gives an agent

5 rules. About 0 are common, 2 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Gate on the bare seed's .com: Before generating anything, check <seed>.com alone.

    line 12
  2. Distinctive:

    Write the candidates as bare names, one per line, in catalog rank order, to a fresh run dir.

    line 23
  3. Distinctive:

    Every lane checks names in file order, so when a quota trips late in a run its UNKNOWNs land on the lowest-ranked names.

    line 29
  4. Very specific:

    Write each verdict back and reprint the table.

    line 58
  5. Very specific:

    Not installed, not logged in, or any error: the source is skipped with one check_owned: cf|gddy skipped, not logged in line on stderr, and …

    line 151

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

affix-domains

Affix a seed word with common brand prefixes and suffixes, check each candidate live against the authoritative registry, against GitHub's org namespace, and against X's handle namespace, and prompt the user to register the free ones.

Steps

  1. Gate on the bare seed's .com. Before generating anything, check <seed>.com alone. It decides which lanes step 3 runs:

    • Free → the seed itself is winnable. Say so up front, then run the affix sweep on .com only — the original contract.
    • Taken → escalate. Every check from here on runs across the full TLD set: .com .net .org .ai .io .co .app .cc. Also sweep the bare seed across the other seven — mate.ai is worth more than matebuddy.com, and it costs eight lookups to find out.
  2. Generate candidates. For seed W, produce W + each suffix and each prefix + W from the catalog below. Lowercase. Dedupe. Always drop triple-letter runs (mateee) and a suffix that repeats the seed (matemate).

    The English-word filter is mode-dependent: in .com-only mode, drop any combination that spells an existing English word (e.g. getup, openbox) — its .com is almost certainly taken and burns a lookup. In escalated mode, keep them — that rationale is .com-specific, and a real word gone in .com says nothing about .ai or .cc. (mately is a dictionary adverb and the flagship -ly SaaS pattern; it is free in six TLDs.) If the user hints a style (playful, techy, marketplace…), weight the matching categories; default is every category.

    Also make the spelling variants of the bare seed, by the four rules in "Spelling variants" below. They change the seed only: never cross a variant with an affix. The same two filters apply to them.

    Write the candidates as bare names, one per line, in catalog rank order, to a fresh run dir; in escalated mode the bare seed is the first line. The spelling variants come next, above every affix:

    RUN=$(mktemp -d -t affix-<seed>) && printf '%s\n' "${cands[@]}" > "$RUN/names"

    Every lane checks names in file order, so when a quota trips late in a run its UNKNOWNs land on the lowest-ranked names.

  3. Run the sweep: every lane at once, as background jobs.

    ~/.claude/skills/affix-domains/scripts/sweep.sh com "$RUN"         # .com-only mode
    ~/.claude/skills/affix-domains/scripts/sweep.sh escalated "$RUN"   # full TLD set

    A lane is one rate-limit pool, checked by one bundled script over all of $RUN/names: com,net · cc · org · ai,io · app · co (com alone in .com-only mode) · GitHub · X · the user's own registrar accounts. .com/.net share Verisign's host and .ai/.io share Identity Digital's, so each pair stays one lane: two jobs on one pool add no speed and trip its quota sooner. GitHub and X check every candidate, not only domain survivors, so they run beside the domain lanes instead of after them; one sweep fits inside both budgets. Each lane re-runs its UNKNOWN lookups once as soon as it ends, and skips a TLD that came back mostly UNKNOWN, with a sweep: line on stderr naming it; a TLD with fewer than five lookups is always retried, since one slow answer is not a quota block (a one-name bitchat sweep had .ai answer UNKNOWN, then TAKEN on the retry, 2026-10-28). The sweep takes as long as its slowest lane, usually X at about one name a second.

    It prints one line per name, in rank order: <name>\t<FREE TLDs, best first>\t<OWNED TLDs>\t<UNKNOWN TLDs>\t<github>\t<x>, with - for none. The raw lane files stay in $RUN; scripts/merge.sh "$RUN" reprints the table.

    OWNED is a TAKEN that is the user's. check_owned.sh lists the user's own domains through cf (Cloudflare) and gddy (GoDaddy) and relabels every candidate it finds there, in any TLD, so a .chat or .xyz of the seed shows up too. A CLI that is not installed or not logged in is skipped with a check_owned: line on stderr, and its domains keep the registry's TAKEN. See "Your own accounts" below.

    UNKNOWN is not FREE. It means the registry never gave a clean answer. Never show it as available; resolve it in step 3b, and say so explicitly only when Cloudflare could not answer either.

3b. Resolve UNKNOWN domains in a real browser. List what the sweep left unresolved:

~/.claude/skills/affix-domains/scripts/merge.sh "$RUN" | awk -F'\t' '$4!="-"{n=split($4,t," ");for(i=1;i<=n;i++)print $1"."t[i]}'

For each name.tld, open https://www.cloudflare.com/domains/search?q=<name.tld> in a local real browser, chosen in the order browser.md gives (Ego Lite, then BrowserOS neo, then jev-chrome). A script will not do: Cloudflare's bot protection answers a bare curl or WebSocket with 403; only a real browser profile gets results. One domain per page load. Read only the row whose name is exactly that domain, not the suggestions around it (agentsyncaroo.com.co, .company, .computer sit right under agentsyncaroo.com). The verdicts, verified 2026-10-28:

  • A Buy now: <name.tld> for $… button → FREE. A high price on an ordinary TLD is a premium name: still FREE, but say "premium" on the name's line.
  • The domain followed by Unavailable and no Buy button → TAKEN.
  • No row for that exact domain (the empty state No domains match your filters, Search is unavailable, an unsupported-TLD, rate-limit or offline message) → stays UNKNOWN. Every .cc query answers Search is unavailable (verified 2026-10-28 on a free and a taken one), so the page resolves seven of the eight TLDs and .cc stays with the registry.

Write each verdict back and reprint the table; merge.sh reads every dom-*.tsv, lets a definite verdict replace an UNKNOWN, and never lets anything replace an OWNED:

printf '%s\tTAKEN\n' mateio.io >> "$RUN/dom-cloudflare.tsv"
~/.claude/skills/affix-domains/scripts/merge.sh "$RUN"

Work in rank order, highest first. A dozen page loads is fine; sixty is not. When the UNKNOWN set is large, resolve the shortlist and say which names were left.

  1. Read the GitHub and X columns. They check the name, not the domain — a brand needs its handles as much as the domain: GitHub is where the code will live, X is where it will be announced. For both, only FREE is claimable. The GitHub verdicts:

    • TAKEN — users and orgs share one namespace, so a name some person holds is exactly as gone as one an org holds.
    • RESERVED — GitHub's own route namespace (settings, new, about, explore, login…). Never claimable, and it is the trap: these 404 on the API and only reveal themselves as a 30x redirect on the web.
    • INVALID — breaks GitHub's account-name rules: anything outside alphanumerics and single interior hyphens, or over 39 characters. Also 404s, so it is screened before the lookup.

    check_x.sh runs in two stages. First twitter user <name> — twitter-cli on your own logged-in Chrome session, two lanes, about 2 s a name: a profile means TAKEN, and that is all stage one decides. Every other name — no profile, or any twitter-cli error — goes to X's sign-up availability check, which is what splits them into FREE, RESERVED and INVALID — a profile miss alone is never FREE. After the sweep the script re-queries every FREE once, serially, and prints the re-check's verdict; you do not repeat that. The script installs twitter-cli with uv tool install twitter-cli when it is missing; when it is installed but not logged in on this host, it says so on stderr and runs the sign-up stage over every name instead, with the same verdicts. The X verdicts:

    • TAKEN — a profile exists; one namespace, case-insensitive: GetMate and getmate are the same handle. A suspended or deactivated account counts — X holds the handle, a deactivated one for at least 30 days.
    • RESERVED — X's sign-up refuses it. That covers route words (home, settings, explore, i, search, login…), anything containing twitter or admin, and a held set of ordinary-looking handles (matearoo, evermate) that show no profile page yet can never be claimed. Never claimable, and it is the trap: x.com/<name> 404s on those, exactly as GitHub's API does on its reserved names.
    • INVALID — outside [A-Za-z0-9_], shorter than 5, or longer than 15; screened locally, so it costs no request. The two namespaces disagree here: GitHub allows hyphens and 39 characters, X allows underscores and 15 — a long candidate can be valid on GitHub and INVALID on X, and that is a real answer, not an error.
  2. Surface the survivors. In .com-only mode, list one line per free .com, in catalog rank order (note each name's category).

    In escalated mode the raw cross-product is far too long to dump. Instead, keep the sweep's order: names by their affix's catalog rank, each name's free TLDs in this preference order:

    .com > .ai > .io > .app > .co > .net > .org > .cc

    In both modes, a name with an OWNED TLD leads the list, marked as owned: the brand is already partly in hand, and the free TLDs beside it are the ones worth buying. Never count an OWNED domain as a loss.

    Show the best one or two TLDs per name, and offer the complete matrix only if the user asks. Note when a name is free across many TLDs — that usually means it is genuinely unclaimed rather than merely available in the leftovers.

    Carry the GitHub and X verdicts on the same line as the name, in both modes — two columns, not two more lists; the user is picking a brand, and the domain, the org and the handle are one decision. A name where the domain, the org and the handle are all free is the strongest result the sweep can return: lead with those, and say so. Where a name's domain is free but the org or the handle is taken, keep it on the list and mark which — it is still registrable, just with a handle compromise ahead.

    When a shortlisted name's X handle is TAKEN, check its variants before reporting. A taken @name is rarely the end of the brand: AI products use a small set of handle patterns, verified live on 2026-10-27 against each profile. Build the variants from this table, run them through check_x.sh (one call, --stdin), and report the free ones on the name's line as "handle: @name taken, @name_ai free". Prefer the pattern that matches the primary TLD (_ai for a .ai domain, _io for .io), and say that the display name hides the suffix in most feeds.

    PatternExampleExamples verified liveFollowers
    _ai suffixname_ai@cursor_ai, @perplexity_ai, @windsurf_ai, @devin_ai494k, 510k
    ai glued onnameai@AnthropicAI, @MistralAI, @claudeai, @VoyageAI, @tavilyai1.8M, 226k, 1.96M
    domain spelled outnamedotai, name_io, name_dev@boltdotnew, @n8n_io, @SST_dev123k, 85k, 16k
    hq suffixnamehq, name_hq@FireworksAI_HQ36k
    get / try / use prefixgetname@getpostman55k
    trailing _name_@OpenBot_, @JinaAI_13k, 18k
    descriptive wordnamecompute, namedevs@togethercompute, @OpenAIDevs65k, 466k

    The _ai suffix is the dominant pattern for AI-native products, and the two biggest examples use it. Squatters follow the same table: @CursorHQ, @trycursor and @Clinebot exist with under ten followers, so a brand that waits loses its second-choice handle too. X's 15-character limit screens long variants locally (nameofficial is INVALID past 15), and name_ is often the first one gone.

  3. Prompt the user to register. Ask which they want to take. Point them to Cloudflare Registrar (or their preferred one) — note that Cloudflare Registrar does not sell every TLD in this set, so a second registrar may be needed. Do not enter payment on their behalf — registration is the user's action.

    For the matching GitHub org, point them at https://github.com/organizations/new — free, no payment, seconds to claim. Worth saying plainly: an org name costs nothing and is first-come, so it is the cheapest part of the brand to lose by waiting. Creating it is still the user's action, not yours.

    The X handle is claimed by signing up at https://x.com/i/flow/signup with that username, or by renaming an existing account at https://x.com/settings/screen_name. Free and first-come like the org, and the same rule: the user claims it, not you.

TLD endpoints

Verified 2026-08-27, each against a known-taken and a known-free control. The script holds these; the table is here so a human can audit it.

TLDMethodEndpointNotes
.comRDAPrdap.verisign.com/com/v1/domain/Verisign, authoritative
.netRDAPrdap.verisign.com/net/v1/domain/Verisign
.ccRDAPtld-rdap.verisign.com/cc/v1/domain/Verisign, but a different host than .com/.net
.orgRDAPrdap.publicinterestregistry.org/rdap/domain/PIR
.aiRDAPrdap.identitydigital.services/rdap/domain/Identity Digital
.ioRDAPrdap.identitydigital.services/rdap/domain/same host as .ai; not in the IANA bootstrap
.appRDAPpubapi.registry.google/rdap/domain/Google Registry; rate-limited, see below
.coWHOISwhois.registry.coNo RDAP service exists. Free ⇔ DOMAIN NOT FOUND

.app rate limiting is a rolling quota, not a concurrency cap. Dropping to -P 2 does not help — once the budget is spent, every request 429s regardless of parallelism. The only fix is serial requests plus backoff-and-retry, which is what the script does. Treat 429 as retry, never as an answer.

.ai and .io share one host, and so share one quota. rdap.identitydigital.services serves both at -P 6, so an escalated sweep hits it with twice the requests of any other host and can exhaust it late in the run — observed 2026-09-16 on a 67-name sweep, where the last 13 .io lookups all came back UNKNOWN while .com and .cc were clean. Once it is tripped the block is long — measured at over 150s of cumulative backoff on a single name without clearing, so neither the script's 4-attempt loop nor a hand-rolled serial retry with 10s-and-up sleeps will outlast it inside a session. Do not grind: a full serial retry of 13 names costs ~30 minutes and can still return all UNKNOWN. Hand those lookups to step 3b, the Cloudflare page in a real browser, which does not share the registry's quota. Spending the quota more slowly does not buy more of it. A block of UNKNOWNs confined to one TLD is a quota symptom, not a registry answer — never let it reach the user as availability, in either direction.

Cloudflare public search (browser fallback)

Verified 2026-10-28 in Ego Lite against x.com (Unavailable), agentsyncaroo.com (Buy now, $10.46) and agentsyncaroo on the other six sellable TLDs (Buy now on each); .cc answered Search is unavailable on both a free and a taken name. It is Cloudflare Registrar's own availability data, with no login, so it is a fair second opinion when a registry endpoint above is blocked. It never replaces the scripts: it resolves an UNKNOWN only, and a registry FREE or TAKEN stands.

TargetMethodEndpointNotes
.com .net .org .ai .io .co .app (not .cc)browser page, exact-domain rowhttps://www.cloudflare.com/domains/search?q=<name.tld>Buy now button free · Unavailable taken · no row for that exact domain UNKNOWN. One domain per load

Two traps. A bare curl or WebSocket to it gets 403 from bot protection, so there is no script lane: open it in a real browser. And the registrar docs' rule "a domain missing from the list is not available" is written for the dashboard's keyword search; here a missing row is UNKNOWN, never TAKEN.

Your own accounts

Verified 2026-10-28 against bitchat.org (in the Cloudflare account, read OWNED) and bitchat.com (not, kept TAKEN). The registry answers "registered", never "registered to you", so this lane reads the user's registrar accounts and relabels the matches. It only ever turns a TAKEN into an OWNED; it never frees a domain.

AccountMethodCommandNotes
Cloudflarecf zones list --per-page 50 --page N, paged until a short pagecf CLI, CLOUDFLARE_API_TOKEN or its loginThe zone list, not cf registrar registrations list: that one caps at 50 and hides its pagination cursor. Cloudflare Registrar needs the zone on the same account, so the zone list covers every registration, plus zones the user points here from another registrar, which are theirs too
GoDaddygddy domain list -o json, .data[].domaingddy CLI with a Personal Access TokenOne call, no paging

cf registrar registrations get <name.tld> is the exact check for one domain: the record when it is the user's, 404 Domain not found when it is not. Use it to confirm a single OWNED, not for a sweep.

Not installed, not logged in, or any error: the source is skipped with one check_owned: cf|gddy skipped, not logged in line on stderr, and its domains stay TAKEN. OWNED is never guessed from memory or from an earlier run.

GitHub org namespace

Verified 2026-09-16 against four controls: github (org) 200, soulmachine (user) 200, agentsyncaroo (free) 404, settings and new (reserved) 302.

TargetMethodEndpointNotes
GitHub org/user nameHTML statushttps://github.com/<name>404 free · 200 taken · 301/302 reserved. No token, no API budget; P8 is comfortable

Do not use api.github.com/users/<name> for this. It answers 404 for GitHub's reserved route names — settings, new, about, explore, login — which would be reported as available when they can never be registered. Only the web endpoint separates reserved from free, by redirecting instead of 404ing. The API is also capped at 60 requests/hour unauthenticated, which a single 67-name sweep blows straight through.

X handle namespace

Verified 2026-09-18. Stage 1 controls: x taken (the preflight's own call, past the local screen), soulmachine hollow (held), agentsyncaroo and matearoo not found. Stage 2 controls: agentsyncaroo available, explore is_banned_word, twitteradmin contains_banned_word; get-mate, abc and abcdefghijklmnop are INVALID from the local screen and never reach either stage (home is four characters, so it is INVALID too, however famous the account).

StageQuestionMethodEndpointNotes
1profile exists?twitter-cli user <name> --jsonGraphQL UserByScreenName on the user's Chrome sessionok:true taken — an empty id is X's UserUnavailable, a held handle; code:not_found and any other code fall through to stage 2. About 2 s a name; the session limit is community-reported at ~95 per 15 min, and twitter-cli retries a 429 itself (5/10/20 s) before surfacing it, so a second sweep inside the window runs slower, not emptier
2registrable?JSON reason fieldapi.x.com/i/users/username_available.json?username=<name>X's own sign-up check, unauthenticated, no API credits, case-insensitive: available free · taken · is_banned_word / contains_banned_word reserved · invalid_username / improper_format invalid

Stage 2 has a budget of about 250 requests per IP, then a 429 that lasts minutes; a burst on the first 200 re-trips it, and fifteen quiet minutes clears it. A sweep sends it only the no-profile names — 18 of 66 in the mate sweep — so it fits many times over; if the column still goes UNKNOWN part-way through, that is the quota, not a registry answer: report those names unresolved and re-run only them after the quiet period.

For a few ordinary-looking names the sign-up answer is not stable. Measured 2026-09-18 on a calm endpoint, serially, nothing else in flight: mateora answered available, then is_banned_word sixty seconds later; quickmate did the same across runs; matehub answered available early in the day and is_banned_word from twenty minutes on. The twelve other banned mate handles held across every query. No name that answered taken ever answered available, but mateor (taken) did answer is_banned_word once, in a run that was also drawing 429s — a flicker can land on a taken name too, and both answers are not-claimable. Which of the two answers is true for a flickering free name cannot be settled without registering it, so the rule is: a FREE that does not repeat is not FREE. The script re-queries every FREE once after the sweep, serially, and prints that second verdict verbatim, whatever it is; the flicker itself is worth a sentence to the user. RESERVED from a clean run is otherwise reliable. Querying a name does not put it on hold — 250 probe names checked once still read available 35 minutes later — but FREE is still a snapshot: re-check the shortlist right before the user claims it.

Endpoints that look right and are wrong

Both of these return HTTP 404 for domains that are definitely registered — a silent false-available that would tell the user to go buy a taken domain. Do not substitute them:

  • rdap.godaddy.com/v1/domain/ — 404s on t.co. It is the registrar's RDAP, not the registry's.
  • rdap.org/domain/ — a bootstrap proxy; 404s on both .co and .io because neither is in the IANA bootstrap file.

And for the X handle, both of these would report a reserved handle as free:

  • https://x.com/<name> HTTP status — 404 for free names, but also 404 for held handles like matearoo and evermate, which sign-up refuses as is_banned_word. It encodes none of the sign-up rules.
  • X API v2 GET /2/users/by/username/<name> (via xurl, or the xapi MCP's user lookup) — answers "does an account exist", not "can you register it", so reserved words and held handles come back not-found. It also spends API credits, which neither stage does; the DomainHunter app answered 402 credits depleted on 2026-09-18.
  • twitter-cli's not_found on its own — it is stage 1, not a verdict: matearoo is not_found there and refused by sign-up. Only the sign-up check promotes a no-profile name to FREE.

Spelling variants

Step 2 makes these from the bare seed on every sweep, usually 2–6 names. Each rule that does not fit the seed gives no variant.

  1. Double the last consonant. dig→digg, get→gett, fiver→fiverr. Skip a seed that ends in a vowel or a double letter, or in h j q w x y (hh, xx and yy read as typos).
  2. Double a vowel. Each single o or e gives one variant: nom→noom, move→moove. Not a i u: English rarely doubles them. Adding -ee or -oo at the end is the suffix catalog's job, not this rule's.
  3. Blend with a word that has a double letter. Propose up to 3 portmanteaus with a common word whose double letter sits where it overlaps the seed (zillions+pillow→zillow, Mosaic+Godzilla→mozilla). These are your choice, not mechanical: label each with its two parts on its result line.
  4. Drop the last vowel before one final consonant. checker→checkr, tumbler→tumblr, flicker→flickr. A seed like mate, which ends in a vowel, gets none.

These patterns come from the web 2.0 era. The 2025–26 corpus behind the catalog ranks has no evidence for them, so they rank by position (right after the bare seed), not by score: they are few, short, and close to the seed.

The brands below inspired the rules; they are history, not worked examples. Some do not follow their rule exactly (Shopee appends -ee, Reddit and Chegg come from phrases, Trello keeps the double of one word). Generate only by the four rules above.

RuleInspired by
1Digg (dig), Fiverr (fiver), Gett (get), Reddit ("read it"), Chegg ("chicken and egg")
2Moovit ("move it"), Noom ("moon" reversed), Shopee (shop)
3Zillow (zillions + pillow), Mozilla (Mosaic + Godzilla), Trello (trellis)
4Flickr (flicker), Tumblr (tumbler), Checkr (checker), Grindr (grinder)

Catalog ranking

Both catalogs are ranked by evidence: how often the hottest AI startups actually use each affix in their brand names — a 433-company corpus (Forbes AI 50 2026+2025, CB Insights AI 100 2026, YC, a16z Top-100 consumer apps, LinkedIn Top Startups US, 2025–26 mega-rounds, AI dev-tools peer group; snapshot 2026-08-28) — blended with fusability and meaning (Score = 2·E + F + M). Generate candidates from every row, but check and surface them in rank order. The full evidence tables (scores, old-vs-new ranks, corpus examples) are in references/ranking-2026-08.md. Known catalog gap, deliberately not auto-added: the era's dominant suffix is a trailing "AI" word (~60 hot companies), plus -lab, -0, -gpt, applied- — see the reference before extending the catalog.

Prefix catalog — ranked

#AffixCategoryHot uses 2025–26Feel · exemplars
1deep-Scale & depth4serious tech (DeepMind, DeepSeek)
2open-Newness & openness4transparent/community (OpenAI, OpenTable)
3super-Scale & depth2boosted (Superhuman)
4live-Newness & openness2real-time (LiveChat)
5agent-AI & agents2autonomous doer (Agentforce)
6ai-AI & agents3AI-native signal (AI21)
7up-Scale & depth1rising (Upwork)
8hey-Call-to-action1friendly hail (Hey.com)
9chat-AI & agents1conversational (ChatGPT)
10the-Possessive1definitive (TheVerge)
11go-Call-to-action0momentum (GoDaddy, GoPro)
12fast-Speed & ease0velocity (Fastly)
13get-Call-to-action0grab it (GetResponse)
14next-Newness & openness0successor (NextDoor)
15quick-Speed & ease0instant (QuickBooks)
16smart-Speed & ease0intelligent (SmartThings)
17my-Possessive0personal (MySpace, MyFitnessPal)
18easy-Speed & ease0frictionless (EasyJet)
19ever-Scale & depth0permanence (Evernote)
20real-Newness & openness0authentic (RealPage)
21neo-Newness & openness0new wave (Neobank)
22hyper-Scale & depth0past the limit (Hyperloop, Hyperscience)
23use-Call-to-action0utility (Usebutton)
24try-Call-to-action0low-commitment invite
25ultra-Scale & depth0extreme
26meta-Newness & openness0beyond (Meta)
27meet-Call-to-action0introduction (MeetUp-style)
28agentic-AI & agents0agent-native workflows (agentic AI wave)
29join-Call-to-action0community invite
30every-Scale & depth0universality (Everlane-like)

Suffix catalog — ranked

#AffixCategoryHot uses 2025–26Feel · exemplars
1-labsTool & hub12R&D shop (Bell Labs)
2-oVowel endings11punchy (Venmo)
3-aVowel endings10smooth (Tesla, Zara)
4-erDoer4actor/agent (Uber, Tinder)
5-iaVowel endings3name-like (Nvidia, Expedia)
6-baseTool & hub2foundation/platform (Coinbase, Firebase, Supabase)
7-lyShort & modern3SaaS all-rounder (Bitly, Calendly, Grammarly)
8-rShort & modern3drop-vowel web-2.0 (Tumblr, Flickr): a seed ending in -er drops the e (spelling rule 4); a seed ending in a consonant gets r (check→checkr)
9-usVowel endings4Latin gravitas (Prius)
10-ifyVerbifier1turns the word into a service (Spotify, Shopify)
11-kitTool & hub1toolkit (ConvertKit)
12-botCompanion1automated agent
13-routerTool & hub1traffic director, AI gateway (OpenRouter)
14-oraVowel endings1elegant Latin (Pandora)
15-castVertical positioning1media/broadcast (Podcast)
16-verseStylized & meme1a whole universe (metaverse)
17-appVertical positioning1application (Cash App)
18-hubTool & hub0gathering point (GitHub)
19-stackTool & hub0tech stack (Substack)
20-orDoer1mechanical (Vector)
21-eeVowel endings1soft (Renee-like)
22-boxTool & hub0packaged tool (Dropbox)
23-mateCompanion0sidekick (Mailmate)
24-worksTool & hub0workshop (SolidWorks)
25-palCompanion0trusted friend (PayPal)
26-padTool & hub0workspace (Launchpad)
27-izeVerbifier0systematize (Rentalize)
28-istDoer0specialist (Stylist)
29-spaceTool & hub0room to work (Squarespace)
30-buddyCompanion0friendly helper (GasBuddy)
31-ixVowel endings0techy (Netflix)
32-maticStylized & meme0machine-magic (Instamatic)
33-bayVertical positioning0marketplace (eBay)
34-tokenVertical positioning0AI-era unit of usage (LLM tokens)
35-mailVertical positioning0mailbox/messaging (Gmail, Fastmail, Protonmail)
36-agentAI & agents0autonomous actor, the AI-agent wave (Superagent)
37-exVowel endings0sharp, techy (FedEx)
38-yShort & modern0cute, casual (Etsy)
39-ateVerbifier0automate/activate (Automate)
40-xShort & modern0edgy, techy (Codex)
41-inboxVertical positioning0the place messages land (Inbox by Gmail, Superhuman inbox)
42-emailVertical positioning0literal email product (Hey email)
43-zillaStylized & meme0monster-big (Mozilla)
44-ooVowel endings0round, cute (Yahoo)
45-arooStylized & meme0bouncy-cute (Kangaroo)

Rules

  • Live lookups only — never claim availability from cached knowledge or prior turns of this conversation. Domains, org names and handles get registered between checks.
  • Only an explicit negative means available. RDAP 404, WHOIS DOMAIN NOT FOUND, github.com/<name> returning 404, or X's sign-up check answering "reason":"available". Anything else — 429, 5xx, a timeout, an empty body, a 30x — is UNKNOWN or RESERVED, reported as such and never as free.
  • Use the bundled scripts rather than hand-rolled curl or a bare twitter user. sweep.sh runs the other four: check_domains.sh for TLDs, check_github.sh for the org name, check_x.sh for the X handle, check_owned.sh for the user's own accounts. The per-TLD hosts, the .co WHOIS special case, the .app retry loop, GitHub's reserved-name redirect, and X's two-stage split are all easy to get wrong in a way that fails silently toward false-available. The one non-script lane is the Cloudflare page in step 3b: browser-only, and it only ever resolves an UNKNOWN.
  • The escalated TLD set is fixed: .com .net .org .ai .io .co .app .cc. If the user wants a TLD outside it, check it explicitly and say the endpoint was not pre-verified.
  • OWNED comes only from a live listing of the user's own accounts in this run, through cf and gddy, never from memory or a prior conversation. When neither CLI is logged in, the domain shows TAKEN, and that is correct: say the lane was skipped rather than guess.
  • A free domain with a taken org or handle is still a result — report it, marked, rather than dropping it. The three namespaces are independent and the user may not care equally about all of them; suppressing part of the picture makes that call for them.
  • Never report a GitHub name as available on the strength of an API 404, nor an X handle on the strength of an x.com/<name> 404, a v2 API not-found, or a twitter-cli not_found alone — see the reserved-name traps above. GitHub's web endpoint and X's sign-up check, or nothing.
  • No payment on the user's behalf. Prompt them to register; they check out. Same for creating the GitHub org and claiming the X handle, which cost nothing but are still theirs to do.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.