# Objection Handling Playbook: How AI Generates Responses to 'Too Expensive' and 'Not Now'

> B2B sales objection classification, prompts for generating responses via LLM, a ready-to-use playbook template with examples. A system for preparing to handle any objection.
> Author: Roman Belov · Published: 2026-05-08 · Source: https://futurecraft.pro/blog/objection-handling-ai/

Closed B2B deals, [per Gong Labs research](https://www.gong.io/blog/handling-sales-objections), typically go through several rounds of objections before anything gets signed. The average sales rep walks in prepared for three or four. That gap — between what objections actually come up and what you're ready for — bleeds conversion.

This article gives you a system: objection classification by type, prompts for generating responses via LLM, a ready playbook template, and worked examples for each category.

## Why Standard Sales Scripts Don't Work

The classic approach: a rep gets a PDF with 20 canned responses. The problem has three parts.

**Static content.** The script ignores context. "Too expensive" from a pre-seed startup and "too expensive" from an enterprise with a $2M tooling budget mean completely different things. One response won't close both.

**Linearity.** Scripts assume objections arrive one at a time. In real conversations, they pile up: "too expensive" + "we already use something" + "need to check with the CTO." You need a matrix, not a list.

**No adaptation.** The script gets written once. Markets shift, products change, competitors move. Three months later, half the responses are wrong.

LLMs fix all three: they generate responses tuned to a specific client and context, handle linked objections together, and let you update the playbook whenever conditions change.

## B2B Objection Classification: 6 Types

Before you generate anything, classify the objection. Without that step, a prompt is flying blind. With it, the LLM has enough context to pick the right approach.

### Type 1: Price Objections

Trigger phrases: "too expensive," "doesn't fit the budget," "the competitor is cheaper," "need a discount."

What's behind it: the client doesn't see the ROI, is comparing to a cheaper alternative, genuinely has budget constraints, or is using it as a negotiating tactic.

Response strategy: shift to value, calculate ROI, break down the cost (cost per day/per user), compare TCO.

### Type 2: Timing Objections

Trigger phrases: "not now," "let's revisit in Q3," "it's not a priority right now," "after we finish the current project."

What's behind it: no urgency, overloaded with current tasks, a polite refusal, or genuinely bad timing.

Response strategy: create urgency through cost of inaction, tie to business cycles, micro-commitment instead of a full launch.

### Type 3: Trust Objections

Trigger phrases: "never heard of you," "do you have case studies in our industry?," "the company is too young," "who are your clients?"

What's behind it: risk aversion, need for social proof, fear of choosing an unknown vendor.

Response strategy: case studies from the client's industry, a pilot project with minimal commitment, guarantees and SLAs.

### Type 4: Authority Objections

Trigger phrases: "I need to run this by management," "the CTO makes this call," "I'll bring it to the next board meeting."

What's behind it: the contact isn't a decision-maker, a complex procurement process, or a polite escape from committing.

Response strategy: materials for internal selling (executive summary, ROI calculator), offer a joint call with the decision-maker, clarify decision criteria.

### Type 5: Competitive Objections

Trigger phrases: "we already use X," "why switch if it works," "your competitor offers the same for less."

What's behind it: switching costs, loyalty to the current solution, insufficient understanding of the differences.

Response strategy: comparative analysis on the client's specific use cases, switching cost vs. gain calculation, unique capabilities with no equivalent.

### Type 6: Need Objections

Trigger phrases: "we don't need this," "we manage without it," "I don't see the problem."

What's behind it: the client doesn't recognize the problem, the problem is handled via workarounds, or the product genuinely isn't a fit.

Response strategy: discovery questions to surface hidden pain, quantify losses from the current approach, step back if there's genuinely no fit.

## Prompt for Automatic Objection Classification

First step: the LLM identifies the objection type and flags a strategy. This makes the process consistent — it doesn't depend on how experienced a particular rep is.

```
You are a B2B sales objection analyst.

DEAL CONTEXT:
- Product: {product_name} — {product_description}
- Client: {company_name}, industry: {industry}, size: {company_size}
- Deal stage: {deal_stage}
- Contact: {contact_role}

CLIENT OBJECTION:
"{objection_text}"

TASK:
1. Classify the objection type: Price / Timing / Trust / Authority / Competitive / Need
2. Identify the likely cause (what's behind the words)
3. Rate severity: Low (tactical move) / Medium (genuine doubt) / High (potential deal-breaker)
4. Identify whether there's a hidden second objection beneath the surface one

RESPONSE FORMAT:
Type: [type]
Cause: [1-2 sentences]
Severity: [Low/Medium/High]
Hidden objection: [yes/no — if yes, what]
Recommended strategy: [brief description of the approach]
```

Example: the client says "Sounds interesting, but let's revisit after the new year — we're mid-SAP migration." The LLM correctly reads this as: type Timing, cause "genuine workload," severity Medium, hidden objection "possibly Priority/Need — not clear this matters more than SAP right now."

## Prompt for Generating Objection Responses

Once you know the type, you need an actual response. The key rule: one prompt per objection type, loaded with as much client context as possible.

```
You are a sales strategist. You generate a response to a B2B client's objection.

CONTEXT:
- Product: {product_name} — {value_proposition}
- Pricing: {pricing_model}
- Client: {company_name}, {industry}, {company_size}
- Decision-maker: {decision_maker_role}
- Current contact: {contact_role}
- Stage: {deal_stage}
- Previous interactions: {interaction_history}

OBJECTION: "{objection_text}"
TYPE: {objection_type}
SEVERITY: {severity}

RULES:
- Response must contain specific numbers or facts, not generic phrases
- Length: 3-5 sentences for a live conversation, 1 paragraph for email
- Include one open-ended question at the end
- Tone: confident but not aggressive
- Don't dismiss the client's objection
- If severity is High — offer a compromise option

GENERATE:
1. Response for a live conversation (call/meeting)
2. Response for email/messenger
3. Follow-up question to dig deeper into the problem
```

## Advanced Prompt: Stacked Objections

Real sales conversations aren't clean. "Too expensive, and we already use HubSpot, and I need to check with the CTO." Three objections, one sentence. You need a prompt that pulls them apart and figures out what to tackle first.

```
You are a senior sales strategist. The client has expressed multiple objections simultaneously.

DEAL CONTEXT:
{deal_context}

CLIENT MESSAGE:
"{full_message}"

TASK:
1. Break the message into individual objections
2. Classify each one (type, severity)
3. Determine processing priority — which objection to address first
4. Identify the root objection (the one generating the others)

For each objection in priority order:
- Response (2-3 sentences)
- Connection to other objections

At the end:
- Overall conversation strategy (order of actions)
- One question that surfaces the core problem
```

Order matters here. If the root objection is "Need" — the client doesn't see the value yet — talking price is pointless. Prove the value first, then discuss cost.

## Playbook Template: AI-Generated

A playbook holds ready responses for each objection type, adapted to your product. You generate it once, then update it when pricing changes, a new competitor shows up, or a big case study lands.

```
Generate an Objection Handling Playbook for a B2B product.

PRODUCT:
- Name: {name}
- Category: {category}
- Target audience: {target_audience}
- Pricing: {pricing}
- Key benefits: {key_benefits}
- Competitors: {competitors}
- Typical sales cycle: {sales_cycle}

PLAYBOOK FORMAT:
For each of the 6 objection types (Price, Timing, Trust, Authority, Competitive, Need):

### [Objection Type]

**Common phrases:** (5-7 phrases that signal this type)

**Root causes:** (2-3 reasons why the client says this)

**Response framework:**
1. Acknowledge — accept the objection (template phrase)
2. Reframe — reframe the problem (template)
3. Evidence — proof (specific fact/case study/number)
4. Bridge — transition to the next step (template)

**Sample dialogues:** (2 examples: one for a call, one for messaging)

**Red flags:** (when this objection means "deal is dead")

**Metrics:** (how to measure whether the response worked)

REQUIREMENTS:
- All examples tied to the product, not generic
- Numbers and facts instead of abstractions
- Every response includes a question to advance the deal
```

## Example: Playbook for a SaaS Analytics Product (Excerpt)

Real product: a SaaS product analytics platform, $500/month for the Growth plan, competing against Amplitude and Mixpanel. The numbers in the Evidence blocks are illustrative — swap in your own customers' real data when building your playbook.

### Price: "Amplitude Is Cheaper at Your Feature Level"

**Acknowledge:** "I get it — analytics budget is limited, and Amplitude has attractive starting prices."

**Reframe:** "The question isn't the subscription cost, it's the cost of the solution the team actually gets. Amplitude's Growth plan is enterprise-tier pricing — typically $40K–80K/year depending on MTU volume. By the time you add the features you actually need, the total is usually higher than it looks at first glance."

**Evidence:** "A few of our clients in edtech (50–200K MAU) ran a full TCO comparison over a year. In most cases, we came out 15–20% cheaper with everything included."

**Bridge:** "Want me to put together a TCO comparison based on your data volume? I can have it in one business day."

### Timing: "Let's Revisit After We Close the Round"

**Acknowledge:** "The round is consuming all your attention right now — that makes sense."

**Reframe:** "Investors ask about retention and unit economics at board meetings. Without analytics, those numbers are guesses. With it, you walk into the room with actual data."

**Evidence:** "One of our clients connected the platform two weeks before their Series A pitch. They showed investors cohort retention and LTV by channel. The round closed."

**Bridge:** "When are you roughly planning to go out for the pitch? We can launch a free pilot so the data is already there by the time you need it."

### Authority: "I Need to Discuss This with the CTO"

**Acknowledge:** "Of course — decisions on analytics infrastructure go through the CTO."

**Reframe:** "To make that conversation productive, I'll prepare a technical summary: integration architecture for your stack, load characteristics, compliance details."

**Evidence:** "At companies your size, CTOs usually ask three things: data security, infrastructure load, and integration complexity. I'll put together answers to all three for your stack specifically — looks like you're on PostgreSQL + React."

**Bridge:** "Could we set up a 20-minute technical call with our engineer and your CTO? It usually resolves 90% of the questions."

## Prompt for Updating the Playbook

Playbooks go stale. A new competitor shows up, pricing changes, a major case study comes in. Instead of rewriting from scratch, run targeted updates.

```
CURRENT PLAYBOOK:
{current_playbook}

CHANGES:
- Change type: {new_competitor | price_change | new_case_study | product_update | lost_deal_analysis}
- Details: {change_details}

TASK:
1. Identify which playbook sections are affected
2. Update only those sections
3. Preserve structure and format
4. Mark changes with a comment [UPDATED: date, reason]

If the change is a lost deal:
- Analyze which objection wasn't closed
- Add the new pattern to the relevant section
- Update red flags if needed
```

## Integration with ICP and Outreach Personalization

A playbook gets sharper when responses are tied to a specific [ICP profile](/blog/icp-definition-ai/). "Too expensive" from a seed-stage startup closes with different arguments than the same objection from an enterprise. The ICP gives you the context: budgets, priorities, pain points, how decisions actually get made.

Prompt for adapting a response to an ICP segment:

```
PLAYBOOK RESPONSE (base):
{base_response}

CLIENT ICP PROFILE:
- Segment: {segment}
- Typical budget for this category: {budget_range}
- Primary pain points: {pain_points}
- Decision-making process: {decision_process}
- Selection criteria: {selection_criteria}

Adapt the response for this segment:
- Replace generic examples with industry-relevant ones
- Adjust numbers for typical scale
- Account for the specifics of the procurement process
```

When [personalized outreach](/blog/ai-cold-outreach-personalization/) gets you the meeting and an objection comes up in that meeting, you're not improvising — you've already got a response built around that client's context. The chain is: ICP → personalization → outreach → meeting → objection handling. Each step makes the next one stronger.

## Workflow: From Objection to Close

**Step 1: Build it.** Generate the base playbook with the generation prompt. Adapt it for each ICP segment. First version takes 2–3 hours.

**Step 2: Pre-call prep.** Before a meeting, load client context into the LLM — company, contact role, deal stage, previous interactions. Ask it to predict the three most likely objections and draft responses. Five minutes of work.

**Step 3: In the conversation.** When something unexpected comes up, write down the exact phrasing. If there's any async gap — messaging, email follow-up — run it through the classification + generation prompt. You'll have a response in 15–30 seconds.

**Step 4: Debrief.** After the call, log the actual objections and how the client reacted to each response. Feed them through the playbook update prompt. Keep what worked, cut what didn't.

**Step 5: Monthly audit.** Look at the data: which objection types come up most, which responses move deals forward, where things fall apart. Update the playbook across the board.

## Prompt for Predicting Objections Before a Meeting

```
You are a sales intelligence analyst.

MEETING CONTEXT:
- Client: {company_name}, {industry}, {size}
- Contact: {name}, {role}
- Stage: {stage}
- History: {previous_interactions}
- Product: {product} priced at {price}
- Client's current solution: {current_solution}

TASK:
Predict 3-5 most likely objections based on:
- Industry and company size
- Contact's role (finance → price objections, tech lead → integration objections)
- Deal stage (early — Need/Trust, late — Price/Authority)
- Current solution (if present — Competitive is guaranteed)

For each objection:
- Likely phrasing
- Type and severity
- Prepared response (3-4 sentences)
- Plan B if the first response doesn't land
```

## Playbook Effectiveness Metrics

Without measurement, a playbook decays. Four metrics worth tracking.

**Objection-to-advance rate.** How often the deal moved forward after you handled an objection. Target: 60%+.

**Repeat objection rate.** How often the same objection comes back in the same deal. If the client says "too expensive" again after you responded, the response failed. Target: below 15%.

**Time-to-response.** In async communication — how long between receiving an objection and sending a reply. With a prepared playbook, target under 2 hours instead of "I'll get back to you tomorrow."

**New objection coverage.** What percentage of objections you encounter are already in the playbook. After 3 months: 85%+.

## Common Mistakes

**Generating without context.** A prompt like "write a response to the 'too expensive' objection" produces something generic that won't close anyone. Always include deal context.

**One playbook for all segments.** A seed-stage startup and an enterprise are operating in completely different worlds. At minimum, one version per ICP segment.

**Skipping lost deals.** Lost deals have more useful signal than won ones. Every loss should update the red flags and patterns in the playbook.

**Treating it as a script.** The LLM gives you the substance. Delivery still depends on tone, timing, and how the conversation is actually going. The playbook provides content — it doesn't replace the ability to read a room.

## Summary

The system has four parts: objection classification (6 types), prompts for generating responses (basic, stacked, adaptive), a playbook template with dialogue examples, and an update process driven by real data.

First version: 2–3 hours to build. Maintenance: 20–30 minutes a month. The payoff is response quality that doesn't vary based on who's on the call that day.

All prompts work with any LLM — GPT-5.4, Claude, Gemini. One ICP segment, 10 deals, one audit cycle. After that, the playbook runs on data, not assumptions.

---

*Need help with AI-powered sales playbooks? I help startups build AI products and automate processes — [belov.works](https://belov.works).*