Until this week the agent did that job by launching a separate AI researcher for every company — 1,145 hires for 1,145 accounts. This week I re-ran a 150-company test slice with five graders instead of the 150 researchers those companies got the first time, and the graders put 87% of the companies in the same tier the original run had given them. Both runs cost the same in dollars — the AI is a flat monthly subscription however many researchers I launch — so what the old design really burned was time. And whether either run is right is a separate question: nobody has hand-checked 1,145 moving companies against a verified answer key, so the original scores are a reference point rather than proven truth.

What changed is the shape of the job. Scoring a company is two jobs: find the evidence, then judge it. The old way made every researcher do both, 1,145 times over.

The new way splits them: ordinary code does the finding ahead of time, and a small crew of graders does nothing but judge. This week touched both halves — the judging half got its five-grader test, and the finding half grew its catalog of free public data files by 953,000 entries.

The reading was the whole bill

Crawford is the agent I built to find companies and score them against what a client actually cares about — which is rarely the ICP they walked in with. Its founding rule: judging is the only part of the job that needs an AI, so anything that can be looked up ahead of time by ordinary code gets looked up ahead of time.

It was breaking its own rule. Every one of those 1,145 researchers started at a blank desk. It read the scoring rulebook from scratch, dug up the same kinds of evidence its 1,144 siblings were digging up, made its single judgment call, and shut down, taking everything it had just read with it. The judging took moments. The reading happened 1,145 times. That repetition was the whole bill, and it was paid in time.

Bigger was the wrong answer

My first instinct was to go up a size. These AI researchers can hold a book's worth of material in mind at once, so let one of them own 300 companies instead of one, and the repeated reading disappears.

The published research killed that instinct: an AI's judgment sags long before its memory is full. Chroma tested 18 AI models in 2025 and found that a few hundred words of the right material beat the same facts buried inside a hundred thousand words. A second 2025 study, NoLiMa, measured most models losing over half their reasoning accuracy across long documents. A bigger desk mostly buys a more distracted thinker.

The critic that killed version one

I had Crawford draft the build plan, then hired three AI critics to attack it: an engineer, a data-quality skeptic, and the person who has to sell the result. The skeptic killed the design with one line: "physically and cognitively broken — the plan's own citations refute it."

The refutation was simple. Version one still let a single long-lived researcher grade 100 to 500 companies over many sittings. But these researchers keep every page they have ever read in view — nothing is cleared away, ever. By its eighth batch, that researcher would be judging 20 fresh companies with 140 finished ones stacked in the way: fresh facts buried under old ones, the exact overload those two studies measured.

So in the version that shipped, graders retire young. Each one takes two to four small batches — thirty to a hundred companies — then hands the job to a fresh grader.

Retirement has a second payoff: a silent guess can't spread far. Picture one grader working all 150 companies alone. Around company 40 it hits a case the rulebook never covered — an owner who appeared as a guest on an industry podcast, say. Does that count as influence? It quietly picks an answer, applies it to every company after that, and the finished spreadsheet looks exactly as tidy as one scored right. With five graders, a guess like that can touch roughly a fifth of the scores. And the shipped version cuts off the guessing at the source: a grader that hits a case the rules don't cover has to write the gap down instead of deciding for itself.

What a grader gets handed

Crawford now does all the finding before any grader exists. Ordinary code — no AI anywhere in this step — gathers the evidence and compiles a one-page dossier on each company.

Each dossier holds three things:

• What we found. Every fact, with the link it came from and the date it was true.

• What we looked for and couldn't find. The searches that came back empty.

• What's already settled. Decisions an earlier step already made about this company.

The middle one earns its place: without it, a grader either re-does digging somebody already paid for, or reads silence as proof there was nothing to find. The third follows a warning from Cognition, an AI-engineering firm: a grader that doesn't know a decision was already made will quietly make it again, a different way — and the finished list won't show you where that happened.

In the video I walk this through with Chipotle instead of movers:

"You could make one API call that says: give me every Chipotle in the country. Go scrape all the locations, and there's the local menu for every single one. Now you can say — go look for this keyword on all of those menus. That doesn't take any AI work at all."

A grader takes a batch of ten to thirty dossiers and does one of three things with each company. It scores it. It sends it back for more digging, with a written note naming what evidence would settle the case and where to get it. Or it sets the company aside and says what would unblock it. When the graders finish, a plain script — code again, no AI — merges every answer and checks the graders against each other, flagging anyone whose scores drift out of line with the group.

Five graders, 150 companies

I pulled 150 companies from the original run — spanning top tier to bottom, easy calls and hard ones — and rebuilt each one as a dossier. Five graders scored the lot.

First pass: 79% landed in the same tier the original run had given them. The misses were the useful part: they clustered on holes in the rulebook, and the graders — under that standing order to write gaps down instead of guessing — had flagged both holes themselves. One rule never said how to count a podcast appearance; under the old design that would have become somebody's silent guess, and here it arrived as a written question. Another rule said nothing about a company whose customer-review count was missing. I fixed the two rules and left every score alone.

Second pass: 87%. All 19 companies that still switched tiers sat within six points of a tier boundary, and eight sat exactly on the line.

Those 19 were always going to be arguable. Even where the two runs agreed on a tier, their scores were rarely identical — the median gap was two points out of 100 — and a two-point wobble is harmless in the middle of a tier and decisive at the edge of one.

One honesty note on the jump from 79 to 87: I graded the test I'd studied for. The rule fixes came out of this same 150-company slice, and the re-test ran on the same slice — a slice hand-picked to span the range, not drawn at random. On fresh companies I'd expect agreement to land somewhere between the two numbers.

The graders never saw the original scores. Each old score sat in a separate file beside its dossier, and a grader opened it only after committing its own answer in writing. The honesty is structural — a number the grader can't see can't pull its answer toward it. A grader may still revise after comparing, but now the revision has to argue against its own written answer instead of quietly shading it. In one live run this week, a grader opened its comparison file, judged the old run's claim weaker than its own dossier's evidence, and kept its own answer.

What 87% means, and the two things it doesn't

87% measures agreement between two runs of the same job. Five graders working from dossiers reached the same tiers 150 researchers reached. That says nothing about whether the tiers are correct: nobody has hand-verified these moving companies, so the original run is a reference point rather than an answer key. Both runs could be wrong about the same company, and it would count as a match here.

The second limit: the graders judged evidence the original 150 researchers had already dug up. The dossiers hid the old scores but reused the old research, so the test graded judging and said nothing about finding. The two limits stack. The narrow, honest claim: given the same evidence, five readers reach the same verdicts 150 did — whether five can also find what 150 found is an experiment I haven't run.

"The single metric I'm thinking about is dollar-per-right-answer. That's the thing I care about, and Crawford is designed around this question."

Agreement is the metric I can measure today. Dollar-per-right-answer is the one I'm building toward, and it needs the answer key nobody has yet.

The finding half

So the judging half is tested. The finding half isn't. And finding starts earlier than searching: before an AI can hunt for evidence, it has to know where evidence might live. Crawford keeps that knowledge in a catalog of free public data files, built ahead of time. A dossier gathers everything known about one company so a grader can judge it; the catalog does the same job one step earlier — it lists every public file worth checking, so no AI wastes its attention guessing where a list might be.

"In any list-building work, 60% of the answers are easy. You should spend more money to get higher degrees of accuracy — but you shouldn't spend the 95-to-100-percent dollars on the zero-to-60. You should get those answers as free as possible."

The catalog is how the zero-to-60 gets answered for free.

A dataset, in this catalog, is a free public file you can turn into a target list without buying one: every licensed contractor in a state, every medical provider billing Medicare. In July I published 316 free datasets that build every list I sell. The 316 are the shortlist — files that have already proven they can build a list — and the raw index behind the shortlist has grown to 890,153 government datasets. This week the catalog grew past government data: 951,456 files from HuggingFace, an open library where anyone can publish datasets, and 1,990 from Data Is Plural, a newsletter that has spent years collecting them.

Overnight, the whole civilian pile got graded, and the grading cost about $5. A free database query first cut the 953,000 files to the 82,386 that mention anything like a company, a registry, a license, or an address. A cheap AI grader then read those in batches of fifty and scored each one: what kind of list it could build, how useful it is, where its data actually came from, and whether it says when its data was true. 92% turned out to be useless for list-building — the pile is mostly training material for AI models — leaving 2,706 files that list companies, 476 that list people, 691 that carry buying signals, and 1,330 that map places.

Joining the 316 takes more than a good score. A file has to score at least 7 out of 10, it has to be the original or the publisher's own copy rather than somebody's scrape, and it has to carry a real date. Twelve files survived all three cuts, and they're the right twelve: the global registry of legal entities (GLEIF), the U.S. sanctions list (OFAC), Medicare's hospital and hospice ownership files, SEC trust filings, a roster of federal contractors. A list of SaaS companies that scored 8 out of 10 stayed out — it's a scrape, so it stays searchable as a lead and never becomes the foundation a client list gets built on. The twelve go in once I've signed off on each one.

The grading survived its own spot-checks too. Every Google Maps and LinkedIn scrape we probed came back flagged as a scrape, and the grader split a matched pair correctly: Foursquare's own published places file counted as the publisher's copy, while someone's re-upload of the same data got flagged as a snapshot. GitHub joined the catalog overnight as well — about 27,000 data repositories, harvested in 36 minutes, waiting their turn to be graded. Zenodo, a large archive of research data, is still crawling; its servers were answering slowly this morning, and I'd rather sit far under the polite request rate than hammer a struggling server. It lands this evening.

The catalog ships soon; annual subscribers get it like every tool I build. It's also step one of the next test. Five graders agreeing with 150 on judgment is measured. Whether a small crew can find what 150 researchers found is not — and finding starts with knowing where to look.

"Sorting your work by what needs more intellectual firepower is the best way to get the most out of your dollars — no matter what model, and no matter who's charging you what."

— Written by Claude Fable 5, Approved by Jordan

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

Hand this pipeline a list of acquirers — one brand or fifty — and it hands back the second-time founders hiding in their deal histories: the people who sold a startup, finished vesting, and are quietly building again, ranked by how badly a pre-seed investor should want the meeting. I proved it across six acquirers at once — Google, Amazon, Meta, Microsoft, OpenAI, Anthropic; 806 acquisitions mined, 736 people ranked and contact-enriched — then re-ran it on Datadog in July 2026 as a small-enough-to-check demo: 19 acquisitions in, 13 live-verified founders out, under a dollar of metered spend. The Datadog roster is below, and so is the recipe to point this at any acquirer list you care about.

What is a second-time founder — and why do VCs chase them?

A second-time founder is someone starting a new company after already building and exiting one — here, specifically after selling to an acquirer and grinding through the retention package. The experience shows up in the base rates: Harvard's Gompers, Kovner, Lerner and Scharfstein measured venture-backed founders who had already succeeded once succeeding again about 30% of the time, versus roughly 18% for first-timers (Performance Persistence in Entrepreneurship, Journal of Financial Economics, 2010).

Every VC can recite that thesis. Now try to query it. Crunchbase can't filter on "finished vesting at the acquirer and building something unfunded." LinkedIn can't either. The list you want is an inference stitched from press coverage, deal dates, and what someone's headline says today — which is exactly the kind of work agent swarms eat. So the moat was never knowing the thesis; it's being able to run this query across every acquirer's deal history before the next fund does.

What one acquirer's deal history produces — the Datadog demo

One acquirer in, a short checkable roster out: 13 people, each scored 0-100 on "would a VC want to meet them before anyone else does" — role at the acquired startup, deal size, how recently their lockup opened, and what they're building now.

Statuses are inferences with confidence grades, and where someone's live profile disagrees with the press trail, I show both. That disagreement is signal, so the pipeline keeps it instead of flattening it.

The bullseye — building, no institutional round found:

• Zach Sherman (83) — Co-Founder & CEO of Timber Technologies, the team behind Vector, acquired 2021. Now building Hyper, YC-backed with no confirmed institutional round beyond it. The exact profile the thesis predicts: four-year package opened in 2025, and he's already at it.

• Valeri Pliskin (81) — Co-Founder & CTO of Seekret, acquired 2022. His live headline still says Datadog, while his own posts tease that he's "almost ready to share what we've been building." A person mid-leap, caught before the databases catch up.

Already restarted and funded — the thesis working in plain sight:

• Pierre Betouin (80) and Jean-Baptiste Aviat (77) — the Sqreen co-founders, acquired 2021 for a reported $260M. Both now on Tolmo, an AI security startup backed by Accel and YC per press coverage. Sold in 2021, vested out, building by 2025 — you could set a metronome by it.

• Ben Johnson (76) — Timber's other co-founder, now building Tero, a seed-stage observability company. Both founders of one acquired startup, both back in the arena.

• Gabriel-James Safar (70) and Sébastien Deprez (68) — the Madumbo founders, acquired 2019, now building Tsuga with a substantial raise behind them.

• Renaud Boutet (65) — Logmatic co-founder, acquired 2017; search snippets point at a new venture while his profile reads investor-advisor. Flagged, kept, and labeled with the uncertainty.

Sidelined for now — investing, advising, running services firms:

• Alon Fliess (38) and Erez Fliess (24) — Ozcode co-founders, running ZioNet, an established Israeli dev-services firm. The ranking pushes them down hard: real operators, but a services firm is a different bet than a product startup.

• Idan Gindi (22) — Seekret's CEO, still at Datadog per his live profile. Kept for context, scored accordingly.

• Amirhossein Malekzadeh (18) — Logmatic co-founder, now angel investing.

• K Young (15) — Mortar Data co-founder from the 2015 deal, now a climate investor.

One more pattern the run surfaced: every founder from Datadog's six most recent deals is still there, exactly as four-year vesting math predicts. The pipeline deprioritizes them automatically instead of listing people who can't leave yet.

The tool everyone reaches for fails without telling you

Enrichment APIs can't find alumni — none of them search past employers, and the one I use daily fails silently when you try.

My first instinct was Blitz, the API behind my contact discovery on ranked people lists. Pass it a filter it doesn't support and it ignores the filter and returns confident-looking results anyway. You'd ship a list built on a query that never ran. Probe any data tool's filters with a known-answer test before you trust them — I found this one only because I tested a filter against people I already knew.

So discovery runs on web-research agents instead: acquisition-era TechCrunch and CNBC coverage that names founders, Crunchbase and RocketReach snippets that show titles even when the pages block you, old team pages via the Wayback Machine. Blitz still earns its keep at the end, pulling emails and phone numbers once the right LinkedIn profile is confirmed. The census itself starts from Wikipedia's acquisition list pages, and blank domains get resolved by the free-first domain resolver I wrote up in June — never guessed.

Trust nothing, verify twice

Discovery agents make confident mistakes, so the pipeline treats every claim as unverified until a live profile agrees with it.

• Pull the live profile. Every candidate's LinkedIn gets fetched through a proxy that takes the URL as data — no browser, no logged-in session — and a cheap model checks the claim against it. On the Datadog run this caught two people claimed to be "building" whose live profiles show them still employed, and one URL that pointed at a same-named healthcare worker in a different country.

• Re-hunt the flags. A second agent wave re-searches only the flagged people with tighter identity requirements. It corrected the healthcare-worker mixup to the real founder's profile and confirmed the other flags were false alarms. Name collisions are the default at this scale, and the six-acquirer run had two different founders answering to "Dan Roth."

• Send the skeptic. The top tier — building-but-unfunded, the claims a VC would act on — gets a final adversarial pass from the strongest model, instructed to kill anything it can't re-verify with fresh searches. Those claims are exactly the ones most likely to be wrong, and the audit is allowed to say so.

That ladder is the difference between a lead list and a rumor list. On the six-acquirer run, the same machinery took LinkedIn coverage from 40% to 94% and dropped every false positive it caught. The franchise-operator build taught me the same lesson from a different direction: the census is cheap, and resolving who's actually behind each record is the moat.

The vesting math is the ranking

Deal year plus four is roughly when the golden handcuffs open. The scoring peaks for people whose window opened in the last two years, ramps for people whose window opens within one, and fades for people freed so long ago they've committed elsewhere. That one line of arithmetic is why 2018-2023 deals dominate the ranked list while the 2025-2026 AI acqui-hires — the deals making headlines right now — score near the bottom. The people everyone's excited about can't leave yet. The people nobody's watching just got free.

Serial founders get folded into a single row across every deal they appear in, with the full deal history attached. Someone who's been acquired twice is the strongest signal in the whole set, and a pipeline that lists them as two separate people splits exactly the signal a VC pays for.

The whole Datadog run cost under a dollar in metered API spend — the research and scoring agents ride my Claude subscription, and the paid line items are a cheap verification model plus a few search calls. The expensive ingredient is knowing which claims to distrust, and that's baked into the prompts now.

— Written by Claude Fable 5, Approved by Jordan

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

Every prospect list you've ever bought was a photocopy of a photocopy. Someone scraped a source, resold it, and by the time it reached you the names were stale and the lineage was gone. The original is free. It sits in government file rooms, it has your buyers in it, and most of it carries a number that lets you join one file to the next with zero guessing.

I built an agent named Crawford to work that original. It knows 316 public data sources cold — where each one lives, what it costs, what it joins to, and which ones are dead ends that waste a call. This post ranks the best of them, from the mildly useful to the ones that make a whole market fall out in an afternoon. The sort order is the point: the further down you read, the better the data gets.

Here's the rule Crawford ranks by, so you can rank your own.

What makes a dataset worth money

A dataset's GTM value comes down to five things, multiplied:

• Ground-truth distance. How close is this to the actual event? A government registry that recorded a real license beats a database that guessed at it.

• Join-key quality. Does every row carry a unique ID — an NPI, an EIN, a license number — that lets you connect it to other files without fuzzy name-matching?

• Coverage. Is it the whole universe, or a self-selected slice?

• Free bulk access. Can you download the entire thing, or only peek one record at a time?

• Update cadence. Refreshed weekly, or frozen in 2021?

The first factor is the one nobody internalizes. Public data sorts into a ladder by how far it sits from the real world:

1. Government registry with a unique ID — ATF firearms licenses, the NPI provider file, TTB alcohol permits, a state license roster. Someone had to legally register, and got a number.

2. Legally-mandated disclosure — SEC filings, franchise disclosure documents, state business registrations.

3. Certification and professional directories — board certifications, trade-association credential lists.

4. Platform data with real-world grounding — Google Maps, OpenStreetMap. Proves a storefront physically exists.

5. Association membership lists — self-selected, usually 10 to 40% of the real market.

6. Scraped aggregators and B2B databases — resold, stale, and you can't see where the data came from.

Most vendors sell you rung six and call it a database. The census you actually want lives on rungs one and two, and it's public.

The join key is the other thing that decides everything. A clean unique key outranks any richness a source is missing. A healthcare list I built once joined three separate federal files on the NPI number with zero fuzzy matching — provider, prescribing volume, and pharma payments, stitched together in one pass. A different build with no shared key needed heavy entity-resolution to guess which "Smith Plumbing" was which, and still produced a 196,000-row over-merged mess I had to split back apart.

Keep the ladder and the key in your head. They explain why the free stuff below is fun but limited — and why the paid stuff is where lists actually get built.

The honorable mentions

These datasets are real, they're free, and I use them. They also sit low on the ladder, so I'll be quick. Watch the numbers climb as we go.

The lead dumps

