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

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)

You've got a list of company names — tens of thousands of them — and you need a domain for every one. Vendors sell you that for fifty cents a row. On a 100,000-company list, that's fifty grand to look up something the internet already knows.

I built a Claude Code skill that does it for about a twentieth of a cent each. Free where the answer is already sitting in a table I own or in Google's Knowledge Graph. A rounding-error search where it isn't. A cheap model only on the names that are genuinely ambiguous. And it checks every domain against what the site says about itself — so it never hands you a confident wrong answer. The whole list lands for about fifty bucks.

The wall every list hits

Every enrichment job starts the same way. You have names. You need domains. Nothing downstream works until you have them — no contacts, no firmographics, no message.

So you reach for one of three things. You pay a per-row vendor — ZoomInfo, Clearbit — fifty cents a row while the meter runs. You Google each name programmatically and take the top result. Or you hand the whole list to an LLM and ask it for domains.

All three have the same hole: none of them check whether the answer is right. The vendor hands you a domain, the search hands you a domain, the model hands you a domain — and at a hundred thousand rows, you're not checking by hand.

At scale, the data is all over the board

Ten companies, you eyeball it. A hundred thousand, and there's no clean rule that holds.

Sometimes the domain is the name. "Anderson Plumbing Heating and Air" lives at andersonplumbingheatingandair.com — the whole mouthful, the "and" included.

Sometimes the domain looks nothing like the name:

• Boston Medical Center → bmc.org. An acronym. A .org. Nothing in the name points to it.

• Sandy Springs Internal Medicine → ssim.com. Four words collapsed to four letters.

• Mass General Brigham → massgeneralbrigham.org, not massgeneral.org, not .com.

This is where the shortcuts break. Google "Boston Medical Center" and the top hit might be a directory, a LinkedIn page, or a different Boston clinic with a similar name. Ask an LLM and it'll hand you bostonmedicalcenter.com with total confidence — a domain that doesn't exist. The hard part was never the obvious names. It's the tail, where the domain shares nothing with the name, and the top result is wrong as often as it's right.

What the tool actually does: a waterfall

No single source resolves a messy list. So you stack them cheapest-first and stop the moment one is confirmed.

• Free first — two sources cost nothing. Google's Knowledge Graph hands back the official site for any company it already knows, free, a hundred thousand lookups a day. And a local table — twelve million US businesses scraped from Google Maps once — carries the small-business tail, phone included. A big slice of your list clears right here.

• A rounding-error search, for the rest. When the owned table misses, one cheap search call returns the candidate — the same Google lookup you'd do by hand, except every hit has to pass verification before it counts.

• A cheap model, only on the genuinely ambiguous. Parent versus subsidiary. A rebrand. A name forty small businesses share. Most rows never reach it.

• Flag, don't guess. When nothing can confirm the domain, the tool returns needs review instead of a confident wrong answer.

Every tier above costs less than the one below it, and most of your list clears in the first two. That's the spend rule the whole thing runs on: as free as is wise. Free when it's right and fast. A fraction of a cent when that's what makes it sure. Never a flat vendor fee for work the website will confirm.

The advice that wastes everyone's time

There's a tip that gets repeated every time domain resolution comes up: "verify it with the SSL certificate — the cert names the company."

It's a coin flip at best. I pulled the live certificate on twelve well-known companies. Five named themselves. Seven didn't. And there's no pattern you can use:

• Name themselves: Apple, IBM, Stripe, Datadog, Snowflake.

• Say nothing: Anthropic, Notion, Ramp, Shopify, DoorDash, Klarna, Gong.

Old guard and modern SaaS sit on both sides — you can't predict it. Their certs are issued by Let's Encrypt, Google, and Amazon, free authorities that never write a company name into the cert.

Now check the businesses actually on your list. The ones from earlier — bmc.org, ssim.com, the plumber — every one runs a free certificate with no name in it. For the tail, the cert is silent. It tells you who issued it, not who owns it.

So how do you know you've got the right domain? You ask the page. Its title says the company name. Its Open Graph tags say the company name. Its structured data — the block sites publish for Google — often lists the company's own LinkedIn and Wikipedia pages. The site tells you who it is. You verify against that, not against a certificate that's blank two-thirds of the time.

The discipline: a wrong domain is worse than a blank

This is the part most tools get wrong. They'd rather return something than nothing.

But a wrong domain doesn't just waste a row. It poisons everything downstream — you enrich the wrong company, you find the wrong contacts, you send a stranger a message about a problem they don't have. A blank you can fix later. A confident wrong answer you ship.

So when the page can't confirm it, the tool says so. "Summit Roofing," no city, a dozen live candidates and nothing that proves which — needs review. It doesn't pick one and hope. That refusal is the feature.

Own the data, don't rent each lookup

The free tier — the twelve-million-business local table — isn't mine. Eric Nowosolski (GrowthEngineX) scrapes Google Maps and ships it open-source. Credit where it's due.

Own the data once, stop renting each lookup. The phone that disambiguates "Riverside Dental in Portland" from the one in Kansas is just sitting in the row. You don't pay a vendor per call for a fact you can hold locally.

The cost, honestly

It's not magic, and the tail is real. On a hard test slice, the confident majority resolved clean and cheap; the rest got flagged for a human instead of guessed. I measured the bill: about $0.0005 a name — fifty dollars for a hundred thousand. The free Knowledge Graph carries the companies Google already knows, the owned table carries the small-business tail, a rounding-error search picks up the rest, and a cheap model settles the genuine ambiguity.

That fifty assumes you're buying search at volume — run a small one-off list at retail pricing and it's closer to a hundred. Either way: your vendor charges fifty cents a row for the same list, skips the verification step, and bills you fifty thousand dollars for a list you can't trust. Fifty dollars for one you can, or fifty thousand for one you can't.

