You've set up an AI agent, connected it to your lead sources, and hit go.

Then you watch it stall the moment real prospect data arrives.

No schema to validate incoming leads. No qualification logic to tier them.

No routing rules to push Hot prospects to your CRM and nurture the rest.

You're stuck manually scoring leads in a spreadsheet.

Here is what this guide covers:

This guide takes you from zero to a production prospecting skill in one afternoon.

You'll copy a minimal Python scaffold and define your input schema: company size, job title, seniority.

Then you write a scoring function that weights your ICP criteria, and wire the output straight to Salesforce, Slack or HubSpot.

By the end, every lead that exits your Sales Navigator export flows through your skill and lands in the right inbox.

Hot prospects are flagged for immediate outreach, Warm leads are routed to nurture, and Cold ones are archived.

Why this works now: Claude Code skills let sales teams register reusable, versioned prospecting functions that RevOps can share across reps.

Agent frameworks now expose typed input schemas and dead-letter handling, which is what makes unattended lead triage reliable.

AI qualification agents report roughly 30% faster triage by running against live lead feeds instead of nightly batches.

Understand What an AI Agent Skill Actually Is

An AI agent skill is a discrete, reusable instruction set that tells an agent what to do and how to evaluate success for a specific task, more structured than a prompt, narrower than a full workflow.

Once built, it repeats identically across hundreds of prospects.