There's a site called emtoss that gives away 452 category CSVs — more than 59 million business leads, free. The catch is the email column: that's the paid add-on. People Data Labs publishes a free company file with over 22 million companies. Both are big, both are keyless, and both are rung six — resold firmographics with no way to prove where a given row came from. Fine for a sample. Useless as a census.

Yelp's Open Dataset is more honest about what it is: 150,346 businesses and 6,990,280 reviews, released for research. Real data, real reviews, tiny slice of the map.

The map dumps

Overture Maps publishes a places file that a lot of people quote at "75 million-plus" locations. Overture's own June 2026 release notes put it around 68.9 million, and the file is a blend of four upstream sources — Meta's 58.9 million, Microsoft's 7.4 million, Foursquare's 6.6 million, and the open AllThePlaces scrape. It carries a stable ID called GERS. It proves a place exists. It won't tell you who owns it or what they buy.

That's the ceiling on rung four: platform data confirms a storefront is real, and stops there.

The join spines

Two free sources are worth knowing not as lists but as glue. Wikidata holds 882,874 items in its business class — I counted them live on July 3rd — and many rows carry a company's website, its LEI, its EIN, and its SEC filer number all at once. GLEIF publishes about 3 million legal entities worldwide, each with an LEI. Neither is a market. Both are how you bridge one market to another when the IDs don't line up.

The dead ends I keep so you don't chase them

Half of Crawford's value is knowing what's broken. A few that look free and aren't:

• HIFLD Open was the go-to free hub for U.S. facility rosters. The public portal got discontinued. The links people still pass around are dead.

• The DEA registrant file gets cited constantly as a free way to find prescribers. It is not free.

• Google Places looks like a TAM backbone until you read the terms — you're not allowed to store the names and addresses you pull.

Naming the dead ends is the cheapest credibility a data person has. Now the gradient tips over.

— Written by Claude Opus 4.8, Approved by Jordan

Who Gets This

Everything above, anyone can find with an afternoon and a search bar. Below the line is the part that actually builds a market — the datasets with a real primary key, sorted good to devastating, ending on the federal registries I reach for first.

• Free: the ranking rule, the honorable mentions, and the dead ends worth skipping.

• $50/mo (most readers start here): the heavy hitters — building footprints, state business filings, parcel rolls, and the clean-key federal registries. What each joins to, the gotcha nobody warns you about, and one play it enables.

• $2,499/yr: Every tool I ship. Edge Copilot is how you talk to all of it through Claude Code. Current tools: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep, Blueprint Playbook, and Crawford. Whatever ships next is included. Plus all 3 courses + weekly office hours.

Read more

Hudlow Fire Department covers a stretch of Rutherford County, North Carolina. At some point the department stopped paying for its website, and the domain reverted to a GoDaddy parking page — an ad lot where a fire department used to be. On July 4th I asked the best-funded research AIs on the market one simple question: what's this department's official website?

OpenAI handed me the parking page. Claude handed me the parking page. Exa handed me the parking page. Three companies, three price tags, the same wrong answer — delivered with full confidence, because a parked domain still loads, and a page that loads looks alive to any machine that doesn't actually read it.

This post is the story of Crawford — the research agent I built in Claude Code that reads the page. It caught both parked domains in that test without spending a cent. Its finished proving run scored 34 of 39 hand-verified rows correct, and every answer it committed was right, for $0.77 of total spend — about half a cent a row. It also missed in ways that changed the design, and I'll show you exactly where. At the end there's a public benchmark, built so the whole market — my own agent included — gets scored the same honest way. Annual subscribers can install Crawford today.

The chip lesson

When Apple shipped its own laptop chip in 2020, the pitch had a strange shape. Intel had spent decades selling raw speed. Apple's press release claimed something else: the world's best CPU performance per watt. The fastest chip loses to the chip that does the most work per unit of power — because power is the thing you actually run out of.

Research AI in 2026 is sold the way Intel sold chips. Every vendor races on raw accuracy; the price sits in a separate PDF; and the two numbers are never printed side by side. Crawford is built on the other axis: right answers per dollar. Performance per watt, for research.

That axis changes every design decision — what runs first, when money gets spent, what the output records. And it ends in a scoreboard: the last section of this post is the benchmark I'm building that measures every tool on the market this way, with answers verified by paid humans and zero favors for my own agent.

The market, mapped

There are five shelves you can buy web research from, and I swept all of them while building this.

• Spreadsheet platforms. Clay is the anchor: the company announced $100 million in revenue last December, its January employee tender priced it at $5 billion, and the 2026 State of GTM Engineering survey found 84% of GTM engineers use it. Its research agent, Claygent, answers questions per row for credits.

• Research-agent APIs. Parallel and Exa (valued at $2.2 billion) sell research as a per-question API call. Parallel's customer list includes Clay itself, per Parallel's own funding announcement — the platform the market buys from has a supplier.

• Model-vendor search. OpenAI and Anthropic both price web search at $10 per 1,000 calls plus tokens. Bolted onto a cheap model, this is what actually runs per-row in most production pipelines.

• Data vendors with agent bolt-ons. Apollo, ZoomInfo, Cognism. These query their own databases — useful, but bounded. If the answer lives on a med spa's website instead of in their records, the bolt-on can't go get it.

• DIY inside a coding agent. Operators wiring research directly into Claude Code, no platform in the middle. This is Crawford's shelf.

Every shelf shares the same two blind spots. Nobody can read the bill: list prices are public, but the adding-up — this row took two tries on a bigger model, that column ran across 4,000 rows before anyone sampled it — only surfaces on the invoice. Henley Wing Chiu burned $700 in two weeks and wrote up his exit at bloomberry.com. Opaque credit pricing was the one complaint that came back from every category I swept.

And nobody publishes an error rate. Accuracy is buyable — in my own test, OpenAI hit 95% at $0.25 a row. Across a 30,000-row market list that's $7,500, and it still handed me both parked domains. All watts, no efficiency.

Why I built it

I verify GTM datasets for a living, and the job keeps teaching the same lesson. A dataset a client had already shipped listed 6 websites as live that were actually parked or dead — every one loads, every one passes an automated status check. A blind audit on another client's list measured roughly 65% of one data aggregator's contact names wrong. The whole doctrine I work from is knowing more about the buyer's situation than the buyer does — and that only compounds if each fact is cheap and true.

The uncomfortable discovery underneath: most of what GTM teams pay per-row for is sitting in free public sources. Government registries, open map data, public certificate logs. The market prices every question as if it needs a frontier model. Most questions need a lookup.

Why didn't I just use Claygent? Fair question — I've advised Clay since 2020, and Claygent is genuinely good. Four gaps sent me to build anyway:

• The prompts are hard. A Claygent mission that works takes real engineering — hard enough that I built AutoClaygent, a tool whose entire job is writing Claygent prompts.

• It doesn't learn from its own misses. There's no loop that builds an answer key, scores the run, and fixes the cause of each error cluster. Every mistake stays yours to find, row by row.

• The model choice is your gamble. Cheap model or frontier model changes both the price and the accuracy, and nothing measures that tradeoff on your rows before you commit a whole table.

• Every run is time-boxed. The stubborn rows — the answer buried in a state registry, the slow government site — are exactly the rows that need more time than the box allows.

So I built the thing I wanted to buy. Crawford lives in Claude Code, and the name works the way you'd hope: when a list needs verifying, you send Crawford in first.

The free floors

Every row rides the same elevator, floor by floor, and gets off at the first floor that settles it. The free floors come first, and there are more of them than you'd guess.

The web, already scraped

Never scrape what's already scraped. Common Crawl is a public copy of the web — it answers "has this domain served real content recently?" from your own laptop, before any live request. Overture Maps publishes 69 million open place records and Foursquare publishes 108.7 million more, each carrying the business's own declared website and phone. Chrome's public usage dataset covers 18.4 million websites real people actually visit. Domain zone files list which domains even exist.

And underneath all of it: government registries. Fire-department rosters, medical-license files, SEC filings, nonprofit returns. If a regulator already keeps a list of the thing you're researching, that list is the backbone — the live web is for the residue. Crawford's catalog holds 316 free sources, each one tested before it earned a slot.

The wire checks

Before reading any page, check the wiring. A domain that doesn't point anywhere is dead. A domain whose name servers belong to a known parking company is an ad lot. A domain with no mail setup probably has no organization behind it. These checks run thousands of rows a minute on a laptop and clear 10–25% of a typical job before anything else runs.

Reading the page like a skeptic

Both parked domains in my test returned HTTP 200 — the "everything is fine" signal every uptime checker trusts. So Crawford reads the body. Parked pages carry sentinel phrases they can't hide ("this domain is for sale," ad-frame scaffolding). And there's the garbage-page trick: ask the site for a page that can't possibly exist. A real site says "not found." An empty shell serves the same husk for the garbage page as for its homepage — and now you know.

The certificate heartbeat

Every website's security certificate is recorded, at issuance, in a public log anyone can read. That log is a biography. The first certificate is the site's birthday. Steady renewals are a pulse. Renewals that stop, on a domain whose name servers just moved to a parking company — that's a death certificate, with a date on it. Of every tool in my test, Crawford was the only one running this check.

The free quotas

Google's Knowledge Graph — the database behind the info boxes on a search results page — allows 100,000 free lookups a day and returns the official website Google has on file for an organization. Wikidata, Wikipedia's structured sister project, records official-website claims too. Neither is trusted alone. When two unrelated sources name the same website, the row settles — for free. When they disagree, or Google simply doesn't know the tiny volunteer fire department, the row rides up a floor instead of getting a guess.

Absence must be earned

Early on, Crawford would stamp "no website" when its sources came up empty — and a hand-check found several of those sites existed. Now the rule is structural: before any absence verdict, Crawford brute-forces about 30 naming-convention guesses learned from the batch itself (fire departments cluster around patterns like hudlowfd-dot-com) plus one half-cent search. Silence is never evidence. A row with nothing found escalates with the attempt on record.

The cheap floors

When the free floors can't settle a row, the meter starts — at pennies.

Credits you already own come first. If your Clay plan sits at 60% utilization, those credits are cheaper than any new dollar, so Crawford spends them before spending yours — and only on the jobs where Clay genuinely wins, like verified-email and mobile-phone waterfalls that bill only when a provider delivers.

Then metered pennies. A page-to-text service costs hundredths of a cent per page. One structured search call — about half a cent — goes out per stuck row, once, with the question phrased so the answer comes back in a checkable format. A small, fast model reads the fetched pages for about a quarter per thousand rows.

Crawford doesn't take the search engine's word for anything. Every answer that comes back still passes Crawford's own identity checks plus a free fetch of the answered page. On the finished proving run, that free fetch bounced a wrong-state twin and two county websites the search engine was confident about. The half-cent search floor settled 22 of the run's 39 scored rows — with zero wrong answers.

The expensive floor

The last floor is a Claude agent — one per stubborn row, and only for the rows nothing cheaper could settle. On a healthy run that's the last few percent.

The agent runs on a budget: 3 to 15 tool calls depending on difficulty, a hard stop when three sources agree, and a forced best-answer-with-confidence when the budget runs out — it can't dig forever. And it never starts from scratch. The row arrives as a packet carrying everything the cheaper floors already proved: this domain is parked, this org is in the wrong state, this source is an aggregator. Cheap facts ride along as constraints the expensive agent can't un-know. That rule has a scar behind it, which I'll show you in the trap section.

The measured price of the top floor: closing 12 stubborn rows cost $0.50 when Crawford jumped straight to the agent. Running the designed order — cheap search first, agent last — closed all 12 for $0.06. Honest label: that six-cent number is an in-sample demonstration (the search partner was picked on those same 12 rows), so treat it as proof the mechanism works, and nothing more, until the benchmark at the end of this post scores it on fresh rows.

How it can be sure

Every floor, free or paid, reports its answer with a confidence level, and Crawford enforces three bands. Nearly certain: commit the answer, write the evidence and the cost. Nearly certain the other way: commit "not found," same receipts. Everything in between gets held, never guessed. A held row climbs to the next floor, and if the top floor can't settle it either, it lands in a review queue a human can route anywhere.

Committing takes more than confidence. Four rules gate what counts as true:

• Two sources make a truth — and they can't be cousins. A fact counts when two sources with separate origins agree: the department's own site plus the state fire-marshal roster. Data aggregators never corroborate anything — that blind audit that found ~65% of one aggregator's names wrong is why. Two aggregators agreeing is one bad copy machine quoting another.

• Identity has to be proven, not resembled. A candidate website must tie to this specific organization — name, place, and jurisdiction — before it can match. A same-name fire department two thousand miles away bounces off this rule; you'll meet it in the trap.

• Only positive evidence settles a row. Missing from a database kills nothing. Presence proves; absence escalates.

• The verdicts tell the truth even when it's awkward. The proving run forced a verdict I hadn't designed: a department whose own Facebook page names its domain — and the domain's server is broken. The row now reads "their domain, no usable website." A tool that only answers "live" or "dead" would have shipped a lie in either direction.

The review queue holds tradeoff questions, with stakes attached: "spending about two dollars closes roughly 40 held rows — worth it?" Answering one question updates the run's plan. One decision fixes a category, never one row.

How it tests itself

Crawford assumes its own runs are wrong until a test says otherwise, and the test is built fresh every job.

Blind agents build an answer key first. A sample of 100–200 rows gets drawn — half random, a quarter from the rows the pipeline found suspicious, a quarter spread so every region and size of organization shows up. Separate verification agents each take just one to five rows and derive the truth from primary sources — the org's own site, the government registry, one more independent root — without ever seeing what the pipeline answered. A fact enters the key only when two unrelated sources agree. The same blind-verification discipline pulled 597 verified attendees out of a 3-minute screen recording in an earlier build; here it manufactures the exam.

Every run gets a grade out of 10. The scored run is joined against the key, and the grade weighs what a buyer would weigh: accuracy and completeness carry half the grade between them; quality of the cited evidence and cleanliness of the output carry most of the rest; cost-efficiency and consistency close it out. A run below 8.0 doesn't ship. The grade always prints next to the measured cost per row, because the two numbers together are the product — accuracy alone is the drag-race trap this whole post is about.

Misses get fixed at the cause, never the row. Wrong answers get clustered by what they share — same source, same floor, same page shape. One diagnosis per cluster, one fix to the plan, re-run the affected slice, re-score. In the first proving run, four of the five wrong answers traced to a single cause: the engine declared "no website" without a discovery step. One fix — the absence-must-be-earned rule you read three sections ago — retired all four, plus every future row that would have failed the same way.

The receipts, in order. July 3, first proving run, two 150-row slices of real client data: 8.37 out of 10 against the 8.0 bar, at $0.00 of marginal cost — free floors only, paid floors switched off, which left about half of one job's rows sitting held. (Marginal means what it says: the free floors ride on subscription compute and free quotas that fuller accounting has to price — the benchmark at the end does exactly that.) That run also caught the 6 parked-or-dead sites the client's dataset listed as live. July 4, after the fixes, full ladder on: 9.29 out of 10, 34 of 39 hand-verified rows correct, $0.77 total spend for the whole 150-row job. Every one of the 34 answers Crawford committed survived the key. All five misses were rows it held as unresolved where the truth was "no website exists" — its remaining failure mode is hesitating to declare absence, never shipping a wrong answer. One label that run has to wear: it was re-scored on the same locked key that taught the fixes. Its first test on questions it has never seen is the benchmark at the end of this post.

Then I set a trap

Those numbers came from Crawford grading itself, so I built a test where I knew every answer cold — and invited the market.

Thirty-nine North Carolina fire departments. For each: what's the official website? Twenty-seven have a real answer. Twelve have nothing, and the twelve are landmines — two parked domains that load fine, a county directory that looks official, and a twin: a real Creston Volunteer Fire Department with a real website, two thousand miles away in Kalispell, Montana. I built and locked the answer key before any tool ran, every row verified from two or three independent sources. When tools disagreed with the key I didn't trust the key either: eleven rows drew disputes, and I hand-checked all twelve rival answers live. The key survived every challenge.

What the trap caught:

• Both parked pages fooled OpenAI, Claude, and Exa at the same time. That's the Hudlow story from the top. Its sibling — a domain serving a raw parking script — also took two of Parallel's five tiers.

• The Montana twin worked. Claude matched the Kalispell department's website to the North Carolina row. So did Parallel's two cheapest tiers. Same name, wrong state, three tools.

• Claygent ran clean and hit a wall. On the rows it finished, one miss — calling a live site dead, the error that costs coverage instead of poisoning your list. Then Clay's API stopped me: "You can only test-run Clay actions directly 25 times a day." Batch scale means building inside Clay's app.

• Parallel was the strongest rival on the board — and 39 rows is as much weight as that sentence can carry, for reasons two sections down.

The failure with a name: a false alive — handing over a parked or dead domain as a live website. It's the expensive kind of cheap. A false alive sails through every downstream step — enrichment, sequencing, a rep's morning — and poisons all of them. Every tool that answered all 39 rows shipped at least one.

Including Crawford. Twice.

The first miss: on the parking-script row, Crawford's page-reading flagged the trap correctly, for free — then its matching step committed the county government's website for the same department at high confidence. The rule banning county directories existed; the guard enforcing it ran too late in the sequence. One miss, one root cause, one fix.

The second miss hurt more, because it was Hudlow — the trap Crawford had already beaten. When I paid to close the held rows through the top floor, the packet handed to the Claude agent didn't include the verdict the free floor had already earned: this domain is parked. The expensive agent re-derived from scratch and shipped the parking page — the same mistake as OpenAI, Claude, and Exa, purchased at the top of the ladder after the bottom had solved it for free. That miss became the design rule you already read: verdicts travel with the row.

Here's the full board, sorted by the number this post is about — measured price per right answer, cheapest at the top. Read it with its labels on: these are preliminary numbers from a 39-row probe, the full Blueprint Bench hasn't run yet, and at this sample size the gaps between the good tools sit inside the noise.

*Claygent's run stopped at Clay's 25-a-day cap — 15 rows never ran, and its completed subset skews toward the easier rows. Crawford's $0.00 is marginal cost only; its free floors ride on subscription compute the benchmark below prices at list. Crawford's two rows here are its pre-fix numbers, measured the same day as everyone else's — the 34-of-39 run from the previous section came after the fixes this trap taught, so it doesn't get to sit in this table. And at this sample size, the gaps between the good tools sit inside the noise — which is the next section.

Why nobody gets crowned

I had the victory post drafted — a dollars-per-right-answer column with Crawford's answers coming in 16 times cheaper than OpenAI's. Then I ran the same adversarial review on my own scoreboard that Crawford runs on its own output, and three flags killed it.

The best composed number was circular: I'd picked Crawford's escalation partner by watching it ace those exact 12 rows, then scored the pair on the same rows. The $0.00 wasn't the whole bill: Crawford's free floors ride on subscription compute, while every rival was billed at list — two accounting systems in one column. And 39 rows can't separate good tools: when I later ran the proper statistics on a bigger draw, no two tools on the board were distinguishable, and that math was right about the 39 too.

Every incident above survived the review — the parked pages, the Montana twin, the daily cap, both of Crawford's misses. They're dated, hand-verified, and sitting in a committed run directory. The ranking died. What replaced it is the last section of this post.

Where the rivals win today

The incumbents beat Crawford on real dimensions, and pretending otherwise would fail the same review:

• A spreadsheet a non-engineer can drive. Clay's UI is the reason 84% adoption happened. Crawford is dispatched from Claude Code — my RevOps friends don't live there. Yet.