It was never really about domains. The same move — take the cheapest source that actually knows, verify what the thing declares about itself, refuse to assert what you can't confirm — resolves LinkedIn URLs, parent companies, rebrands. Verify, don't buy.

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

My friend Matt Braley was at Chili-palooza last week with me.

He texted me. He wanted to see Claude.

Most people, when they say that, they want a demo. Watch me type a prompt. Watch the cursor blink. Watch a paragraph of marketing copy appear. Then they nod. Then they go home and don't change anything.

That's not what I do anymore.

I told Matt to come over. We sat down. I opened my laptop. I said, "What do you actually need."

He's a CRO. He sells big-deal vertical SaaS, and he advises a portfolio of AI companies. He was at a conference and wanted to follow up with people. He wanted leads — not in general, leads scored against him.

Sixty minutes later he walked out with one Google Sheet. Three tabs. Every tab was a working list he could call on Monday, all three graded against the same one-page rubric of who Matt actually is.

This is what showing Claude looks like now.

The three tabs

First, the rubric. Before any of the three tabs, we built one file: matt_profile.md. I pasted in his LinkedIn, then ran three sub-agents in parallel to enrich what was missing — his AI advisor portfolio, his investor network from Stage 2 Capital, his exit history at EngageSmart. The output was a one-page profile of who Matt is, who he's already talking to, and what kind of person it would be a waste of his time to meet.

Every score on every tab grades against that file. Same rubric, three populations. That's the only reason any of this means anything.

Every attendee at the conference, scraped and enriched

Matt sent a screenshot. Some WhatsApp group from the conference had dropped a link: ████████████████████████████.lovable.app. Chili-palooza had built a Lovable app that listed every attendee — name, company, title, LinkedIn URL, all alphabetized A through Z.

Claude OCR'd the URL out of the screenshot. Loaded the Lovable app. Walked every letter section A–Z. Pulled 138 attendees into a CSV with name, title, company, and LinkedIn.

Then enrichment. For every attendee Claude pulled the full LinkedIn profile via RapidAPI — work history, location, headline, photo. Then the company side: what the company does, headcount, funding stage. Then FullEnrich for cell phone and personal email on every row.

That's one tab. 138 humans, every one of them with a phone, an email, a LinkedIn, a company description, and a photo. Matt didn't make this. He didn't pay for this. Chili-palooza handed him an A–Z directory and we turned it into a contactable spreadsheet in about fifteen minutes.

Every Series A–D vertical SaaS startup that raised in the last year

This tab has nothing to do with the conference. This tab is about the rest of Matt's year.

I host 501 public go-to-market playbooks at playbooks.blueprintgtm.com. Every one is a real vertical SaaS deal I've worked or modeled — the company, the segment, the pain, the data signal. Three years of pattern library.

I asked Claude: take all 501. Filter to the ones where the company itself raised Series A through D in the last twelve months — that's Matt's investing band. Find the CEO, the founder, the CRO, the president. Find their email. Find their phone. Score every one of them against Matt's same rubric.

It's an eight-stage pipeline. Each stage writes a checkpointed CSV so I can re-run any step. Stage 1 loads the 501. Stage 2 hits Exa for funding news on every domain and uses GPT-4o-mini to extract the round and date — 501 in, 54 out. Stage 3 resolves each surviving domain to LinkedIn via Blitz. Stage 4 runs Blitz's waterfall to find every CEO, Founder, CRO, and President — 169 contacts stacked across the 54 companies. Stage 5 enriches each contact's LinkedIn profile via RapidAPI. Stage 6 finds email and cell phone for all 169 — Blitz first, FullEnrich on the misses. Stage 7 grades every one with Sonnet 4.6 against Matt's rubric — fit score, fit band, the talking point. Stage 8 writes a tab on the same Google Sheet.

Matt's not getting a list. He's getting an ordered queue. The top is the call he should make Monday morning. The bottom is the people he should skip. Every row already has the talking point. He doesn't have to think about it. He has to dial.

Every conference attendee scored against Matt — five swarm agents, six minutes

Back to the 138 attendees. Out of 138 people, who should Matt actually walk up to.

This is where I stopped touching the keyboard and let agents do it. Blueprint Swarm: five Opus sub-agents in parallel, each one given Matt's profile and a chunk of the attendee list. The job for each sub-agent — read this attendee's LinkedIn, read Matt's rubric, score the fit 1–10, label it high/medium/low, write the reason, write a one-line conversation starter Matt could literally say to them at the bar.

Five agents, 138 attendees. About six minutes wall-clock.

Output: 33 high, 65 medium, 40 low. Every row had a paragraph of reasoning and a tailored opener. "Curious how you're thinking about attribution for AI-driven outbound at Upside — at EliseAI we're wrestling with how to credit pipeline when an agent is doing 80% of the touches. Where does Upside draw the line?" That kind of opener. Specific to that human, written by an agent that had read both their LinkedIn and Matt's bio.

Then Claude built a mobile-responsive HTML leadbook out of it. Photos, filters by tier, click-to-call, click-to-email, the conversation starter visible right on the card. Modeled after a leadbook I'd built for a previous client. Published it live with the publish-html skill so Matt could open it on his phone walking into the next session.

That's the third tab — same data, ranked, with the talking point.

What this is not

This is not a demo.

A demo is when you show someone the tool and they leave with a story. "Jordan showed me Claude. It was cool."

This is when you show someone the tool and they leave with the work. "Jordan and I built three lists. I'm calling forty of these people on Monday."

The difference is whether the thing you made survives the meeting.

Most demos don't. The screen goes dark. The slides go away. Nothing changes on Monday. ← OPUS LOVES THIS FUCKING PATTERN!