I think of a skill as a trained decision-maker. It takes input (a prospect's profile), applies logic (evaluate fit against criteria), and returns a structured output (matched or rejected, with reasoning).

Your Ideal Customer Profile (ICP) is the precise description of the company type and buyer role most likely to close and retain, it becomes the criteria your skill evaluates every prospect against.

Skills vs. Tools vs. Prompts: What's the Difference?

A prompt is a one-time instruction: "Find LinkedIn profiles matching these keywords and summarize them." Flexible, but not reusable.

A tool is a software function that does one narrow thing: fetch a LinkedIn profile URL, extract an email from a domain, validate a phone number.

Tools are deterministic; they don't reason or adapt.

A skill is the repeatable, reasoned layer on top.

When I'm prospecting, a skill might be "Identify decision-makers in target accounts": it combines prompts (instructions to the AI), tool calls (fetch a profile, look up the company), and decision logic (does this person match our persona?) into one atomic unit that fires the same way for each prospect.

The key difference: skills understand intent and adapt logic. Tools execute mechanics. Prompts issue one-off commands.

For a deeper dive into how these skills fit into your broader prospecting strategy, read our guide on B2B sales prospecting methodologies.

When to Build a Prospecting Skill vs. a One-Off Prompt

Not every prospecting task needs a skill. A prompt solves the problem once; a skill solves it every time the pattern appears.

Build a prospecting skill when the task involves:

Use a one-off prompt when:

The timing matters more in 2026 than it did a year ago.

Quick Start: Copy-Paste Prospecting Skill Template

A prospecting skill needs three things: structured input, qualification logic, and a structured output. Copy the scaffold below, swap in your own lead fields, and you have a working skill in minutes.

The Minimal Skill Structure (Input → Logic → Output)

Every prospecting skill follows the same three-part anatomy:

This separation keeps your skill modular and reusable across different lead sources and sales workflows.

The input schema defines what fields your skill expects; the logic is your decision rule or calculation; the output is what the calling system receives and acts on.

The Template Code Block

Copy the function below into a Python file or Jupyter notebook. Replace the lead_fields list with the fields you plan to filter or score on, and customize the logic block to match your prospecting criteria.

python
import json

def prospect_skill(prospect_json: str) -> dict:
    """
    Minimal prospecting skill scaffold. Input: JSON string with prospect data (e.g., from a Sales Navigator export).

Output: Dictionary with decision and optional enriched fields. """
    prospect = json.loads(prospect_json)
    
    # Define the lead fields your skill cares about
    lead_fields = [
        'first_name',
        'last_name',
        'company',
        'title',
        'seniority'
    ]
    
    # Validate input has required fields
    for field in lead_fields:
        if field not in prospect:
            return {"decision": "skip", "reason": f"Missing {field}"}
    
    # Your prospecting logic here
    title = prospect.get('title', '').lower()
    seniority = prospect.get('seniority', '').lower()
    
    # Example: target VP+ titles at target companies
    if any(x in title for x in ['vp', 'director', 'head of']):
        return {"decision": "qualify", "score": 0.85}
    elif 'manager' in title and seniority == 'mid-level':
        return {"decision": "qualify", "score": 0.65}
    else:
        return {"decision": "skip", "reason": "Does not match seniority criteria"}

# Test the skill
test_input = json.dumps({
    "first_name": "Jane",
    "last_name": "Doe",
    "company": "Acme Corp",
    "title": "VP of Sales",
    "seniority": "senior"
})

result = prospect_skill(test_input)
print(result)  # Output: {"decision": "qualify", "score": 0.85}

After copying, swap in your own lead_fields from your export: for example, job_title, industry, company_size, and adjust the logic block to encode your target prospect profile.

To learn how to prepare clean lead data for your skill, see our guide on exporting Sales Navigator lead lists to Excel.

This is where you encode what you've learned from your best closes.

Define Your Skill's Input Schema

Your skill's input schema defines what lead data it expects to receive and process.

A well-designed schema accepts the fields that drive qualification logic while remaining flexible enough to work with incomplete records.

Start by listing the fields you actually need to score or filter leads.

When I built Evaboot's prospecting engine, I included company size, industry, job title, decision-making level, and any budget or timeline signals visible in the source data.

Each field should map back to a concrete attribute in Sales Navigator: "company size" might correspond to employee-count ranges in search filters, or "industry" might align with the classification on a company profile.

Which Lead Fields Should Your Skill Accept?

Include fields that directly inform your qualification rules. Company size targets organizations within your market sweet spot, industry narrows to vertical fit, and job title and seniority signal buying authority.

Each field needs a clear data type: string for names and titles, integer for employee counts, array for multiple industries, boolean for yes/no signals.

Document where each field originates: Sales Navigator profile attribute, enrichment provider, or a custom flag in your export.

Don't invent fields your prospecting data cannot supply. If your exported leads don't include a "budget confirmed" flag, your schema shouldn't require it.

Mark Fields as Required vs. Optional

Designate fields as required only if your skill cannot function without them.

A lead's company name and job title are typically essential; industry or company size might be optional if your logic degrades gracefully when they're missing.

Optional fields let your skill score or route leads even when some attributes are unavailable, common with incomplete data or fresh exports.

Use optional fields to improve scoring confidence when present, but don't fail qualification if they're absent.

Define a default or fallback behavior for each optional field. For example: "if industry is missing, assume broad B2B relevance." That keeps downstream decision-making predictable.

Write the Qualification Logic and Routing Rules

Qualification logic scores each prospect against your ICP criteria and routes them to the right action automatically, no manual triage required.

Build a simple scoring function that buckets prospects into Hot, Warm, or Cold, then trigger downstream workflows.

Build a Simple ICP Scoring Function

Start with the core inputs: company size, industry fit, and job seniority.

Weight each one based on what matters to your sales team.

Say your ICP targets mid-market software companies with 50–500 employees. Score company size on a 0–3 scale: 3 points if they're 50–500 people, 1 point if 500–5,000, and 0 otherwise.

Industry fit gets 2 points for Software, SaaS, or Tech; 1 point if adjacent (Finance, Marketing); 0 if they're outside your target.

Job seniority: 2 points for Director/VP/C-suite, 1 for Manager, 0 for IC.

Add the scores: 7–8 = Hot, 4–6 = Warm, 0–3 = Cold. You can run this in a spreadsheet formula or a simple script. The mechanism doesn't matter, consistency does.

Test your scoring against 10–20 known closed wins and losses. If your system ranks your best customers as Hot, you've got calibration; if not, adjust the weights.

Route Each Tier to the Right Action

Tie it together with conditional logic: if score >= 7 then hot_alert() and create_task(due="tomorrow") else if score >= 4 then nurture_sequence() else archive().

Most CRM tools (Zapier, Make, native CRM workflows) handle this without code.

To identify which roles matter most in your scoring criteria, review our guide on finding decision-makers in a company.

Handle Errors and Edge Cases in Your Prospecting Skill

Prospecting skills face three predictable failure modes: missing or null lead fields, duplicate records, and enrichment API timeouts.

Handle each with a distinct pattern: graceful degradation, dedup hashing, and retry-with-backoff, so no lead is lost silently.

Missing or Null Fields: Graceful Degradation Pattern

Not every lead will have a phone number or email visible. Rather than reject the entire record, route incomplete leads to a manual-review queue.

Wrap your CRM write in a try/except block. Check for required fields (email, company name, job title) and assign a default status like "pending_enrichment" if any are missing.

Log the lead ID and the missing field, then move on. Your sales team manually verifies or enriches these records later, and you avoid silent data loss.

Duplicate Lead Detection

The same person shows up in multiple searches or lists. A lightweight dedup check before CRM write prevents duplicate records and wasted outreach.

Create a composite hash of email + company domain (or LinkedIn URL if email is absent). Query your CRM for a match; if found, log a skip and move on.

This single check eliminates most duplicates without expensive database scans.

Which Framework Should You Use in 2026?

Most teams should start with the Anthropic SDK (Claude) or the OpenAI function-calling API (ChatGPT), both handle prospecting skill scoring with minimal boilerplate and strong schema support.

Your choice depends on what stack your team already knows, your budget, and how many leads you're scoring.

The table below compares the four most common paths for implementing a prospecting skill like score_lead.

Framework Comparison Table: Registering a 'score_lead' Skill

Both the Anthropic SDK (Claude) and the OpenAI function-calling API (ChatGPT) handle prospecting skill scoring with minimal boilerplate, either works for teams already on those platforms.

LangChain adds flexibility if you're chaining multiple tools or swapping models later, but it adds complexity upfront. A custom REST endpoint bypasses agent framework overhead entirely.

For a comprehensive comparison of available platforms and tools, see our review of the best AI sales tools for outbound prospecting in 2026.

Connect Your Prospecting Skill to Your Sales Stack

Connect your skill to any destination by emitting one shared JSON schema, lead_id, tier, recommended_action, enriched_fields, then POST or PATCH that payload to Salesforce, Slack, or HubSpot without modifying the skill itself.

To understand how these integrations fit into your broader automation toolkit, explore lead generation automation tools that can amplify your skill's output.

1. Design an Output Schema Your Integrations Can Consume

Every prospecting skill should emit four core fields: lead_id, tier, recommended_action, and enriched_fields. This schema becomes your contract with downstream systems.

One consistent schema means one skill can power three different integrations without modification. Each downstream tool extracts the fields it needs and ignores the rest.

2. Integration 1: Create a Salesforce Lead

Once your skill outputs a prospect, POST the lead_id and enriched data to Salesforce Leads via the REST API.

Map your tier field directly to Salesforce's Lead Status: Hot → "Qualified," Warm → "Open," Cold → "New."

Here's the pattern:

POST /services/data/v57.0/sobjects/Lead
{
  "LastName": "enriched_fields.last_name",
  "Company": "enriched_fields.company",
  "Status": "Qualified",
  "Description": "recommended_action"
}

Salesforce responds with the new Lead ID, which you store for future updates. This one-way push keeps your CRM in sync with skill output in near-real time.

3. Integration 2: Send a Slack Notification to the Sales Team

For Hot-tier prospects, send an immediate Slack alert to your sales channel via an Incoming Webhook. Filter your skill's output: only send prospects where tier == "Hot".

Build a Slack payload like this:

POST <your-webhook-url>
{
  "text": "🔥 Hot prospect identified",
  "blocks": [
    {"type": "section", "text": {"type": "mrkdwn", "text": "**enriched_fields.name** at enriched_fields.company\nAction: recommended_action"}}
  ]
}

The webhook receives the JSON, parses it, and posts a formatted message to your channel. Your sales reps see the prospect name, company, and next action in seconds.

4. Integration 3: Update a HubSpot Custom Property

To track prospect tier in HubSpot, create a custom property called ICP_tier (or use an existing one). Then PATCH the contact record with your skill's output.

The call looks like this:

PATCH /crm/v3/objects/contacts/<contact-id>
{
  "properties": {
    "ICP_tier": "enriched_fields.tier"
  }
}

HubSpot updates the contact in real time. Once the property is set, you can segment lists, trigger workflows, or report on ICP alignment, all downstream of your skill's single output schema.

Test and Deploy Your Prospecting Skill

Before you run your qualification skill against a full export, validate it in isolation and against real data. This two-stage approach catches logic errors and schema mismatches before they affect your entire pipeline.

1. Unit-Test Your Qualification Logic

Write test cases for three scenarios: an ideal ICP lead, a lead with partial or missing data, and a known duplicate.

For an ideal ICP lead (say, a VP of Sales at a mid-market SaaS company), your skill should return qualified: true with a clear reason.

For a partial-data lead (missing job title or incomplete company info), it should either return qualified: false with a specific reason or flag it for manual review, depending on your rules.

For a known duplicate (same email or LinkedIn URL as a prior record), it should return qualified: false and cite the match.

This simple table catches rule contradictions and null-handling bugs before you export.

2. Smoke-Test With a Real Lead Export Before Going Live

Run the skill against a small, real export from Evaboot: 20 to 50 leads from a LinkedIn Sales Navigator search you control.

Use the cleaned CSV that Evaboot (a LinkedIn Sales Navigator export and lead-cleaning tool) delivers, including the "No Match Reasons" column if present.

Watch for schema mismatches: missing columns, unexpected data types, job titles as null or blank strings.

Once the skill runs cleanly and flags the right leads, you're ready to scale to your full export.

Package Your Prospecting Skill for Team Reuse

Package a prospecting skill as a versioned Python file in a shared .agent/skills/ directory tracked by Git, teammates pull it and their agent auto-registers it on startup.

Once you've built a working skill, the entire sales team should be able to use it without re-writing the same logic.

Version the skill file and store it in a shared location: a team repository, a .agent/skills/ folder synced via Git, or an internal package registry.

Each skill gets a semantic version number (1.0.0, 1.1.0) so teammates know when breaking changes land.

Convention: one Python file per skill, named score_lead_v1.py or dedupe_lead.py. The agent runtime scans the skills directory on startup and auto-registers every function decorated with @skill or listed in a manifest.

If you change the input schema, bump the version and update the changelog comment at the top of the file so the next person knows what changed.

Push the file to your shared repo. Teammates pull, and the skill appears in their agent's toolkit. No second installation step: just a git pull and the agent picks it up.

Where to Save the Skill File So Your Agent Finds It

Put your skill file in .agent/skills/ at the project root, the agent scans that folder on startup, imports every Python module, and registers decorated functions.

Most frameworks (Claude Desktop, LangChain, Semantic Kernel) check that path by default. Create the folder if it doesn't exist, drop your file in, and restart the agent.

File tree example:

project-root/
├── .agent/
│   └── skills/
│       ├── score_lead.py
│       ├── dedupe_lead.py
│       └── identify_decision_maker.py
└── main.py

Hosted AI agent platforms like Relevance AI and Voiceflow (no-code environments for deploying agent skills) let you upload the file through their skill manager UI instead of a file path.

Same logic, different interface.

Restart the agent after adding a new file. It won't hot-reload mid-conversation in most setups.

Write a SKILL.md Manifest So the Agent Knows When to Fire It

The skill file holds your Python or TypeScript logic. The SKILL.md manifest tells the agent what the skill does and when to invoke it, without reading your code.

Most runtimes (Codex, Claude Desktop, Replit Agent) auto-discover skills by scanning .agent/skills/ or .agents/skills/ for a SKILL.md file alongside the code.

When a user message matches a skill's description or trigger phrase, the agent fires that skill instead of generating a generic response.

Minimal SKILL.md for a prospecting skill

Save this as .agent/skills/score_lead/SKILL.md:

score_lead

Description: Scores an inbound lead against ICP criteria (employee count, tech stack, funding stage) and returns a numeric score with reasoning.

Triggers:

Inputs:

Outputs:

Dependencies:

• Clearbit API key (env: CLEARBIT_API_KEY)
• HubSpot CRM (read-only, company properties)

The agent reads Description and Triggers to decide whether your user's message ("Does Acme Corp fit our ICP?") should invoke score_lead or fall back to chat.

What goes in each field

Why this matters: Without a manifest, the agent treats your skill as a black box.

It won't know when to invoke it, what data to pass, or how to explain the result to the user.

A two-minute SKILL.md file turns a fragile script into a discoverable, self-documenting tool the agent can route to automatically.

Four More Prospecting Skills Your Team Can Copy-Paste

Beyond score_lead, here are three more named, reusable skills that cover the gaps in a typical outbound workflow. Drop these into .agent/skills/ and your agents inherit the logic.

identify_decision_maker

from pydantic import BaseModel, Field

class DecisionMakerInput(BaseModel):
    linkedin_url: str = Field(description="LinkedIn profile URL")
    company_domain: str
    target_role: str = Field(default="VP Sales", description="Role you want to reach")

@skill(name="identify_decision_maker", description="Find the best contact at a company for a given role")
def identify_decision_maker(params: DecisionMakerInput) -> dict:
    # Call LinkedIn enrichment API or scrape title/department
    # Return name, title, email if found
    return {
        "name": "Jane Doe",
        "title": "VP Sales",
        "email": "jane@company.com",
        "confidence": 0.92
    }

Use case: Agent sees a company domain, hunts for the right person before sending outreach.

dedupe_lead

class DedupeInput(BaseModel):
    email: str
    existing_crm_ids: list[str] = Field(description="List of CRM record IDs already in the system")

@skill(name="dedupe_lead", description="Check if this lead already exists in CRM to avoid duplicates")
def dedupe_lead(params: DedupeInput) -> dict:
    # Query CRM by email, phone, or LinkedIn URL
    # Return match status and existing record ID if found
    existing = next((id for id in params.existing_crm_ids if match(params.email, id)), None)
    return {"is_duplicate": bool(existing), "crm_id": existing}

Use case: Before adding a lead to a sequence, verify they're not already in the pipeline under a different name.

detect_intent_signal

class IntentInput(BaseModel):
    company_domain: str
    signals: list[str] = Field(description="List of intent keywords or events to watch for")

@skill(name="detect_intent_signal", description="Check if a company shows buying intent (job posts, tech stack changes, funding)")
def detect_intent_signal(params: IntentInput) -> dict:
    # Check job boards, Crunchbase, BuiltWith, G2 reviews
    # Return boolean + list of detected signals
    return {
        "has_intent": True,
        "signals_found": ["Posted 'Sales Ops Manager' role 3 days ago", "Added Salesforce to tech stack"],
        "priority_score": 8
    }

Use case: Prioritize accounts that just raised funding or posted a relevant job, your agent auto-bumps them to the top of the list.

extract_company_metadata

class CompanyMetaInput(BaseModel):
    domain: str

@skill(name="extract_company_metadata", description="Pull firmographic data: employee count, industry, revenue estimate")
def extract_company_metadata(params: CompanyMetaInput) -> dict:
    # Call Clearbit, BuiltWith, or LinkedIn Company API
    return {
        "employees": 450,
        "industry": "B2B SaaS",
        "revenue_range": "$10M–$50M",
        "hq_location": "Austin, TX"
    }

Use case: Auto-qualify inbound signups or enrich a raw CSV of domains before outreach.

Building a prospecting agent requires three skill sets: prompt engineering, API integration, and schema design. The table below maps each to what it covers and why it matters.

Frequently asked questions