# source-candidates-2

Builds a scored candidate list for a hiring role from exemplar profiles or described experience, with one search per candidate population.

Skill by Clay. Category: Data and backend.

## Install

Project (for this project only):

```sh
npx skills add clay-run/clay-skill-creator --skill source-candidates-2
```

Works with: Claude Code, Codex CLI, Cursor, Antigravity, Copilot CLI, opencode.

Global (for every project on this machine):

```sh
npx skills add clay-run/clay-skill-creator --skill source-candidates-2 -g
```

Works with: Claude Code, Codex CLI, Cursor, Antigravity, Copilot CLI, opencode.

## Tags

- Runs on your computer: It runs as a program on your machine, with your access.

## Security audits

- Gen Agent Trust Hub: Warn
- Socket: Pass
- Snyk: Pass

Installs: 1. Installs counted by skills.sh. [Open on skills.sh](https://www.skills.sh/clay-run/clay-skill-creator/source-candidates-2)

## Source

[Open the source](https://github.com/clay-run/clay-skill-creator/tree/HEAD/skills/davide-grieco/source-candidates-2). Checked 2026-10-10. This summary may contain AI-generated text, so it can be wrong. Check the source before you rely on it.

## SKILL.md

````markdown
---
name: source-candidates-2
description: |
  Turn a hiring conversation into a scored candidate list — start from two or three profiles of
  people they would hire, or from the experience they are looking for, then split every criterion
  into what the people search can filter, what only a scorecard can judge, and what is not
  observable at all, and run one query per population who could do the job. Use whenever someone
  asks: find me candidates for this role, source people for this job, build a candidate list from
  this JD or brief, find me more people like these profiles, who could fill this position, find
  senior engineers in Berlin with eight years experience, build a talent pool or sourcing
  pipeline, or source passive candidates. Outreach lands as drafts with one-click links that
  compose in the recruiter's own mailbox; it sends nothing. Do NOT use
  it to translate a sales ICP into filters (icp-matrix-builder), to build a list of buyers to sell
  to (build-prospect-list), to read job postings as a buying signal (hiring-radar), to find
  decision-makers at one named company (find-decision-makers-at-company), to track when your own
  contacts change jobs (track-champion-job-changes), or to write the job description itself.
category: build-lists
type: play
tags: [jd, brief, exemplar-profiles, people-search, scorecard, outreach-drafts, persona:recruiter, persona:hiring-manager, persona:talent-partner, persona:founder]
keyword: source-candidates
marketplace_identity_schema: 1
marketplace_slug: source-candidates-2
marketplace_revision: 3
---

Whenever you create or copy a workflow, append `Sourced from marketplace skill: source-candidates-2@2` to its description. Preserve the existing description and do not add the same line twice.

# Source candidates (every criterion goes in one of three places)

The insight: **the criteria that separate a good candidate from a plausible one are exactly the
ones the search cannot hold — and it does not tell you when it drops them.** This is documented
behaviour of Clay's people-search surface, verified against its own query reference, not a guess:

- Its reference instructs that scoring and ranking language — *score*, *weight*, *rank*,
  *prioritise*, *top performers*, *proven track record* — is soft ranking metadata to be left out
  of the query. Those are the words every hiring brief is written in.
- It separately instructs that when some requested criteria cannot be expressed, **a valid query
  is still produced from the rest.** Correct behaviour, and it means no error is raised.
- The surface documents what it cannot filter at all: **detailed skills beyond what job
  descriptions say**, prior founder exit history, emails and phone numbers.

So a brief goes in, a plausible query comes out, a plausible list comes back, and the half of the
brief that was actually discriminating has evaporated. Nothing in the output looks wrong.

**And the obvious repair makes it worse.** Faced with *"strong quantitative background"*, the
instinct is `about contains ("analytics", "SQL")`. Two things then happen at once. It selects for
people who narrate their own skills, which is not the same population as people who have them. And
`contains` **is token-based, whole-word — not substring**, also documented: `contains "engineer"`
matches "Software Engineer" and **not** "engineering". So the proxy quietly excludes on spelling.
A soft criterion belongs on a scorecard or in a separately-queried population. Never in a keyword.

**A second thing follows, and it is why this skill is a conversation rather than a form.** There
*is* a find-people-like-this-profile action — `find-people-lookalikes`, Clay-owned, seeded with a
profile URL, and it cost 0 credits on a live call. **The problem was never that the feature is
missing. The problem is that it chooses the similarity axes and does not tell you which.**

Verified 2026-08-28, seeded with one exemplar — a growth manager at a physical-security company —
it returned 26 people, and it had anchored on exactly two things: **the literal job-title token**,
and **the seed's employer industry**. So the results were IT-ops and security vendors across nine
countries, including an HR "People Growth Manager" caught by token match on *Growth Manager*. Both
axes it chose were ones the hiring manager had explicitly ruled out — *"that's me recognising
logos, not a requirement"*. It reproduced the over-specification error, silently, at speed.

That is the whole case for the conversation. Three profiles a hiring manager likes share dozens of
attributes and **they care about four of them. Which four is judgment that exists only in their
head** — and neither a decomposition nor a lookalike engine recovers it. One of them at least shows
you its filters. Use lookalikes as **a population you seed and then judge** (Step 4), never as a
substitute for asking. And note the approximation you must still disclose either way: the reference
maps a named company in a similarity ask to an **industry anchor**, not an exact match, so the
exemplar's employer arrives as an approximation.

## Declared inputs

**Nothing here ships with a value.** Every row is the installer's. Ask for it, never substitute a
plausible default, and where an answer does not exist say which step becomes unavailable rather
than guessing. Where a default IS defensible it is named below, and using it means saying so in
the output.

| Input | What the installer supplies | If it is missing |
|---|---|---|
| **The role** | the title, and one line on what the person will own | **stop.** Nothing downstream is derivable |
| **The seed** | either two or three profiles of people they would hire, or the specific experience they are looking for, in their words | **stop.** This is the intake; a JD alone is context, not a definition — see Step 1 |
| **Which shared attributes matter** | of everything the seed profiles have in common, the ones that are the point | the skill cannot guess and must not average them. It proposes and asks |
| **Location** | cities, states, countries, or a region — and whether remote counts, and remote from where | no default. "Anywhere" is a real answer that roughly triples yield; never quietly use the company's HQ |
| **Seniority and experience** | a seniority band and a years-of-experience floor or range | no seniority filter at all, per the platform's own guardrail: an unmentioned level is omitted, never guessed |
| **Scorecard criteria and weights** | the criteria a filter cannot hold, each weighted | no default. Weights nobody stated are this skill's opinion wearing numbers |
| **Band cut-offs** | the score at which a candidate is worth contacting | **70 / 40 out of 100 is a stated default** — strong from 70, possible 40–69, weak below. Nothing validates it against hire outcomes; see the gaps |
| **Per-employer cap** | how many candidates may come from one company | **2 is a stated default.** Without a cap one large employer floods the list; the platform supports the cap natively |
| **Do-not-source list** | companies not to approach — current employer, customers, partners, anyone under agreement | no exclusions applied, and the output must say so. This is the omission a recruiter notices from the wrong side |
| **Suppression list** | optional list of people already in the pipeline, by profile URL, or name plus employer | no dedupe against an existing pipeline |
| **Target list size** | how many candidates they want to review | **50 is the stated default**, whatever the plan — enough to show the yield split across populations, small enough that a hiring manager actually reads it, and reachable on every tier including Free. Raise it freely on a paid plan; nothing validates 50 beyond it being a readable list |
| **Contact address** | personal email, work email, or profile link only | **profile link only.** Never default to a work address — see Step 9 |
| **Sender and pitch facts** | who the mail is from and their relation to the role, plus level, comp band if shareable, hiring manager, team size, remote policy, funding or traction, and the one thing that makes this different | the copy step is skipped rather than filled with invention |
| **Availability heuristic** | on or off, and the tenure threshold if on | **off.** It is a guess, not a signal — see Step 4 |
| **The Clay plan tier** | nothing to supply beyond being signed in — but read the tier, because it sets the shape of the run, not whether it happens | **scope the run down; never refuse it.** Verified 2026-08-28: Free is **50 per request, 50 per search, 100 per month**; Trial 10,000; Paid 1M/yr; Enterprise 10M/yr. On Free, run **two populations at 25 rows each** and say the populations are not exhausted — which is true, and is the honest thing to report. **Lookalikes cost 0 credits and no result allowance at all**, so a seeded population is the one path the ceiling does not touch |

## Step 0 — Verify the platform, pull the field list live, and say where the work runs

```
clay whoami; echo "exit_code=$?"
```

Non-zero or no user id: run the Clay plugin's `setup` skill, then re-run. **Say which workspace,
out loud.**

Pull the query surface fresh every run. **Never write a query from a remembered field list:**

```
clay search query-mode reference
```

**Use advanced query mode, and confirm from the reference you just pulled** that it still carries
a years-of-experience field, an education array, and per-experience seniority. The older filters
mode has **no years-of-experience field at all** — a query written there silently drops the single
most common criterion in any brief, and approximates it with a count of roles, which measures
job-hopping. If advanced mode has lost those fields, say so and stop rather than approximating.

**Pull the action catalog too, and never plan from the routine list alone.** This is the mistake
that looks like a platform limitation and is not one:

```
clay routines list                                  # workspace routines: check `source`
clay workflows actions list                         # the Clay action catalog — a different surface
clay workflows actions schema <packageId> <actionKey>
```

`clay routines list` returns a handful of `managed` routines plus whatever `custom` ones that one
workspace happens to have. **It is not the catalog.** The action catalog is separate and much
larger, and the Clay-owned packages in it are available to every workspace. Verified 2026-08-28,
reading the routine list alone leads to the false conclusion that Clay cannot read a person's
profile — it can, portably, and Step 6 names the action. **A `custom` routine or a Claygent found
in the current workspace will not exist in anyone else's; a Clay-owned action will.** Identify every
action by the **pair** of packageId and actionKey — action keys collide across packages.

**Three separate meters run in this skill and they are not interchangeable.** Cost is a design
property here, not a footnote:

| The work | Where it runs | What it consumes |
|---|---|---|
| The conversation, decomposing exemplars, writing queries, designing the scorecard | the agent | nothing |
| Creating a search (`create`) | the platform | nothing — it returns a `searchId` and no rows |
| Seeding a lookalike population from an exemplar URL | a Clay action | **0 credits and no result allowance on one live call.** Confirm it live; one call is not a price |
| Paging results (`run`) | the platform | plan **result** allowance, not credits — capped per request, per search, and per period |
| Reading a profile — an exemplar's, or a candidate's | a Clay action, in a workflow | **credits, per row** — priced live in Step 6. Also the only source of a profile URL |
| Finding an email address | the managed `Email` routine | **credits, per row** — priced live in Step 6 |
| Scoring against the scorecard, and ranking across the set | the agent, over the text the enrichment returned | **free** |
| Writing the copy — **per population, not per row** | the agent | **free** |
| Building the compose links | the agent | **free** |

Scoring 300 candidates in the agent costs nothing. Scoring them as a table column bills 300 rows
for the same arithmetic, and is right only when the table is a working surface a team returns to.
Choose deliberately, and say which you chose.

## Step 1 — Have the conversation. It is the intake, not a formality

**A JD is context, never the definition.** It was written to attract applicants and it is full of
the unfilterable — *ownership*, *bar-raiser*, *thrives in ambiguity*. Read it if there is one, and
still do this step.

Ask for the role and where, then take **one of two entry points. Let them pick; both are real:**

**Seed A — exemplars.** *"Give me two or three profiles of people you'd hire for this."* Then go
to Step 2. This is the faster route and usually the more accurate one, because a hiring manager can
recognise the right person long before they can specify them.

**Seed B — described experience.** *"Tell me the specific experience you're looking for."* Then
follow up on what they actually said, not from a checklist. The useful follow-ups are the ones that
distinguish populations: have they done this exact job before or the adjacent one, at what scale,
building the team or running an existing one, and what would rule someone out.

Then **write the whole definition back to them and let them correct it** — the populations, the
three-way split from Step 3, and the scorecard. Do not keep interviewing first. A hiring manager
corrects a wrong population in four words and answers an abstract question in a paragraph that has
to be reinterpreted anyway.

**Never invent a criterion the conversation did not contain.** A role that was never described as
needing a degree does not get a degree filter because it sounds like it should. Anything the skill
proposes rather than heard is **labelled as proposed, on screen, before it reaches a query.**

## Step 2 — Decompose the exemplars, then ask which parts are the point

Only on Seed A. For each profile, get the attributes — either pasted by the installer, free, or by
running a person enrichment on two or three rows, priced live in Step 6. Read off:

current title · seniority · years of experience · current employer, its industry and size ·
previous employers and the shape of the path · education · **and the words they use about their own
work**, which is the raw material for the scorecard, not for a filter.

Then **lay out what the profiles share, and ask which of it is the point.** This is the question the
skill exists to ask, because the exemplar is over-specified: three people the hiring manager likes
may all have been at Series B companies, all have MBAs, and all be in London — and only one of
those three is a requirement. Averaging them produces a query nobody asked for. Guessing produces
one that looks right.

Where they differ, **that is usually two populations, not noise.** An ex-consultant and a lifelong
operator are not one blurred profile with error bars.

**Run the lookalike action on each exemplar too, and read what it returns as evidence about the
exemplar rather than as candidates.** It is free, it takes the profile URL you already have, and
what it anchors on tells you which attributes are loudest on that profile — which is the question
you are asking the hiring manager anyway. When it comes back with the seed's employer industry and
job-title token, as it did on 2026-08-28, **show them that**: *"the machine thinks the point is
that they work in security — is it?"* A hiring manager corrects that in four words. Keep the rows
as a seeded population per Step 4 if they are any good, and drop them without ceremony if not.

**The exemplar's employer becomes an industry anchor, and you must say so.** There is no
similar-companies-by-domain filter for this: the reference requires mapping the company context to
`company.industry` values inside `experiences.any(...)`, and requires telling the user that an
approximation was applied. Do both. **Only** use `clay.filter_to_companies((...))` when the
installer explicitly wants people *at those exact companies* — a farm list, not a similarity anchor.

## Step 3 — Split every criterion three ways, in front of the person who set them

**Show the table. A criterion that appears nowhere has been dropped, and dropping it silently is
the failure this skill exists to prevent.**

**Filterable — goes in the query.** Confirm each against the reference from Step 0:

- years of experience, as a number
- job title, current or past — and title exclusions, which must never be dropped
- seniority, from the experience ladder: founder, owner, board member, partner, C-suite, VP,
  director, head, manager, senior, mid-level, entry, intern
- employment type — full-time, contract, internship, freelance
- named employers: **current** employer by identifier at the top level; **former or any-tenure**
  employer by domain inside the experience expression
- employer industry and size
- role start and end dates, so "has held this title two years" and "started over 30 months ago"
  are both expressible
- location of the person, and separately the location of the role
- education: school, degree, field of study, dates
- languages on the profile
- keywords in headline, about, and experience descriptions — **whole-word, and this is the trap**

**Scorecard — a real criterion, not filterable, judged after the search.** Everything soft lands
here: depth versus breadth, has-done-this-exact-job versus adjacent, quantitative rigour, ownership
versus execution, scrappiness, whether the scale resembles yours, whether they built the team or
inherited it. Each gets a **weight** and **the profile field its evidence is read from** — headline,
about, or experience descriptions.

**Not observable — named out loud, then dropped.** This is a go-to-market database, not a candidate
database:

- **whether they want a job.** There is no open-to-work signal anywhere in it
- **compensation**, current or expected
- **work authorisation**, visa status, notice period
- **detailed skills beyond what the job descriptions say** — documented as not filterable, so a
  tools-and-technologies checklist is scorecard material at best
- **actual performance** — references, attainment, promotion velocity, whether any of it went well
- **prior founder exit history**, documented as not filterable and specifically **not** to be
  approximated by excluding people who are currently founders

**NEVER move a scorecard criterion into the query as a keyword.** The two reasons are at the top of
this file and both are documented: it selects for self-narration, and `contains` matches whole
tokens, so it also excludes on spelling. If a soft criterion must shape the search, the honest form
is **a separate population** whose people genuinely sit somewhere else — not a keyword bolted on.

**One carve-out, and it is narrow: keywords for category, never for quality.** Some titles do not
encode which *discipline* a person practises, and that is a hard category the query surface cannot
otherwise express. Verified 2026-08-28: at early-stage B2B companies, `job_title is_similar_to
("Growth Manager", "Growth Lead")` expands into **sales** roles — founding BDRs, enterprise AEs, a
VP of Sales, and in the worst case a Director of ASIC Digital Design caught on the token *Growth*.
**14 of 25 rows were the wrong ladder.** Adding paid-marketing terms to the **current role's
description** — `description contains ("paid search", "paid media", "google ads", "performance
marketing", "demand generation", "SEM", "paid social")` inside the current-experience expression —
returned 7 rows of which **7 were the right ladder.**

Three conditions on using it, and they are the whole difference between this and the failure above:

- **Category, not quality.** *Is this marketing or sales* is a fact about the role. *Strong
  quantitative background* is a judgment about a person. The first is a legitimate keyword; the
  second is scorecard material and always was.
- **The current role's description, not the about section.** Verified the same day: the same keyword
  list against `about` returned 8 rows of which 2 were the weakest already-scored candidates. The
  about section is where people narrate themselves, so a keyword there reintroduces exactly the
  self-narration bias — the description of what a role *was* is closer to a fact.
- **Run it as its own population, never as a patch to an existing one.** Precision cost recall
  hard: 25 rows became 7, exhausted. Report both yields and let the installer see the trade rather
  than silently shrinking their list.

## Step 4 — One query per population

A **population** is a group defined by where its people sit right now: title, seniority, and the
kind of employer. It comes out of Step 1 or Step 2 — **however many the conversation actually
produced.** One is a legitimate answer. Do not manufacture a third for symmetry.

**Run each one as its own query, and keep the label on every row it returns.** The yield per
population is the part a hiring manager can act on: *"forty here, six there, none at all from
consulting"* answers whether to widen the location, drop a level, or stop waiting for people who
are not there. A single merged query cannot report it — an `and` across populations asks for the
intersection, an `or` returns rows that no longer say which group they came from.

**A seeded population is a legitimate fourth kind, and it plays by different rules.** Rows from
`find-people-lookalikes` arrive with no location, seniority or experience filter applied — the
action takes a seniority list and nothing else the brief cares about — so they are **not
comparable** to the queried populations and must never be folded into one yield line. Report them
as their own labelled population, name the exemplar that seeded them, say what the engine appears
to have anchored on, and filter them against the brief **after** the fact rather than pretending a
query held. Their virtue is costing nothing and sometimes surfacing a population the decomposition
missed; their vice is that the axes are not yours.

**Hold location, seniority and the experience floor constant across populations.** Those come from
the brief. What varies is title, employer type, and history — otherwise the yields are not
comparable and the split says nothing.

**The syntax that decides whether the query means what you think.** All of this is from the
reference, and each line is a mistake worth not making:

- **`is_similar_to` is the default for job titles** — it expands into synonyms, abbreviations and
  variants, and takes a list: `job_title is_similar_to ("Head of Growth", "VP Growth")`. Switch to
  `=` or `in (...)` only for an explicit exact-title ask, and to `contains` only when the installer
  phrased it as literal keywords.
- **Current employer is top-level; past employer is not.** `clay.filter_to_companies(("acme.com"))`
  at the top level for people **currently** there. `company.domain` inside `experiences.any(...)`
  for former or any-tenure history. Swapping these silently changes who you get.
- **Tenure scope is not neutral.** A generic role search and anything phrased *currently* means
  `is_current = true`; *former*, *past*, *alumni* mean `is_current = false`; *has experience at*
  and *ever worked* mean omitting it. A population defined by where someone **used to** work is a
  different query from one defined by where they are **now**.
- **Do not guess a seniority level.** If the conversation did not name one, omit the filter — the
  title predicate already carries the role. And keep the ladders apart: individual-contributor
  searches must not carry leadership values, and the experience seniority enum is **not** the same
  value set as the job-posting one.
- **Exclusions go in every population's query, identically**, and are never dropped:
  `not experiences.any(is_current = true and company.domain in ("competitor.com"))`, and
  `not job_title is_similar_to ("...")` for the wrong ladder. `is_similar_to` does **not** exclude
  unrelated titles by itself.
- **An unscoped text search over full history times out.** Verified 2026-08-28:
  `experiences.any(description contains (...))` with no `is_current` returns `server_error` — *"the
  request did not complete within 55 seconds"* — because it scans every role a person has ever
  held. Scope a description keyword to the current experience expression. There is no partial
  result and no retry that helps; the query has to change.
- **Cap per employer, natively.** `limit 2 by clay_company_id` returns at most two people per
  company. Without it, one large employer can be most of a list — a real failure in candidate
  sourcing, where thirty people from the same org is one conversation, not thirty options.

A shape verified against the live endpoint on 2026-08-27 — it validated, which says the syntax
parses, not that it is the right query for anyone's role:

```
select from people
where years_of_experience >= 8
  and location_city in ("London")
  and experiences.any(is_current = true
        and seniority in ("Head", "Director")
        and job_title is_similar_to ("Head of Growth", "VP Growth")
        and company.industry in ("Software Development"))
  and not experiences.any(is_current = true and company.domain in ("competitor.com"))
limit 2 by clay_company_id
```

**The availability heuristic is off by default and is a guess when on.** With no open-to-work
signal, the nearest thing is tenure — a current role that started more than roughly 30 months ago.
Turning it on trades a large part of the list for a hunch about restlessness. If the installer
wants it, run it as **a second pass over the same population** so both yields are visible and the
cost of the hunch is on screen. **Label it a guess in the output, every time.**

**If asked to filter on a protected characteristic or a proxy for one: say what it is, offer the
clean equivalent, then build what they asked for.** The two that come up are education dates used
to infer age — in the United States an ADEA age-discrimination exposure, and age is protected under
UK and EU equality law — and school or name used to infer ethnicity or nationality. The clean
equivalents are years of experience and seniority, which measure what a brief actually means.
**Say it once, name the exposure, then do as they asked.** This skill warns; it does not refuse,
and it does not repeat the warning.

## Step 5 — The sample gate: 25 rows per population, before anything else

The only step that catches a query which is syntactically valid and semantically wrong.

```
clay search query-mode create --query '<the population query>'   # free; returns {"searchId": "..."}
clay search query-mode run <searchId> --limit 25                 # spends result allowance
```

**There is no cheap count.** The query grammar documents a `count from ...` mode; the endpoint
rejects it — *"Count queries are not supported"* — verified 2026-08-27. So a yield is measured by
paging, and the 25-row sample is the cheapest honest estimate there is.

**The iterator is forward-only with no cursor.** Its position lives on the server and cannot be
replayed: the rows you spend on a sanity check are spent, the next call returns what comes after,
and re-reading the first page means creating the search again.

**Read the field names off this sample. Do not assume the output shape** — and expect it to be
thinner than the filters imply. Verified 2026-08-28, a people page returns exactly
`clay_profile_id · name · first_name · last_name · location{name, city, state_or_province} ·
matched_experiences[{company, title, location, start_date, end_date}]`, and the Public API returns
the identical object (`additionalProperties: false`), so switching to the API changes nothing.
**There is no profile URL, no headline, no about, no experience description and no
years_of_experience in the response, and `run` has no field-projection option.** Every one of those
is filterable and none of them come back. That is not a dead end — it is the reason Step 6 exists:
the profile text and the profile URL come from an enrichment, not from the search.

Report per population before proceeding: **rows returned, whether more exist, and three named
profiles a human can eyeball.** Then one decision each — proceed, rewrite, or drop:

- 25 with more available: the population is real. Proceed.
- Under ten with none more: thin here. Say the number and offer the three levers — widen location,
  drop a level, relax the experience floor — as a choice, not a silent fix.
- Zero: **a real answer, and one of the most useful this skill produces.** Never pad it, never
  loosen the query to avoid reporting it, never fold the population into another one.
- Obviously the wrong ladder or industry: the query is wrong, not the market. Rewrite and re-sample.

**On `quota_exceeded` (exit 1, HTTP 402) do not retry blindly** — backoff never helps. Read the
message. A per-request cap: retry once with a smaller `--limit`. A partial per-search or period
allowance: retry once with a limit no larger than what remains, then stop. Fully exhausted, or a
credit limit: **stop paging and say so** — an upgrade or a period reset is the only path, and a
half-built list reported as complete is worse than a stated shortfall. `validation_error` (exit 2)
is a malformed query. `rate_limited` (exit 4) carries a retry-after and may be retried once.

## Step 6 — State the cost, then wait

Nothing past here is free. Put the whole bill on screen and get an explicit yes.

- **Result allowance**: target size per population, plus the 25 already spent on each sample.
- **Per-row enrichment — the profile, and optionally the address.** The search gives you a name and
  an employer. Everything the scorecard reads, and the profile URL itself, comes from here.

  **The profile.** A Clay-owned action takes a plain search string — `"<name> <company domain>"` —
  and returns the profile: `url` (the profile link), `headline`, `summary` (the about section),
  `education`, and `experience[]` with a **per-role `summary`**, which is the richest scorecard
  evidence available anywhere in this flow. Verified 2026-08-28 as
  `cpj-enrich-person-from-search` in package `e251a70e-46d7-4f3a-b3ef-a211ad3d8bd2` at
  **0.2 credits per row** — and **confirm both the key and the price live**, because packages and
  prices drift and the pair is what identifies an action:

  ```
  clay workflows actions list | grep -i enrich-person
  clay workflows actions schema e251a70e-46d7-4f3a-b3ef-a211ad3d8bd2 cpj-enrich-person-from-search
  ```

  It resolves through a web search, so **a common name at a large employer can return the wrong
  person.** Check the returned employer against the row you sent before scoring — that is Step 8's
  `identity_conflict`, and it is free.

  **The address**, only if asked for: the managed `Email` routine, which needs a company domain —
  and the enrichment above returns `company_domain`, so the two chain. Two behaviours verified
  2026-08-28 that a naive implementation reads as failure:

  - **It rejects an empty `company_domain` outright** with a `validation_error` — *"Must be a valid
    hostname"* — so the domain has to come from the enrichment or be supplied. Do not send `""`.
  - **It returns no partial results.** The run reported `finished: 9` of 10 with `data: []` for
    minutes, then all ten at once. **Poll for `status: "complete"`, never for row count**, and never
    conclude from an empty `data` array that the run failed. On one live call it resolved **8 of
    10** addresses — one call, not a hit rate.

  Name four things before spending: **what runs** (the action or routine, by packageId and key),
  **what goes in** (which fields, from which population's results), **what to verify in the
  response** (a run can complete and return nothing — check for a `url`, not for success), and
  **what it costs per row.** Multiply by rows, out loud.

- **The one artifact this skill builds in Clay, and why it must.** `execute_clay_action` is a
  **test** surface with a daily cap — right for proving an action on two or three rows, useless for
  a hundred. And actions cannot be batch-run directly: `clay routines create` accepts a table id or
  a workflow id, not an action or a Claygent. So the only portable path to enrichment at scale is
  one workflow wrapping the action:

  ```
  clay workflows list                                  # reuse it if it already exists
  clay workflows create --name "Candidate Profile Enrich"
  clay workflows nodes create <wf> --input node.json   # nodeType "tool", the action in `tools`
  clay workflows triggers create <wf> --input trig.json # triggerType MUST be "manual"
  clay workflows nodes update <wf> <toolNodeId> \
      --input '{"incomingEdges":[{"sourceNode":"<triggerNodeId>"}]}'
  clay workflows graph validate <wf>
  clay workflows publish <wf>
  clay routines create workflow <wf> --name "Candidate Profile Enrich"
  clay routines runs start workflow:<wf> --input -     # up to 100 items per run
  ```

  **Four build facts, each verified 2026-08-28 and each a dead end if you guess:**

  - **A trigger is not a node you can create.** `nodes create` accepts only
    `agent|tool|code|conditional|delay` — `nodeType: "trigger"` is rejected. Triggers come from
    `clay workflows triggers create`, which materialises the trigger node for you.
  - **The trigger type must be `manual`.** A `webhook` trigger publishes and validates fine, then
    `routines runs start` fails with *"has no manual trigger"*. And `triggers update` **cannot
    convert** webhook to manual — delete the trigger, create a new one, then delete the orphaned
    webhook trigger node it leaves behind.
  - **Wire the edge from the downstream node.** Setting `outgoingEdges` on the trigger node returns
    *"At least one field is required"*; setting `incomingEdges` on the tool node works.
  - **Run results are paginated at 20 by default.** `clay routines runs get <id>` silently returns
    the first 20 of 36 rows with a `cursor`. **Pass `--limit 100`** or page the cursor, or you will
    quietly deliver a partial list. Note `--wait` can outlive a shell timeout; poll instead.

  **Check for it before creating it, and reuse it across roles.** A skill that leaves a new
  workflow behind on every run is littering someone's workspace. **Build nothing else in Clay:**
  `clay tables` has no create or write, and an audience is a saved filter over records already in
  the workspace, so neither can hold an external candidate list. One workflow, reused. The
  deliverable itself lives outside Clay.

- **Scoring and copy: keep them in the agent, and say so.** Both are free there and both are worse
  in Clay for this job. Scoring per row in Clay bills for judgment the agent does at no marginal
  cost once the text is in hand, and a per-row scorer reads each candidate **in isolation**, which
  cannot rank a set. A deterministic formula cannot help at all here: every scorecard criterion
  reads prose, and the parts a formula could compute are already query filters. **Copy is per
  population, so a per-row generator is a category error** — three populations need three drafts,
  and generating a hundred produces each one blind to the others. Score in Clay only when the list
  must be a living surface a team works in, with rows still arriving after this run ends; say which
  you chose and why.

Then wait. **Spending someone's money without having asked is a defect, not a style.**

## Step 7 — Page the full set, then score it

Page each population separately, reusing its `searchId`, while more results exist:

```
clay search query-mode run <searchId> --limit <n>
```

Stop at that population's target, or when no more exist, or on the quota rules in Step 5 —
whichever comes first. **Keep the population label on every row**; it is the axis the whole
deliverable is built on and cannot be reconstructed later.

Then score against the Step 3 scorecard and nothing else:

- **Every score quotes the profile text it was read from**, one line, naming the phrase. A number
  with no evidence is not reviewable and cannot be defended to a hiring manager.
- **Score only what the scorecard names.** A criterion nobody weighted does not quietly influence
  the number here.

## Step 8 — Verdicts: evidence status first, then the band

Two verdicts. The second is emitted only when the first is `scored` — a band on an empty profile is
the error this split prevents.

**Part A — evidence status, in precedence order. First match wins.**

1. `identity_conflict` — the returned record contradicts the query that found it: current employer
   or title is not what was filtered for. Profile data goes stale. Check it free, from the row you
   already have, before scoring.
2. `suppressed` — on the do-not-source or existing-pipeline list. Reported, never scored, never
   contacted.
3. `unscoreable` — **the profile carries no text the scorecard can read**: no about section, no
   experience descriptions, a headline that repeats the job title. **Not a zero and not a weak
   candidate.** It skews senior, because the people least likely to narrate their work are often
   the ones who have done the most of it. Excluded from the ranking, reported as its own group,
   worth a human skim on title and employer alone.
4. `scored` — the scorecard had evidence to read.

**Part B — the band, only when Part A is `scored`.** Weights sum to 100.

1. `strong` — 70 and above. Worth contacting.
2. `possible` — 40 to 69. Worth a skim first.
3. `weak` — below 40. Reported; not contacted, and never padded into the list to hit a number.

**The 70 and 40 cut-offs are a stated default, not a measured one.** No hire-outcome data anywhere
in this skill validates them. They exist so it is runnable rather than aspirational, and they are
the installer's to move — say what they are, say they are unvalidated, change them without argument.

## Step 9 — Outreach copy, per population, drafts only

**Copy is per population — not per candidate, and not one template for the role.** That is the
point of splitting them: they are moved by different things. The operator wants scope and budget;
the person who builds wants to own a surface; the consultant wants to stop advising and start
owning. One email to all three lands with none of them.

**Derive the pitch from the brief first, show what you extracted, then ask only for the gaps.** A
JD usually carries the mission, scope, team and remote policy. It almost never carries the three
that matter most, so ask for exactly those: **the comp band if it is shareable, the hiring manager,
and who the mail is from and their relation to the role.** A recruiting email with no level, no
money and no named human is a form letter.

Each draft carries: why **this population** specifically, what the person will own, the concrete
facts (level, band, manager, team size, remote policy, traction), one low-friction ask, and the
sender's real name. **No invention** — a fact that was not supplied does not get a sentence. A
fabricated detail about a role surfaces in the first conversation.

### The one-click compose link

A link per candidate that opens a **pre-filled compose window in the recruiter's own mailbox**. Two
columns, because a plain `mailto:` routes to a desktop client and a browser Gmail user needs a web
compose URL:

```
mailto:<address>?subject=<url-encoded subject>&body=<url-encoded body>
https://mail.google.com/mail/?view=cm&fs=1&to=<address>&su=<url-encoded subject>&body=<url-encoded body>
```

**Cap the link body near 900 characters of raw text.** Encoded compose URLs stop working past
roughly 2,000 characters, and newlines cost three each as `%0A`. Measured 2026-08-28 on eight real
rows: **bodies of 652–733 raw characters encoded to `mailto:` URLs of 1,094–1,203 and Gmail URLs of
1,128–1,237** — an inflation of roughly 1.65×, not 3×, because prose is mostly unreserved
characters. So a 900-character body lands near 1,500 encoded and clears the ceiling comfortably.
The cap is therefore about **what a first recruiting email should be**, more than about the URL
limit. **Compute the encoded length and assert it rather than trusting the ratio**, and if a body
exceeds the cap, **keep the full copy in its own column and say the link version is trimmed** —
never ship a link that truncates mid-sentence.

Two ways to build the encoding, at two prices:

- **In the agent, free.** The delivery is a CSV or a table handed over once: encode both fields in
  the agent and write finished URLs into the columns. Nothing bills.
- **As a table column, per row.** The table is the working surface, bodies are generated per row,
  and links must exist for rows arriving later. Use Clay's own URI-encoding action — **discover it
  in the catalog rather than trusting a name in this file:**

  ```
  clay workflows actions list > /tmp/actions.json     # find the Clay-owned URI encoding action
  clay workflows actions schema <packageId> <actionKey>
  ```

  It takes text plus an optional prefix, which is what makes it work: encode the subject first, then
  encode the body with a prefix carrying the scheme, the address and the already-encoded subject.
  Identify it by the **pair** of package id and action key — action keys collide across packages,
  and the wrong one is a different vendor at a different price.

**Which address, and why the default is neither.** The search **does not return email addresses** —
documented — so every compose link depends on a per-row enrichment priced in Step 6. Ask which
address, and say this when you ask: **a recruiting email sent to a work address is delivered onto
the current employer's mail system**, where it may be scanned, archived, or read by someone other
than the candidate. Personal-address finders exist, cost per row, and hit less often.

1. **Profile link only — the default.** The profile URL comes from the Step 6 enrichment, so this
   costs the profile enrichment and nothing more; no address is found and no compose link is built.
   The recruiter opens the profile and messages there, which for passive senior candidates is often
   the better channel anyway.
2. **Work address** — the managed `Email` routine, chained off the `company_domain` the enrichment
   returned. Portable, and the line above is what it costs the candidate. Say it, then build it if
   they still want it.
3. **Personal address**, only if a personal-address finder is available in that workspace — check
   the action catalog rather than assuming, and expect a lower hit rate.

Where no address is found the row keeps its profile URL and **no compose link** — never a `mailto:`
built on a guessed address.

**This skill sends nothing and enrols nobody.** There is no send step; copy lands as drafts. That is
a design choice, not a gap: candidate outreach pushed through a cold sales sequencer burns the
sender's domain reputation and reads, to the candidate, exactly like what it is. A link that
composes in the recruiter's own mailbox sends from a real human, returns replies to a real inbox,
and stops at a human's click.

## Step 10 — Deliver, with the shape of what is missing

Per population, in this order:

1. **The yield line** — rows found, target, whether the population is exhausted. **Including the
   populations that returned nothing.**
2. **The bands** — strong, possible, weak, plus `unscoreable`, `suppressed` and `identity_conflict`
   as their own rows. These do not fold into weak.
3. **The candidates**, ranked within band: name, current title and employer, location, years of
   experience, profile URL, score, the evidence line, and the compose link or the reason there is
   none.
4. **The outreach draft** for that population.

Then once, across the run:

- **Every criterion and where it went** — query, scorecard, or not observable. The part a hiring
  manager should read first and will not think to ask for.
- **Every approximation applied**, named: an industry anchor standing in for "companies like
  theirs", a tenure heuristic standing in for availability.
- **What was spent**, in result allowance and credits, against what was approved.
- **What was built in Clay, and what was left behind** — the enrichment workflow, whether it was
  created this run or reused, and its id. Nothing else should appear on this line.
- **What this list is not**: people who match a shape, not people who want the job. No
  availability, compensation or work-authorisation signal exists in this data.

## What this skill does not claim

- The logic came from an interview with its author, not from a workflow that has run end to end.
  No measured yield, cost, response rate or hire rate exists for any of it.
- What was verified live against the platform on 2026-08-27 is narrow and worth separating from the
  rest: that advanced query mode carries years-of-experience, education and per-experience seniority
  fields; that the worked example's query shape parses; that `count from ...` is refused despite
  appearing in the grammar; and that the field list is as quoted. **Nothing about result quality was
  measured.**
- The claim that keyword-proxying a soft criterion loses most of the qualified population is
  reasoned from two documented behaviours — the ranking-language policy and whole-word `contains`.
  **The size of that loss has not been measured**, and it will differ by role and seniority.
- The author's framing of populations — that a merged query fails in both directions — is the
  author's reading, not the creator's claim. **The creator's instruction was that the definition
  should come out of a conversation with the hiring manager, from exemplar profiles or described
  experience, rather than from the skill decomposing a brief on a theory of its own.** The
  one-query-per-population mechanic is theirs; the strength of the merged-query failure is not
  established.
- The 70 and 40 band cut-offs are defaults chosen so the skill runs. No hire-outcome data validates
  them, and nothing here can say whether they match an installer's bar.
- The per-employer cap of 2 is a stated default with no measurement behind it beyond the platform
  supporting the cap natively.
- The tenure-based availability heuristic has never been checked against whether those people moved.
- Scoring reads a public profile, so it measures what someone wrote about their work, not the work.
  That bias runs against senior and less self-promotional candidates in a direction this skill can
  flag but cannot correct.
- **The wrong-ladder measurement is one role, in two cities.** That 14 of 25 rows from a
  growth-title query were sales people, and that a current-role description keyword took 7 of 7 to
  the right ladder, was observed on one brief on 2026-08-28. **It is a real observation and not a
  general precision figure** — the size of the title/discipline collision will differ by function,
  seniority and market, and the keyword list itself is this skill's proposal, not a validated one.
- **The lookalike finding is one call, on one seed.** That it anchored on job-title token and
  employer industry, and returned a mis-matched HR role, is a real observation and **not a
  characterisation of the action's general behaviour.** Its precision on other seeds, roles and
  seniorities is unmeasured, as is whether 0 credits holds across plans.
- What was verified on the platform on **2026-08-28** and is worth separating from the reasoning:
  the people search response carries no profile URL and no profile text and the Public API returns
  the identical object; the workspace routine list is **not** the action catalog, and reading only
  the former leads to the false conclusion that profile text is unobtainable; the profile action
  named in Step 6 returns a profile URL, headline, about and per-role summaries and priced at 0.2
  credits on one live call; and the Free plan's 100-results-per-month ceiling cannot complete a
  three-population run. **One call is not a hit-rate measurement** — nothing here establishes how
  often that action resolves the right person, and its web-search resolution makes common names the
  obvious failure mode.
- The recommendation to score and write copy in the agent rather than in Clay is reasoned from
  architecture — relative ranking needs the whole set in one place, and copy is per population —
  **not from a measured comparison.** No per-row agent-node price was measured, so the cost side of
  that trade-off is argued, not quantified.
- No credit price appears anywhere in this file, deliberately — which also means it cannot tell an
  installer in advance what a run will cost.
- The compliance warning in Step 4 names two common exposures in two jurisdictions. It is not legal
  advice, not a complete list, and does not survey the installer's jurisdiction.

## What good looks like

- **The definition came out of a conversation** — two or three exemplar profiles taken apart with
  the hiring manager saying which shared attributes were the point, or their own description of the
  experience followed back. Not a JD parsed on the skill's authority.
- **Every criterion appears in exactly one of three places, and the split is on screen before any
  query runs.** The not-observable ones are named in the final delivery, not quietly absent from it.
- Each population has its own query, yield, bands and copy — **including the one that returned
  zero**, reported as a finding rather than dropped from the summary.
- Every approximation is disclosed where it was applied, not just in a preamble: "companies like
  theirs" became named industries, and the output says so.
- Every scored candidate quotes the profile phrase behind the score, so a hiring manager can
  disagree with one score instead of distrusting all of them.
- Thin profiles sit in `unscoreable` as their own reviewable group. A bottom band full of senior
  people with empty About sections is a list that scored profile-writing.
- No employer is more than the cap of the list.
- Every compose link opens with real facts in it — a level, a named manager, a real sender — or the
  row carries a profile URL and no link.
- **The commonest failure: taking "strong quantitative background" out of the brief, adding
  `about contains ("SQL", "analytics")`, and shipping a valid query, a plausible list, and the
  silent removal of most of the qualified population.** Nothing in the output looks wrong.
- **The second: one merged query.** Two hundred rows, no way to tell which population they came
  from, and a hiring manager who cannot tell whether the market is thin or the query was.
- **The third: averaging the exemplars.** Three profiles share an MBA, a city and a Series B
  employer; all three go into the query; the list comes back small and nobody knows which filter
  did it.

## Rules

- MUST start from a conversation — exemplar profiles or described experience — and MUST write the
  definition back for correction before running anything. NEVER treat a JD as the definition.
- MUST treat a lookalike population as seeded, not queried: MUST label it, name its seed, say what
  the engine appears to have anchored on, and filter it against the brief afterwards; NEVER fold
  its rows into a queried population's yield line, and NEVER use it as a substitute for asking
  which attributes are the point.
- MUST ask which of the exemplars' shared attributes are the point; NEVER average exemplars into a
  single query, and never guess which attribute mattered.
- MUST use advanced query mode and confirm the years-of-experience, education and per-experience
  seniority fields exist in the reference pulled **this run**; NEVER write a query from a remembered
  field list, and never fall back to filters mode, which has no years-of-experience field.
- MUST show the three-way split of every criterion before running anything, and MUST report the
  not-observable ones in the delivery; NEVER let a criterion disappear without being named.
- NEVER convert a scorecard criterion into a keyword filter. Where a soft criterion must shape the
  search it becomes a separate population, or it stays on the scorecard.
- MUST run one query per population and keep the label on every row; NEVER merge populations with
  `or`, and never `and` traits from different populations.
- MUST hold location, seniority and the experience floor constant across populations.
- MUST use `is_similar_to` for job titles by default; MUST use the exact-company function at the top
  level for current employers and employer-domain-inside-experiences for past ones; MUST omit
  seniority when no level was named; MUST keep every exclusion. NEVER mix the experience seniority
  enum with the job-posting one.
- MUST apply a per-employer cap; NEVER deliver a list where one company is most of it.
- MUST disclose every approximation where it was applied — an industry anchor standing in for
  company similarity, tenure standing in for availability.
- MUST sample 25 rows per population and report the count before the full run; MUST report a zero
  yield as a finding; NEVER pad a thin population, and never loosen a query to avoid reporting one.
- MUST state the full cost — result allowance and per-row credits, discovered live — and wait for an
  explicit yes before the first paid call; NEVER quote a credit price from memory or from this file.
- MUST name the routine, its inputs, what to verify in its response, and its per-row cost before any
  enrichment. "Enrich for emails" is an intention, not an instruction.
- MUST mark a profile with no readable text `unscoreable` and exclude it from the ranking; NEVER
  score it low, and never let it fall into the weak band.
- MUST quote the profile evidence behind every score.
- MUST warn once, name the specific exposure, and offer years-of-experience or seniority as the
  clean equivalent when asked to filter on a protected characteristic or a proxy — and MUST then
  build what was asked for. NEVER refuse, and never repeat the warning.
- MUST default the contact address to profile-link-only, and MUST say that a recruiting email to a
  work address is delivered onto the current employer's mail system before that option is chosen.
- MUST cap the compose-link body near 900 characters and keep the untruncated copy in its own
  column; NEVER ship a link that truncates mid-sentence, and never build one on an address the
  enrichment did not return.
- MUST pull the **action catalog** as well as the routine list before concluding anything is
  unavailable, and MUST identify every action by packageId **and** actionKey; NEVER plan a step on a
  `custom` routine or a Claygent found in the current workspace without saying it will not exist in
  anyone else's, and never infer a platform limitation from the routine list alone.
- MUST check the plan tier before paging and MUST stop and say so on a tier that cannot finish the
  run; NEVER start a run the allowance cannot complete and report a partial list as a list.
- MUST verify the enriched record's employer against the row that was sent before scoring it; the
  profile action resolves through a web search and can return the wrong person.
- MUST build at most one Clay artifact — the enrichment workflow — MUST check for and reuse it
  before creating another, and MUST report its id in the delivery; NEVER attempt a table or an
  audience for the candidate list, and never leave a second workflow behind.
- MUST keep scoring and copy in the agent unless the installer wants a living surface a team works
  in, and MUST say which was chosen; NEVER generate copy per row when copy is per population.
- NEVER send anything, enrol anyone in a sequencer, or write to a CRM. Copy lands as drafts and a
  human clicks.
- NEVER state a pitch fact the installer did not supply.
- NEVER invent a criterion the conversation did not contain; anything proposed is labelled as
  proposed.

## Worked example

Asked: *"We're hiring a Head of Growth in London. Here are three people I'd hire."* Three profile
URLs, plus a JD. **The yields below are the shape of a run, not measurements — this skill has not
been run end to end, which is the first thing its does-not-claim section says. The query is real and
parsed on 2026-08-27.**

**Decomposing the three exemplars** produced eleven shared attributes. Read back, the hiring manager
kept four and killed the rest:

| Shared by all three | Their call |
|---|---|
| 8–12 years, Head or Director level | **keep** — the floor |
| currently at B2B SaaS, roughly 50–500 people | **keep**, as an industry and size anchor |
| owned paid acquisition *and* lifecycle | **keep** |
| in London | **keep** |
| MBA | *"coincidence — two of them, and it's not why I like them"* |
| all worked at a company I've heard of | *"that's me recognising logos, not a requirement"* |
| all posted on LinkedIn in the last month | not a criterion |
| two came through consulting | **not a shared attribute — a second population** |

That last row is the conversation earning its place. Averaging the three would have produced one
query with an MBA filter in it and no consultant population at all.

**The split, shown before anything ran.** Of twelve criteria from the JD and the conversation, five
were filterable, four went to the scorecard — *"owned a number, not a channel"* at weight 25,
*"strong quantitative background"* at 20, *"built a team rather than inherited one"* at 20, *scale
resembling ~$10M ARR* at 20, *scrappiness* at 15 — and three were named not-observable: **whether
they want to leave, their comp expectations, and their right to work in the UK.** Those three are
what a recruiter assumes was handled.

**Two populations, two queries, same floor and location in each.** The first, verified to parse:

```
select from people
where years_of_experience >= 8
  and location_city in ("London")
  and experiences.any(is_current = true
        and seniority in ("Head", "Director")
        and job_title is_similar_to ("Head of Growth", "VP Growth")
        and company.industry in ("Software Development"))
  and not experiences.any(is_current = true and company.domain in ("competitor.com"))
limit 2 by clay_company_id
```

Disclosed with it: *"companies like the ones your three exemplars are at"* became named industries,
because similarity-by-domain is not available for people searches.

| Population | Sampled (25 max) | Full yield | Read |
|---|---|---|---|
| In-house growth leaders at B2B SaaS | 25, more available | 140 | the population is here |
| Ex-consultants two to four years in-house | 25, more available | 61 | real, and a different pitch |

**Bands on the 140 — and note what had to happen first.** The search returns no profile text, so
**there are no bands until the Step 6 enrichment has run.** Here it ran: 140 rows enriched, and the
scoring read the headline, about and per-role descriptions it returned. 31 strong, 58 possible, 34
weak, **14 `unscoreable`**, 3 `suppressed`. Had the installer declined the enrichment — a legitimate
choice, and free — this line would instead read *"140 rows, unscored, with the scorecard handed over
as a rubric"*, and that is the correct output rather than a degraded one.

The fourteen `unscoreable` are not weak — they are profiles with no About section and one-line role
entries, several at companies the hiring manager had named unprompted. They went back as their own
group for a skim on title and employer.

**Contact channel:** the enrichment returns the profile URL, so profile-link-only on the first pass
cost nothing beyond the enrichment already approved. After reading the strong band the installer
asked for addresses on those 31 rows only — priced live, approved explicitly, and the managed email
routine returned an address for 22 of 31. Those 22 rows carry two compose links each. The other nine
carry a profile URL and no link.

**Copy:** two drafts — **two, not 140.** The in-house draft leads with budget and scope; the
consultant draft leads with owning the number instead of advising on it. Both under 900 characters
of raw body, both naming the hiring manager, the level and the band, both from the founder rather
than a careers alias. The per-candidate part is only the merge and the encoding, which is free.
Nothing was sent.

## Listing
- **one-liner:** Turn a hiring conversation into a scored candidate list, one query per population who could actually do the job.
- **problem:** The criteria separating a good candidate from a plausible one are the ones a people search cannot hold — and it never says when it drops them. A brief goes in, a valid query comes out, the list looks plausible, and the discriminating half has evaporated. The usual repair, turning "strong quantitative background" into a keyword, makes it worse: it selects for people who narrate their skills and excludes on spelling.
- **delivers:** A definition built in conversation — two or three profiles you'd hire, with you saying which shared attributes are the point — then every criterion split three ways: filterable, scorecard, or not observable. One query per population, so an empty one is reported rather than hidden. Scores that quote their evidence, thin profiles marked unscoreable instead of weak, and outreach drafts that compose in your own mailbox.
- **example prompt:** We're hiring a Head of Growth in London — here are three profiles of people I'd hire, find me more.
- **also asked as:** Source people for this job | Build me a candidate list from this brief | Who could fill this role, and is the market even there?
````

- Previous: [scrape-any-website](https://syn4pse.dev/terminal/clay-scrape-any-website.md)
- Next: [source-local-businesses](https://syn4pse.dev/terminal/clay-source-local-businesses.md)
- [Terminal](https://syn4pse.dev/terminal.md)
- [Suggest a change](mailto:terminal@syn4pse.dev?subject=Terminal%20suggestion)