What we did survives because Matt has it on his laptop. He has the GitHub repo — I invited his braley-ai handle so he owns the code. He has the Google Sheet shared to his email. He has a published HTML leadbook on his phone. He has a license to re-run the whole pipeline next time he goes to a conference.

The asset doesn't depend on me being in the room.

The hour

I want to be specific about the hour.

We didn't write any code by hand. I didn't pull up a notebook. We didn't open a Python file together.

I told Claude what we were doing. Claude scraped the Lovable app. Claude built the enrichment pipeline. Claude spun up the swarm. Claude wrote the HTML leadbook. Claude built the eight-stage playbook pipeline. Claude pushed every output to the same Google Sheet and to a published page.

I sat next to Matt the whole time and narrated. "OK now we're scraping the directory. Now we're enriching contact data. Now the swarm is reading his profile. Now we're scoring 138 people against him in parallel."

Matt didn't need to learn anything. He needed to see the shape of it.

That's what showing Claude is. You sit next to someone. You tell the agent what you both want. The agent builds the thing. The other person watches the shape of the work and goes, "Oh. That's how this is supposed to feel."

Why I'm writing this down

Because most of you, when somebody asks to see your tool, you still do a demo.

Stop.

Ask them what they need. Build it while they watch.

If you can't build it in an hour, your tool isn't ready. If you can build it in an hour and you're still doing slide decks, your job isn't selling — it's stalling.

The shift is small and total. Demos are about you. Builds are about them. One ends with a thank-you email. The other ends with three tabs, a published leadbook, and 169 vertical SaaS CEOs already scored against your rubric.

Matt's calling forty people on Monday. He didn't see Claude. He used it.

That's the only version of "showing Claude" I do anymore.

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. Whatever ships next is included.

• All 3 courses: GTM Engineer, Pain-Qualified Segments, The Inversion.

• Weekly office hours.

Run /edge install agent-swarm once your license key arrives — the swarm I used to score Matt's 138 attendees 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)

Every post you've read on this Substack was touched by six separate systems before it reached your inbox. Not one of them is Substack's editor.

I didn't plan it this way. It started with a session capture hook — a script that fires at the end of every Claude Code session and logs what I built. That was March. By May I had 40+ scripts, 5 sub-skills, a 458-entry knowledge corpus, and a publishing pipeline that bypasses Substack's own tools because they can't render images correctly.

The whole thing runs for about fifty cents a post.

This is what's behind the curtain.

The six systems

1. Session capture. A hook fires every time I close a Claude Code session — any session, any project, anywhere on my machine. It reads the transcript, extracts what tools I used, what files I touched, what topics I worked on. Tags everything to a taxonomy. Appends to a daily log. When enough sessions pile up on the same topic, the queue tells me I have material for a post.

I don't decide what to write about. The capture system tells me.

2. Voice enforcement. Three files govern everything that sounds like me. A style guide extracted from 20+ transcript recordings. An anti-patterns list with 18 categories of words and patterns I never use — "game-changer," "leverage," "dive into," "unlock," all dead on arrival. And a translation map that catches internal jargon before it leaks into prose.

Every draft runs through automated grep checks before it gets near Substack. If it catches "methodology" or a bare CLI flag in narrative text, the draft blocks. No exceptions.

3. Headline optimization. Every title scores on six axes: Specificity, Action Promise, Pattern Interrupt, Identity Signal, Curiosity Gap, Readability. The system generates 3-4 alternatives with subtitles and SEO titles, then runs demand research through Serper and Exa — what people actually search for, what questions they ask, how saturated the topic is on Substack.

Cost: four cents per research run. The 33-character rule is enforced automatically. Gmail mobile truncates there. If the first 33 characters of your title don't stand alone, you've already lost the open.

4. Image generation. Every post gets images — no exceptions. One per 200-300 words. Half are AI-generated via Gemini (concept illustrations in the calligraphy aesthetic you see on every hero). Half are programmatic — HTML templates screenshotted through headless Chrome. Quote cards, stat cards, framework diagrams.

I built the programmatic pipeline because Gemini can't reliably produce stat cards with correct numbers. Turns out an HTML template with Playwright is more reliable than a diffusion model for data visualization. Who knew.

5. Publishing pipeline. Substack's MCP tool can't render images. Its markdown-to-ProseMirror conversion puts image types in the wrong field and leaves critical attributes null. Images show up as raw text.

So I reverse-engineered the ProseMirror JSON schema and built a direct API publisher. It converts markdown to the exact node structure Substack expects. Uploads images to Substack's CDN, builds the JSON document, PUTs it directly to the API.

The auth is self-refreshing. A wrapper script pulls the session cookie from Chrome on every launch. No credentials stored on disk. No rotation. Sign in once in your browser, the pipeline handles the rest.

6. Knowledge corpus. 458 entries organized in four layers — Resources, Ideas, Context, Evidence. Nine kinds of page. Every entry carries structured metadata with tier gating, bitemporal validity, and a closed vocabulary of 13 relationship types.

This is what Edge Copilot reads when subscribers ask it questions. The corpus is the brain. The Substack is the mouth.

The numbers

• 40+ scripts — Python, TypeScript, shell

• 5 sub-skills — content generation, headline optimization, image generation, session capture, Slack recaps

• 458 wiki entries — the Corpus behind Edge Copilot

• $0.50 per post — Whisper transcription + Gemini images + headline research

• $0.04 per headline research run — Serper autocomplete + Exa semantic search

• 6 API keys — Anthropic, OpenAI, Google AI, Serper, Exa, Substack (cookie-based)

— Written by Claude Opus 4.6, Approved by Jordan

Below is how every piece connects — the architecture, the pipeline order, the APIs, the costs. Enough to understand the system. Not enough to clone it.

If you're a fellow Substack creator and want the actual repo, DM me on LinkedIn. This isn't part of the annual subscription. It's a separate conversation.

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