• CRM writeback. Clay lands enrichment in HubSpot or Attio automatically. Crawford ends at a CSV.

• Pay-on-delivery waterfalls. Clay's contact waterfalls bill only when a provider actually delivers. Crawford writes down its spend but doesn't yet route on pay-per-hit versus pay-per-attempt.

• Watching for changes. Parallel and Exa both sell re-research when something changes. Crawford runs batches; it doesn't watch.

• Calibrated confidence. Parallel publishes evidence that its confidence scores mean what they say. Crawford's are self-reported — its harness generates the data to check them, and nobody's drawn that curve yet.

• Speed. The rivals answer in seconds, fast enough for inbound triage. Crawford is built for batch depth, and a hot lead won't wait for it.

• Hostile websites. The proxy infrastructure that gets past bot-blocking sites is real, and Crawford doesn't have it.

• Someone else keeping score. The rivals get benchmarked by third parties. Crawford's only tests so far are ones I ran myself.

That last line is the setup for the ending.

Blueprint Bench: performance per watt, scored

I went looking for the benchmark I should be citing instead of my own. I tried to trace the flagship accuracy numbers three major vendors publish; none of the three led back to anything checkable. Web-research agents get measured on essay-writing benchmarks. Nobody scores them on a med spa's website — the questions GTM teams actually pay per-row to answer.

So I'm building Blueprint Bench: the per-dollar benchmark for GTM web research, with answers verified by paid human panels and zero favors for the house.

• A thousand fresh questions every quarter — ten question types, drawn live from public registries days before the run, so no model can have memorized them. Is this the business's website. Is this domain alive or parked. Who runs this org today. Does this person still work there. Whose email is this.

• Every answer findable on the open web. Only one single allowed gated source for B2B profiles. Licensed private datasets are banned as questions and as truth.

• Each question type carries its own named trap — the failure that costs real money: shipping a parked site as live, naming the previous chief instead of the current one, pattern-guessing an email nobody published, merging two people who share a name.

• Truth comes from two panels of paid humans who never see each other's work. One panel judges the documented evidence. A separate panel researches every question blind, from scratch, no hints. A fact enters the key only when both panels and the machine derivation agree — and where the two panels disagree, that gap gets published too, because it measures how much evidence-framing sways people.

• The house plays by visitor rules. The answer key's digital fingerprint posts publicly before any tool runs. Crawford's configuration is frozen and fingerprinted before the questions are even drawn — anything I tune after seeing results waits for the next edition. Every scored vendor reviews its own rows before the board publishes. Retired editions are open-sourced in full, with tripwires that expose anyone training on them. Crawford competes; it never referees.

• The headline metric is Total Cost to Clear — the performance-per-watt number: what it takes to get 1,000 rows actually finished. The spend, plus a price on every wrong answer, plus the cost of routing every held row to something that can close it. Crawford's subscription compute gets priced at list like everyone else's. A free tool that ships poison stops looking free.

Where it stands: the harness is built and passes its 123 automated tests. A 54-row pilot has been drawn, keyed blind, and run against three cheap tools — total contestant spend, $1.08. The trap machine already works: one drawn business's domain expired two days before the draw and now serves a parking page, and two of the three tools handed it over as a live website. One fire department's chief can't be named from the entire open web — the roster literally reads "Chief Unknown," with two plausible wrong names one town over, waiting to be guessed. The blind human panel has come back: on all 13 rows where both hired researchers committed an answer, they matched the machine-built key, and the two rows humans got wrong both validate the traps. The evidence panel is still in its vendor's review queue. Crawford has not been scored on any of it.

And the early numbers cut against the house: on the small pre-Bench data, the best buy on the board is a rival's cheap tier, and pricing Crawford's subscription compute at list can only move Crawford's costs up. Crawford enters its own benchmark as the challenger. If it wins, you'll watch it earn that quarterly, on fresh questions, under a key it can't touch. If it loses, you'll see that too.

First full edition — all ten question types, the full board, Crawford included — is next. Estimated cost to produce: $400–580. Then every quarter, fresh.

— Written by Claude Fable 5, Approved by Jordan

Who Gets This

Above this line: the story — the market, the machine, the trap, and the benchmark. Below it: the exact build — floor by floor, rule by rule, formula by formula.

• Free: the story you just read.

• $50/mo (most readers start here): the build mechanics — every rung of the ladder with its real thresholds and tools, the adjudication rules, the answer-key harness and its grading formula — plus the Bench internals: all ten question types with their named traps, the two-panel truth pipeline and its consensus math, the neutrality mechanics, and the metric Crawford has to win.

• $2,499/yr: Every tool I ship. Edge Copilot is how you talk to all of it through Claude Code. Current tools: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep, Blueprint Playbook, Crawford. Whatever ships next is included. Plus all 3 courses + weekly office hours.

Read more

Every revenue team bought the same AI. So everyone sends the same email — same opener, same "saw you're hiring," same "congrats on the raise."

Here's the thing about average. AI is a machine for producing it. Feed it the prompt everyone feeds it and you get the same competent, forgettable paragraph everyone gets. Average is free now, and nobody reads the floor.

What gives you the edge is what you know about a buyer's situation — and about the competitors circling them — that they can't see for themselves. So I built a tool that goes and finds it.

What it does

You hand it one company's website. It hands back a GTM playbook — who to target, the public data that proves they're in pain, and the messages to send — in about twelve minutes.

Here's a run, start to finish. Say you sell safety-compliance software, and your buyers are plant safety managers.

• It reads your site and works out what you sell and who feels the pain.

• It goes hunting for public records that prove a plant is in trouble right now — and lands on OSHA's enforcement data. Every serious workplace-safety violation a U.S. employer gets is public record, with an inspection number, a date, a violation type, and a dollar penalty.

• It builds a segment the list-sellers don't have: plants the government cited for a willful or repeat violation in the last ninety days — the exact thing your product prevents.

• It drafts the outreach — a message that names the inspection, the date, and the penalty, and hands the reader something useful about it without asking for anything back.

• It shows the math behind every number it used.

That's the shape. You give it a URL; it gives you a play grounded in a record the buyer can click.

A few it's already built

The safety example up top is illustrative. These are real. Point it at a real company and it does real work — hundreds of these are already public. Here are ten, each grounded in a public dataset you can go check yourself:

• Fiserv — FDIC enforcement actions, CFPB complaints, and FFIEC deposit data to find ZIP-level customer-underservice gaps.

• Everlaw — PACER federal court records to flag privilege-log gaps before opposing counsel does.

• BeyondTrust — the HHS breach portal to reach healthcare facilities right after an insider breach.

• Vantage Risk — EPA violations and OSHA serious-to-willful reclassification deadlines for oil & gas risk.

• ArrowStream — 130,000+ restaurant purchase orders and state health inspections to show distributors their pricing gaps.

• DoorLoop — HUD inspection scores and expiring housing contracts to find failing affordable-housing properties.

• Deenova — CMS infection metrics and state sterilization citations to surface hospital instrument-tracking failures.

• ComplyAuto — OSHA Establishment Search and FTC Safeguards breach data for dealerships nearing a willful violation.

• AGRIVI — the FDA Food Traceability List and USDA data to reach farms against FSMA deadlines.

• CHA Consulting — FTA grants and EPA water-permit data to find transit and water utilities with budget gaps.

Different industry every time. Same move: a public record nobody else bothered to read, turned into a reason to call.

Want one for your own company? Generate it at playbooks.blueprintgtm.com — or browse the rest by industry while you're there.

Why this works when "punchier copy" doesn't

Most people aim AI at the email — make it sharper, write ten variants. That's polishing the floor.

The records are where the edge is. Court filings, regulatory orders, permits, license actions, inspections, government data job by job — all public, all sitting there. No human can read all of it. AI can read thousands of those records, find the three that matter, and pull the exact number, date, and dollar figure that proves the pain.

When you know exactly who's in pain and can prove it with a record, the words barely matter — but you still have to write them.

I built it to sound plausible. Don’t believe AI’s bullshit.

The engine is built to produce very plausible output. So the messages it drafts look finished. They aren't.

The engine nails the targeting — the right segment, the real record, the proof. Then it drafts the outreach, and the draft reads like a robot reading the database back to you. Specific, competent, lifeless.

So the draft is a starting point. You take the angle to a real customer who lives in that pain and ask them if it lands. Then you write the note yourself, like someone who actually understands the situation.

The machine manufactures the playbooks. You still evaluate them and write the message. That last mile is yours.

You can run this engine yourself now

I've been a Clay advisor since 2020, and for years my team built these plays by hand for clients. We packaged the method into a tool.

Give it one company's website — yours, or an account you want to land. It runs the whole pass: reads the site, works out who they sell to, scans public records across fifty-plus sources, scores the segments against the same gates we use internally, and drafts two pain-qualified messages and two permissionless-gift messages — each with the math behind every number.

The first door is done-for-you. Go to playbooks.blueprintgtm.com, type in a company website, and a full playbook comes back in twelve to fifteen minutes. It's $49.99. One company, one time. No subscription, no account to babysit.

The second door is for people who want to run it again and again — and who want to see exactly how the engine decides what's real. That's below.

— Written by Claude Opus 4.8, Approved by Jordan

Who Gets This

Above this line: what the tool does, and why pointing AI at public records beats sharper copy. Below it: the full run, step by step, on a worked example — and what a finished play actually looks like.

• Free: what it does — the public records it pulls, how it turns them into a segment, and why the draft copy still needs you.

• $50/mo (most readers start here): the whole engine on one example — how it locks the problem, builds a niche with a data moat, lists the exact record fields it'll use, grades its own confidence, scores a message the way the buyer would, and the anatomy of a finished play with the worksheet behind the number.

• $2,499/yr: Every tool I ship. Edge Copilot is how you talk to all of it through Claude Code. Current tools: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep, Blueprint Playbook. Whatever ships next is included. Plus all 3 courses + weekly office hours.

Read more

A talk I recorded on camera. Video above. Below is the transcript, lightly cleaned — my words, not a rewrite.

Chapters

• 00:00 — The only thing AI is for in go-to-market

• 01:03 — Structure and connect all your internal data

• 02:10 — Find the public signal that predicts a closed-won

• 03:13 — The go-to-market no competitor can copy

• 04:18 — Attack the truth from multiple angles

• 05:20 — Thin messages come from thin context

• 06:21 — Information is useless without action

• 07:23 — Understand better, act better — that's the ballgame

• 08:24 — July 22, San Francisco (Gradient Ventures)

You like how I just went on camera and said, fuck it, I'm not going to do anything with my hair. Today I want to talk about the only thing that AI should be used for in go-to-market. I feel pretty strongly about this. It causes us to look back at fundamentals — what matters to us — and it lets us frame the value in a different way.

There are two fundamental values of AI. The first is to understand ground truth — what is actually happening with your customers. Forget the market for a second. And there's a hierarchy to that truth. There's what your team knows — least valuable. What the customer said — second least valuable. And most valuable: what the customer did. What are they actually doing in your app? This is a progression closest to dollars, closest to truth.

When people vote with their wallet. (I was trying to find my wallet — but I don't have it. I'm in a post-money world.)

So the very first thing you do with AI is go structure and connect all your internal data. Use Claude Code, Codex, whatever, to do it. I create things called customer dossiers. If you're a yearly subscriber to On the Edge, you get access to Edge Copilot, which has this skill built in — you can just say, help me with this. This is the most important piece: making sure your data is right, validating it, connecting it, and putting it all on a timeline. The timeline is really important. Where did the customer come from? What did they say on all the calls they've ever had? When did they become a customer? What did they do? What do the CS calls look like? You have that, and you can just ask questions. You don't have to guess — "well, in the market, here's my ICP." You can literally use a statistician — a Claude Code statistician — and say: go look at the public market and benchmark it against my internal data.

Look at closed-won and closed-lost deals — everything they ever said, everything they ever did — and then go online and see if you can find a statistically defensible piece of information that lets me identify what a closed-lost or a closed-won non-customer looks like in the public.

Then you say: great, now reveal all the truth. Do one session to put all this stuff together. Then say, hey Claude, go put these in cohorts. Clear the session and say: I want you to look at these two cohorts now and figure out why they might be right for my product. Then merge them together — don't tell Claude which is which. And you should probably be using Parallel.ai or Exa.ai as your search agent. Do not use the built-in Claude search agent. You do that, and Claude comes back and says, well, this is the thing that held up. And by the way, you can embed intelligence from the calls and their actions —

look at how they do payments online, or look at whether they lost a big client, or whatever. The raw intelligence from the first call — ideally the first call, maybe other calls. Then you understand what no competitor can. Where are your customers, and which customers are voting with their wallet?

Once you do that, you know how to build your TAM. You know how to structure it based on why people actually choose you. And this is defensible — because your competitors are going after your TAM too. But if you know why you close customers, and the public data that indicates why they're good fits, suddenly you know where you should be targeting and what to say. Because you have a strong understanding of the people who actually voted with their wallet — who, on statistical analysis, don't hold up against the closed-lost set. That's your full go-to-market. That's it.

So the very first thing you do: put all your customer actions and voices on a single timeline. Then ask Claude to run some tests as several sub-agents against closed-won and closed-lost. Blend the two. Remix it a couple of ways so Claude can say, okay — looking at it from these four lenses. One lens: only look at closed-won and closed-lost in separate agents. Another: blend them. Another: sort this by topic and go investigate those topics. If you have Claude attack this from multiple angles, it can say: the thing that has stood up under scrutiny, from multiple angles, is X, Y, or Z. Then you know what you're looking for.

This is what AI is good for. Understanding ground truth — what customers said and what customers did. We don't do that today. And then matching that ground truth to market data — structuring whole worlds of data by meaningful dimensions, which is actually why your customers vote with their wallet.

This is what "what the customer said" actually sounds like. Real calls from customers of companies I work with — every name, company, and identifying detail stripped out. The words are theirs.

All this stuff we're doing to point AI at the market — the reason the messages are so thin, the reason you wouldn't reply to the messages your reps are sending — is that you can't come to any one of those prospect interactions and give the prospect more valuable information than someone from the market who doesn't have all your intelligence. And if that's the case — if your targeting, your messaging, the way you go about your market doesn't involve any information from your actual customers — why bother?

You cannot point AI at something with thin information. That's why you need to build up your layer cake of context. First, make sure the ground truth is good, the data is good. Then compile it. Then go test it. Then go validate it. And suddenly everything multiplies. Once that's the case, everyone works in a shared repo to build on top of — you have a foundation to do your go-to-market. The next person gets compound value. They can talk to all the context in your whole system. They don't have to worry about data quality. They don't have to worry about whether it's put together the right way. They don't have to worry about whether the analysis is done right — because it's been battle-tested.

The last thing I'll say: people love to think about AI as gathering information. But information is useless. Information is useless without action. If you know something and you aren't prepared to act on it, it doesn't impact anything. The purpose of good information is to drive better action, at a faster clip — to evaluate whether that action made an impact, and to improve fast. Once you've gathered all the information you can, you can't stop your AI go-to-market efforts there. You have to work backwards from: if I'm going to test this churn hypothesis, if I'm going to test this top-of-funnel hypothesis, if I'm going to test this upsell motion, if I'm going to test this churn reduction — how do I test it quickly and get feedback quickly, and iterate? That's the whole ballgame.

If you don't begin with the customer, if you don't begin with their insight, if you don't begin with things that are actually ground-true — that people voted with their wallet for — then why are you using AI in the first place? Just go do the same bad thing you've been doing for decades. The purpose of AI is to better understand, to better act, and to validate that those actions actually matter. That's it. Go do that, in that order, and you'll be surprised at the results you find. If you can better understand and better act — if you do those two things, as a go-to-market leader — that's the ballgame.

I'm going to be building on stage on the 22nd — July 22nd, here in San Francisco, 2 to 6:30pm at Gradient Ventures in downtown San Francisco. Come join me. We're going to pick a founder from the crowd, and I'm going to show you how quick and fast and wonderful and easy this is — and how the only weapon you need is a good framework, your voice, and access to a $200-a-month subscription. That's everything.

Thanks so much for watching. I've heard beautiful, wonderful, kind comments from my yearly subscribers, from my monthly subscribers, and just from people on the internet. I'm so grateful that you spend your time and attention here, watching and learning. I want to congratulate you for being on the edge — for educating yourself about the very latest tools and technologies in the go-to-market engineering space. There aren't many people like you. So thanks. Bye.

— Written by Claude Opus 4.8, Approved by Jordan

What Annual Adds

This one was free. Paid gets the build. Annual gives you the tools that run it.

• Every tool I ship. Edge Copilot installs to your Claude Code — talk to all my knowledge, every method, every data source. Current: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep, Blueprint Playbook. Whatever ships next is included.

• All 3 courses: Who to Target and What to Say, Agent 7, AutoClaygent.

• Weekly office hours.

Run /edge install dossier-builder once your license key arrives — the customer-dossier skill I mention in this video drops into your Claude Code in one command.

License key hits your email.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Somewhere there's a post that says there are only twelve real marketing channels.

I don't even remember where I saw it. But it stuck, because it can't be true. Twelve might be the menu. They are not the answer for any one buyer. So I sat down and built a tool to find the real answer — for any market — and recorded the whole thing.

The premise: point it at a market — lawyers, home services, dentists — and it hands back a ranked list of the best ways in. Not the twelve we all know. The specific channels where those buyers actually pay attention, what each costs, why it's the bet, and how to test it cheap.

Most channel advice starts from the channel. Meta, LinkedIn, SEO, a conference — pick one, go. That's backwards. You should start from your channel experiments of the past and market exploration of ways to reach your buyer.

Build the picture in concentric circles

The first thing I told it: don't start from the channel. Start from the buyer, and work in concentric circles.

Innermost — world knowledge. Before anything, go learn the buyer. If it's lawyers: where do they gather, which associations run their world, what do they have to do every year to keep their license. That grounds everything after it.

Outward — market wisdom. Someone has already tried to sell to these people. Find the case studies. Find the marketers who target this exact buyer and read what they did. There's wisdom in markets — if every competitor sponsors the same conference, that conference matters.

The other direction entirely — the buyer's own voice. Work backwards from what real buyers have said: where they first heard about a vendor, the words they use. I've mined recorded sales calls for exactly this before; it's some of the best signal there is, and almost nobody does it.

Three ways of looking at the same market, each strongest at a different job — and I had them argue with each other.

The part I couldn't stop thinking about: where are they forced to be?

While I was building this, I dropped the same question into ChatGPT and Claude and used them as sparring partners. I do this constantly — it's a cheap way to surface the thing you didn't think to ask.

And one of them said it. Internet data misses the channels that matter most — local reputation, referrals between attorneys, the places lawyers are required to show up.

That's when it clicked, on camera. Lawyers have to earn continuing-education credits every year. They pay dues to a state bar. They file through systems they can't opt out of. Nobody lists "continuing education" as a marketing channel. But every single lawyer has to be there.

So I made it a principle, not a legal trick: for any buyer, where are they legally or ethically compelled to show up? When your buyer is required to be in a room, that room is the best channel you've never bought. That's the alpha — underpriced, high-trust, and everyone else is looking past it.

Wide first, then deep

Here's the order I made it run.

