Running Lead Generation on Autopilot With Claude Code and MCPs

Back when I was carrying an SDR quota, my mornings looked the same: open a prospecting tool, stack ten filters to isolate founders of UK financial services firms, export the list, push it into an enrichment tool, verify the emails, score them against ICP, then start writing sequences. By the time the first send-block was ready, the day was gone. The work wasn't hard. It was just a chain of clicks long enough to eat eight hours.

That exact chain is now a single prompt sitting inside Claude Code, wired into the same tools I used to operate by hand. The lead sourcing, the email validation, the ICP qualification, the copywriting, the campaign setup in Smartlead, all of it runs from one chat window. Below is how the pieces actually fit together, why MCPs are the unlock, and what a working lead generation loop looks like once the plumbing is done.

Why prompts beat dashboards for lead generation

Most outbound tools were built around a UI. You click through filters, you export, you switch tabs. Each handoff between tools is a place where time leaks and where context gets lost. The chat-driven version flips that. You describe the outcome you want in English, and the model decides which tools to call, in what order, with what arguments.

The practical difference shows up in iteration speed. If a list comes back too broad, you don't redo ten filter dropdowns. You type "narrow to companies under 50 employees founded after 2018" and the model rebuilds the query. The dashboard becomes a fallback, not the primary surface.

What an MCP actually is, without the jargon

MCP stands for Model Context Protocol. Strip the acronym and it's a standard way for AI clients like Claude to talk to outside software. Instead of writing API integrations, registering webhooks, or stitching together Zapier steps, you point Claude at an MCP endpoint and it gains a menu of actions inside that platform.

For outbound, this matters because the tools that hold your prospect data, your sending infrastructure, and your enrichment logic finally speak the same language as the model orchestrating them. Connect a prospecting database, an email sender, and a verification tool through MCP, and Claude can run a full campaign without you ever leaving the chat.

Connecting Smartlead to Claude in five steps

The stack I run leans on Smartlead's MCP for sourcing, verification, and sending. The connection itself takes a few minutes inside the Claude desktop app.

1. Sign in at claude.ai, open your profile menu in the bottom left, and go to Settings.

2. Find the Connectors area (it now lives under the Customize section).

3. Click Add custom connector and paste in the Smartlead MCP URL. The tail end of that URL is where your API key goes.

4. In a separate tab, open your Smartlead account, head into Settings, then API Key Management, and create an admin key. Name it something you'll recognize later. Copy it.

5. Paste the key into the connector URL, save it as smartlead.ai, and approve the connection. Switch the permission setting from "needs approval" to "always allow" so Claude can run actions without prompting you each time.

Once that's done, hitting the plus icon inside any Claude chat shows Smartlead as an available connector. Every prospecting, validation, and campaign action in that platform is now reachable by prompt.

Running the first list from inside your IDE

Claude Code lives inside an IDE. Visual Studio Code, Cursor, and Antigravity all work. I use the VS Code desktop app, open a new Claude Code session, and start a chat there. The IDE matters because Claude Code can read and write files on your machine, which is what lets it save campaign assets, store skills, and pick up where it left off.

A first prompt looks something like: "Use Smart Prospect through the Smartlead MCP to find founders of financial services companies in the UK. Show me the first ten in a table."

Flip the permission mode to bypass so Claude can run end to end without stopping. It queries the Smartlead database, returns the ten contacts with emails attached, and then asks what to do next. The follow-ups are the rest of the SDR workflow, compressed into checkboxes:

• Validate the ten emails (catch-all, verified, unverifiable).

• Enrich the contacts and score them against an ICP definition you paste in.

• Draft outreach. Email only, in my case, since Smartlead handles the sending.

What used to be four tools and a spreadsheet is now four answers in a single chat.

Why deliverability still decides whether any of this works

None of this matters if the mail lands in spam. A well-qualified list with personalized copy still needs healthy sending domains, warmed inboxes, and a sender reputation that hasn't been torched by a previous campaign. The prompt-driven workflow makes it dangerously easy to scale volume before the infrastructure underneath can carry it.

If you're pushing meaningful volume, treat inbox health as its own project. Rotate domains, keep per-mailbox sends conservative, and monitor reply and bounce rates per sending identity, not just per campaign. Tired of worrying about deliverability? Check out Slicey.ai's Inboxes. Treat the AI layer as the brain and the sending layer as the lungs. Both have to work.

Turning a one-off run into a reusable skill

The part that actually changes how you work is what happens after a successful campaign. Type "turn this into a skill" and Claude Code packages the entire sequence (source, validate, enrich, qualify, draft, push to Smartlead) into a saved skill directory on disk. It records the steps, the tool calls, and the conventions it learned from your back-and-forth.

Next time, the prompt collapses to a single line: "Find me 200 founders of SaaS companies in Germany." The skill handles the rest. Validation runs automatically. Enrichment runs against the ICP you already defined. Copy gets drafted in the voice the model has seen you approve before. The campaign gets created inside Smartlead through the MCP.

This is the part that makes the system feel like leverage instead of a toy. The first run is exploratory. Every run after that is execution.

What a sane GTM stack looks like with Claude Code in the middle

A few principles are worth holding onto once you start building this out.

Keep the model as the conductor, not the soloist. Claude is good at deciding which tool to call and stitching outputs together. It is less good at being your prospecting database, your verifier, or your sender. Let the specialists do their jobs and let Claude route between them.

Define your ICP in writing, once. The qualification step is only as good as the criteria you feed it. Save the ICP as a file in the project, reference it by name, and update it as you learn what actually closes. Vague ICPs produce vague lists, and the model will happily generate noise if you let it.

Version your skills like code. Because Claude Code stores skills on disk, you can commit them to a repo, branch them per campaign type, and roll back when a change makes results worse. Treat your prospecting flows the way an engineering team treats deployments.

Measure what the model can't see. Open rates, reply rates, meeting bookings, and pipeline created still need to flow back to a place where you can compare campaigns. The chat will tell you a campaign was created. It won't tell you which version of the copy actually booked meetings six weeks later. That's your job.

Where this leaves the SDR motion

The manual SDR day, the one where you spent half your hours stitching together filters and exports, is on its way out. Not because the work disappears, but because the work moves up a layer. The valuable input is no longer how many filters you can stack in a UI. It's how well you can describe an ideal customer, how cleanly you can codify a qualification rule, and how reliably your sending infrastructure can carry the volume the model can now produce.

The people who win the next phase of outbound will be the ones who treat Claude Code as a runtime, MCPs as the wiring, and tools like Smartlead as the muscle. The hours saved aren't the prize. The prize is being able to test five ICPs in the time it used to take to build one list.