Read more

April 7, 2026 · Build log

A vertical SaaS company has 1,200 churned accounts sitting in their CRM. Dead customers. Money that walked out the door. The CRO wants to know one thing before the board meeting: could we have seen any of this coming?

Not from internal usage data. Not from NPS scores. From the stuff anyone can pull up in a browser — public company registrations, Google profiles, BBB filings, LinkedIn, socials.

If the answer is yes, the churn problem isn't a churn problem. It's a qualification problem that got missed at the top of funnel.

So I pointed a swarm of research agents at it. All parallel. Each agent taking a single account and running it against the same five hypotheses — is this the right type of operator, is there a specific pain the product actually solves, are the stakeholders multi-seat or a one-person show, is there a real decision-maker on the deal, and does the company's age and operating footprint match the customers who stay. Validate or invalidate each one with public evidence. Write the findings as structured records. Move on.

Here's the tension. If I'm wrong — if churn really is random or driven by stuff you can only see post-sale — then this whole exercise is theater. The board gets a pretty report. Nothing changes. Sales keeps selling the wrong people and the bucket keeps leaking.

If I'm right, the sales team has been qualifying on vibes for years and nobody noticed.

The swarm came back. 19% of the churned accounts weren't even the right kind of operator. Not close. Wrong business registration category, wrong service model, the kind of miss you can spot in under a minute of browser research. That's sales closing deals they shouldn't have pitched.

Six signals survived the cut. Specific pain present. Multi-stakeholder engagement on the deal. Side-job operators versus full-time. Decision-maker absent from the call history. Deal velocity. Company age. Two signals I wanted to matter didn't — public review volume barely moved the churn rate, and whether they were switching from a named competitor barely moved it either. Cut them both. If it's not predictive, it doesn't belong in front of a board.

Then the report broke.

I'd handed the synthesis to Claude Opus in the afternoon. Clean HTML, charts, the whole thing. Opened it up in the evening and four signal bars were showing 0.0%. Opus was emitting percentages in a format the renderer didn't understand. Classic. I stopped trusting the synthesis layer and pulled the bar values directly from the raw per-account CSV. Bars came back.

The second problem was worse. The report listed churned account names in a recovery section with no way to actually act on them. A name in a PDF doesn't help a CS rep on Monday morning. So I embedded the underlying tables straight into the HTML as base64-encoded CSVs. One per archetype. One per closed-lost reason. One per risk tier. Every bucket with a count got a download button next to it. Each row carries the ICP score, the signals in plain English — switching from a named competitor, multi-stakeholder engagement — and the risk factors. Not codes. Not internal gate IDs. Words a human can read.

Last pass was the language audit. Opus had been helpful and creative, which is to say it had editorialized all over the thing. "ARR destroyed." "Ghost company." Names for the gating logic that read like internal Slack jokes. None of that goes in front of a board. I wrote a sanitizer that runs at render time. "Destroyed" becomes "lost to churn." Internal nicknames become plain descriptions of what the check actually does. If a board member has to ask what a word means, I've already lost them.

Shipped to a password-protected URL an hour before the meeting. The conservative-gate scenario pressure-tests next. If the model holds up when a skeptical CFO tries to poke holes in it, the sales team gets a new qualification checklist on Monday and 19% of their pipeline stops existing.

That's the right outcome. Smaller pipeline. Better close rate. Customers who actually stay. The board's job this week is to figure out if they believe it.

The lesson I keep relearning: a synthesis layer is a narrator. Narrators embellish. When the output is going to an executive audience, pull the numbers from the source, never from the narrator's summary.

— Written by Claude Opus 4.7, 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

April 5, 2026 · Build log

The repo looked like a junk drawer.

A dozen directories at the root with no organizing principle. Duplicate skill folders. A dead worker project sitting there like a ghost. Loose PNG files. A stray interview-prep HTML file parked next to the Vercel configs. I'd been meaning to clean it up for weeks.

You know the feeling. It's the codebase equivalent of that drawer in your kitchen with the batteries, the takeout menus, and one rubber band. You keep opening it. You keep closing it. You keep not dealing with it.

Today I dealt with it.

I kicked off three research agents in parallel — one auditing structure, one auditing Vercel deployments, one auditing symlinks. They came back with a full inventory. The plan wrote itself. Two buckets for skills — enrichment and blueprint. Four new top-level directories for tools, knowledge, infrastructure, and assets. One rule for the products with brand names: those stay at the root, where they belong.

Then I executed the moves in logical chunks.

Here's where it got ugly.

One of the subdirectories had a hidden Git directory tucked inside it. Which means it wasn't tracking as part of the monorepo at all. It was a repo hiding inside a repo, pretending to be a folder. I stripped it, added it back as a Git subtree, and wired the symlink so Claude Code could find the skill. That took three tries. The first two, I had the subtree pointing at the wrong ref. Git does not care about your feelings when you do this.

The marketing site problem hit right after the push. When I'd committed the marketing site nested inside the Blueprint Cloud project, the Next.js compiler decided the marketing pages were Blueprint Cloud routes. Vercel build broke. Red everywhere.

The fix: untrack it, move it to the repo root as a first-class product directory next to the other brand-name products, and guard it in gitignore so nobody nests it again. Then I updated the project docs so the next person — probably me, in three weeks, with no memory of today — knows why it lives there and why it's manual-deploy-only.

That was session one. Session two was this thing. On the Edge.

The design question was simple and hard: how do you make a Substack sound like me and not like a polished pundit blog? I've read those. You've read those. They all sound the same because they all start with "In today's rapidly evolving landscape" and end with three bullet points nobody will remember.

The answer was to start at the capture layer, not the writing layer.

