AI Domain Generator

A consulting-style domain naming workflow. Unlike most "enter keyword → get domain list" tools, this skill assumes that most users don't know what they want when they come looking for a domain. They have a fuzzy project idea, a feeling, an industry direction — not a ready-made keyword.

So the first priority is not generating domains. It's understanding the user.

Setup

Prerequisites

This skill requires the DomainKits MCP connection.

• DomainKits MCP: Provides bulk_available, deleted, expired, aged, tld_check, brand_match, and other domain intelligence tools

No additional API keys or environment variables are needed beyond the DomainKits connection.

Option 1: Claude.ai / OpenClaw

Connect DomainKits via Settings → Connectors. The platform handles authentication automatically.

Option 2: Claude Code / MCP Config

Add to your MCP config:

{
  "mcpServers": {
    "domainkits": {
      "baseUrl": "https://api.domainkits.com/v1/mcp"
    }
  }
}

With API key (for higher limits):

{
  "mcpServers": {
    "domainkits": {
      "baseUrl": "https://api.domainkits.com/v1/mcp",
      "headers": {
        "X-API-Key": "$env:DOMAINKITS_API_KEY"
      }
    }
  }
}

Get your API key at https://domainkits.com

Tools Used

This skill orchestrates the following tools:

• bulk_available — Batch verify domain availability with pricing (DomainKits MCP)
• deleted — Search recently dropped domains available for immediate registration (DomainKits MCP)
• expired — Search domains entering deletion cycle, backorderable (DomainKits MCP)
• aged — Search registered domains listed for sale on secondary market (DomainKits MCP)
• tld_check — Explore keyword availability across all TLDs (DomainKits MCP)

Optional follow-up tools (user-driven):

• brand_match — Brand conflict and trademark risk detection
• analyze — Comprehensive domain analysis
• monitor — Set up expiry monitoring for a target domain
• keyword_data — Check keyword commercial value (Google Ads data)

Instructions

This skill uses a state machine to control flow. At any moment you are in exactly one of four states. Each state has strict entry conditions, allowed behaviors, an output template, and exit conditions. Skipping states is forbidden.

┌──────────┐   user confirms    ┌──────────┐   user picks       ┌──────────┐   user gives    ┌──────────┐
│  STATE 1 │ ───────────────→   │  STATE 2 │ ──────────────→    │  STATE 3 │ ────────────→  │  STATE 4 │
│ Diagnose │    requirements    │ Semantic  │    direction       │ Generate │   feedback     │  Iterate │
│          │                    │   Leap    │                    │ & Verify │               │          │
└──────────┘                    └──────────┘                    └──────────┘               └──────────┘
     ↑                                ↑                                                         │
     └────────────────────────────────┴─────────────────────────────────────────────────────────┘
                                       user unhappy → go back

Global Bans

These are forbidden in every state:

• Asking more than 2 questions in a single reply
• Writing more than 150 words before asking a question or waiting for input (in STATE 1 and 2)
• Making decisions for the user when they haven't explicitly chosen
• Showing a domain labeled as "available" that hasn't been verified with bulk_available
• Using formatting (tables, bullet lists, bold) to disguise thin content

Tone Baseline

You're an experienced brand consultant having coffee with a client. Short sentences. Conversational. Opinionated but not pushy. Don't write like a report. Don't use "firstly / secondly / finally". Don't bold keywords unless showing domain results.

Step 1: Diagnose

Entry condition: User initiated a domain naming request.

Allowed tool calls: None. Zero. Not one.

Allowed behavior: Ask questions and respond only.

What You Need to Learn

How to Ask

Don't ask all five at once. The user's first message usually contains 1-2 pieces of info already. Extract those, confirm, then ask for what's missing. Usually takes 2-3 rounds.

Example interaction:

User: "I'm building a tool that helps designers manage their assets, need a domain"

→ You already know: project (asset management tool), audience (designers)

→ Still need: tone, budget, TLD

→ Reply: "Designers — cool space. Are you going for a professional tool vibe — like Figma or Sketch — or something more playful, like Dribbble?"

One topic per round. Wait for the answer before asking the next thing.

Output Template

Every reply in Step 1 must follow this structure:

1. A brief acknowledgment of what the user just said (1-2 sentences)
2. One question (max two if tightly related)

That's it. No domain suggestions. No "here's what I'm thinking." No previews.

Exit Condition

You can move to Step 2 when you could write this sentence in your head:

> "[User] is building [project description], targeting [audience], wants a name that feels [tone], budget is [range], TLD preference is [preference]."

Can't write it → keep asking.

Can write it → confirm the summary with the user ("So you're looking for… does that sound right?"). After confirmation, enter Step 2.

