AI Prospecting: Which Steps It Actually Removes

A team adds a model to its prospecting workflow and the message count goes up eightfold in a month. The research that used to take a morning now takes four minutes an account. The reply rate falls, and the post-mortem concludes the copy was not personalised enough, so the next iteration adds more model output to the same messages.

The useful question about AI prospecting is not whether a model can do the work. It is which of the steps inside prospecting were ever bottlenecked by the thing a model removes.

Prospecting decomposes, and the steps have different bottlenecks

Prospecting is at least six distinct jobs, and they fail for unrelated reasons. Treating it as one activity is what makes AI look like either a revolution or a disappointment, depending on which step somebody happened to be stuck on.

Defining who fits. Bottlenecked by judgement about your own market. A model can propose criteria and can find contradictions in the ones you wrote, and it cannot know which of two plausible segments actually pays.

Finding accounts that match. Bottlenecked by data coverage. This step was already automated by databases long before language models arrived, and the model adds little to a filter that a query already performs.

Reading an account. Bottlenecked by time. This is the step where a model genuinely changes the arithmetic: reading a careers page, a product page, a changelog and a newsroom feed and summarising what changed is exactly what the technology is good at.

Deciding whether what it found is a reason. Bottlenecked by judgement again. A model will happily present the existence of a careers page as a hiring signal, and distinguishing an event from a state is the whole of that decision.

Finding and verifying the person. Bottlenecked by data and by verification infrastructure. A model can guess an address format. Guessing is not verification, and the cost of the difference lands on your sending domain.

Writing the message. Bottlenecked by having something to say. A model removes the cost of the writing and does nothing about the input.

Genuinely changedTime-bound steps

• Reading and summarising an account's public surfaces
• Normalising messy inputs into structured fields
• Drafting variants once the premise exists
• Triaging a long list into a reading order
• Translating a found fact into plain language

Barely changedJudgement and infrastructure steps

• Deciding which segment is worth pursuing
• Deciding whether a finding is a reason or a state
• Verifying an address is deliverable
• Deciding what a qualified conversation is
• Handling the reply when it arrives

The step that got cheaper is not the step that was scarce

The scarce input in prospecting was never sentences. It was a specific, checkable fact about an account that implies a problem you solve, arriving inside the window where it still matters. Model output is abundant and that fact is not, which is why adding generation capacity to a motion with no research behind it increases volume and nothing else.

This has a market-level consequence as well as a local one. When the cost of producing a plausible message falls for everyone at once, the number of plausible messages in every inbox rises, and the bar for what counts as worth reading rises with it. The economics of that shift, and what it does to the value of volume, are worked through in AI lead generation.

The local consequence is more actionable. If a model is added to the step that was already fast, throughput improves at a step nobody was waiting on. Adding it to the reading step, which was genuinely slow, changes what a small team can cover. The two look identical on a tooling invoice and produce completely different outcomes.

1. Step 1Start with reading

   Have it summarise each account's own published surfaces into a few structured fields. This is the slow step and the one it does well.

2. Step 2Keep the reason decision human, at first

   Read its summaries and decide yourself what counts as a reason. The decisions you make here become the rule you can later encode.

3. Step 3Encode the rule, then sample it

   Once the rule is explicit, let the model apply it, and read a fixed sample of its judgements every week rather than trusting the aggregate.

4. Step 4Draft last, from the premise

   Generation goes at the end, working from a premise the research produced. A draft written before the premise exists is a template with variance.

What breaks, specifically

Confident wrongness about dates. A model summarising a page cannot reliably tell you when the thing it describes happened unless the page says so. Prospecting depends on windows, and a stale event confidently presented as current produces messages that reference something that finished last year.

Manufactured specificity. Asked to find a reason where none exists, a model will produce a sentence that has the shape of a reason. It reads as personalised and contains no information, which is a worse failure than an obviously generic message because it costs research budget to produce.

Verification confused with plausibility. A generated address in the right format is a guess. Sending to guesses damages deliverability in a way that no amount of message quality recovers, and it is one of the few mistakes in this field that is expensive rather than merely wasteful.

Judgement quietly outsourced. The most common path is that a model proposes criteria, the criteria look sensible, and nobody ever tests whether the segment converts. The decision has been made and no human remembers making it.

Volume treated as the goal. A tool that raises output eightfold will raise output eightfold whether or not the population deserves it. The constraint has to come from somewhere else, because it does not come from the tool.

Everyone reading the same public surfaces. The pages a model can read are the pages every competitor's model can read, so a reason available to automated reading alone is available to your whole category simultaneously. The advantage sits in what somebody knows about the market that is not written on a page, which is precisely the input that cannot be automated. Treating the readable layer as proprietary is how a differentiated motion turns into a faster version of the generic one.

Evaluating it without running a pilot for a quarter

Most evaluations of this technology in prospecting measure the wrong quantity, because output volume is the easiest thing to count and the least informative. Four cheaper tests answer more.

The deletion test, applied to model output. Take a generated message, remove the sentence that references the account, and read what remains. If the message still works, the research contributed nothing and you are paying for decoration. This test is more useful on model output than on human drafts, because a model will always produce the reference whether or not it found anything.

The date test. For a sample of accounts, ask what the model claims happened and when, then check the source page yourself. Errors here are systematic rather than random, so a sample of twenty tells you most of what a quarter would.

The disagreement test. Have the model judge a set of accounts you have already judged yourself, and read the cases where you disagree rather than the score. The disagreements are where the encoded rule differs from the real one, and they are the only part of the exercise that teaches you anything.

The empty-hand test. Feed it accounts where you know there is no reason to write. A tool that returns a confident reason for every one of them has told you that its output carries no information, and that finding is worth more than any accuracy figure.

None of these needs a quarter or a procurement process, and all four can be run on twenty accounts in an afternoon. The reason to run them before scaling is that the failure modes above are invisible in aggregate metrics: a motion producing manufactured specificity looks identical, on a dashboard, to one producing real reasons, right up until the reply rate is read.

Where our own constraint lands

We run one message per campaign: no bumps, no thread replies, no second attempt underneath the first. That policy interacts with this technology in a specific way, and it is the reason the reading step matters more here than the writing step.

When a campaign is one message, generation capacity buys nothing on its own. There is no sequence to fill, no variant ladder to climb, no follow-up to automate. What it can buy is coverage of the research step, which means more accounts read properly, which means more real reasons found, which is the input the single message needs. A model pointed at the drafting step under a one-message policy is optimising the cheapest part of the job.

The same logic explains why the seat question is separate from the tooling question. What a model can and cannot take over from a person in this role, framed as a job rather than as a feature list, is in AI SDR, and the tool categories that get sold under one label are separated in AI lead generation tools.

The short version

AI prospecting is worth judging step by step rather than as one thing. Models materially change the reading step, where the constraint was time, and change almost nothing about the judgement steps, where the constraint is knowing your market, or the verification step, where the constraint is infrastructure. The scarce input was never sentences, so adding generation to a motion with no research behind it produces volume and nothing else. Introduce it at the reading step, keep the reason decision human until the rule is explicit, sample its judgements rather than trusting aggregates, and never treat a generated address as a verified one. What survives the whole exercise is the same thing that mattered before: a specific fact about an account, inside the window where it still matters. The test for whether a finding is a real signal is in B2B prospecting.

If you would rather see the research step run against your own market than evaluate another tool, we will build the campaign and show you what it found.