I built a Claude Code hook that fires every time a session ends. It reads the transcript, tags the work against a taxonomy tree I'd mapped out, and writes the session into a daily log. A queue file holds readiness scores so I can see which topics are warming up. Then the principles file — no fabrication, clients are sacred, information ink. A section and topic tree. An anti-patterns file pulled straight from transcript analysis, so the thing knows what I'd never say. Kyle Norton got his own page (I ripped all he has ever said — and gave it to him so he could use it.)

The notification rule: stay quiet unless five sessions pile up on the same topic, or eight total. I do not need another tool pinging me.

Then came the unlock. And it came from one message.

I'd written a first draft that morning about pain segments. It read fine. It sounded like me. It was also completely made up — a composite campaign with invented numbers, the kind of thing that sounds real but isn't. I was about to ship it.

Then I got a note from Jacob: "Last week I ran two campaigns. Same ICP. One got 1.2% positive replies. The other got 11.4%."

Real numbers. Real campaigns. And my draft had nothing to do with either one.

I deleted it.

That's the rule now, baked into the capture layer: never invent the scenario. Write from what actually happened or don't write. The next pain-segment post goes out when there's a real session to anchor it to. Not before.

A Substack that invents the example proves you're a writer. A Substack that only writes what actually happened proves you're a practitioner. Those are different products. Only one is worth reading.

— Written by Claude Opus 4.7, 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

March 26, 2026 · Build log

"Wait, wait, wait. You have zero call transcripts."

That was me, mid-session, staring at a finished churn analysis. Three years of customer data. 2,400-plus accounts classified. Churn patterns, active health, deal counts, all split by tier. The agents had run. The report script had opened. Every dossier looked complete.

Then I scrolled. Five customer voice snippets per account. No transcripts. None.

The whole thing was CRM metadata wearing a costume.

Here's the thing. We had 72,000-plus call recordings sitting in the database. Over 500 megabytes of actual human conversations. Churned customers explaining why they left. Champions describing botched onboardings. The reason we pulled those recordings in the first place. And the agents had ignored all of it, because the dossiers they were reading from had five snippets stapled on top of CRM fields and called it a day.

It's like hiring a detective, handing them the suspect's LinkedIn, and asking them to solve the murder.

So I killed it. Started over.

A parallel session had been doing the right thing in the background — enriching every dossier with the actual call transcripts. While that ran, I wrote four new agent definitions: a churn forensics pass, an active health pass, a churn classifier, and an auditor that sits on top of the whole thing. Plus a batch preparation script and a status monitor. Nothing fancy. Just the plumbing to fan work out across a lot of agents and catch them when they lie.

Before I launched eight hundred-plus agents, I tested three accounts by hand.

One rich account with sixteen transcripts. Confidence score came back at 0.92. Eighteen verbatim quotes. A full story about a champion who got burned by onboarding. That's what good looks like.

One metadata-only account. Confidence: 0.35. The auditor correctly flagged it as a data quality disaster — 167 timeline entries misattributed from other accounts. The agent didn't try to make something up. It said "this is broken" and moved on.

One thin account with almost nothing. Confidence: 0.15. Output: "Unknown / Insufficient Data." No fabrication. No hallucinated insight. Just silence, which is exactly what I wanted.

All three passed. Ship it.

The final swarm: over eight hundred agents across two tracks. Churn forensics on one slice of accounts. Active health on another. Originally I'd assigned the thinnest accounts to Haiku to save money. I was wrong about that. A thin account deserves the best read of whatever scraps exist, not the cheapest. A thin dossier is harder to read well, not easier. I reassigned everything to Opus and launched in waves of ten.

If I'd shipped that first version to the client, the deck would have read clean. Charts, percentages, churn reasons ranked by frequency. It would have been convincing. And every conclusion would have been built on structured field data from a CRM nobody trusts, instead of the seventy-thousand-plus recordings of customers actually telling us what happened.

That's the failure mode with agent work. The output looks done. The files exist. The JSON is valid. The dashboard renders. You have to actually read what went in.

One quick aside from later that night. I pulled up the agent-swarm skill and spent thirty minutes writing plain-English copy for it — ten numbered steps, a three-sentence pitch. Not for a report. Just so I could explain to someone why fanning out across parallel Opus agents with a mandatory auditor beats one giant context window trying to hold everything. The short version: you test on three before you fan out to eight hundred, and the auditor catches the fabrications before they hit your output.

Next up: wait for the remaining batches to land, run synthesis across the full account list, and read the damn transcripts this time.

— Written by Claude Opus 4.7, 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

March 24, 2026 · Build log

Every vertical I've built this year started the same dumb way. Fire departments. Chiropractic software buyers. 3PL logistics. Each time I'd sit down and hunt for data sources by hand. Score them in my head. Pick an anchor. Hope I picked right.

Three builds. Three different patterns. Zero shared code.

My pipeline had six phases on paper. Five of them worked. The sixth — the one at the very front, source discovery — was an empty file and some comments in a doc. The most important decision in the entire system was getting made on vibes.

I didn't want to just build it. I wanted to see the hole from the outside first.

So I asked Claude to explain the whole pipeline back to me in plain English. The six-phase arc. The dual-file schema — canonical for salespeople, enriched for everything else. The sub-agents. Then the question that mattered: what's not built?

Phase 0. No scorer. No registry. No build planner. Nothing.

Here's what bugged me. I had done source discovery. Three times. It just lived in my head and in three different codebases that didn't talk to each other. The fire department work ran through ten phases and about eighty-nine scripts, all anchored to a national incident registry. The chiropractic build used Google Maps plus a federal provider registry with address-based fuzzy matching. The logistics work needed multi-attempt domain resolution — fuzzy first, then Serper, then Exa, then OpenWebNinja — because single-pass resolution shits the bed on messy company names.

Same shape every time. A scored anchor source, a universal entry point, a plan. I just kept rebuilding it from scratch like an idiot.

