← Patterns

Judgement and taste
AI helps us move at lightspeed. There's no time to write everything up. So I've used my personal voice and based this on my actual work, to be able to share in real time what I'm doing with the teams I work with.

Judgement and taste

The machine scores, only a human rejects

A large language model, the kind of AI behind chat tools, may score a list too long for anyone to read, but only a person removes something from it. When a model answers a riskier question, such as whether a product name is free to use, it gives links as evidence, each link is opened, and its verdict is rebuilt from the ones that are really there. It is human in the loop, a person kept on the decisions that matter, with the line drawn at rejection.

One of 15 patterns I've found working with AI coding agents. An agent drafted the words from my notes, and I haven't edited them yet. See all 15, or read how they are made.

An agent drafted the words from my notes, and I haven't edited them yet. The code was run before it went in.

The problem

Say you need a name for a product. A large language model, the kind of AI behind chat tools, can suggest hundreds of candidates in an afternoon. One run of a naming tool of mine held 756. That is more names than a person will read with care, so a second pass asks a model to score each one for fit, and it is tempting to let it clear out the weak ones.

Then you take a shortlist and ask a harder question: is the name free to use? That means trademark registers, other companies with the name, what the word means abroad, and whether the domain, the web address, can be registered. I call this step clearance. A model with web search will answer all of that, and it gives links.

Both steps look like work a machine can finish alone. My tool ended up letting it finish neither. Its first version marked every name scoring under 6 out of 10 as rejected. Rejection became optional later the same day, and a week later the option was removed.

I think two things work against the automatic version. A low score can be argued with, but a row marked rejected leaves the view, and then it stops being questioned. And the two mistakes cost different amounts. Dropping a good name early is cheap and goes unseen. Clearing a bad name late is expensive and public.

The idea

On the long list, the full set before anyone has cut it, the scoring pass may write one field, a score from 1 to 10, but not a name's status. If the model leaves a name out of its reply, or the request fails, the name gets a middle score of 5 and stays.

Rejections made before this rule, and any made by a lookup, a direct check such as whether a domain is taken, carry a reason saying who made them: a low score, a domain that is taken, or a person. That lets an undo restore exactly the machine's rejections and leave a person's alone.

At clearance, the model's opinion is not the evidence. Each name starts at 100 and loses points for each risk found. Every link a model returns is opened, and a finding whose link comes back page not found is dropped. The verdict is rebuilt from what survives, so a model that calls a name a blocker, its worst risk level, and lists nothing gets low risk.

Two models, one cheaper than the other, answer each question side by side, the worse reading wins, and the printed result for each name says where they disagreed. Where a lookup can answer, such as whether a domain exists, the lookup is used and not a model. And a check that did not run counts as unknown, not clean: each check that did not run lowers the highest score the name can get by 3, to a floor of 50.

A version small enough to read

This is the shape of the naming tool I built, cut down. The two prompts, the instructions sent to the model, are plain files. The scoring prompt asks for a score from 1 to 10 for every name and says what makes a name score high or low.

machine-scores/score.md
You are a brand naming expert scoring name candidates for a new product.
Product: a shared notebook for small research teams.
Feel: calm, precise, friendly.
Score each name 1 to 10. Use the full range; do not cluster around 4 to 7.
- 9-10: a genuinely great brand name (rare)
- 7-8: solid, would work well
- 5-6: acceptable but generic, forgettable or slightly off
- 3-4: weak: hard to say, too corporate, or close to another brand
- 1-2: bad: confusing, offensive or unpronounceable
What makes a name score high: easy to say on first sight, distinctive, one
clear stress, not like an existing product.
What makes a name score low: hard to spell after hearing it, sounds like a
well-known brand, a generic compound of common words, too many consonants
in a row.
Return a score for every name you are given.

The clearance prompt asks a model with web search for any company, product or trademark the name clashes with, and the address where it saw each one. Its last paragraph is a ruling of mine, written into the prompt so every run reads it.

machine-scores/clear.md
You are checking whether a proposed product name clashes with an existing
company, product or service. Search the web. For each clash you find, give
what kind of thing it is (company, product, trademark or other), how serious a clash it would be (low, medium, high or blocker),
and the web address where you saw it. Give only addresses you actually
visited in a search result. Then give your overall risk for the name.
Be calibrated on how names sound. Two names that share four letters but are
said differently are at most a low risk on sound alone.
An empty list of clashes, with a low overall risk, is a valid answer.

