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

Most closed B2B deals 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.

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. “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 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.

FAQ

How do you handle objections in a live call when there is no time to run a prompt?

Build the pre-call preparation habit instead. Five minutes before any meeting, load the deal context into the LLM and ask it to predict the three most likely objections with draft responses. Print or copy them to a notes app. In the live call, you are retrieving a pre-generated response, not improvising — the AI work happens before the meeting, not during it. For objections that weren’t predicted, write down the exact wording and process them in the async follow-up, which is where the classification and generation prompts apply.

When should a rep deviate from the playbook response and go fully off-script?

When the objection reveals information not captured in the ICP profile — an undisclosed decision-making layer, a specific competitive deal already in progress, or a budget freeze that wasn’t in the CRM. The playbook handles the median case well; edge cases require genuine discovery. The signal is when the client’s words don’t match any of the six objection types cleanly, or when the severity reads as High but the words are unusually calm. In those situations, ask a discovery question instead of delivering a prepared response.

How many lost deals should we analyze before updating the playbook with new patterns?

Three is the minimum threshold. A single lost deal may be an outlier — a difficult contact, bad timing, a competitor with a temporary promotion. When the same objection type appears in three consecutive losses with the same response failing to advance the deal, that is a signal the response itself is broken, not the rep’s delivery. Pull those three deals, run them through the playbook update prompt together, and look for the common failure point in the Acknowledge → Reframe → Evidence → Bridge sequence.