I sent three agents in parallel to read the three old builds and tell me what they had in common. Patterns came back fast. Every successful build had the same implicit structure — I'd just never externalized it.

So I built Phase 0 that afternoon. A schema module for the constants — source categories, access methods, pipeline phases. A source-discoverer sub-agent. A scorer with a four-criteria rubric: coverage, website presence, data quality, cost. Plus a registry, a field mapper, a build planner, a research adapter, and an init.

Four verification tests. All four passed on the first real run.

The national fire incident registry scored 70 and ranked first — which is exactly right, because that's the anchor I'd actually used when I built that vertical by hand. The scorer matched my intuition on the one build I knew cold. That's the only way you trust a scorer the first time you turn it on: you make it explain a build you already understand, and you check whether it agrees with you.

Here's the part that actually mattered, and I almost missed it.

My first instinct was to treat Phase 0 as a one-time thing — the step you run when you start a new vertical. That's wrong. This needs to run for everything. Every re-run. Every refresh. Every time the data landscape shifts under a vertical I already built. Data sources disappear. New ones show up. Costs change. Coverage changes. If Phase 0 is only the kickoff, you've frozen the pipeline to whatever was true the day you launched it.

The source registry isn't a kickoff step. It's the universal front door. Updated all four architecture docs to say so before I closed the laptop.

Next up: Phase 1 ingestion. Pull the winning anchor into the canonical companies file and kick off the enrichment waterfall. But that's tomorrow.

The thing I keep re-learning: the build that matters is usually the one that turns a pattern you keep repeating into a thing that repeats itself.

— Written by Claude Opus 4.7, 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

Last year I ran the same question against two SaaS vendors: who uses this thing?

Jira: 80+ confirmed customer tenants. Three hours. $0.

Jane App, a patient-portal EHR: 34,677 practice domains across sixteen platforms. One afternoon. $148 all in.

Different cost. Different tools. Different technique entirely. And if I'd tried Jira's technique on Jane App, I'd have gotten zero. Vice versa.

That's the most expensive lesson in vendor-customer discovery, so learn it off my dime: silver bullets are vendor-architecture-dependent. Before you write a scraper, you have to diagnose what kind of vendor you're hunting.

Family A — the embed trick. EHR vendors ship JavaScript and iframes that practices paste into their own websites. The embed is the product. Jane App's value to a practice is the booking widget that lives on yourclinic.com/book — the practice doesn't move to janeapp.com, they integrate Jane's code into their site.

That means every Jane App customer's website contains Jane's code in its HTML source. Every one. PublicWWW indexes 516 million pages of HTML. Query: "cdn.janeapp.com". Get back every site that loads Jane's script. Thirty queries across sixteen EHR platforms cost $148 and returned 34,677 domains at 80%+ precision.

Family B — the tenant trick. Jira Cloud doesn't embed in customer sites. Every Jira customer gets their own subdomain: acme.atlassian.net, beta-corp.atlassian.net, fifty thousand of them. PublicWWW finds zero of those tenants. It finds Atlassian's own marketing site and some blog posts that link to acme.atlassian.net. Not customers.

What works: Common Crawl has crawled the web 121 times. Each crawl writes a CDX index listing every URL it hit. Query all 121 indices for **.atlassian.net*. You get a noisy list of candidate subdomains.

Then the dagger. Atlassian returns a specific HTTP header on 404s for tenants that don't exist: atl-missing-tcs: true. For tenants that DO exist, that header is absent. Run a HEAD probe against each candidate. Binary 1/0 confirmation. No false positives, no false negatives. Three hours, 80+ confirmed tenants. $0.

Family C — the logo wall. Most enterprise B2B vendors display customer logos on a /customers or /case-studies page. Near-100% precision because the vendor's legal team approved every logo. Crawl the page once, extract names from alt-tags, resolve to domains. Marketing teams can't help themselves.

Here's the asymmetry. PublicWWW query for "atlassian.net" returns Atlassian's own marketing pages. Not customers. Customers don't embed Atlassian's HTML — they ARE Atlassian, at a subdomain Atlassian itself hosts. Family B HEAD probes against Jane App sweep for **.janeapp.com* subdomains Jane doesn't use. Generic 404 with no signature header. Zero. Family C scrape on a vendor without a customer page — zero.

The scraper isn't broken. The scraper is matched to the wrong architecture. The fix isn't more queries, better regex, or a more expensive tool. The fix is diagnosis first.

That's the whole lesson. Three families. Ask which one applies before you write anything. Yes to "does it embed in customer HTML?" → Family A. Yes to "does it host customers at subdomains with a tell?" → Family B. Yes to "does it publish a customer page?" → Family C. No to all three → you need a swarm, not a silver bullet.

Diagnose first. Scrape second.

— Written by Claude Opus 4.7, Approved by Jordan

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

Or don't. Annual subscribers don't build it. They type the vendor name into Claude Code and the tool shows up.

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

Read more

April 13, 2026 · Build log

Here's the thing nobody tells you about shipping an AI product: the problem isn't the model. The problem is memory.

Every time a subscriber typed /edge into their terminal, Claude was starting from scratch. No sense of what I'd written. No sense of what I'd built. No sense of the years of actual work sitting on my desktop. Just a menu of six commands and a shrug.

That's a search bar with extra steps. That's not me in your terminal.

So I read a Karpathy gist yesterday about LLM-maintained wikis. Raw sources stay immutable. The model keeps a set of structured pages. A schema file governs the rules. Read it twice. Thought: that's the thing. Not a vector store. Not a RAG pipeline. A wiki with a contract.

Then one idea compounded four times before I slept.

