Sales Enablement Kit

Reps lose deals they should win when they walk in armed with a feature list and a hope. Enablement is not a deck — it is the small set of assets a rep reaches for in the moment: the one-pager they leave behind, the battlecard they glance at before a competitive call, the demo path they run without fumbling, and the objection answers they deliver without flinching. This skill builds those four, in the order a rep encounters them, so the whole pack reads as one motion.

This is the asset-authoring step in a Go-to-Market Launch workflow. It assumes the positioning and message are already settled — it renders them into sales-ready collateral; it does not invent them.

When to use this skill

Reach for it once [[positioning-statement]] fixes the category and the "for whom / unlike what" frame, and [[messaging-hierarchy]] settles the value ladder. Pull battlecard inputs from [[competitive-intelligence]] (do not re-research competitors here). Hand the live-call tactics — what to say when an objection lands mid-conversation, and how fast to respond to inbound — to [[objection-handling-and-speed-to-lead]]. The kit is the durable artifact; that sibling is the in-the-moment playbook. Sequence the rollout with [[launch-plan-sequencer]] and brief the team on launch day with [[launch-day-runbook]]. For a self-serve motion where there is no rep in the room, the assets shift — see [[plg-motion-designer]].

The four assets, in the order a rep meets them

Build them in sequence; each feeds the next.

1. Sales one-pager — the leave-behind. One page a champion can forward to an economic buyer without you in the room. It must survive being read in 60 seconds. Open with the positioning one-liner ("we help [who] do [what] so they get [outcome]" from [[positioning-statement]]), then the three proof-backed value pillars from [[messaging-hierarchy]], a single hero metric or customer outcome, and one clear next step. No feature dump — pillars, not bullets.
2. Competitive battlecard — the pre-call glance. One card per primary competitor. Pull the landscape, their strengths, and their structural weaknesses from [[competitive-intelligence]]; do not re-derive them. The card translates that intel into what the rep says: where you win, the traps to set, the landmines to avoid, and the one-line reframe when the prospect name-drops them. Honest, not chest-thumping — a card that pretends a competitor has no strengths gets the rep caught flat.
3. Demo script outline — the repeatable path. Not a feature tour. A narrative that opens on the prospect's pain, hits the two or three "wow" moments tied to your value pillars, and lands on the outcome. Mark the moments to pause and ask, and the features to skip unless asked. The best demos show less, in the order that builds desire.
4. Objection-handling matrix — the durable answer set. The recurring objections, each mapped to a root concern, a reframe, and the proof that closes it. This is the written artifact reps study; the live delivery, tone, and speed-to-lead routing belong to [[objection-handling-and-speed-to-lead]]. Build the matrix here; rehearse the delivery there.

Workflow

1. Confirm the inputs exist. Pull the one-liner and "unlike" frame from [[positioning-statement]], the value ladder from [[messaging-hierarchy]], and the competitor dossiers from [[competitive-intelligence]]. If any is missing, stop and build it first — enablement assets inherit their truth from these; they cannot manufacture it.
2. Draft the one-pager. Positioning line, three value pillars (each with one proof point), one hero outcome, one CTA. Cut anything a buyer would not care about. If it spills past one page, you are listing features, not selling value.
3. Build one battlecard per primary competitor. For each: when they come up, where we win, where they win (state it honestly), the traps to set early, the landmines to sidestep, and the one-line reframe. Keep each to a single screen.
4. Outline the demo. Pain open → 2-3 wow moments mapped to pillars → outcome close. Mark pause-and-ask points; list the features to skip unless asked.
5. Fill the objection matrix. List the top recurring objections, classify the root concern (price / risk / fit / timing / status quo), write the reframe and the proof for each. Route delivery tactics to [[objection-handling-and-speed-to-lead]].
6. Pressure-test with a rep. Have someone run the demo and field the objections cold. Anything they fumble is an asset bug, not a rep bug — fix the asset.