The script calls both through the command line of Claude Code, Anthropic's coding agent. Everything around the models is plain code: the score is the one field the model's reply can change, a missing score becomes a 5, every cited link is fetched, and the verdict is rebuilt from the links that are still there.

machine-scores/scores.ts
// A model scores a long list of names but never rejects one, and a model's verdict on a
// name counts only as far as its cited links survive being fetched. Both models are real.
// Run: bun scores.ts. Needs the claude CLI, logged in, and a network. Costs well under a dollar.
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
function claude<T>(model: string, system: string, prompt: string, schema: object, tools = ""): T | null {
const cwd = mkdtempSync(join(tmpdir(), "names-"));
try {
const r = Bun.spawnSync(["claude", "-p", "--model", model, "--safe-mode", "--setting-sources", "", "--no-session-persistence",
"--tools", tools, ...(tools ? ["--allowed-tools", tools] : []), "--system-prompt", system,
"--json-schema", JSON.stringify(schema), "--output-format", "json"], { cwd, stdin: new TextEncoder().encode(prompt) });
return (JSON.parse(r.stdout.toString() || "{}").structured_output as T) ?? null; // null: the check did not run
} finally {
rmSync(cwd, { recursive: true, force: true });
}
}
const prompt = (f: string) => readFileSync(join(import.meta.dir, f), "utf8");
// 1. The long list. Two names were rejected earlier by a person, with a reason.
type Row = { name: string; score?: number; rejected?: "low-score" | "person" };
const names = ["Talvo", "Merin", "Quessa", "Brolle", "Fennic", "Orvane", "Lusk", "Pellar", "Trova", "Cindral",
"Vossa", "Hembry", "Ardel", "Nimbre", "Sollen", "Kavra", "Druell", "Ostra", "Pimley", "Wendal"];
const fresh = (): Row[] => names.map((name) => ({ name, rejected: name === "Hembry" || name === "Wendal" ? "person" : undefined }));
const scored = claude<{ scores: { name: string; score: number }[] }>("claude-sonnet-5-5", prompt("score.md"), `Score these names: ${names.join(", ")}`,
{ type: "object", properties: { scores: { type: "array", items: { type: "object", properties: { name: { type: "string" }, score: { type: "integer" } }, required: ["name", "score"] } } }, required: ["scores"] });
const reply = new Map((scored?.scores ?? []).map((s) => [s.name, s.score]));
// The old form: score, then reject everything under 6. The undo reads the reason on each row,
// so it restores the scorer's rejections and nobody else's.
const old = fresh();
for (const r of old) { r.score = reply.get(r.name) ?? 0; if (r.score < 6 && !r.rejected) r.rejected = "low-score"; }
const byMachine = old.filter((r) => r.rejected === "low-score").length;
for (const r of old) if (r.rejected === "low-score") r.rejected = undefined;
console.log(`Old form: the scorer rejected ${byMachine} of ${names.length}. The undo restored ${byMachine}; still rejected: ${old.filter((r) => r.rejected).map((r) => r.name).join(", ")}`);
// The settled form: the scorer writes one field. A missing score is a middle 5, and the name stays.
const settled = fresh();
for (const r of settled) r.score = reply.get(r.name) ?? 5;
const top = [...settled].sort((a, b) => b.score! - a.score!).slice(0, 3).map((r) => `${r.name} ${r.score}`);
console.log(`Settled form: ${settled.length} scored, ${names.filter((n) => !reply.has(n)).length} missing and given 5, 0 removed. Highest: ${top.join(", ")}`);
// 2. Clearing the top name. Two models search the web; every link either gives is fetched.
type Risk = "low" | "medium" | "high" | "blocker";
type Clash = { kind: "company" | "product" | "trademark" | "other"; severity: Risk; link: string };
const RANK: Risk[] = ["low", "medium", "high", "blocker"];
const worst = (rs: Risk[]): Risk => rs.reduce((a, b) => (RANK.indexOf(b) > RANK.indexOf(a) ? b : a), "low");
const CLEAR = { type: "object", properties: { risk: { enum: RANK }, clashes: { type: "array", items: { type: "object",
properties: { kind: { enum: ["company", "product", "trademark", "other"] }, severity: { enum: RANK }, link: { type: "string" } }, required: ["kind", "severity", "link"] } } }, required: ["risk", "clashes"] };
async function status(url: string): Promise<number> {
try { return (await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(10_000) })).status; } catch { return 0; } // 0: no such host
}
const name = top[0]!.split(" ")[0]!;
console.log(`\nClearing ${name}:`);
const readings = ["claude-sonnet-5-5", "claude-haiku-5-5"].map((m) => ({ m, a: claude<{ risk: Risk; clashes: Clash[] }>(m, prompt("clear.md"), `The name: ${name}`, CLEAR, "WebSearch") }));
const rebuilt: Risk[] = [];
let unchecked = 0;
// What each clash is, but not its name: the names are real businesses found by the search.
for (const { m, a } of readings) {
if (!a) { unchecked++; console.log(` ${m}: did not run`); continue; }
const kept: Clash[] = [];
for (const c of a.clashes) {
const s = await status(c.link);
if (s === 404 || s === 410 || s === 0) console.log(` ${m}: dropped a ${c.severity} ${c.kind} clash, its link gave ${s || "no such host"}`);
else { kept.push(c); console.log(` ${m}: kept a ${c.severity} ${c.kind} clash${s >= 400 ? `, page could not be read (${s})` : ""}`); }
}
// The verdict comes from what survived, not from the model's own summary at the top.
const own = worst(kept.map((c) => c.severity));
rebuilt.push(...kept.map((c) => c.severity));
console.log(` ${m} said ${a.risk}; from its surviving links, ${kept.length ? own : "low, nothing survived"}`);
}
// Two models: the worse reading wins. A check that did not run is not a clean check.
const cap = Math.max(50, 100 - 3 * unchecked);
const score = Math.min(cap, 100 - { low: 0, medium: 15, high: 35, blocker: 60 }[worst(rebuilt)]);
console.log(` overall ${worst(rebuilt)}, score ${score}, best possible ${cap}`);