First compound: the schema. Before writing a single page, I needed to know what a page even was. I pushed four research agents at the problem in parallel — one mapping how other people have solved it (Obsidian, MemGPT, Graphiti), one grounded in my actual transcripts and articles, one pressure-testing what a single pattern page should look like, one arguing about how tools should live alongside concepts.

They came back with the taxonomy I wanted. I named it RICE — Resources, Ideas, Context, Evidence. Nine kinds of entries. Thirteen ways they connect. Three tiers — free, paid, annual — baked into the page itself, not bolted on at the API. Pages never get deleted, only invalidated. That last rule matters more than it sounds: the wiki gets to be wrong on purpose, because wrong-and-visible teaches better than missing.

Second compound: it had to actually work end to end. I walked the full subscriber flow — register, email, install, verify, lookup — and hit two bugs that would have burned everyone. The subscriber sync was regenerating user IDs on every run, which meant every license key died every time the cron fired. Silent, recurring, catastrophic. The fix was obvious once I saw it. The lesson wasn't: anything that runs on a schedule and touches identity should be a read-then-update, never a blind write. I've shipped that bug three times in different products this year. Locking it in as a pattern now.

Third compound: the voice layer caught me leaking. A parallel session flagged that I was letting internal vocabulary into subscriber prose — schema words like "entities" and "primitives" and numbered section IDs. Words that mean something to me and nothing to a reader. If your internal nouns reach the reader, you've built a database, not a product.

So I wrote a translation map. Every internal noun gets a reader-facing substitute. "Entity" becomes "page." A grep check runs before publish. Three places the leak gets caught before anyone sees it. This is the boring work that separates a thing I built for myself from a thing someone else can use.

Fourth compound: fill it, then change the interaction. I ran a six-pass sweep across my active work — verticals, data sources, tools, patterns, people — and wrote the whole thing into the wiki. That part was mechanical.

The part that wasn't mechanical: the old /edge was a menu. You picked a command. You got a thing. The new /edge is presence. You type anything — a question, a project, a half-formed idea — and the skill reads what you're working on, finds the closest page in what I've written, pulls the content into Claude's context, applies it to your situation, quotes me directly, ends with one sharpening question.

Pull. Reason. Apply. Not "here's a link to an article." More like — what would I say if I were reading over your shoulder right now.

There's also a watch mode. Flip it on and the skill fires on every tool call you make, checks what you're doing against the wiki, writes a one-line hint into your status bar if you're touching something I've already solved. Ambient, not interruptive. The terminal itself becomes the reminder.

I rate-limited it hard. 50 full-page fetches per subscriber per day. Auto-kill at 100 requests in 10 minutes, because somebody was always going to try to scrape it. These limits aren't about cost — they're about forcing the skill to be selective. If you can pull everything, you pull everything, and then nothing is signal. The cap makes the skill choose.

Here's the shift that matters, at least to me: subscribers aren't searching anymore. They're being remembered to.

Search is a question you ask. Memory is a voice that shows up when you need it. Those are different products. One gives you a list of blue links. The other pulls an opinion into the room you're already in.

Every RAG pipeline I've seen tries to make search feel like memory by stapling a chat interface on top. It doesn't work. The model is still retrieving strings and hoping they're relevant. The subscriber is still the one doing the reasoning.

A wiki with a contract inverts it. The model maintains the pages. The pages know what tier they are. The skill knows when to surface them. The subscriber just works, and the right context shows up on its own.

That's what I'd been trying to build for months and couldn't name. A gist from Karpathy named it in one read.

— Written by Claude Opus 4.7, 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

April 1, 2026 · Build log

Opened Claude Code and found a Supabase service key hardcoded as a fallback in 3 Python files inside a client repo. Not in an env file — in the source code, committed, visible to every collaborator on the project. Anyone with read access could upload anything to my Supabase storage. The fix took about 20 minutes: strip the hardcoded values, commit, push. But the key was still in git history. So I had Supabase disable the legacy JWT keys entirely and issued new ones. Then updated ~/.env locally, Vercel env vars, and Modal secrets. One incident, five places to patch. Lesson: fallback values in source code are just hardcoded secrets with extra steps.

While that was in flight, I ran a playbook audit on playbooks.blueprintgtm.com. The domain search index had grown to 615 entries, and a chunk of them were junk — 28 "Not a Match" rejection pages, empty stubs with "No messages generated" in the play sections, and auto-generated test entries. Pulled all 615 through a content checker, removed 106 bad entries, brought the index down to 509. Also found 2 empty stubs in the showcase catalog — both had the framework scaffolding but zero plays — and removed them. Catalog went from 503 to 501.

The longer session was a technology detection build for a vertical SaaS client. The problem: a database of ~32K records had only 6.3% coverage on which technology each account was running. I knew the data was there — 55,097 scraped web pages sitting on disk from an earlier crawl. The original keyword scan had missed most of it because the fingerprints were too shallow. So I wrote enrich_tech_scan_scraped.py: a regex scanner that runs 22 vendor fingerprint configs against every local file. Each vendor config has primary keywords, secondary keywords, URL patterns, and known customer page structures. No API calls, no cost, just pattern matching against what we already had.

The real win came from a different script — an async subdomain prober. One vendor's customer portals all follow a predictable URL pattern — a department identifier as the subdomain. I had a list of ~196K department identifiers. The probe fired a HEAD request per identifier, filtered out DNS errors (no portal) from HTTP 200s (live portal). Ran at 211 requests per second. Result: 705 confirmed portals, up from 6-9 known. That's a 100x increase in coverage for a single vendor, in under an hour of compute time. The regex scan was still running through state directories — I/O bound, reading 55K small JSON files — so I committed all 4 scripts and let it finish overnight.

Next: run the scan to completion, merge all sources, and see what combined coverage looks like across those 32K records.

What Annual Adds

This is what I built today. Annual subscribers run the same tools.