Quality bar

The kit is ready when:

• The one-pager survives the forward test: a champion can send it to their boss and it sells without you narrating it.
• Every claim traces to a proof point that exists — a metric, a named customer, a live capability. No aspirational features written as shipped.
• Each battlecard names at least one place the competitor genuinely wins. A card with no honest weakness gets the rep ambushed.
• The demo outline could be run by a rep who joined last week and still land the wow moments in order.
• Every objection in the matrix has a root concern tagged, not just a snappy comeback — reps adapt a reframe they understand and parrot one they memorized.
• Positioning, one-pager, battlecard, demo, and objection answers tell the same story. A buyer who reads the one-pager and then sees the demo should feel one coherent argument, not four authors.

Do NOT

• Do NOT re-research competitors here. Battlecard inputs come from [[competitive-intelligence]]; this skill translates intel into rep language, it does not gather it.
• Do NOT write live, in-call rebuttal scripts or speed-to-lead routing — that is [[objection-handling-and-speed-to-lead]]. Build the written matrix; route the delivery.
• Do NOT put fabricated or rounded-up metrics on the one-pager. A number a prospect can disprove in diligence costs more than the deal it won.
• Do NOT build a demo that tours every feature. Showing more lowers conversion; the discipline is what you cut.
• Do NOT write a battlecard that pretends a competitor is strictly worse. Honest weaknesses build rep credibility; dishonest ones get exposed on the call.
• Do NOT duplicate pricing or packaging logic here — pull it from [[pricing-strategy]] / [[saas-pricing]] and reference it; do not re-derive tiers.
• Do NOT invent positioning or messaging on the fly. If the "for whom / unlike what" frame is not fixed, stop and use [[positioning-statement]]; if the value ladder and proof points are not settled, use [[messaging-hierarchy]] first. This skill renders those decisions into collateral; it does not make them.
• Do NOT use this to plan the rollout calendar or run launch day — sequence the rollout with [[launch-plan-sequencer]] and brief the team with [[launch-day-runbook]].
• Do NOT build rep-carried collateral for a self-serve motion where no rep is ever in the room — the assets are different (in-product onboarding, activation nudges, self-serve trials). Use [[plg-motion-designer]] instead.

Fill-in template — the four assets

Copy this, replace every <...>, and delete any line you cannot back with a real proof point.

# Sales Enablement Kit — <Product>

## 1. One-pager (the leave-behind, one page max)
**Positioning line:** We help <who> do <what> so they get <outcome>.
**Value pillars (3, each with proof):**
  - <Pillar 1> — proof: <metric / customer / capability>
  - <Pillar 2> — proof: <metric / customer / capability>
  - <Pillar 3> — proof: <metric / customer / capability>
**Hero outcome:** <one customer result, with a denominator and a date>
**Next step (one CTA):** <book a scoping call / start a pilot / …>

## 2. Battlecard — vs <Competitor>  (one card per primary competitor)
**When they come up:** <the trigger phrase a prospect uses>
**Where we win:** <2-3 honest, structural advantages>
**Where they win (state it):** <1-2 real strengths — do not hide these>
**Traps to set early:** <questions that surface our advantage / their gap>
**Landmines to avoid:** <topics that play to their strength — redirect>
**One-line reframe:** "<the sentence the rep says when the prospect name-drops them>"

## 3. Demo script outline (a path, not a tour)
1. **Pain open:** <the prospect reality you start on, in their words>
2. **Wow moment 1 → Pillar 1:** <what you show; pause-and-ask: "<question>">
3. **Wow moment 2 → Pillar 2:** <what you show; pause-and-ask: "<question>">
4. **Wow moment 3 → Pillar 3 (optional):** <show only if engaged>
5. **Outcome close:** <the after-state, tied to the hero outcome>
_Skip unless asked:_ <features that dilute the narrative>

