Build an AI brand and name generator

Naming a new Northwind project always stalls in the same place: someone calls a meeting, the room throws out a dozen names, and there is no record of which ones were any good or why. A week later nobody can remember the shortlist.

This script turns that scramble into a logged shortlist. You give it a short brief, it asks Claude for ten name candidates — each with a fit score and a one-line rationale — and it appends every idea to a tracking sheet with a timestamp. Run it a few times with different briefs and you build a searchable history of every name you have considered, instead of a whiteboard photo.

What you’ll need

• A Google Sheet to log the candidates. The first tab needs a header row: Generated, Brief, Name, Score, Rationale.
• An Anthropic API key saved as ANTHROPIC_API_KEY in Script Properties — see Store API keys and secrets securely.

The script

// The spreadsheet that logs every name candidate.
const NAMES_SHEET_ID = '1abcNamesId';

// How many name candidates to ask for per brief.
const CANDIDATES_PER_BRIEF = 10;

/**
 * Asks Claude for a batch of name candidates for a given brief.
 *
 * @param {string} brief A short description of the project to name.
 * @return {Array<Object>} Objects of {name, score, rationale}.
 */
function brainstormNames(brief) {
  // 1. Build a prompt that pins the output to a strict JSON schema,
  //    so each idea carries a score and a reason.
  const prompt =
    `Generate ${CANDIDATES_PER_BRIEF} product/project name candidates for: ` +
    brief + '. Return ONLY a JSON array — no prose, no markdown — in this ' +
    'shape: [{"name": string, "score": number, "rationale": string}]. ' +
    'Score each name 1-5 for fit, and keep the rationale to one sentence.';

  // 2. Sonnet does the brainstorming; strip any code fence, then parse.
  const reply = callClaude(prompt, 'claude-sonnet-4-6', 1500);
  return JSON.parse(stripFences(reply));
}

/**
 * Generates name candidates for a brief and appends each one, with a
 * timestamp, to the tracking sheet.
 *
 * @param {string} brief A short description of the project to name.
 */
function generateAndLog(brief) {
  if (!brief) {
    Logger.log('No brief supplied — nothing to generate.');
    return;
  }

  // Get the candidates, then write one row per idea.
  const ideas = brainstormNames(brief);
  const sheet = SpreadsheetApp.openById(NAMES_SHEET_ID).getSheets()[0];
  ideas.forEach((idea) => {
    sheet.appendRow([new Date(), brief, idea.name, idea.score, idea.rationale]);
  });
  Logger.log('Logged ' + ideas.length + ' candidates.');
}

/**
 * Claude occasionally wraps JSON in a ```json code fence. Strip it so
 * JSON.parse never chokes on the markdown.
 */
function stripFences(text) {
  return text.replace(/```(?:json)?/g, '').trim();
}

/**
 * Minimal Anthropic API call. The key lives in Script Properties — it
 * is never pasted into the code.
 */
function callClaude(prompt, model = 'claude-haiku-4-5-20251001', maxTokens = 400) {
  const key = PropertiesService.getScriptProperties()
    .getProperty('ANTHROPIC_API_KEY');
  const res = UrlFetchApp.fetch('https://api.anthropic.com/v1/messages', {
    method: 'post',
    contentType: 'application/json',
    headers: { 'x-api-key': key, 'anthropic-version': '2023-06-01' },
    payload: JSON.stringify({
      model,
      max_tokens: maxTokens,
      messages: [{ role: 'user', content: prompt }],
    }),
    muteHttpExceptions: true,
  });
  return JSON.parse(res.getContentText()).content[0].text.trim();
}

How it works

1. brainstormNames takes a brief and builds a prompt that pins the output to a strict JSON schema — an array of objects, each with a name, a score, and a one-line rationale.
2. It calls Claude Sonnet, which produces more varied, on-brief names than a smaller model. stripFences removes any code fence, then JSON.parse turns the reply into objects.
3. generateAndLog is the entry point. It bails out early if no brief was passed, so an empty call never hits the API.
4. It calls brainstormNames, then appends one row per idea to the tracking sheet, stamping each with the current date and the brief that produced it.

Example run

Call generateAndLog('a lightweight time-tracking app for freelancers') and the tracking sheet gains rows like these:

Generated	Brief	Name	Score	Rationale
2025-11-15	a lightweight time-tracking app…	Tally	5	Short, plain, and hints at counting hours.
2025-11-15	a lightweight time-tracking app…	Clockwise	4	Memorable, but a few products already use it.
2025-11-15	a lightweight time-tracking app…	Hourglass	3	On-theme but feels slow rather than light.

Sort the sheet by the Score column and your shortlist rises to the top, with the reasoning attached so the next meeting starts from a real discussion.

Run it

This is an on-demand job — you run it whenever a project needs a name:

1. In the Apps Script editor, write a one-line wrapper that calls generateAndLog with your brief, then select it and click Run.
2. Approve the authorisation prompt the first time.
3. Open the tracking sheet and sort by Score to see the shortlist.

Watch out for

• Scores are Claude’s opinion, not a verdict. They are useful for ranking ideas against each other, but a 5 is not a guarantee — read the rationale and judge.
• It does not check domain or trademark availability. The description promises “domain available” as a goal, but that needs a separate lookup; treat every name as a candidate until you have checked.
• Each run appends, it never clears. That is deliberate — the log builds up — but it means duplicates accumulate across runs. Sort or de-duplicate when you review.
• Keep briefs specific. “An app” yields generic names; a brief with audience, tone, and what the product does gives Claude enough to be original.