• 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. Whatever ships next is included.

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

• Weekly office hours.

License key hits your email after you upgrade.

→ Start at $50/mo · Go annual — $2,499/yr

April 3, 2026 · Build log

Left Claude Code running and went to the pool. That's the sentence that describes most of April 3.

Before I left, I handed off a clean task: find the updated Blueprint Swarm skill, run the full pipeline, publish the playbooks. No subprocess calls, no Anthropic API — just the Agent tool, the way the swarm is designed to run. The orchestrator picked it up from there.

First thing it did: pull fresh revenue data from the CRM. Prep the full active account base across classification batches. Then run a rule-based pass first to get the playbooks published fast — three playbooks shipped to playbooks.blueprintgtm.com before the AI agents even finished their first wave. That's the lazy phase. Get something out the door while the better work runs in parallel.

The better work: AI agents on the same batches. The comparison was instructive. Rule-based put about a third of the at-risk accounts in the "Engage or Lose" bucket — accounts showing silent disengagement signals. The AI put roughly twice as many there. The rules were miscategorizing those accounts as product issues or payment problems because they pattern-matched on keywords. The AI read the full context and recognized the difference between a keyword and a root cause. The "Engage or Lose" bucket doubled in size. The playbooks got republished with the corrected distribution.

Then the swarm stayed running through the night — hundreds of batches of churned account forensics, five accounts per batch. Peak throughput hit sub-4 minutes per batch. One consistent pattern across the entire run: CRM labels were symptom labels, not root-cause labels. An account tagged "Charges and Fees" turned out to be a bankruptcy. An account tagged "Product" was a sales misrepresentation. An account tagged "Unresponsive" was a ghost that had never activated. The AI flagged the mismatch every time; the rules would have just inherited the bad label.

Next: run the same pass over active accounts and see if the pattern holds.

What Annual Adds

This is what I built today. Annual subscribers run the same tools.

• 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. Whatever ships next is included.

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

• Weekly office hours.

License key hits your email after you upgrade.

→ Start at $50/mo · Go annual — $2,499/yr

April 12, 2026 · Build log

Six research agents before I wrote a single line of code. That's how April 12 started. I wanted to build Edge Copilot — the Claude Code extension annual subscribers get — and I didn't want to architect it wrong. So I ran three explore agents first (Claude Code's hook system, the AutoClaygent auth flow, the existing Substack content setup), then three design-and-critique agents (architecture, GTM engineer persona, CRO buyer persona). Both critique agents independently said the same thing: don't make it "always watching." Make it pull-based — subscribers invoke it when they need it. That shaped everything.

The build itself took one session. I adapted AutoClaygent's license key pattern — same OTE- prefix format, same Supabase lookup — and wired it to a Vercel API with seven routes: register, verify, index, content, feedback, usage, and sync. Type-checked clean on the first pass. Deployed to edge-copilot.blueprintgtm.com. Then the right question came up: how do people actually get their key? The Substack subscriber API has no endpoint to check if a specific email is paid. So I built a Stripe webhook instead — same pattern as AutoClaygent, catches the annual subscription event, generates the key, emails it via Resend. Sent a test email to confirm the flow. The whole thing was live and returning a proper 401 before we hit a DNS snag that resolved itself in under ten minutes once the CNAME pointed at Vercel.

While Edge Copilot was being built, a parallel session published the first On the Edge post — "I Built a Swarm to Read Every Call" about the Blueprint Swarm open-source repo. The Substack MCP tool was silently stripping all inline formatting: bold text passed through as literal asterisks, links rendered as raw text. I dug into the source at post_handler.py and found the bug on line 1289 — _extract_text_from_content() was stripping all marks before handing off to the paragraph builder. The fix: bypass that pipeline entirely and use Post.from_markdown() from the underlying python-substack library, which handles inline formatting correctly. Patched it. Cleared the bytecache. The post went live with working bold, links, and code blocks.

Two more skills shipped before midnight. The Headline Optimizer: four Opus research agents (Cannonball GTM historical data, Substack-specific mechanics, timeless copywriting principles, demand research APIs), then a demand scoring script that runs Serper Autocomplete across 26 alphabetical queries plus Exa Reddit and FindSimilar calls — total cost ~$0.04/run. Ten headline frameworks ranked by B2B relevance, the 33-character Gmail truncation rule baked in, the dual-title system documented. Symlinked and wired into the existing /on-the-edge skill so it auto-runs on every draft. The Image Generation sub-skill came next: Gemini for hero and concept images, HTML-to-Playwright-screenshot for programmatic quote cards, stat cards, and diagrams. Built the Fraunces font setup, watermark compositing, five HTML templates, and three uv run --script Python scripts. First watermarks were invisible against dark backgrounds — the purple "OTE" had a 2.1:1 contrast ratio. Fixed it by generating gold monochrome watermarks from the original brush-stroke asset and bumping opacity to 18%.

The last fix of the day was the ugliest to discover: the Stripe webhook for playbooks.blueprintgtm.com had been failing for three weeks. Twenty-two deliveries, twenty-two failures. The signing secret in Vercel didn't match the endpoint's actual secret in the Stripe dashboard. Pulled the right value, updated the env var, redeployed, verified the endpoint returned the correct error on a malformed test POST. Then added a Vercel cron that runs every 6 hours and checks seven components — Supabase connectivity, Stripe API and webhook config, Anthropic credit balance, stuck jobs, failure rate, and webhook delivery — alerting to #pipeline-alerts in Slack if anything breaks. Next: watch whether the webhook actually catches a live subscription before trusting it.

What Annual Adds

This is what I built today. Annual subscribers run the same tools.

• 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. Whatever ships next is included.

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

• Weekly office hours.

License key hits your email after you upgrade.

→ Start at $50/mo · Go annual — $2,499/yr