First, breadth. There are maybe ten to fifty channels you should always evaluate — paid search, Meta, LinkedIn, Reddit, email, partnerships, associations, podcasts, newsletters, conferences, the lot. Pull them all, judge nothing yet. Then a second, smarter pass that hunts for the channels the checklist would never name — driven by questions about your specific buyer: where are they compelled to be, who do they trust, where do they go looking when something breaks.

Only then does it go deep — pressure-test the contenders, find the real audience size, the real cost, the real contact, and cut the long tail.

Most people skip the wide pass. They optimize the one channel they already picked. That's how you miss the cheap attention nobody else has found.

How it actually runs

Under the hood it's a swarm of Claude agents at once. One group studies how other people have solved channel discovery — before it ever looks at my own tools, so it isn't anchored on what I already have. Another group argues about how to build the buyer picture. Then one agent per channel, each hunting for hard proof: is this really where these buyers gather and trust? A second set of agents checks that work, a verifier signs off, and only the conclusions come back to the main agent — so it never drowns in detail.

And the score is not the AI's opinion. Each agent gathers the evidence; code turns it into the rank, from a fixed scorecard of eight things — how tightly the buyer clusters there, whether real buyers say that's how they found you, whether customers from that channel actually stick around, how contested it already is. Same evidence in, same number out, every time. It can't drift on a mood. It also won't trust a link until an agent has opened the page — the real group with its member count, the real sponsor page — not a homepage that looks right.

The real test: make it rediscover what I already knew

Here's the rule I set, don't bake in the legal answers. Bake in the thinking — "where are they compelled to be," "who do they trust" — then run it on lawyers and see if it finds the answers on its own. If it doesn't, the principle is wrong, not the lawyer.

So I ran it twice. Once knowing what I knew. And once cold — a blind pass with the buyer profile stripped of every answer I'd fed it.

It found them. On the cold pass it named the state bar, mandatory continuing education, the practice-management software lawyers live in, and the peer groups where they actually talk — on its own. The compelled-channel idea I'd only just had on camera, it rediscovered from first principles.

All in, it scored 330 channels and ranked them. 31 came back genuinely underpriced. 27 were openings the business wasn't using at all.

None of it came clean on the first run. Running too many of the heavy checking agents at once kept tripping a rate limit, so I throttled them. The first links it handed back looked right and were wrong — a "real" Facebook group that was the wrong group, a subreddit that resolved to a dating board — so I made it open the page and prove the link before trusting it. And it kept giving me bare names: a person, no title, no reason to believe them. Useless. So I made it find the actual role, a real contact, and a Monday-morning next step for every channel. A ranking isn't a deliverable until every line is something you can do.

Lawyers were just the guinea pig. Next I point it at a market that has nothing to do with law. If it holds up there, it graduates.

— Written by Claude Opus 4.8, Approved by Jordan

The whole build is below — about 26 minutes of me thinking out loud, using two AI models as sparring partners, and shaping the plan in plain English. Then the part every channel guide skips: exactly how the tool scores a channel, the eight tests it runs on each, and how to install it and point it at your own market.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

Well, hello. Good to see you.

There's a line I keep coming back to. William Gibson, early '90s: "The future is already here — it's just not very evenly distributed."

AI is the same. It's here, and it's unevenly amazing. The best place you can stand is in the future, at the top of the peak.

TL;DR: A job is just a collection of tasks, and AI is jagged — incredible at some of those tasks, useless at others. Most people approach their AI transformation by working backwards from the jobs they already have. Flip it. Start from the impossible thing you'd do with a magic wand, then work back to what has to exist to make it real — on the sharpest tools that exist. That's where the value hides.

A job is just a collection of tasks

I said this on the podcast with Kyle Norton a couple months ago: a job is just a collection of tasks. And AI is jagged. Amazing at coding. Can't tell you how many r’s are in strawberry or how to get your car to a car wash (just walk if you’re close, it says).

Some of those tasks you should never hand to AI. They're human judgment, and they stay yours.

Donald Rumsfeld had a framework I love (I like the framework not the bombing of Iraq): there are known knowns, known unknowns, and unknown unknowns. The tasks we know about, we can sort — is a human better at this, or is the machine? That's what forward-deployed engineers do when they study your job. They ask what they can take off your plate to give you time back.

But the real prize is in the unknown unknowns: the task that only the very peak of a jagged AI edge can do. Nobody's mapped it yet, because nobody could do it before.

Live at the top of the peak

The future is here and it's unevenly distributed. AI is here and it's unevenly amazing. So stand in the future, at the top of the peak.

That's how I've built my whole business since Claude Code. I don't like being tied to a tool — tools come and go. But this agentic way of working isn't going anywhere.

The edge is the meeting point of two peaks: the very latest in AI — the best model (Opus 4.8 today, Fable soon, hopefully), the best harness (Claude Code in the terminal), the best tools — and the most imaginative use case you can point it at.

What AI is still bad at

I got a message on Substack today. A guy with 300 followers wanted us to recommend each other. Here's part of what he wrote: "I came across your Substack and really like your approach to AI and go-to-market. Your focus on sharing actual use cases and practical tools people can use Monday stands out in a space that often gets lost in theory."

The thing is, what he's saying isn't bad. A person could have written that. But it's so AI-coded.

You won't get much out of these models by asking them to write better in a box. That's not what they're great at. Taste, judgment, knowing what's worth saying — still yours.

What AI is incredible at

Now here's what they're amazing at: sorting the world.

I took 16,000 fire chiefs and asked who has the most influence. Who's the most well-known nationally? In Pennsylvania? In California? Who has associations with other software vendors? Who actually shapes the standards your software has to live up to?

I attacked that from multiple angles and ranked all 16,000. About 400 came out the other side. If you were going to give equity in your company to one person in this market, this is the one — and here's exactly why. They open the doors. They influence the standards that govern your product.

You could never ask that question before. That's the kind of thing AI is incredible at.

The two questions

So when you think about your AI transformation, ask two things:

• Am I using the very latest tools and capabilities?

• What are these tools — Claude Code, Codex — incredibly amazing at, and how does that capability fit my problem?

I hate tool-forward thinking as a general matter. But this is such a step change that exploring the tool is the only way I know to find the creativity you need.

Work forward from the magic wand

Here's the inversion. Don't work backwards from a job. Don't work backwards from a task. Work forward from the impossible action.

If you could wave a magic wand, what would you wave? Then ask: what has to exist to make that real? You start to see you're not so far off.

I worked with a client who kept asking about churn. Who's churning, why, what are people saying — over and over. A reasonable place to begin. But there's a better question than why. Ask: what's the lightest lift for the highest value, which customers are in that exact spot, and can I test it tomorrow?

It doesn't even matter if the model is wrong. If you never try to change anything, you'll never know.

Use the sharpest tool

And use the latest tool. When I hear someone say they're using Claude Cowork, I say stop — it's not nearly as powerful as the terminal.

Claude will quietly set you up on Sonnet, too. You open it and you're on Sonnet, low effort. Change it to the latest Opus 4.8 and crank the effort to the top. Do it in Claude Code.

Then begin from the action. What would I need to know? And what action would have the biggest outcome?

You don't need the best model for everything

I read a post from a team that had been paying six figures for Claude and got excited about a great open-source model. I think the approach was wrong, but the intuition was right: you don't need the latest model to do everything.

What you need is tranches. You divide the work.

Split the work into tranches

I was finding the technologies a company runs. How are we detecting that? We read the HTML. So I asked — can we just download the whole website locally? Sure. What does that cost? Nothing for 80% of sites, because they're not behind Cloudflare. I can pull the whole thing for $0.

So half the job is free. The next slice is harder — maybe a little AI here. Then there are problems that need the very best intelligence, some that need none, and a lot that sit in between.

Divide your problem into that gradient and you can point near-free tools at most of it, and the expensive intelligence only where it earns its keep. Low cost, a lot of output.

Open your eyes

So that's the lens. Don't work backwards from a problem, a job, or a task. Start from the biggest form of your imagination. Figure out what that is, then work back to what has to exist to make it happen — and make sure you're on the very latest tools to do it.

Once your eyes are open, you can't close them again. It changes the way you work.

Have a beautiful Monday. Thanks for letting me ramble.

Chapters

• 00:00 — The future's here, just bunched up at the edge

• 01:07 — A job is a collection of tasks, and AI is jagged

• 02:12 — Live at the top of the peak

• 03:19 — What AI is still bad at

• 04:24 — What AI is incredible at: ranking 16,000 fire chiefs

• 05:26 — The two questions to ask

• 06:29 — Work forward from the magic wand

• 08:35 — Use the sharpest tool: Opus 4.8, in the terminal

• 09:40 — You don't need the best model for everything

• 10:43 — Split the work into tranches

• 12:46 — Open your eyes and you can't close them again

What Annual Adds

This one was free. Paid gets the build. Annual gives you the tools that run it.

• Every tool I ship. Edge Copilot installs to your Claude Code — talk to all my knowledge, every method, every data source. Current: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep. Whatever ships next is included.

• All 3 courses: Who to Target and What to Say, Agent 7, AutoClaygent.

• Weekly office hours.

Your license key installs /edge in one command — then every tool above drops in on top, each one a /edge install away.

License key hits your email.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

I'm not an engineer. I run an AI that writes code, builds lists, digs through public records — and before it does any of it, it shows me a plan and asks, basically, "good?" I say good. It goes.

That little "good?" is the most important moment in the whole thing. It's the contract. It's me signing.

And for a long time the plan I was signing looked like a parts catalog. A wall of file names, settings, and command lines. The engine bay, not the dashboard. I'd skim it, not really understand it, and say "good" anyway.

You've done this. We all do this. We rubber-stamp the thing we can't read because the machine seems confident and we're busy.

Rubber-stamping a plan you can't read is like signing a contract in a language you don't speak because the other side smiled. Most of the time it's fine. The one time it isn't, it costs you.

This month, it almost cost me about $700.

What is plan mode, and why does the plan matter more than the code?

Plan mode is the step where the AI shows you what it's about to do before it does it. For anyone who can't read code — most founders, most revenue leaders, most buyers — that plan is the whole surface you get to judge. Read the plan, catch the mistake. Can't read it, and you're trusting the machine on faith.

So the plan is the product you're actually approving. You'll never look at the code. The plan is where you either catch the problem or sign it.

Can you trust AI coding agents?

Not on faith. You can't trust the code if you can't read it, and most people can't. What you can trust is the plan the agent shows you first — but only when it's in plain English and its numbers add up. People are asking this out loud right now: "Can AI agents be trusted?" is a live question on Google as of June 2026 (DataForSEO). The honest answer is that you trust what you can check, and the plan is the only thing most buyers can check.

So I changed the plan. I taught my AI to write the thing it asks me to approve like a newspaper brief instead of a parts catalog. I call it Plain Plan Mode. Four things make it work:

• Plain English, ninth-grade. Short sentences. If a 12-year-old couldn't read it aloud and know exactly what they're approving, it gets rewritten until they can.

• A real "how," in plain words. It still has to tell me the method — which tools, wired together how — but it names a tool the way a newspaper would: "a web-research engine built for AI," not its insider code name. I approve the method, not a mystery.

• Five little symbols, each meaning one thing. What you get. What it costs. A warning. A question for you. Your move. Your eye learns them in one read and routes itself.

• An honesty rule on every number. This is the one that saved me.

What's the real risk of letting an AI build for you?

The dangerous mistake is the plausible one — a confident, clean, wrong number you approve because it looked right. You'd catch an obvious error. This kind wears a tidy headline and slides straight past you.

Here's the honesty rule in plain terms: if two numbers in the plan multiply into a third, they have to agree. Per-item price times the number of items has to equal the total. Sounds obvious. Machines break it constantly, because they write the headline and the line items in different breaths and never check them against each other.

While I was testing Plain Plan Mode, a sample plan headlined its cost as "$50 to $75." Cheap. Easy yes. But down in the same plan, the per-item price times the number of items came to about $700. Roughly ten times the headline. The AI had written both numbers itself — and never noticed they disagreed.

The rule caught it. The plan got bounced back and rewritten before it ever reached my "good?" On a real run, that's the gap between a fifty-dollar yes and a seven-hundred-dollar surprise on a card.

And these aren't toy jobs. Earlier this month I cleaned 1.34 million public franchise location records down to about 60,000 real multi-unit operators — the kind of list that's worth real money — where the final step is a small paid look-up on every single row. That's exactly the shape of plan where a quiet cost error hides: a cheap headline sitting on top of a big job. You'd approve it. I almost did.

How do you review AI work when you can't read code?

You stop trying to review the code and you make the plan reviewable instead. A plan you can read is a plan you can argue with. When the plan is in plain English, names its tools in plain words, and proves its own numbers add up, a non-engineer can do the one thing that actually matters: spot the thing that's wrong and say "wait."

That's the whole game. The AI got faster than any of us can check by hand. So you force it to show its work in a language you speak — and to prove its own math before it asks you to sign.

I built this for myself because I sign these contracts every day. Then I made it the default for everything I do, and shipped it. The before-and-after isn't subtle: the same job, once a wall of jargon I'd have waved through, now a half-page brief that catches its own lies.

The plan is the contract. Make the contract readable, and you stop signing things you can't see.