## 4. Objection matrix (the written answer set)
| Objection (verbatim) | Root concern | Reframe | Proof that closes it |
|---|---|---|---|
| "<too expensive>" | price | <reframe to value/ROI> | <metric / payback> |
| "<we already use X>" | status quo | <cost of staying> | <migration story> |
| "<not sure it fits>" | fit | <where you fit best> | <named lookalike customer> |
| "<bad timing>" | timing | <cost of waiting> | <quick-win proof> |
_Live delivery, tone, and speed-to-lead routing → objection-handling-and-speed-to-lead._

Runnable artifact — one-pager linter

Drop this in a file and run it on a one-pager draft to catch the failure modes the Quality bar names — over-length, feature-dumping, unproven claims, and missing CTA — before a rep ever carries it. Pure Python, no dependencies.

#!/usr/bin/env python3
"""Lint a sales one-pager for the Sales Enablement Kit quality bar.
Usage: python onepager_lint.py onepager.md"""
import re, sys

FEATURE_WORDS = ("feature", "functionality", "capabilities", "module", "integration")
PROOF_HINT = re.compile(r"\d|%|customer|case study|named|trusted by")
WEASEL = ("world-class", "best-in-class", "revolutionary", "seamless", "cutting-edge", "synergy")

def lint(text: str) -> list[str]:
    issues = []
    words = len(text.split())
    bullets = [l for l in text.splitlines() if l.strip().startswith(("-", "*"))]

    if words > 350:
        issues.append(f"LENGTH: {words} words — a one-pager should read in ~60s (<=350 words).")
    if len(bullets) > 9:
        issues.append(f"FEATURE DUMP: {len(bullets)} bullets — collapse into 3 value pillars.")
    feat = sum(text.lower().count(w) for w in FEATURE_WORDS)
    if feat >= 4:
        issues.append(f"FEATURE-LED: '{'/'.join(FEATURE_WORDS)}' appears {feat}x — lead with value, not features.")
    if not PROOF_HINT.search(text.lower()):
        issues.append("NO PROOF: no metric, %, or named customer found — pillars need proof points.")
    weasels = [w for w in WEASEL if w in text.lower()]
    if weasels:
        issues.append(f"WEASEL WORDS: {', '.join(weasels)} — replace with a concrete claim a buyer can verify.")
    if not re.search(r"(book|start|try|schedule|request|get|talk to|see)\b", text.lower()):
        issues.append("NO CTA: no clear next step — every one-pager ends on one action.")
    return issues

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("usage: python onepager_lint.py onepager.md"); sys.exit(2)
    problems = lint(open(sys.argv[1], encoding="utf-8").read())
    if not problems:
        print("PASS — one-pager clears the enablement quality bar.")
    else:
        print(f"FAIL — {len(problems)} issue(s):")
        for p in problems:
            print("  - " + p)
        sys.exit(1)

Worked example. Running it on a draft that opens "Our world-class platform offers 14 powerful features and seamless integrations…" with twelve bullets and no metrics prints:

FAIL — 4 issue(s):
  - LENGTH: 372 words — a one-pager should read in ~60s (<=350 words).
  - FEATURE DUMP: 12 bullets — collapse into 3 value pillars.
  - FEATURE-LED: 'feature/functionality/capabilities/module/integration' appears 5x — lead with value, not features.
  - NO PROOF: no metric, %, or named customer found — pillars need proof points.

Fix the four issues — three pillars with a proof point each, the positioning line on top, a single CTA — and the linter prints PASS. That is the one-pager a champion can forward without you in the room.

Deliverable

Four rep-ready assets in one document: a one-page leave-behind that passes the forward test and the linter, one honest battlecard per primary competitor, a demo outline that lands its wow moments in order, and an objection matrix with every objection tagged to a root concern. All five — positioning, one-pager, battlecard, demo, objections — tell one story. Hand live delivery to [[objection-handling-and-speed-to-lead]] and sequence the rollout with [[launch-plan-sequencer]].