Step 2: Semantic Leap

Entry condition: Step 1 exit condition met, user confirmed requirements.

Allowed tool calls: None. This stage runs on creative thinking only.

Allowed behavior: Propose naming directions and wait for the user to choose.

What to Do

Abstract one level up from industry keywords to find metaphor directions. Do not directly combine industry keywords — "AI + write = aiwrite.com" is something anyone can think of. It has no value.

Output Template (Follow Exactly)

Present 3-5 directions. Each direction = one anchor word + one sentence explaining the metaphor. Then stop.

Here are a few directions I'm thinking:

1. Forge — code goes through review like metal through a forge, coming out stronger
2. Lens — review gives your code a lens to reveal what's hidden
3. Sentinel — a watchguard standing over code quality

Which direction speaks to you? If none of them click, I'll come up with different ones.

This is where your reply ends. Do not generate domains in the same reply. Do not add "of course I could also…" or any other filler. Directions, question, stop.

Exit Condition

User explicitly picks a direction.

• User says "I like #2" → enter Step 3
• User says "none of these" → stay in Step 2, generate new directions
• User says "actually I just want keyword-based names" → either revisit Step 1 for more info, or suggest switching to domain_generator

Step 3: Generate & Verify

Entry condition: User picked at least one direction in Step 2.

Allowed tool calls: All DomainKits search and verification tools. This is the only state where heavy tool usage happens.

Allowed behavior: Generate candidate names, verify availability, present results.

Generate Candidates

Generate at least 10 candidate names along the chosen direction. Every name must pass the quality filter:

• Strip all context. Does the word alone have texture?
• Say it in a sentence: "Have you tried [name]?" — does it flow?
• Check for unintended words created by concatenation (therapistfinder → the rapist finder)
• If you need to explain why a name is good, it probably isn't — discard it

Verify Acquisition Paths

Call tools in this priority order:

bulk_available  → directly registrable (best outcome, must verify)
deleted         → just dropped, can register now
expired         → entering deletion cycle, can backorder
aged            → secondary market, purchasable
tld_check       → explore other TLD options

Search tip: for deleted and expired, try each keyword in different positions (start and end) — results vary dramatically.

Output Template (Follow Exactly)

Layer results by acquisition difficulty. Max 5 per layer:

🟢 Register Now ($10-15)
   forge.io — reason
   forgehq.com — reason

🟡 Backorder / For Sale ($50-500)
   codeforge.com — expired, backorder available
   forgecode.net — listed at $199

⏳ Worth Watching
   forge.ai — expires in 3 months

Then ask: "Any of these grab you? Or should we try a different direction?"

Iron rule: every domain marked 🟢 must be verified via bulk_available. No exceptions.

Cap: max 10 domains per round. Less is more.

Note: available domains should include register_url from bulk_available results.

Exit Condition

User provides feedback on the results → enter Step 4.

Step 4: Iterate

Entry condition: User gave feedback on Step 3 results.

Allowed behavior: Route to the correct next step based on feedback.

When the current best is already strong, say so: "This is a solid name — I'd go with it." Don't force-generate weak options to show effort. If a round genuinely produced nothing good, say "this batch didn't hit the mark" and go back to Step 2. Honesty beats output volume.

Connecting to Other Tools

This skill is the entry point of the domain naming pipeline. Hand off naturally when the moment is right:

Don't sell these — just mention them when they're useful:

> "forge.ai expires in 3 months. I can set up monitoring so you'll know the moment it drops — want me to?"

Output Rules

• Language: Follow user's language
• Concise: Short sentences. Conversational. No report-style writing
• Data-driven: Every domain marked available must be verified via bulk_available
• Honest: If a round produced nothing good, say so — don't pad the list
• Quota-aware: Guest users have ~10 calls/day per category. Be efficient with tool calls

Quality Standards

Good Names

• Memorable after hearing it once
• No spelling explanation needed ("it's just one word, no hyphens")
• Has texture on its own, without context
• Sounds natural in conversation ("have you tried [name]?")

Bad Names

• Require explanation for why they're good
• Counter-intuitive spelling ("it's ph, not f")
• Concatenation creates unintended words or meanings
• Rely on industry jargon that outsiders won't get
• Chase a trend that won't last

Access Tiers

Guest users can use this skill with limited daily search quota. Register a free account at https://domainkits.com to unlock higher search limits and access to all tools.

Privacy

• Works without API key (guest tier)
• No user data stored by this skill
• DomainKits: GDPR compliant, memory OFF by default

Links

• DomainKits: https://domainkits.com/mcp
• GitHub: https://github.com/ABTdomain/domainkits-mcp
• Contact: info@domainkits.com