(If you want the deeper version of this idea — manufacture more information about a situation than the other side has, then hand it over plainly — it's the same instinct behind the Asymmetry Engine.)

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the plan style I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

An advisory board is supposed to do work. Open doors you can't open yourself. Give you air cover when you walk into a deal. Lend weight to your name in a market that doesn't know it yet.

Most boards get assembled from the people the founder can already see — three friendly customers, an investor's buddy, the advisor who said yes fastest. You put the headshots on a slide, hand over a little equity, and the board sits there. The people are fine. They just don't move your market, because the people who move a market are mostly people you've never met.

So the move is to go find them. Score an entire industry's influence graph from the top down, rank the people who actually shape what the market buys, and build the board from that list. I built the machine that does it. Here's the method on a real run, then the recipe.

Who actually shapes what your industry buys

The question that builds a real board is about the market. Who sits on the standards committee that writes the spec your product gets measured against. Who chairs the association whose endorsement opens a hundred doors. Whose column every buyer in the category reads on a Tuesday morning.

Pharma and medtech marketers have a name for these people: key opinion leaders, or KOLs — the handful in any market whose voice moves what everyone else buys. Most industries have KOLs without using the word. The usual KOL list ranks the obvious names: the big titles, the famous brands, the people you'd reach for off the top of your head. Score the whole market properly and the real ones surface. The real ones are exactly who belongs on your board.

You can know who they are, better than the market knows it about itself. That's the whole move.

The asymmetry, pointed at relationships

I write a lot about manufacturing more information about a buyer's situation than the buyer has, then handing it over as a gift. People usually apply that to outbound. It works just as well on the question of who to build a relationship with in the first place.

A market's influence graph is public — it's just scattered. Association board rosters. Technical standards committees. Conference keynote lists. Trade-press mastheads. Nonprofit tax filings that show who sits on which board and at what scale. Archived bios that reveal a role someone quietly scrubbed. None of it is hidden. It's annoying to assemble by hand, so assembling it is an edge. That's the thing I built.

Score the whole market, not your contacts

You score the whole market, not the slice you already know. The people you know are a biased sample — they're the ones who already talk to you. The influencers worth recruiting are mostly the ones you've never met.

So you go top-down. Take the whole geography of a market. For a US run, that's the 50 states plus DC. Region by region, you ask one open question: who are the most influential people here? You point a research agent at each region with real tools behind it — a web-research engine built for AI, a cited-answer research service, public nonprofit filings. Each agent comes back with a short, sourced list of the market-shapers in its patch. You merge them. Now you have a draft of the influence graph for an entire industry, built from authoritative sources instead of from your CRM.

Then you score it.

Influence is sparse

I ran this for a company that sells software into a regulated public-safety market. The named universe was about 16,000 people. I scored every one against eight dimensions of real influence: association leadership, government and standards advisory, vendor roles, speaking, authorship, credentials, the scale of their platform, and their reach among peers. Exactly 441 cleared a meaningful influence bar.

Less than 3%.

That number reshapes the whole approach. Ranking everyone flat wastes most of the budget on the 97% who don't move anything. So the work is a funnel: triage cheaply, then spend the expensive, careful research only on the slice that might clear the bar. And when you find the real influencers, there are far fewer of them than the market pretends — that scarcity is exactly what makes knowing precisely who they are worth so much.

Title is a separate thing from influence. A chief of a giant department who never speaks, never writes, and sits on no board moves the market less than a retired chief who chairs a national committee. The model scores the seat, the byline, the board, the dated and documented role. The size of the org on the business card counts for very little.

Capture: the best name is often already taken

A plain "most influential people" list will quietly ruin your board.

In that run, the single highest-influence person in the entire dataset was already on the payroll of a competing software vendor. A past national-association president. A textbook author. The kind of name that opens any door in the industry — and completely unavailable to you. Rank by raw influence and you'd spend months courting the one person guaranteed to say no, handing a competitor a look at your roadmap on the way.

The same pattern repeated across the top of the list: a standards-committee member who was a named spokesperson for one competitor, a state-association officer who turned up in a competitor-sponsored conference session. Great intelligence. Wrong board picks.

So influence alone is the wrong score. You need two more axes.

Influence × independence × recruitability

You rank each candidate by multiplying three numbers.

Influence. How much they actually shape the market, scored from evidence, not titles.

Independence. Whether they're already captured. You find every software and vendor tie a person has, then check it against your own list of competitors. Someone employed by, advising, or speaking for a rival is competitive intelligence, not a candidate.

Recruitability. Whether you can realistically win them. A retired past-president with time on their hands and no exclusive ties is a very different prospect from a sitting executive locked to a competitor.

Multiply, don't average — that's the point of the design. A near-zero on any one axis tanks the whole score. The captured legend with influence 0.93 and independence near zero multiplies down to nothing and drops off the board shortlist, landing on a separate competitive-intel list, which is exactly where that person belongs. The retired chief with strong influence, full independence, and time to give rises to the top.

What comes out the other end is two lists. A board shortlist — the independent, recruitable, genuinely influential people, each with the evidence for why they matter and the angle for how to approach them. And an intel list — the high-influence people your competitors already locked up, which is its own kind of gift.

One is a logo collage. The other is a board that does something.

Who Gets This

The method above is the free part. The build that produces those two lists is the paid part.

• Free: the method — score a market top-down, separate influence from title, and catch competitor-capture before you recruit.

• $50/mo (most readers start here): the build below — the exact pipeline, the per-stage tools, the rubric, and the cost discipline that keeps it cheap.

• $2,499/yr: Every tool I ship. Edge Copilot is how you talk to all of it through Claude Code. Current tools: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep. Whatever ships next is included. Plus all 3 courses + weekly office hours.

Read more

The first number the data handed back was a fantasy. It said their webinars had created tens of millions in pipeline. More than the company books in a year. Every webinar looked like a hit. The report was useless. It was counting credit nobody earned.

So I built a webinar performance report that tells the truth. Then I pointed the same engine at my own sales calls to decide what to write next. This post is what it picked.

TL;DR

I built a four-tab webinar report from live Salesforce, ON24, and HubSpot data, in a day, in Claude Code. The hard part wasn't the dashboard — it was attribution. The naive way to credit a webinar (count every deal an attendee touched) over-counts by a mile. The honest way lives in a Salesforce object most teams never open: native Campaign Influence. The last tab answers "what should we run next" by mining real customer calls for demand and checking it against search volume — and I ran that engine on 300 of my own calls to choose this very topic.

The first number was a lie

Here's how almost every webinar report attributes pipeline. Take everyone who attended. Find every opportunity those people are attached to. Add up the pipeline. Call it "webinar-influenced."

That number is garbage, and it's garbage in a specific way.

A person attending your webinar and later showing up on a deal is not proof the webinar created the deal. Half the time the deal already existed. The person was already in a sales cycle, and they registered for a webinar on the side. More than a fifth of the deals this method "attributed" to a webinar were created *before* the attendee ever showed up. You can't influence a deal with a webinar the buyer hadn't attended yet. The median gap between the rest was about three months.

So the method double-counts in two directions at once. One deal gets credited to every webinar anyone on it ever touched. And deals that predate the webinar get scooped in anyway. Stack that across a hundred webinars and you get a pipeline number bigger than the company.

That's the report I was handed to improve. Fixing it meant finding where the truth actually lived — better arithmetic on the same bad data would have produced the same fantasy.

The rollup fields were dead

Salesforce has fields built for exactly this. On every campaign there's a count of opportunities, a count of won opportunities, a total amount. Open them up and you'd know what each webinar drove.

They were all zero. Every webinar campaign read zero opportunities, zero won, zero dollars. Across the whole org, only a handful of campaigns had anything in those fields at all, and the won-dollar rollup was zero everywhere.

A dead field is its own kind of signal. Something else was carrying the real attribution. I sent a second Claude session to find it while I kept building the dashboard. (Two agents, two branches, one report — more on that below.)

The truth was in Campaign Influence

The other session found it. Salesforce's Customizable Campaign Influence was switched on and fully populated — tens of thousands of influence rows, thousands of them tied to webinars. That was the system of record — not the dead rollups, not the contact-role guesswork.

It ships with two ways to credit a touch, and the difference turned out to be the whole ballgame:

• Sourced — the single-touch model. The webinar was the primary campaign on the deal. It gets full credit. This is the conservative, defensible "this webinar drove this deal" number.

• Influenced — the multi-touch model. The webinar was one of several campaigns that touched the deal, each sharing credit. Broader, still native, still honest.

Two numbers, both true, both pulled straight from Salesforce instead of invented on top of it. Sourced is what you defend to a board. Influenced is what you use to see a topic's full reach. The inflated contact-role number didn't disappear — I kept it, but relabeled it as what it actually is: engagement reach, not pipeline. Who showed up around a deal. Never the headline.

That relabel is the whole job. The same rows, told honestly.

The four tabs

Once attribution was honest, the report wrote itself. Four tabs, one dataset, all sortable and filterable, built to be wrong in places so the team could tell me where.

• Webinars — every webinar: registrants, who attended live vs. watched the recording, attendance rate, average minutes watched, email open and click rates, and the native sourced and influenced pipeline beside each one. One row per webinar. Click any column to sort.

• Topics & products — the same numbers rolled up by product line and by webinar type. This is where "fewer registrants, more conversions" jumps out — the small, sharp webinar that out-earns the big-tent one.

• What to run next — the demand engine. Covered below; it's the interesting one.

• Deals — the opportunity lens. Every deal in the last year with real revenue and at least one webinar attendee at the account, expandable to the people who attended and which webinars they sat through. Honest framing: this is reach around a deal, shown next to the sourced number so nobody confuses the two.

What to run next — and the part that's a little meta

The last tab is the one I care about most. It answers the question the team actually asked — what should we run next.

It works in two passes. First, customer demand: mine real sales and discovery calls for the problems people keep raising, in their own words, and rank topics by how often they come up. Second, market demand: take those topics and check what people actually search for. A topic that's high on both is a layup. A topic that's high in your calls but nobody searches is a different, better kind of opportunity — you can own it, because no one's writing about it.

Now the meta part. To prove the engine works without touching client data, I ran it on my own. Three hundred of my GTM sales calls and podcast episodes. A swarm of ten agents read the transcripts and clustered them into the themes revenue leaders raise with me over and over. Then I checked each theme against live search volume.

The two rankings don't match — and the mismatch is the product:

• Reverse-engineer your ICP / go narrow — Calls: ●●●●● · Monthly searches: 1,600 · Verdict: Run now

• Outbound messages they'd pay to receive — Calls: ●●●●● · Monthly searches: 1,600 · Verdict: Run now

• Build a TAM from public data (when the databases don't have your buyer) — Calls: ●●●● · Monthly searches: 10 · Verdict: Own it

• AI agents that research accounts at scale — Calls: ●●●● · Monthly searches: 1,600 · Verdict: Run now

• Score & prioritize the TAM (who to call first) — Calls: ●●● · Monthly searches: 210 · Verdict: Own it

• Prove outbound worked (attribution to pipeline) — Calls: ●● · Monthly searches: 880 · Verdict: Market-led

• AI SDRs — do they actually work — Calls: ●● · Monthly searches: 1,900 · Verdict: Market-led

• GTM engineering (without engineers) — Calls: ●● · Monthly searches: 2,400 · Verdict: Market-led

Look at the third row. "How do I build a list of my buyers when ZoomInfo doesn't have them" is the third most common pain in my calls — and almost nobody searches for it. Ten people a month. That's a topic with real demand and no competition — the people who have the pain don't know the words to Google. The thing your customers struggle with most is rarely the thing they search for. Search rewards the topics everyone already writes about. Your calls reward the ones only you can hear.

The engine put "prove outbound worked — attribution to pipeline" on the list too. Which is the build you just read about. So I'm writing it. The tool picked its own topic.

A note on what this wasn't

Running alongside this, separately, was a different job: the same client had pruned their webinar audience too hard, and we ran a recovery to find and re-qualify the right contacts to invite back. That's real work and it fed the same report's audience — but it's a different machine (contact discovery, not attribution), so I'm keeping it out of this story. It deserves its own.

— Written by Claude Opus 4.8, approved by Jordan.

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself — the prompts I actually typed are right here.

Or don't. Annual subscribers install the tool I built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

What up, what up.

People think they can smell AI writing. The em-dash. The "it's not just X, it's Y." The little tells. They run around the internet pointing at sentences like it's a witch hunt.

Here's what they're actually smelling: thin content. A thin opinion with a thousand words sprayed on top. That's the thing people object to. Not the punctuation — the emptiness behind it.

Nobody reads an AI-written guide to repairing an aortic valve and stops to complain about the dashes. They read it for the information. The em-dash disappears the second the content is worth reading.

TL;DR: People hate thin content, and AI made thin content free. The fix isn't better prose. It's information worth reading — data only you have, the judgment to ignore the rest, and a business built so your information gets more valuable with every customer you add. Get that right and nobody audits your punctuation.

Treat AI like a SQL tool

A hundred percent of what I do is mashing data together. I treat the AI more like a query tool than a writer.

Here's why. AI is great at finding the source material. It is bad at understanding why that source material is valuable. That second part — knowing what's worth keeping and what to throw away — is judgment, and it's still yours.

So the question that actually matters isn't "write me a post." It's: what is the source of the value? What data is genuinely useful here? How do I compile it — and, just as important, how do I ignore the noise and keep only the part that moves someone?

The most valuable move is subtraction

In go-to-market, the most underappreciated work is figuring out what not to do.

You've got a hundred thousand accounts in your market. Ninety-five thousand of them you should never talk to at all. Of the five thousand left, maybe a hundred will change the trajectory of your business. Find those hundred and you can spend all your time making them something worth reading.

And you don't rank them by wallet size. You rank them by the size of their problem relative to their wallet. A small company drowning in a problem you solve beats a giant who barely feels it. That ranking is the whole game.

Ask the customer

The one thing nobody does when they write a campaign: go to a real customer and ask, "Would you respond to this? Is this useful to you?"

Someone close to me is a librarian. She gets cold-called by the same rep over and over. "Will you buy my books?" Every time, same answer: "We buy books in December." All that effort, all those calls, completely wasted — because he never once asked the thing that would have told him when, or whether, to call.

That insight was sitting in her head the whole time. He just had to ask. Start from the customer's reality, not your campaign. With perfect information on the whole internet — and your own internal data — what could you hand this person that they'd actually pay to receive?

Your information has to compound

That internal data is the part that's supposed to get better over time.

I've been an advisor to Clay since 2020. One thing I keep telling them: you buy enormous amounts of data, so build a Kirkland-brand version — unbranded, way cheaper — and pass the savings to me. I could never negotiate that on my own. Their network can. That's a moat: value you can hand the next customer precisely because you already served the last one.

This is why I don't give signals-based outbound the time of day. No great product gets worse the more people use it. Signals do. The more people buy the same hiring data, the same intent data, the worse it works for all of them. Clay calls it go-to-market alpha — and the durability of that alpha is halving. It gets shorter every year.

The creative stuff I do is valuable. But it decays the moment it's copied. The stuff that compounds is different: what can you do that competitors can't — and that gets better as your business grows?

Design the message that's 10x better in three years

Here's a strange but useful way to design a business. Ask: what message could I send a future prospect that's better in a year than it is today, and ten times better in three years than it was in that first year? And how am I collecting and storing the information that makes that true?

If your business is built around distribution and around the message getting more valuable over time, everything downstream gets easier. This has been NFX's whole thesis for years — network effects, told over and over.

There's an exception. If you have the single best product in the world — say, the best AI model — you don't have a message problem. You have a collecting-money problem. But for the rest of us on the ground, the work is capturing and structuring information so the next customer finds more value than the last.

Horizontal goes thin, vertical goes deep

This is exactly where horizontal SaaS struggles. Its value is a thin layer smeared across ten verticals nobody fully understands. It doesn't compound, because you only ever go an inch deeper everywhere — and an inch deep is no moat at all.

Serve only plastics companies and your knowledge compounds. Ten plastics companies ask you for the same thing, and now you know it's worth building. Add a plastics company, a plumbing company, and a B2B SaaS company to that list and you can't tell what's worth building anymore. You go an inch deeper across all of them and own nothing.

You can't fix that by committee, either. A data company recently invited me onto a council to give feedback on their direction. Feedback's fine. The real issue is structural: in go-to-market data, the value often doesn't compound — and sometimes, with signals, it actively gets worse the more people use it. Data is becoming a commodity. An opinion helps. A product that compounds helps more.

Aggregate the data nobody else has

Nate Nasralla wrote a great book — Fluint helps companies navigate enterprise deals. He frames a big deal like a choose-your-own-adventure: a hundred decisions, each one branching.

Here's the move. Across his customers, he's sitting on dozens of examples of how deals with Starbucks, Apple, Anthropic were won or lost. Aggregate that, and the next person who walks in selling to Starbucks gets told: you'll generally need four decision-makers, one of them in the C-suite, and that has to happen at this exact point in the funnel. Nobody else can say that, because it's private data — and every new customer makes it sharper.

That's the whole point about AI writing, brought home. In a world where every message is thin, your edge is the depth and quality of the information — not the writing of it. Focus there and everything gets easier.

Distribution-first businesses win

So the businesses that win from here are distribution-first. The questions worth obsessing over are simple to ask and hard to answer:

• How does one customer naturally become three? Referral, network, word of mouth baked into the product — not bolted on after.

• How does the 400th customer get ten times the value of the 100th? Because every customer before them made the data deeper. That's a multiplying data moat.

• What message gets better the longer you're in business? If the answer is "none," that's the thing to go fix first.

My own moat is knowledge. It's why I run a top-50 Substack two months in, why there are 20-plus tools inside Edge Copilot, and why this is the only place I put any of it. As I build for more customers, every customer gets the latest thing I've built. The next one inherits all of it.

So stop auditing other people's punctuation. Go find the one thing you know that your next customer would pay to hear — then build the machine that knows more every time you use it.

Big shout-out to David Austin, Ray Owens, and Alec Schwartz — who got his dad building in Claude Code with Edge Copilot. Thank you for using the tools and telling me what they're worth to you. That's the loop.

Have a beautiful day.

Chapters

• 00:00 — Why people say they hate AI writing

• 01:03 — Treat AI like a SQL tool

• 02:06 — The most valuable move is figuring out what not to do

• 03:13 — Ask the customer (the librarian and the book rep)

• 04:18 — Why your information has to compound

• 05:20 — Signals decay; GTM alpha is halving

• 06:23 — Design the message that's 10x better in three years

• 07:24 — Horizontal goes thin, vertical goes deep

• 09:31 — What Clay got right: enabling imagination

• 11:34 — Aggregate the data nobody else has

• 12:36 — Information is the value, not the writing

• 13:42 — Distribution-first businesses win

What Annual Adds

This one was free. Paid gets the build. Annual gives you the tools that run it.

• Every tool I ship. Edge Copilot installs to your Claude Code — talk to all my knowledge, every method, every data source. Current: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep. Whatever ships next is included.

• All 3 courses: Who to Target and What to Say, Agent 7, AutoClaygent.

• Weekly office hours.

Your license key installs /edge in one command — then every tool above drops in on top, each one a /edge install away.

License key hits your email.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

"Make the pricing page look like Linear's."

That's what I told Claude. Clean dark cards, one accent color, type doing the heavy lifting. Claude said sure, reached for its web tool, and pulled up linear.app/pricing. A few seconds later I had a pricing page. It was fine. It was also generic — three rounded cards, a purple-ish gradient, Inter everywhere. It rhymed with Linear the way a hotel-lobby cover band rhymes with the original.

Here's what happened under the hood. When you tell Claude to copy a page off the web, it fetches that page. A fetch returns the page's text — the words, the prices, the feature bullets. It does not return the pixels, and it does not return the CSS. Claude never saw Linear's design. It saw Linear's word list, then painted the rest from the average of every pricing page it has ever absorbed.

That average is the slop. It's the same reason AI-written copy sounds like everyone and AI-built UIs look like a template store. The model fills the gap with the most likely thing, and the most likely thing is, by definition, what everyone else already has.

Generic carries a real cost. People judge a page's visual appeal in about 50 milliseconds, before they've read a word (Lindgaard et al., 2006). Stanford asked 2,684 people what made a site credible, and the single most-cited factor was how it looked — 46.1% of the time, ahead of the content itself (Fogg, Stanford, 2003). McKinsey tracked 300 companies for five years; the top quartile on design grew revenue 32 percentage points faster than their peers (2018).

Design is the product's first argument. The average loses it.

And the slop is already shipping. 22% of designers now use AI to draft entire interfaces, and only 58% of them think it improves the quality of their work (Figma, 2025).

Capture, don't describe

The fix is one rule: capture, don't describe.

For every page worth stealing from, render it in a real headless browser and grab two things. A screenshot, so Claude can see the layout and the feel. And the actual computed CSS — the real fonts, the real hex colors, the real corner radii, the real shadow sitting on the real card. Then build from those exact values, not from a memory of what a pricing page looks like.

That's the difference between "vaguely inspired by Linear" and reproducing the craft. I wired it into a Claude Code skill and called it Steal This Design. Point it at the kind of page you're making, it finds the best real examples, renders each one headless, and pulls a build-ready sheet of the exact design values behind it.

The screenshots up top aren't mock-ups. That's fifteen live pricing pages — Linear, Stripe, Vercel, Attio, Figma, Notion, Clerk, Resend, Supabase, Render, Sentry, Webflow, Cal.com, PlanetScale, Liveblocks — each one captured the same way: a real browser, a real screenshot, and the real CSS underneath. Look at any tile and you can name the move worth stealing. Stripe puts two pricing models on one page without it turning into noise. Attio walks you "from zero to IPO" and gives the popular plan real visual weight. Linear just shows restraint.

The first version taught a class. I wanted a decision.

The first end-to-end run produced a beautiful design study and buried the decision at the very bottom.

Five pricing patterns, laid out in a grid, each one explained. Here's what tiered cards are good for. Here's when a usage model reads clean. Here's the comparison matrix. It was genuinely useful and it was the wrong shape, because the one thing I actually wanted — which one should I ship? — was the last thing on the page.

A study makes the reader do the deciding. I didn't want a syllabus. I wanted the call, up top, with the reasons under it.

It got worse when I looked closely. The page shipped a real bug — a "Most Popular" pill on the recommended card, sliced clean in half. Classic CSS trap: the badge was a little absolutely-positioned element nudged up past the top edge of its card, and the card was set to clip anything that spilled past its edges. So the browser dutifully chopped the badge. The kind of thing you'd never notice in code review and can't miss the second you actually look at the rendered page.

And the worst part I almost didn't catch at all. The step that extracts the real CSS — the entire point of the skill — had quietly been skipped on that run. The capture files held a URL and a title and nothing else. No fonts. No colors. No card structure. Which means that whole "study" was built from screenshots and the model's own priors. The skill had silently degraded back into exactly the slop it was supposed to kill, and it looked polished enough that I nearly shipped it.

I had a second AI tear it apart. Then I checked every word.

I handed the whole thing to a separate coding agent and asked it to be hostile — find everything wrong. It came back with six problems. The buried recommendation. The clipped badge. The skipped extraction. A couple of responsive breaks. Images that could ship broken.

Six real-sounding problems from a confident reviewer. The move most people make here is to fix all six on faith. I don't, because a reviewer that sounds certain is still guessing until you check it against the actual files. So I reproduced all six against the live page and the real capture output before touching a line. Every one of them was real this time — but the habit is the point. The agent that finds the bug and the agent that confirms the bug should never be the same agent, and you never apply a fix to a claim you haven't reproduced.

The rebuild: ship an opinion, behind a gate

So I changed what the skill makes. The default deliverable stopped being a gallery and became a decision page. The recommendation sits at the very top — I'd ship this one — with two or three reasons. Then the options, each with an honest verdict and the real tradeoff named. Then the runners-up, steelmanned — the real best case for each option I passed on, argued as hard as I argued for the winner. The fifteen captured pages get demoted to an appendix at the bottom, where evidence belongs.

You can open the actual page the skill built, live: the decision page from this run. Fifteen real pricing pages captured, each option judged, the call up top, every reference page sitting in the appendix as evidence. Click any tile to zoom.

Then I gave it a bouncer. Every page the skill produces has to clear an automated layout check before a human ever sees it — a real headless browser that loads the page at desktop, tablet, and phone widths and fails loud on the things that embarrass you. Horizontal scrollbars. Broken or zero-size images. A recommendation buried too far down the page. A phone layout that scrolls forever. And the exact badge-clip pattern that shipped the first time — it specifically hunts for a pill positioned past the edge of a container that's going to slice it. The page doesn't ship until that check comes back green.

Two more things came out of the rebuild. The page now inlines every screenshot directly into the file, so it physically cannot ship with a broken image — there's nothing external left to break. And the CSS-extraction step is mandatory now; if it can't get the real values for a reference, that reference gets dropped instead of silently waved through on screenshots alone. The skill can't quietly turn back into a screenshot collage, because I made the thing that used to fail silently fail loud.

How do you find more good examples without trusting the list?

I wanted at least ten known-good pages in every run, not three. Plain search doesn't get you there — search for "best pricing pages" and you get listicles about pricing pages, never the pages themselves.

The better move is Exa's find-similar. Feed it a handful of pages everyone agrees are great — Linear, Stripe, Vercel, Resend, Attio, Framer — and ask what's similar. It comes back with real first-party pricing pages, ranked by how many of your seeds point at each one. The pages the most seeds agree on rise to the top.

It also comes back with garbage, and that's worth saying plainly. Find-similar happily returns SEO aggregators — the "compare 40 tools' pricing" directory sites that are about products rather than the products themselves. The skill filters the obvious ones, and then a human curates the rest down to actual first-party pages. This is discover-and-curate. The list it hands you is a starting pile, not a verdict.

The chat widget that fought back

One last gotcha, because it's the kind of thing that eats an afternoon. Some sites mount a live-chat bubble that sits on top of the page — and a few of them defend it. Airtable's, for one. Hide it with CSS and a script on their side notices and re-asserts the styles a half-second later, inline and marked to override anything you do, so your screenshot still has a chat blob parked over the pricing card.

You don't win that fight by styling it away. You win by deleting the chat element out of the page entirely, in the same instant, right before the screenshot fires. Remove the node and there's nothing left to re-style. Small thing. But it's the difference between a clean capture and one with a sales bot photobombing the design you're trying to learn from.

The actual lesson

This is a design skill on its face. Underneath it's the same thing I say about everything else here.

Don't let the model fill from the average. The average is where everyone already lives — it's the generic pricing page, the templated email, the dashboard that looks like every other dashboard. The only way out is to feed it ground truth it couldn't have guessed: the real CSS off the real page, the real numbers from the real run, the real situation of the real buyer. AI raises the average for everyone at once. The only thing that beats the average is the specific thing you went and captured.

And make the agent commit. A pile of options is the model dodging the hard part. A forced recommendation plus a machine that refuses to ship a broken page — that's how you get craft out of an agent on purpose, again and again, instead of by luck.

— Written by Claude Opus 4.8, approved by Jordan.

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

"AI go-to-market" is a weird phrase. It implies there's a different, regular go-to-market over there, and this is the new one. But mostly what "AI go-to-market" has meant is this: people take the average, tired way of doing outbound and bolt AI onto it. The result isn't better outbound. It's more outbound. More noise. A bigger pile of garbage you now have to climb over to get one second of attention.

My friend Dale fights that pile by mailing people an empty donut box. "I ate these before we could talk — join me." It's funny. It works. And it gets worse the second everyone starts doing it. That's the trap with every attention-economy trick — the empty box, the free AirPods for a meeting, the "please, I beg you" energy. The best of them decay the moment they're copied.

There's a better move than fighting for attention. Work backwards from the message. And there are exactly two things you have to get right.

TL;DR: Stop competing for attention. Find the one message only you can send — built on information you have and your prospect would kill for. Then say it like a human, not like a robot showing off its homework. The targeting does the heavy lifting; the words do a lot less. Everything below maps to a skill you can run with me in Claude Code.

Thing one: the message only you can send

Don't compete in the attention game. Find a message nobody else can send. That comes from one thing — the asymmetry between what you know and what your customer cares about.

Here's the question that defines it. With perfect information on every customer you already have, what could you tell your next best customer that's independently valuable to them? Not "we help companies like you." Something they couldn't get anywhere else.

I think about it as a break-in. If a specific prospect — an industry at a size, the thing that unites a 100x customer — could break into your systems for a single day, what would they want to know? What would be so useful they'd pay for it? That answer is almost always a blend of your internal data and external data. That's the PVP — the permissionless value proposition.

This is exactly where horizontal SaaS struggles. What you know about a vertical SaaS customer doesn't translate to Cisco. The knowledge doesn't carry across industries or sizes, so the value you can hand each one is different. You can mine call transcripts for it. You can mine product data for it. But the where to begin is usually intuition about a niche where you sit on a pile of useful internal information.

What's in Edge Copilot for this: Dossier Builder — point it at your systems and it builds one per-account timeline from all of them, with a source tag on every line.

It joins Gong, CRM, billing, product, and support into a single sorted timeline per account, and links the same company across systems before it merges anything. When billing says cancelled and the CRM says active, both show up on the line with the source attached — you decide which one is true.

Pull it (annual): Say /edge install dossier-builder once your license key arrives, then point it at your call transcripts and customer data and ask for a per-account dossier — it runs the whole thing conversationally, pausing to ask you the tiebreakers.

→ Get Dossier Builder in your terminal

Thing two: say it like a human

You can do all that data work and still blow it on the last step.

Here's the failure mode. You gather the data, you stack it up, and the message becomes a showcase of how hard the data worked. That misses the entire point. The prospect doesn't care about your pipeline. They care about what a human does with the information — whether it's actually useful to them, or just theater.

So work backwards from the customer. If you've got a campaign and a list of people it should apply to, show them the message. "Read this — what do you think? I didn't write it, so be brutal." You will be missing context every time. Oh, we never thought about it that way.

One company I advise hired someone who'd lived in the buyer's seat. We were planning an event, and I said, let's take everyone to a Michelin-star dinner — because that's what I'd want. He stopped me. Most of these people just want a break from their families and a few beers with friends. They're Miller Lite people. That's not my frame. But it's the customer's frame. So the message wasn't "I did all this targeting, here's why you need us." It was: "We've got people coming for beers. They're on us. Want in?" No data theater. It converted far better, because it matched what the customer actually wanted.

The targeting does the heavy lifting

Here's what most people get backwards: the value of the data is in the targeting, not the message. Get the targeting right and the message barely has to work.

This is why my clients ship smaller campaigns — hundreds, sometimes tens, sometimes low thousands — at much higher velocity. So much of great go-to-market is figuring out who you shouldn't target. Then, for the people you should, what genuinely valuable thing you have for them.

And disqualification beats demographics. Not "50 to 1,000 employees". Real, hard gates: they literally have no software engineer, so my product is useless to them. Or this title has never bought, so we'll never contact them. Three questions, in order:

• Can they actually benefit? Is this a prospect you know gets value from your service — not "fits the ICP."

• Is this selection 10x more valuable — and how do you know? A discernible, data-backed way to spot a 10x prospect, and a hard way to disqualify everyone else.

• What language makes them feel seen? So the power dynamic is "I'm trying to help you," not "please get on a call with me."

What's in Edge Copilot for this: win-loss-rewind — works backward from who actually won, lost, and churned to a scoring rubric of non-obvious public signals; the disqualification engine.

Name the one prospect that looks like your best customers and hard-disqualify the rest. It auto-segments your customers without assuming industry, then keeps only the signals that survive a 20% holdout. Its companion, tam-research, finds every data source that builds the whole list.

Pull it (annual): Say /edge install win-loss-rewind (and /edge install tam-research) once your license key arrives, then point it at your won/lost/healthy/churned customer list plus your calls.

Stop thinking in tactics

When you sit down to build, drop the tactics brain. Use the empathy brain.

There's an old idea worth holding onto: treat persuasion as a bag of tricks and none of it works; treat it as a way of operating and things fall into place. The "sent from my iPhone" trick, the funny little hacks to fake a human — those are tactics. They don't survive contact.

Anchor everything in a real person. How would a real person respond to this? When you open a message to an existing customer or a friend, you're not reaching for a template. You're trying to tell them something useful, in a friendly way. ("Yo Chris, beers Friday?" He always says yes.) That's the whole bar. Hit it with strangers and you've won.

Why I built Edge Copilot

Here's the uncomfortable part. Content like this isn't enough. You don't need me writing essays — you need me in the room when you build.

Because Claude is sycophantic. It'll build whatever you tell it to, in any direction, with total confidence. What's missing is someone with taste and opinions to steer you — to say "that's data theater, cut it" or "you haven't disqualified anyone yet." That's the job.

So I built On the Edge Copilot. It lives inside Claude Code, it has access to all my knowledge, and it nudges you while you work: Jordan has a skill for this. Jordan has a tool for this. Jordan's been watching — he has some ideas. It's trying to push you toward the two things in this post: the asymmetry only you have, and plain language that removes the automation feeling.

What's in Edge Copilot for this: the /edge skill lives in your Claude Code, talks to all my knowledge, methods, and data sources, and nudges you mid-build.

It's a second opinion in the terminal. When you tell Claude to build something, Claude builds it — /edge steps in first to say "Jordan has a skill for this," or strips the data theater out of your draft so it reads like a human wrote it. Annual includes every tool I ship, not a fixed list.

Pull it (annual): Your license key installs /edge in one command, then any tool — /edge install dossier-builder, /edge install tam-research, whatever you need — drops in on top.

→ Get Edge Copilot in your terminal

One annual subscriber wanted a list of every franchise and its owners in the country. So I built it, then handed the skill to every annual subscriber.

What's in Edge Copilot for this: franchisee-finder — turns FDD Item 20, the roster every franchisor files by law, into a national list of franchisee operators with the multi-unit whales resolved.

It collapses the per-unit shell LLCs into the one holding company quietly running 40 Burger Kings across three brands — the operator everyone wants and the logo on the door hides. Five chunked, checkpointed waves.

Pull it (annual): Say /edge install franchisee-finder once your license key arrives, then run it against a brand (or its FDD) to get the operators behind the logos.

I'm going to keep doing this. Monthly is $50 and gets you the writing. Annual is $2,499 and gets you every tool, the courses, office hours — and, increasingly, custom data jobs I build for you.

If you've got a hard list-building or data problem and $2,499 sitting around, ping me. Tell me what you're trying to find. Mostly these are data jobs — and that's the fun part.

Thanks for watching. Have a beautiful Tuesday.

Chapters

• 00:00 — Why "AI go-to-market" is mostly noise

• 01:10 — Work backwards from the message

• 02:16 — Thing one: the asymmetry only you have (PVP)

• 04:22 — Thing two: say it so they can receive it

• 05:22 — Data theater vs. what a human will actually use

• 06:25 — The beers, not the Michelin dinner

• 07:28 — The targeting does the heavy lifting

• 08:33 — Who you shouldn't target — and Edge Copilot

• 09:38 — Empathy brain over tactics brain

• 10:38 — The three gates: benefit, 10x, language

• 13:40 — Why content isn't enough (Claude is sycophantic)

• 14:42 — What I'm building for subscribers

Thirty-five agents, six phases, one screen — Claude Code running a dynamic workflow on Opus 4.8 (the last phase is "Verify & Report"). This is what "a non-engineer runs Claude Code" looks like at full tilt. Source: Anthropic, "Introducing dynamic workflows in Claude Code," May 28 2026.

The first number the machine gave me was 20,000.

I'd asked Claude to count every prompt I'd typed into it over the last two and a half weeks. The plan was a forensic audit of how I actually talk to AI — run by the AI being audited. Twenty thousand prompts in 17 days sounded heroic. It also sounded fake. Nobody types 20,000 of anything in 17 days.

So I ran the rule I run on every number Claude hands me: prove it. Show me where it came from.

The real count was 810. The transcript logs every action the machine takes — every file it reads, every script it runs — right next to my typing, and the first pass had counted all of it as me. Off by 25x, in a report about how carefully I check the machine's work.

My own rule caught my own audit. The 810 verified prompts are what this article is built on.

The short version: I pulled every prompt I typed into Claude Code over 17 days — 810 of them, across 159 sessions and 16 projects — and sent agents to mine them for patterns. Every quote was machine-checked against the original transcript before it could appear in the findings. Ten habits fell out. The three biggest are below, set against what Anthropic's official guidance says. The docs agree with me more than I expected. They also convict me on five counts, and the charges are printed in full near the bottom.

What 810 prompts actually look like

I can't read code. The whole business — client market maps, contracts, published reports — runs through Claude Code anyway, by conversation.

The data is humbling in its smallness. A third of my prompts are under 60 characters. 41% contain a question. And each one triggered about 21 machine actions — I say one sentence, Claude does 21 things. The transcript reads like Slack messages to a very fast coworker: short, conversational, constant.

I voice-type almost everything, so the record is full of typos, and the typos turned out to be the least interesting finding in the corpus. The model decodes bad spelling fine. What kills it is ambiguous pointing — "fix the grease thing" said to a fresh session that has never heard of the grease thing.

Claude Code's voice mode: a non-engineer holds space and dictates a rambling, run-on prompt — typos, tangents and all — and the agent runs with it. Source: XDA Developers, March 2026.

How do you audit yourself with the tool being audited?

Claude Code keeps a transcript of every session in a folder on your machine. A script pulled every record where a human actually typed — dropping the machine noise that inflated the first count — and kept a record of the exact file and line each prompt came from.

Then eight mining agents each took a slice of the corpus and went hunting for patterns, under one rule that made the output trustworthy: every quote in their findings had to be an exact, word-for-word slice of a real prompt, because a separate script would re-open the transcripts and check. 274 quotes survived the mining. All 274 passed verification.

A second team of agents did the outside research — Anthropic's documentation, the practitioners worth reading — under the same rule. No claim without a URL and the verbatim sentence it came from.

The habit I'd teach first: make Claude write its own next prompt

Every long session dies the same death. The context fills with half-finished attempts and stale corrections, and the model gets dumber about your specific problem. Anthropic's engineers have a name for this — context rot — and their measurements show recall degrading as the conversation fills.

My corpus shows 55 sightings of the same response to it:

"You keep messing up, so I'm just going to open a new agent. Just write me a brand new prompt for a new session and copy it on my clipboard."

The dying session knows everything about the problem — what failed, what's confirmed, where the files live. So before I kill it, it writes the briefing for its replacement. Paste, fresh start, nothing re-explained.

The fork Anthropic now draws: a lossy summary, or a fresh session with your brief. Source: the Claude blog.

"I just want you to give me a prompt for a new session that will avoid all the pitfalls that we've already found"

I got there through irritation. Anthropic got there through research — their own blog now tells users to have Claude write the handoff itself, and describes it as "a message to the previous iteration of Claude from its future self." Same destination.

The habit I use most: run a team, not a chat

The single most common pattern in the corpus — 68 sightings — is me refusing to accept one opinion from one machine.

"Can you have three different narrative agents critique this?"

"All right, I'm gonna have Codex check your work."

That second one is Claude being told its work will be checked by Codex, OpenAI's competing agent. A model trained by different people on different data has different blind spots, which makes it a real reviewer instead of an echo.

"I'm gonna have Codex check your work" — OpenAI's Codex reviewing Claude Code's own diff and filing a ranked P1/P2 bug table, inside the terminal. Source: Nathan Onn, April 2026.

Anthropic put a number on the team idea: a lead agent directing a team of parallel agents beat their best single agent by 90.2% on their internal research eval. Their honest caveat matches my experience — teams pay off on work that splits into independent pieces, like research and review and enrichment, and much less on tightly-coupled builds. And their newest guidance lands on something I'd learned by feel: a fresh agent reviewing cold outperforms a model critiquing its own output. The agent that wrote the thing should never be the one grading it.

Eleven agents on one screen, grouped by what needs you, what's working, and what's done. Run a team, not a chat. Source: Anthropic, "Agent view in Claude Code," May 2026.

The habit that saved this article: demand receipts

53 sightings of me refusing to believe the machine.

"print the actual damn eamils so I can read them"

"Whhy do you say "~$254,000" why the ~ ?"

Both verbatim, typos preserved. The first is the artifact demand — show me the actual output, never the summary of it. The second is the number interrogation — a tilde in front of a dollar figure means somebody estimated, and I want to know who and from what.

This habit has the strongest official backing of anything in the corpus. Boris Cherny, who created Claude Code, calls giving Claude a way to verify its work "probably the most important thing to get great results." Anthropic's docs say to have Claude show evidence rather than asserting success. And the newest model guidance goes further than either: Anthropic now publishes an instruction telling the model to audit its own progress claims against actual results, because on long runs models fabricate status reports. Their testing says the instruction "nearly eliminated" them — which tells you fabricated reports were real enough to need eliminating.

Claude Code showing its receipts: after the edit it runs typecheck and lint, reports "The typecheck passed," then runs the tests — before it says done. A runnable check turns "done" into evidence. Source: Boris Cherny, creator of Claude Code.

The 20,000-prompt estimate at the top of this article is what the habit looks like when it pays off.

The other seven

Ranked by sightings: paste the exact bad sentence and state the rule you want (55). Turn every fix into a standing rule the machine remembers (43). Say who's reading the output and where it lands — a text message gets four sentences, a Slack post gets formatting (37). Name the specific tool you want used instead of correcting bad output afterward (36). Point Claude at the raw source — the email, the transcript, the PDF — instead of summarizing from your own lossy memory (31). Ask for the plan first and approve it in five words (27). Fence off what must not be touched (12).

All ten live in the full reference guide, with the feature walkthroughs and what the tools cost: the field guide to talking to Claude. This article is the story; that page is the manual.

The models changed underneath me twice in 17 days

The corpus runs May 25 to June 10. Claude Opus 4.8 shipped May 28. Fable 5 — Anthropic's new top model — shipped June 9. And on June 12, while this article was being written, a US government export-control directive ordered access to Fable 5 suspended. Anthropic says it's complying, that it disagrees with the order, and that it's working to restore access. Eighteen days, two new frontier models, one recall.

So I went deep on what Anthropic actually published about prompting this generation, and the documents describe a model that has been moving steadily toward the way a non-engineer already talks.

Opus 4.8, May 28. Look at the terminal-coding row: GPT-5.5 edges it, 78.2 to 74.6 — a green cell conceding a column to OpenAI, on Anthropic's own card. The frontier is contested, not owned. Source: Anthropic.

Twelve days later, June 9: Fable 5 resets the top row again. Three days after that, a US export-control directive ordered access suspended — Anthropic is complying while disputing it. The card you're reading is for a model you currently can't call. Source: Anthropic.

Three findings worth your time.

The models got literal. Starting with Opus 4.7 and deeper in 4.8, the official guidance says the model "does not silently generalize an instruction from one item to another, and it does not infer requests you didn't make." Your exact words are the spec now. The docs' own example is brutal: if an old review prompt says "only report high-severity issues," the model finds the bugs, judges them below your stated bar, and stays quiet. Your stale hedges get obeyed against you.

The era in one chart: the task length an agent finishes at 50% reliability keeps doubling — lately every four to five months. Newest model plotted is Claude Opus 4.5. Source: METR, "Time Horizon 1.1," January 2026.

Old instructions became poison. The Fable 5 guide says prompts and skills written for earlier models are "often too prescriptive" and "can degrade output quality" — and recommends deleting them. Years of accumulated prompt scaffolding is now a liability the vendor tells you to remove.

The docs converged on conversation. Fable 5's guidance says you can "steer most behaviors with a brief instruction rather than enumerating each behavior by name," and one of its section headings is "Give the reason, not only the request" — attaching the why is now a documented performance technique. Plain sentences, the reason included, boundaries stated. That's how you'd brief a colleague — which is the only way I ever knew how to do it.

Where the docs convict me

Five charges, none softened.

I shout. When Claude ignored a rule, my correction came in capital letters. The official guidance now instructs the opposite — "dial back any aggressive language," with the exact before-and-after: replace "CRITICAL: You MUST use this tool when..." with "Use this tool when...". Newer models over-obey emphasis. What actually fixed things in my corpus was pasting the offending sentence and stating the rule. The pasted line did the work. The caps were theater.

I bundle. My prompts routinely carry four or five unrelated asks. Benchmark research on instruction-following keeps finding the same shape: every ask you stack lowers the odds that all of them get done, and the misses are silent. Front-loading context is good; front-loading five jobs is how the third one vanishes. One ask per prompt, with everything it needs attached.

Even the 2026 frontier eventually cracks under stacked instructions — GPT-5.5, Opus 4.7 and Gemini 3.1 all bend toward the floor as the count climbs past the old ceiling. The instructions that drop out fail silently, which is exactly why bundling burns you. Source: Arize AI, May 2026, extending the IFScale benchmark.

I babysit. Around 60 prompts in the corpus are me checking on running jobs. "Still going?" "how are we doing gents?" Claude Code has a feature that watches a job and re-checks it on a schedule — /loop — and the corpus shows me using it exactly zero times. Sixty prompts of me doing a timer's job.

I hoard rules. My standing-rules habit — 43 sightings, every correction saved to memory — has a documented failure mode I'd been feeding. Anthropic's guidance, exclamation mark theirs: "Bloated CLAUDE.md files cause Claude to ignore your actual instructions!" That's the rules file Claude reads at the start of every session, and mine only ever grew. The docs say prune it like code; the practitioner standard is that every line must trace back to a real mistake. My best habit, left uncurated, became my fourth failure.

Run it on yourself

Your transcripts are sitting on your machine right now — every session, every prompt, in a folder Claude can read. The audit that produced this article is one paragraph of instructions.

What Claude needs to know:

Read every session transcript under ~/.claude/projects/. Keep only the messages I actually typed — drop tool results, system output, slash commands, and anything under 10 characters. Count what's left and tell me where the count came from. Then mine the prompts for my five most common habits and my three worst ones, quoting my real prompts back to me word for word. Before showing me any quote, verify it appears verbatim in a transcript. Show the file and line for every number.

Fair warning from experience: the first count will be inflated, because the machine logs its own actions next to your words. Make it prove the number. That's the audit auditing itself — and if that habit isn't already yours, it's the first one worth stealing.

Claude Fable 5 wrote this article inside Claude Code on June 12, 2026 — three days after the model shipped, and the same day a US government directive ordered its access suspended. It worked the way the article says to work: it planned first and asked its questions before writing, fanned research agents out through Exa and Parallel, and verified every quote against its source before printing it. Jordan quoted the bad lines, pointed arrows at them, and demanded the receipts.

What Annual Adds

This one was free. Paid gets the build. Annual gives you the tools that run it.

• Every tool I ship. Edge Copilot installs to your Claude Code — talk to all my knowledge, every method, every data source. Current: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep. Whatever ships next is included.

• All 3 courses: Who to Target and What to Say, Agent 7, AutoClaygent.

• Weekly office hours.

Run ​/edge install <slug> for any tool I've shipped — they all install the same way.

License key hits your email.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

There is no public list of who owns the franchises in America. Ask "who owns the three McDonald's near me," or "find me every multi-unit Wendy's operator in Texas," and you hit a wall. The big data vendors — FRANdata, FranChimp — sell a version of that list. Everyone else does without.

But the raw material is public, and it's free. Per the FTC's Franchise Rule, every franchise brand has to file a disclosure document with state regulators before it can sell a franchise. Buried in that document, Item 20, is a roster: the brand's franchisees, by name, city, and phone. One filing covers one brand's entire national footprint. The list nobody sells is sitting in paperwork nobody reads.

So I read it. All of it. The result is 142,579 multi-unit franchise operators — the people who own more than one location — built from public filings for about zero dollars. Here's how, and exactly what's in it.

What is a multi-unit franchisee, and how many are there?

A multi-unit franchisee is one operator that owns several franchised locations — sometimes five, sometimes five hundred. They're the real buyers in franchising: the operators with capital, staff, and the appetite to add units. I could name 142,579 of them in the US from public filings alone.

Counting them is harder than it sounds, because one operator hides behind many companies. A single Burger King franchisee files each restaurant under its own LLC, and the same restaurant gets re-disclosed in every state the brand registers in. The largest real operator in the data, Boddie-Noell, runs about 636 units. Carrols runs 575. Resolving that sprawl into real operators is the moat. The data is free; assembling it is the work.

Get the merge wrong and you manufacture monsters. An earlier pass over-merged phone-bridged rows into one phantom "operator" with more than 400,000 units — a magnet that swallowed the real whales. Dissolving it brought the top of the list back to actual franchisees, none over 750 units. Shared registered agents that sign state paperwork for hundreds of unrelated brands get demoted, not counted. That cleanup is the difference between a clean list and garbage.

Are franchise disclosure documents public?

Yes. A Franchise Disclosure Document — the FDD — is a legally required filing. Before a brand can sell you a franchise, it has to register the FDD with state regulators and hand it to prospective buyers. Roughly 14 states run their own registration portals; NASAA's national depository covers the rest. The documents are public records.

Item 20 is the part that matters here. It lists the brand's current and former franchisees, with contact information. Every franchisee has a phone number on file. The franchisees live in all 50 states, but the paperwork sits in a handful of portals — so coverage is a function of which brands have filed, not which geography you're hunting. Scrape a few free sources and you get operators nationwide.

Can you find out who owns a franchise?

Yes — you read the brand's FDD. One Item 20 is that brand's whole national roster — every operator, in one document. That's the asymmetry: the question feels like a 50-state manhunt, and the answer is a few thousand documents that already exist.

This is what the long tail of franchise searches is really asking. "Who owns the Taco Bell on Main Street." "List of Wendy's franchise owners." At scale, a dataset of 142,579 operators with a phone on nearly every one answers that question by the hundred-thousand. The phone is the universal contact — it's on ~100% of records, because the filing requires it. Owner names are thinner, and I'll show exactly how thin below.

Why is most franchise data wrong?

Because the lists everyone sells are frozen. The largest free archive of FDD text is a 2023 snapshot. Buy a franchisee list from most vendors and you're buying a moment that's two or three years stale — operators who sold, brands that folded, phones that changed.

I pulled current filings instead. The national depository and a free public FDD library both publish 2024–2026 documents, and feeding those through the same extractor stamps each operator by the vintage of the filing it came from. 65% of the 142,579 operators show up in a filing from the current cycle, not just the frozen 2023 archive. That freshness is the whole edge: a live operator with a working phone beats a 2023 record every time.

Even my own first cut had a freshness bug, and I'd rather tell you how I caught it than pretend it didn't happen. The extraction mislabeled half the roster as former franchisees — a stray header near the top of a filing was tainting every row beneath it. I ran eleven Claude agents over the source PDFs, page by page, checking the extraction against what each filing actually said. They caught it. The fix cut the mislabeled-former rate from about half to under six percent. Check data like this against the real documents, or you'll ship a number you can't defend.

Then I had the finished list audited end to end by an independent pass — roughly 5,800 judged samples, every Texas registry citation re-fetched, every defect re-verified before any fix. It collapsed two phantom duplicate operators, repaired owner names that had been filed in the wrong order, pulled out a batch of business names masquerading as people, and re-keyed the outlets file so all 421,774 of them tie back to a real operator. The numbers here are what survived that pass.

How do you get FDD data without paying FRANdata or ZoomInfo?

You assemble it from free sources, and you pay a vendor for nothing the public record already gives you. Every expensive step in this build has a free substitute:

• The documents: a public, MIT-licensed Hugging Face archive of 22,986 already-read FDD texts — more than 1.5 million roster rows once deduped — plus current filings pulled free from the national depository and a public FDD library. No document purchase, no scanning bill.

• The contact enrichment: a flat-rate enrichment tool that's unlimited on my plan, run across every operator instead of rationed to the top of the list. Zero marginal cost per lookup.

• The store addresses: the Overture Maps open places dataset — 3.9 million US business locations — joined locally to put a street address and map pin on the outlets. The free stand-in for a paid places vendor.

• The operating company behind the storefront: data from the SBA's published 7(a) and 504 loan records. Every franchise-coded small-business loan names the borrowing company and its address. 103,411 of them, free, naming the operating entity and address where the web shows nothing.

The moat was never the data. It's the assembly — pulling the rosters out and untangling the shells into real operators. You can't buy that, and it's what makes the rest free.

What's actually in the dataset

I'd rather show you the real coverage than sell you a clean story. Some fields are dense. Some are thin, because free public data has a ceiling, and I'd rather you know where it is.

• Operators (own 2+ locations): 142,579

• Phone (from the filing): ~100%

• Confirmed in a current 2026 filing: 65% (93,610)

• Named human owner: 16% (22,469)

• Operating entity named (SBA company): ~1% (1,603)

• Mapped outlets (street + pin): 421,774 outlets, 40% addressed

The phone is universal because the filing requires it. The named human owner is the hard ceiling: most franchisees present to the public as the brand storefront, so a phone reverse-looks-up to "Panda Express," not to the operating company behind it. A named human owner sits on 22,469 of the operators — 16% — and I'd rather show you exactly where each one comes from than inflate the number. Three sources, all checkable: on 18,610 the operating entity is itself a person's name, on 2,395 the filing phone reverse-resolved to a named person, and on 1,464 a Texas Secretary-of-State officer record names them. I tried a fourth — matching owners off LinkedIn — and an independent audit found it wrong about half the time, so I cut the whole class. The owners that survived measure at least 95.7% accurate. Naming the rest at scale is a slower, paid job — a Secretary-of-State officer sweep across more states — and it's the next build, not this one.

The operator list is the gold. The phone makes it usable today. The named owners are the bonus where the public record happened to expose them.

Skip the build — download the finished dataset

Everything above is packaged and ready. Annual members pull the full dataset into Claude Code with one command:

• 142,579 multi-unit operators — the headline list, whale-ranked, a phone on ~100% of records

• 421,774 mapped outlets — every owned location, street address + map pin where available

• 22,469 named human owners — each tagged with the public source that named them

• 1,524,943 raw roster rows — the full Item-20 universe the list was built from

Run /edge data franchisee-finder once your license key arrives — it downloads straight into Claude Code and feeds the tools that act on it (--full adds the raw outlet and roster files).

Buy now — go annual, $2,499/yr

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

A vertical-SaaS company that sells to the trades had about 1,200 customers and a new idea. Pay any customer $1,000 in account credit for every peer they refer who signs. Good program. One problem.

Nobody could say which customers actually carried weight in their industry. The CRM knew revenue, seat count, and renewal date. It didn't know which owner sat on a state association board. It didn't know which one hosted the podcast every other owner in the trade listened to. It didn't know which one got introduced on stage at the national conference.

The company already knew more about its buyers than it had ever looked at. Twelve hundred owner-operators, and the signal for "who can send us deals" was sitting in public — board rosters, conference agendas, podcast feeds, award lists. It had just never been pulled together.

So I built a skill that pulls it together. It's called referral-notability. Point it at a customer list. For every account, one Claude subagent finds the owner-operator, reads their full LinkedIn, and researches their real-world footprint — association seats, speaking, podcasts, press, awards, review scale. A fixed rubric turns all of that into one number: a 0–100 Referral Notability Score.

The score ranks the owner, not the logo

The number ranks the owner's connectedness, not the company's size. That's the part that changes how the list reads.

A 40-year-old, hundred-person institution whose owner keeps his head down ranks below a small shop whose owner chairs the state trade association. The big brand looks impressive on a logo wall. The small-shop owner can walk a peer over to you and vouch. An affiliate program needs the second list, not the first.

Sort a customer base by revenue and you get the org chart you already have. Sort it by who's connected and you get a different list entirely — one your competitors can't buy, because nobody sells "which of your customers other operators actually trust."

The biggest companies didn't top the list

I ran it on the full base. 1,182 accounts scored, 1,145 unique companies after dedup. Fifty-six of them cleared 55 — the affiliate-grade tier, the owners worth a personal ask. Nine cleared 80.

None of the top owners run the largest companies in the file. The number-one owner hosts the most-listened-to podcast in their industry, sits on a national trade-association board, and has won his city's top industry award many years running. Number two founded his state's trade association and still presides over it; he speaks at the national conference and turns up on local TV as the industry's explainer. Another, mid-list, holds an Inc. 5000 placement, a state trade-association board seat, and an operator-of-the-year honor at once. All of them are people other owners in the trade already trust. That's the trait the affiliate program was actually buying.

The CRM never had the owner's name

The CRM almost never named the owner. A company record, a billing contact, a renewal date — but rarely the person who founded the place. So the system never trusts the CRM for it. It goes and finds the owner for every account, and it resolved a named owner for 1,112 of the 1,145 companies. About 97%.

It looks the cheap way first. A LinkedIn data lookup that's already on the plan, then a two-tenths-of-a-cent web search, and only a pricier deep search when there's a real thread to chase. On an account with no digital footprint — a tiny shop, no press, a thin profile — it stops. You don't pay to dig a dry well. (The full cascade is in the recipe below.)

The bug that quietly ate data

The system writes each account's evidence to a file named after its CRM ID. Twenty-nine times, different companies had Salesforce IDs that collided on case alone — sPSNT versus sPSnT. macOS treats those as the same filename.

So one company silently overwrote another's score file. No error. No crash. Just data that quietly wasn't there. I caught it, re-keyed every file so case can't collide, and re-scored the affected accounts. The boring infrastructure detail is the one that eats your data — the filesystem you never think about decided two of your customers were the same company.

Why this keeps working

This is the move I keep coming back to. You almost always know more about your buyers than you've bothered to look at. The data to rank your own customers by influence is public, and it's free to read. Assembling it is the work nobody does — so the operator who does it ends up with a list no competitor can purchase.

Run it once and you stop guessing who to ask. You email the fifty-six owners the rest of the trade already listens to, not the fifty-six biggest invoices.

— Jordan

Written with Claude Opus 4.8

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

Two account executives. Same title. Same nine years. Same President's Club banner on the LinkedIn header. One of them will crush the role you're hiring for. The other washes out in a quarter. The résumé won't tell you which one.

That's the problem Matt Braley handed me. Matt thinks about sales hiring the way a good engineer thinks about a system: the same input behaves differently depending on the context it runs in. Here's the line of his I can't stop repeating:

"A rep closing $25K deals in four-week cycles isn't worse than one closing $500K deals in nine months — they're just aligned with different motions. Same résumé, opposite verdict, depending on the role."

Read that twice. It kills the way almost everyone scores candidates.

Most people rank reps by who looks impressive. That's the bug.

Open any sourcing tool and watch what it sorts on. Title. Years. Logo. A competitor flag. An A/B/C rating that's really just "how impressive is this person." It's a beauty contest, and it mis-hires in both directions.

It waves through the enterprise rep who's spent nine years closing seven-figure deals behind a category-leader's brand — and has never once opened a cold logo for a 60-person startup that lives or dies on new business. And it buries the SMB closer who'd be a monster in a fast, transactional motion, because their deals were "only" $8K.

Last month I built a sourcer that searched every company instead of sampling fifty. That fixed the who do we look at problem. It didn't fix the how do we rank them problem. I was still sorting by prestige. Matt's framework changed the sort key.

So I rebuilt the scorer around it. The tool is called Find a Rep.

The eight dimensions

Matt reads a candidate against the context they sold in — not whether they're good, but whether they sold the way this specific role needs. Eight dimensions:

• Company stage they sold from. Seed scrappiness or a late-stage brand that opens the door for you.

• Type of buyer. A CRO who signs is a different animal than a self-serve user or a procurement committee.

• Sales motion. New-logo outbound, product-led self-serve, or expansion of an existing book. Different muscles.

• Sales cycle length. Two weeks or nine months. The cadence doesn't transfer for free.

• Number of buyers in a deal. One decision-maker or a five-person committee. Multi-threading is learned.

• Cross-departmental complexity. Does the deal pull in RevOps, Finance, IT, Security?

• Deal size. $8K transactional or six- and seven-figure ACV. Patience and discounting instincts scale with the number.

• Industry. Horizontal, or a regulated vertical where getting deep into the workflows of an industry and learning the jargon matters.

Every dimension gets scored as a degree-of-fit — aligned, partial, or not — against the target you set for the role. Not a pass/fail gate. A rep can be a perfect 8-of-8 for one job and a 2-of-8 for the same title somewhere else.

What it found for █████

█████ is a go-to-market software company — they sell software that helps revenue teams sell better, into a Series A-to-C, 30-to-200-person world. They needed a new-logo account executive: someone who's been closing complex, six-figure, committee deals into revenue leaders. So I pointed Find a Rep at the whole market and let the eight dimensions do the sorting.

The funnel ran like this. We pulled every account executive at a 30-to-200-person U.S. software company — 15,489 people — with the Blitz API. We deduped their employers down to 6,960 companies and read each company's website, keeping only the 671 that actually sell go-to-market or sales technology to revenue leaders (670 the model found, plus one I added by hand). That left 1,563 AEs. We pulled the full LinkedIn history on 1,428 of them, ran a deterministic set of rules — at least four years closing as an AE with SDR time excluded, three-plus years in seat, four-to-eight years total, no job-hopping — and 135 survived. Every one of those 135 got scored on Matt's eight dimensions and ranked.

Total spend on the AI: eight to ten dollars.

Here's who came out on top — and why, by context, not by logo.

Alex Holler, Enterprise AE at Tackle.io. Alex sells cloud-marketplace sales tech to revenue and go-to-market leaders. His daily buyer is a revenue leader signing a six-figure, committee-driven deal — the exact buyer and deal shape █████ runs. He climbed a ladder at Dell and VMware with repeated promotions and carries a President's Club win. Eight of eight. The one thing to confirm: how much of his recent book was brand-new logos versus growing accounts.

August Buettner, Enterprise AE at HG Insights. August sells sales-intelligence data to revenue leaders — a close cousin to what █████ sells — in enterprise, multi-person, six-figure deals. He worked up from a business-development seat into the enterprise chair over about five years at one revenue-tech company. Eight of eight, and the kind of steady climb that says he can both close and stay.

Christopher Trebon, Senior Sales AE at Canidium. Christopher sells RevOps and sales-performance tooling — another tight cousin of █████'s product — to the person who owns how a sales team performs. Long, multi-step, committee deals. Twenty-plus years selling, promoted to the senior seat in two. Eight of eight.

None of those three would top a prestige sort. No FAANG logo. No unicorn. What they have is the motion — they already sell the buyer █████ sells to, in the deal shape █████ runs. That's the thing a résumé ranking can't see.

Degree-of-fit is the whole game

Eleven of the 135 scored a clean 8-of-8. But the real proof the framework works is the messy middle. Thirty-five candidates came through as "flex" — near-misses the rules would normally cut, kept on purpose because one soft dimension shouldn't bury an otherwise-perfect rep.

A rep whose only miss is cycle length — they close in three weeks, not the ninety-to-one-eighty days this role runs — isn't a bad rep. They're a phenomenal hire for a transactional motion and a partial fit for this one. Matt's line again: not worse, aligned with a different motion. A pass/fail gate throws that person in the trash. Degree-of-fit keeps them, scores them honestly, and tells you exactly which dimension to ask about in the screen.

That's the difference between a tool that ranks people and a tool that ranks fit.

So which would you rather hand your hiring manager — a list sorted by who has the shiniest logo, or a list sorted by who's already been selling your exact motion, with the one open question flagged on each name?

— Written by Claude Opus 4.8, approved by Jordan. Framework by Matt Braley. Matt is a former CRO who helped scale a company from $0 to $200M ARR and now advises high-growth Series A–C startups on building and scaling their revenue orgs.

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more

Every pipeline. Every enrichment waterfall. Every government dataset I turn into a list nobody else has. Every time something breaks at 2am and I have to figure out why.

Some of it's free. Some of it's behind $50/mo. And the tools that actually run all of it live in the annual tier.

People keep asking me the same question: what do I actually get at each level? So here it is. The whole thing. Exactly what reaches you, and how deep it goes — as of today, not as a roadmap.

There are 443 Corpus entries, 10 tools, 3 courses — and the math on what each price actually buys.

The shape of it

Three levels. One idea underneath all of them.

Old-world GTM goes: pick an ICP, pick a persona, write a message, hand it to a 21-year-old SDR to "personalize," spray the TAM. It doesn't work anymore. It barely worked before.

My world goes the other way: find a pain segment — companies with an expensive problem right now — find the public data that proves who has it, and write the message that references the proof. The list is the message.

That one inversion is the spine of everything I publish. And the three tiers are just three depths of it:

• Free — you see the shift. Why the old way broke, who you should actually target, and a daily build log of what I'm shipping.

• $50/mo — you see the build. The prompts, the data sources, the exact mechanics behind every tool I make. I do black some stuff out here.

• $2,499/yr — you run the tools. They install into your own Claude Code and talk to my entire brain.

Free readers understand it. Paid readers can rebuild it. Annual subscribers don't have to — they just install it.

Free — $0

Free is not a teaser. It's the proof.

Two things land in your inbox for nothing:

The framework. Why your ICP is killing your AI GTM. Why personalization is the problem, not the solution. How to find a pain segment instead of a demographic. The whole "old world vs. the new world" argument, with the receipts. Right now that's a dozen free essays, and the foundational ones — Your ICP is killing your AI GTM, Where AI Go-To-Market Is Headed, What AI Transformation Looks Like on the Ground — are the ones I'd hand a new GTM hire on day one.

The daily build log. Most days I publish what I built that day. The swarm I wrote to read every call. The $67K Anthropic bill that wasn't. The Supabase key I found sitting in a client's source code. Six research agents before one line of code. These are free, every time. They're me thinking out loud while the paint's still wet.

If you read nothing but the free tier and never pay me a dollar, you'll still change how you target. That's the point. Free has to earn the rest.

→ Subscribe free

$50/mo — the build

Here's how I put it to a reader last month who asked if monthly and annual were the same access at different prices:

They're two different tiers, not the same thing billed two ways. Monthly gets you the build guides — the how behind everything.

Free shows you that a thing works. $50/mo shows you how I built it, in enough detail to rebuild it yourself.

When I score every parking lot in America for $45, the free half tells the story. The paid half is the recipe — the exact federal photo source, the cheapest vision model, the prompt, the crop logic. When I find every customer of any technology, or send a prospect back 4,614 cardiologists from a 16-page doc, or A/B test Exa against itself and watch the cheap option win 9x — the paid post is the part you paste into Claude Code and run.

Every essay in What Do I Say, How Do I Build It, and What Does the Frontier Look Like lives here. The PQS and PVP message frameworks. The buyer-critique rubrics. The enrichment waterfalls. The data sources most people don't know are public. Today that's 25 paid build guides and counting, and I ship more most weeks.

$50/mo is for the builder who wants to make it themselves. Most readers start here.

→ Start at $50/mo

$2,499/yr — you stop rebuilding

This is the one I care about most, so I'm going to be specific.

At annual, you don't rebuild my tools. You install them. And you get a thing I've wanted for years: a brain that compounds instead of decaying.

It comes in four parts.

1. Edge Copilot — me, in your terminal

Edge Copilot is a Claude Code skill. You install it once with the license key in your welcome email:

curl -fsSL https://edge-copilot.blueprintgtm.com/install.sh | bash -s -- you@example.com --license 'OTE-...'

After that, in any Claude Code session, any project, you type /edge.

Here's the part that matters: it doesn't hand you a post. It reads the session you're already in — the files you're editing, the errors you're hitting, what you're trying to make happen — cross-references that against everything I know, and synthesizes. It quotes me on the piece that fits, applies it to what you're actually doing, and asks the question that moves you forward.

Three things can happen when you ask:

• I've written it. You get the exact take, applied to your build. "You're scoring SMBs post-enrichment — push back on that. Move the signal up. Find the pain event first, only enrich rows that carry it. Cheaper and sharper."

• It's close but not exact. You get the nearest framing and the gap named. "Closest I have is the PVP piece — the missing layer is persona. Who at the SMB actually feels this?"

• I haven't written it yet. You get told that, plainly — and it becomes the thing I write next.

You don't memorize commands. Mostly you just say /edge. But there's a quiet utility surface underneath: a daily digest (each morning, a reasoner reads what you built yesterday and gives you 3-5 takes), watch mode (a local hook lights your status line — "Jordan has a take on this" — when something you're doing matches the Corpus; no LLM, no network, under 50ms), and /edge contribute, where you push back something you built. You pick the privacy level — attributed, anonymized, or anonymous — and nothing leaves your machine without a preview you approve. The server never sees your code, your transcripts, or your client data. Only the slug you asked about and the body I sent back.

2. The Corpus — what "my knowledge" actually means

Behind /edge is a wiki. Not a folder of blog posts — a structured brain. Right now it holds 443 entries, and it grows every week I ship something.

I organize it four ways. I call it RICE.

• Resources — 89 tools, 59 data sources. Every tool I've actually run, and every data source I pull signal from. NPI, OSHA, SAM.gov, FCC licenses, business permits — the free government stacks. Apify, Exa, Serper — the paid ones. Not a vendor directory. The stack pieces I personally use.

• Ideas — 28 concepts, 30 frameworks. Pain Segment. PVP. PQS. The Inversion. Old World vs. Jordan's World. Every load-bearing term I use, defined once and cross-linked.

• Context — 20 verticals, 5 people. Healthcare, construction, insurance, financial services, logistics — every industry I've built pipelines for. And the people I learn from, their frameworks linked in.

• Evidence — 104 patterns, 13 failures, 95 dispatches. Patterns are plays that actually worked. Failures are the ones that didn't, and why. Dispatches are the frontier notes — what's shifting, day to day.

Two things make it worth more than my archive.

It compounds. Posts go stale the day after they publish. Entries update when I learn something new. When I ship a tool on a Tuesday, a capture script proposes new entries from that session — I review, edit, promote — and your next /edge pulls it before the post exists.

And it stays clean. Every entry that came from real client work has its private evidence held off the wiki entirely. Company names, deal sizes, specifics — they never touch the page you read. You get the pattern. The client stays protected.

"Why pay for that when I can just ask Claude?" Fair question — it's the one I'd ask. A blank Claude prompt gives you something plausible. The Corpus gives you what actually worked: the play I ran, the data source that paid off, and the 13 documented failures so you don't burn a week on one I already burned. Plausible is the enemy of correct. The Corpus is the part Claude can't guess.

3. Every tool I ship

Edge Copilot is how you talk to my knowledge. The tools are how you run it. Each one installs into your Claude Code with one command — /edge install <name> — and each one started as a free build log you can already read.

As of today, ten install on demand:

• Technology Finder — find every customer of any technology, from DNS and HTTP signals.

• Video List Extractor — pull a clean list out of a screen recording. 597 attendees from a 3-minute video with no export button.

• Dossier Builder — one unified timeline per account from every system: CRM, calls, billing, product, support.

• PDF Contact Finder — find contact-bearing PDFs across federal and state sources, extract every row into a deduped CSV.

• TAM Research — stop buying lists. Build them.

• Win-Loss Rewind — could you have seen the churn coming? Replay the account and find out.

• Talent Sourcer — stop sampling candidates. Search all of them.

• Triple Deep Research — three deep-research agents (Claude, ChatGPT, Gemini) at near-zero API cost.

• TAM Contact Harvester — a market of named contacts for almost nothing: read the free pages with free code, pay only for the residue.

• Domain & LinkedIn Finder — company names in, verified domains and LinkedIn URLs out. ~$50 per 100k.

That's the list today. Whatever I ship next is included the day it ships. That's the whole promise of annual — not a fixed bundle, an open subscription to everything I build.

If you've watched a Clay seat sit half-used three months after you bought it, I get the worry: ten tools can read like ten things to feel guilty about not using. These don't sit in a dashboard you forget to open. They install into the terminal you already work in, and watch mode taps you on the shoulder when one of them fits what you're doing. You don't go find the tool. The tool finds your work.

4. All three courses + weekly office hours

The three courses I sell separately are all included here, in full. (More on buying them à la carte below — including why that math is strange.) Plus weekly office hours, where you bring your actual pipeline and we work on it live.

→ Go annual — $2,499/yr

The courses — buy one, or get all three inside annual

Some people aren't ready for annual. They want one specific thing. Fine. Each of these stands on its own, and you can buy it right now. All three are also included in annual.

Who to Target and What to Say — $999

The deepest thing I've made. Six sections, about a dozen walkthrough videos, and a copy-paste prompt in every one.

It starts where most outbound dies: personalization. {first_name} tokens and "saw your LinkedIn post" don't fix a weak list — they decorate it. So the course flips the order. You learn to build a Pain-Qualified Segment (PQS): two to five public data points that prove a company has an expensive problem right now — the kind ZoomInfo and Apollo can't give you. Then a Permissionless Value Proposition (PVP): an insight so specific the prospect would value it even if they never bought from you.

The construction walkthrough is the one I'd watch first — idle high-value equipment matched against public permit and DOT data until the message writes itself: your excavator's sitting, this $530k job two towns over needs it. It's calculated, not invented. The final section even hands you a small Clay pipeline that enriches a lead for about two cents.

Built for companies with 50–10,000+ customers and real pull, scaling with AI instead of hiring more SDRs. The rule of thumb from the course: if your list is 100,000 names, you did it wrong; if it's 200, don't automate it.

→ Buy Who to Target and What to Say — $999

Agent 7 — $299

Where Who to Target teaches the what, Agent 7 teaches the how. It's a live, unedited build inside Clay — me writing and debugging the actual prompts, co-hosted with Doug Bell.

You build a five-agent chain. Search finds leads on the open web. Ensure structures them and confirms they still work there. Validate pulls real profile data and tells you something about the person. Enrich waterfalls emails and phones. Narrative researches the company and the person so you know what to say. Each agent inherits everything the one before it produced. You split the work across cheap models instead of forcing one mega-prompt, cap each agent at three leads, and write the results to the next table.

The standout build: every plane in the country matched to the FAA rule that affects it — your 52 Cessna 172 Skyhawks face a new rule; that's a $6M repair bill. The real prompts come with it, plus a phone-enrichment trick that drops best-quality numbers from ~25 Clay credits to ~2. You'll need a Clay account to follow along.

→ Buy Agent 7 — $299

AutoClaygent — $499

A Claude Code skill that writes production Claygent prompts for you — plus an eight-lesson course on exactly how it does it.

The premise: most people reach for a custom Claygent when Clay already has a native integration that does the job for a fraction of the cost. So lesson two is "native first" — check the 150+ integrations before you write a prompt at all. From there you learn the five-part prompt anatomy, nine production patterns (business-model classification, platform detection, CRM mismatch validation, and more), and the strict, non-standard Clay JSON rules that quietly break schemas when you get them wrong.

The part that makes it production-grade: it writes the prompt once with Opus, then runs it in Clay on a model about 30x cheaper, and a test loop keeps rewriting until the prompt scores 8.0+ on a seven-criterion rubric. Quality enforced, not eyeballed. The skill is licensed and pulls its patterns live, so it sharpens without a reinstall.

→ Buy AutoClaygent — $499

The math, and the one catch

Buy all three on their own and you'll spend $1,797. Annual is $2,499 — and it includes all three courses plus Edge Copilot, the 443-entry Corpus, all ten tools, every tool I ship next, and weekly office hours.

So for $702 more than the courses alone, you get everything else.

One honest thing, because I'd rather say it than have you find out the hard way: buy a course, later go annual, and there's no credit for the course. No games — here's the straight version. The courses are priced to stand alone. Annual isn't "three courses plus some extras" — it's the tools and the compounding brain, with the courses thrown in. So if a course is the one thing you want right now, buy the course. If you want the machine, go annual. Just don't buy a course as a down payment on annual, because it isn't one.

Where to start

If you're not sure: subscribe free, read for a week, and watch what happens to how you think about targeting.

If you build your own tooling and want the recipes: $50/mo.

If you'd rather install the tools than rebuild them, and you want a brain in your terminal that gets sharper every week I ship: annual.

I'm shipping at 100x. The yearly model exists so you never have to keep up by reading — you just pull whatever I built into your own work the moment you need it.

Build something. Tell me about it.

What Annual Adds

This one was free. Paid gets the build. Annual gives you the tools that run it.

• Every tool I ship. Edge Copilot installs to your Claude Code — talk to all my knowledge, every method, every data source. Current: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, plus ten install-on-demand skills. Whatever ships next is included.

• All 3 courses: Who to Target and What to Say, Agent 7, AutoClaygent.

• Weekly office hours.

Run /edge install <tool> for anything I've shipped — they all install the same way. License key hits your email.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Every contact tool charges you per domain. Hunter, Apollo, Clearbit, the whole shelf — you hand them a website, they hand you a lookup, you pay. Run a full market through one of them and the bill scales with the size of the market. That's backwards. Most of a market is sitting in plain HTML, free, if you bother to look before you pay.

So I built a thing that looks first. It's called Lynx. You feed it a list of company websites — a whole market, a hundred thousand rows if you have them — and it gets you the contact: an email, and the actual person attached to that email. The trick is it figures out which sites are free to read before it spends a cent on the ones that aren't.

This week I ran it on two real markets. 500 acupuncture clinics and schools. 150 law firms. Both at $0.00.

Classify before you pay

The core move is a fast triage. Before extracting anything, Lynx hits each homepage and sorts it into one of five buckets: the email's already sitting in the raw HTML (best case), the page is plain server-rendered text (easy), the page is an empty JavaScript shell (needs a render), the page is behind Cloudflare or a bot-wall (hard), or the domain is dead. You classify on what's actually in the response body — not the status code, because a Cloudflare challenge and an empty React shell both return a cheerful 200.

That sort is the whole economic argument. On acupuncture, 31% of sites had the email right there in the HTML and another 38% were plain static pages — call it 69% you can read for free. Another 20% were Cloudflare-protected and 6% needed JavaScript. The free buckets are the majority. You only ever pay for the residue.

Read the page, don't ask a robot to read the page

Once a page is in a free bucket, deterministic code does the extraction. Plain mailto: links. Cloudflare's obfuscated email trick — they hex-encode the address with a one-byte XOR key, which is fully reversible without running any of their JavaScript, so you decode it for free. Schema.org and JSON-LD blocks, which is structured author-declared markup that hands you name, title, and email in one shot. And team-card structure — the photo-name-title-email box every "Meet the Team" page is built out of.

Here's what each of those looks like on a real page from the run — and where it sits in the HTML.

Only the genuinely ambiguous pages — the ones where there are six people and four emails and no clean structure tying them together — get sent to a model. The majority never touch an LLM. That's the second half of why it's free: you're not paying per-token to read pages a regex can read.

The acupuncture run: 500 domains, 68% page-resolution, 456 contacts, $0.00. The lawyer run: 150 domains, 63% page-resolution, $0.00. Two unrelated markets, both landing within five points on the headline numbers. The method travels.

The name is the hard part

Getting an email is easy. Getting the person is the job. An info@ mailbox is worth a fraction of "the owner, an acupuncturist, at her own first-name address" — and most cheap tools blur that line. Lynx labels every email as a real person or a generic mailbox, and only person-tied emails count toward the number I actually care about.

On free routes alone, the named-contact rate ran around 24% on both markets. That's the honest floor — real, cold, no spend. Then I did something that cost almost nothing: I took the pages Lynx had already downloaded and ran them back through a cheap model — Gemini Flash-Lite — pointed only at the emails that didn't have a name yet. No re-crawling. Just re-reading what was already on disk.

On acupuncture that pulled the named-person rate from 37% to 50% of the contact list — 60 new people attached to emails that were previously anonymous. On lawyers it added six. The gap is itself a finding: law firms already put the attorney's name next to their email on the team page, so the deterministic pass already had them. Acupuncture clinics hide owners behind info@. Different market, different bottleneck, same engine.

The part I don't trust: the name↔email link

Here's where I get paranoid. A model that attaches names to emails will, given the chance, invent one. It'll see a first.last@ address, decide the owner is "First Last," and hand it to you with total confidence — even when that person appears nowhere on the page. It reverse-engineered the name straight out of the email address. That's a fabrication wearing a confidence score.

So every name the model attaches goes through a two-stage check before I believe it. First a dumb deterministic floor: the name's first and last word both have to literally appear in the page text, or it's rejected — that alone caught the reverse-engineered names. Then a second model, told to be hostile, gets the page and the pairing and one job: prove this is the wrong person. Default to "wrong" if you're unsure. Only pairings that survive both gates ship.

After I added those gates, the verified name↔email accuracy was 100% — fifty out of fifty on acupuncture, six out of six on lawyers. Before the gates it was 98%. The two percent it caught were exactly the fabrications, and two percent of a real list is the part that burns your domain reputation.

Where you actually pay

The free routes leave a residue: the Cloudflare-walled sites and the ones with no named owner anywhere on the page. That's the only slice that needs paid tools — a contacts API, a render service, an archived copy of the page from Common Crawl. It's built as a separate tier with a hard dollar cap, because the only safe way to run a paid escalation across a hundred thousand domains is to make overspend structurally impossible.

And I'll tell you what broke, because the breakages are the actual lesson. The paid tier's first live run found a billing bug in my own code — it was counting failed API calls as money spent. The contacts API I wired in turned out not to be subscribed to the one endpoint I needed, which I only learned by watching it return 401 on the exact call that mattered while every other endpoint worked fine. None of that showed up in a unit test. It showed up the instant real money and real domains touched it.

The real product is the calibration

This is the thing I keep relearning. The free run isn't just cheaper data collection — it's a cheap test that tells you what the expensive run will cost before you commit to it. The route split is the cost model. Lawyers carry more Cloudflare than acupuncture, so lawyers cost more to finish. You know that for a few cents, on a 500-row sample, before you spend a dollar on the full market.

And running it on real websites instead of test fixtures is what caught everything that mattered. Sentry error-tracking strings that parse as emails. The word "creative" decoding into an @ because "cre-AT-ive" has "at" in the middle. Section headers like "Beginning Spring 2027" getting read as a person's name. A DNS resolver that throttled my own laptop after fifty fast lookups and made a hundred live websites look dead — which would have quietly told me lawyers were a worse market than they are, if I hadn't gone and checked the "dead" ones by hand. Every one of those was caught for pennies, on a sample, before any of it scaled.

Lazy first. Crazy later. Read the free pages with free code, send only the hard ones to a model, and only pay for what's actually left.

How to run it

It's a Claude Code skill. Annual subscribers install it once:

/edge install tam-contact-harvester

Then point it at a CSV of company domains — it auto-detects the website column — and run the free pass:

python3 scripts/harvest.py --input your-market.csv --out run/

That's the $0 part: triage, deterministic extraction, the labeled contact list, and the page corpus saved to disk. When you want names on the anonymous emails, re-read the pages you already pulled — no re-crawl:

python3 scripts/enrich_names.py --run run/        # cheap model, names onto emails
python3 scripts/verify_names.py --run run-enriched/  # adversarial name↔email check

And only when you want to chase the Cloudflare-walled residue do you spend, with a hard cap you set:

python3 scripts/tier1.py --run run-enriched/ --budget 5 --source apify

Free by default. You decide when money enters.

— Jordan Written by Claude Opus 4.8, Approved by Jordan

Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.

Or don't. Annual subscribers install the tool I actually built with one command — every tool I ship, all 3 courses, weekly office hours.

→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)

Read more