Run with Bun, a JavaScript runtime, one real run printed:

What one real run printed
Old form: the scorer rejected 7 of 20. The undo restored 7; still rejected: Hembry, Wendal
Settled form: 20 scored, 0 missing and given 5, 0 removed. Highest: Nimbre 8, Sollen 8, Talvo 7
Clearing Nimbre:
claude-sonnet-5-5: kept a low company clash, page could not be read (403)
claude-sonnet-5-5: kept a low company clash
claude-sonnet-5-5 said low; from its surviving links, low
claude-haiku-5-5 said low; from its surviving links, low, nothing survived
overall low, score 100, best possible 100

The old form, which rejected anything under 6, would have removed 7 of the 20 names. On an earlier run of the same script it was 10, which is the point: a threshold on a score that moves between runs removes different names each time. The undo restores the machine's rejections by their reason and leaves the person's two alone. The settled form scores all 20 and removes nothing.

Clearing the top name, every link the two models gave was fetched. On this run none failed, and one page existed but could not be read, so it is kept and labelled. On the earlier run, one link from the cheaper model pointed at a host that does not exist, and its clash was dropped. The printout says what kind of thing each clash is but not its name, because the names are real businesses the search found.

Where the plain form falls short

The plain form is a model that scores and rejects, and a model that searches and reports. I saw each of these in the one tool.

  • A missing score reads as a low one. A failed request or a short reply leaves names with no score. If no score counts as zero, a network error rejects good names. A middle score keeps them in view.
  • The undo is only as good as the reason on each row. The undo could tell the machine's rejections apart only by a reason on each row. An earlier tidy-up of the stored list had stamped that reason onto rejected rows that had none, so it was no longer a perfect record of who rejected what. Leave a row's reason empty when you do not know it.
  • An undo can miss a copy of the list. The list was also copied to a shared table that people worked from. The undo cleared the status there but left the reason out of its update, so that copy kept the stale rejection. A second option was added to the undo to find and clear the leftovers.
  • A search model can invent links. Company, podcast and register pages came back not found when opened. A link to a page that does not exist reads exactly like one that does.
  • Two models can agree on something false. Both said a business was trading on a country-code domain, one ending in a country's code such as .de. A DNS lookup, which asks the internet's directory of domains whether one exists, showed the domain did not exist.
  • A summary can claim more than its own list shows. One model returned the worst risk level with one minor item listed, and in another case with none.
  • Missing data looks like good news. When the account paying for the models ran out of credit mid-run, the model checks came back empty and the name scored 100.
  • The clearance prompt's rules can be too strict. Two names sharing their first three letters were rated a high sound-alike clash. I disagreed. The prompt, the instructions sent to the model, changed, the score at which two names count as a clash changed, and a written note recorded the case and the reason.

Trade-offs

  • The worse reading raises false alarms. Taking the more pessimistic of two models flags things a person then has to clear. I pushed back on those rules at least three times.
  • The machine still writes a recommendation. At the clearance stage the tool sets recommend, consider, hold or reject, and rewrites it on every run, while the person's field is a notes column. The rule in the title holds firmly at the long-list stage only.
  • A kept list is only as useful as what reads it. Rejected names stay in the list, and code compares each new candidate against all of them. But the prompt carries only 50 earlier names, and they are the last 50 in alphabetical order, not the most recent. A near-repeat of a rejected name can get through.
  • Not found and could not read are easy to mix up. The comments in the link-checking code say an address with no DNS record counts as not existing. The code itself treats any request that fails, for whatever reason, as could not read, and keeps the item. Decide which you mean, and test it.

When to use it, and when not to

It suits a list too long to read, scored by a model, where a wrong removal is hard to notice, and any question a model answers from the web where a wrong answer is costly and public. It is not worth the extra parts when a person can read the whole list, or when a removed item is cheap to bring back. It comes from one tool, and six names went through its clearance once, so treat it as a starting point. Its results are signals for a person to weigh, not legal clearance.

Example. The scorer and the clearance check, on GitHub

A draft skill for this pattern

A skill is a short set of instructions you give a coding agent so it applies a pattern the way you would. Copy the text below into a file called SKILL.md, in the folder your coding agent reads skills from. In Claude Code, Anthropic's coding agent, that is .claude/skills/machine-scores/. It is a draft, and I haven't tried it on anyone else's project yet.

machine-scores/SKILL.md
---
name: machine-scores
description: Use when a model sorts a list too long for a person to read (names, candidates, leads, findings) and you are tempted to let it drop the weak ones, or when a model with web search is asked whether something is safe to use. The model scores and never rejects; its verdict is rebuilt from the evidence that survives a check.
---
# Machine scores, only a human rejects
A model can rank hundreds of items in minutes. Letting it remove the weak
ones looks like the same job, but a removed item leaves the view and stops
being questioned. Keep the two apart: the model writes a score, and only a
person changes an item's status.
## The long list
1. Give the scoring pass one field it may write: the score. It never changes
an item's status.
2. If the reply leaves an item out, or the call fails, give the item a middle
score and keep it. A missing score is not a low one.
3. Record a reason on every rejection, naming who made it: a score threshold,
a lookup, or a person. Do not add a reason later to old rows that have
none, because then the reason no longer says who decided.
4. If the machine ever did reject, write the undo against that reason, so it
restores the machine's rejections and leaves the person's alone. Make sure
it clears the field everywhere the list is shown, not only in one copy.
5. Keep rejected items in the list, and compare each new candidate against
all of them, so a rejected item does not come back under a new spelling.
## Asking a model whether something is safe to use
1. Open every link the model returns. Drop a finding whose page is not
found. Keep a page that exists but could not be read, and label it.
Tell the model in the prompt that this will happen.
2. Rebuild the verdict from the findings that survived: take the worst
severity among them. An empty list is low risk, whatever the model said
at the top.
3. Ask two models the same question side by side. The worse reading wins,
and where they differ, print that they disagreed beside the finding.
4. Where a lookup can answer (a name-server lookup for a web address, a
register for a trademark), use the lookup and not a model.
5. Treat a check that did not run as unknown, not clean. Lower the best
score an item can reach for each one, so a run where every check failed
cannot score full marks.
## When a person disagrees with the rubric
Write the ruling into the model's prompt itself, with the case that caused
it ("two names that share four letters but are said differently are at most
a low risk on sound alone"), so every later run reads it. Keep the case and
the date beside it, so the next person who disagrees can see why the line
is there.
## What it does not do
It does not decide anything. A list kept whole is still long, and "the worse
reading wins" raises false alarms that a person has to clear. It is triage
for a person's judgement, not legal or any other clearance.