sales-enablement

Overview of sales-enablement skill

The sales-enablement skill helps create B2B sales assets that reps can actually use: sales decks, one-pagers, objection handling docs, demo scripts, playbooks, and proposal-support materials. It is best for teams that already have a product, a buyer, and a sales motion, but need sharper collateral for real deals rather than generic marketing copy.

Who this sales-enablement skill is for

Use the sales-enablement skill if you need materials for:

• sales conversations and follow-up
• deal-specific proposal support
• enablement docs for reps and champions
• structured talk tracks for discovery, demos, and objections

It is especially relevant for sales-enablement for Proposal Writing when you need proposal inputs grounded in buyer pain, proof, differentiators, and next-step logic.

What job it really does

The real job is not “write a deck.” It is turning scattered product knowledge into sales-ready assets matched to a buyer, a use case, and a stage of the deal. This skill is strongest when you need the output to be situation-specific, not just polished.

What makes this different from a normal prompt

A normal prompt often produces feature lists and generic persuasion. The sales-enablement skill pushes toward:

• audience-specific framing
• sales-motion-aware content
• proof and objection handling
• structured formats from the included references
• materials reps can use live, not just review internally

Best-fit outputs

The repository evidence points to strong support for:

• 10–12 slide sales decks
• objection handling documents
• discovery and demo scripts
• product and use-case one-pagers

When this is not the right skill

Skip this skill if you mainly need:

• website copy or homepage messaging
• cold outbound email sequences
• competitor battlecards only

The repo itself routes those jobs toward other specialized skills.

How to Use sales-enablement skill

Install context for sales-enablement

The upstream SKILL.md does not publish its own install command, so a common install pattern is:

npx skills add https://github.com/coreyhaines31/marketingskills --skill sales-enablement

If your environment uses a different skill loader, add the skill from coreyhaines31/marketingskills and target the skills/sales-enablement path.

Read these files first

For a fast decision and faster usage, start with:

1. skills/sales-enablement/SKILL.md
2. skills/sales-enablement/references/deck-frameworks.md
3. skills/sales-enablement/references/objection-library.md
4. skills/sales-enablement/references/demo-scripts.md
5. skills/sales-enablement/references/one-pager-templates.md
6. skills/sales-enablement/evals/evals.json

Why this order matters:

• SKILL.md shows trigger conditions and workflow.
• references/ contains the practical templates that actually shape output quality.
• evals/evals.json shows what the skill expects a good answer to include.

Check for product context before prompting

The sales-enablement usage flow starts with one key check: look for .agents/product-marketing-context.md or .claude/product-marketing-context.md. The skill explicitly wants that context read first before asking repeated discovery questions.

If that file exists, use it. If not, gather only what is missing.

Minimum input the skill needs

To get useful output, provide at least:

• what you sell
• who the buyer is
• main pain/problem
• differentiators versus alternatives
• proof points or evidence
• sales motion and deal context
• desired asset type

Without these, the skill can still draft, but it will drift generic.

Turn a rough ask into a strong prompt

Weak ask:

• “Make me a sales deck.”

Stronger sales-enablement guide prompt:

• “Create a 10–12 slide sales deck for our B2B SaaS product. Buyer: HR directors at 500–5000 employee companies. Main pain: low employee engagement visibility across distributed teams. Differentiator: real-time pulse surveys with AI-generated insight summaries. Proof: one customer improved manager response time by 38%. Sales motion: mid-market inside sales, 45-day cycle. Include slide goals, core copy, speaker notes, and what proof is still missing.”

That extra detail helps the skill choose the right story arc, proof placement, and objection framing.

Use the built-in deck framework

For deck work, the repository guidance is more specific than a generic “pitch deck” prompt. The references point toward a story structure like:

• current world problem
• cost of the problem
• why current solutions fail
• a better way
• your solution
• how it works
• proof
• pricing or commercial shape
• urgency / why now
• next steps

This is a practical reason to install sales-enablement instead of improvising from scratch.

Use sales-enablement for Proposal Writing

For sales-enablement for Proposal Writing, do not ask only for a proposal narrative. Give the skill the sales context behind the proposal:

• buyer stakeholders
• deal stage
• success criteria
• rollout scope
• objections already raised
• pricing shape
• expected ROI or cost-of-delay logic

Then ask for proposal components such as:

• executive summary
• problem framing
• solution fit
• implementation approach
• success metrics
• proof points
• commercial assumptions
• next-step CTA

This produces proposal-ready material that sounds tied to the deal, not recycled from marketing copy.

Best workflow by asset type

Use this simple path:

1. Gather or load product marketing context.
2. Choose one asset type only.
3. Tell the skill the audience, stage, and use case.
4. Request the output in the repo’s reference structure.
5. Review missing proof, numbers, and examples.
6. Run one revision for specificity, not style alone.

This skill works better asset-by-asset than when asked to generate an entire enablement library in one shot.

Practical prompts that fit the repository well

Good requests include:

• “Create an objection handling doc for these six recurring objections.”
• “Write a discovery-to-demo script for a 30-minute first call.”
• “Draft a use-case one-pager for IT leaders evaluating vendor consolidation.”
• “Build a sales deck with slide-by-slide copy and presenter notes.”

These align with the reference files and evals, so you will get more grounded output.

Common mistakes during sales-enablement usage

The biggest avoidable mistakes are:

• giving no buyer or deal context
• asking for “marketing copy” instead of a sales asset
• skipping proof points
• combining too many outputs in one prompt
• not specifying whether the asset is generic, vertical, persona, or deal-specific

Most poor output comes from weak inputs, not from the skill format.

sales-enablement skill FAQ

Is sales-enablement skill good for beginners?

Yes, if you already know the product and buyer. The templates reduce guesswork. But beginners may still struggle if they cannot provide differentiators, proof, or sales-stage context.

What does sales-enablement do better than ordinary prompting?

The sales-enablement skill gives you stronger structure. Instead of broad persuasive copy, it tends to organize around buyer pain, proof, objections, and rep usability. The included references are the main value.

Is this only for SaaS?

The examples and objection library are clearly B2B SaaS-leaning, so that is the safest fit. Other B2B contexts can still use it if the buying process, proof style, and sales assets are similar.

Can I use sales-enablement install without reading the references?

You can, but output quality will usually be worse. The references contain the concrete frameworks for decks, demo scripts, objections, and one-pagers. They are the fastest way to understand how the skill wants to work.

Is this a good fit for proposal writing?

Yes, especially for sales-led proposals. The skill is useful when the proposal needs better problem framing, stakeholder-aware messaging, differentiators, and proof. It is less suited to procurement-heavy legal formatting by itself.

When should I not use sales-enablement?

Do not use sales-enablement when your main need is:

• homepage or landing page copy
• outbound prospecting emails
• deep competitor alternatives research only

Those jobs need a different skill or additional support.

Does the skill need internal company files?

It helps a lot. The explicit check for .agents/product-marketing-context.md or .claude/product-marketing-context.md is one of the strongest signs that this skill expects reusable company context, not blank-page drafting.

How to Improve sales-enablement skill

Give sharper commercial context

The fastest way to improve sales-enablement output is to provide:

• deal size or range
• sales cycle length
• self-serve vs inside sales vs field sales
• buying committee roles
• current alternatives the buyer uses

This changes messaging, objection handling, and CTA quality.

Add proof before polishing copy

If the first draft sounds generic, do not start by asking for “better writing.” Add:

• customer outcomes
• quantified results
• implementation speed
• time saved
• replacement or switch stories

The skill’s frameworks assume proof is central.

Specify the exact audience and stage

A one-pager for a champion is different from a one-pager for an economic buyer. A demo script for first discovery is different from a late-stage tailored walkthrough. Tell the skill:

• persona
• industry
• company size
• deal stage
• intended use

That information usually matters more than tone guidance.

Ask for missing-information flags

A strong prompt for sales-enablement usage includes:

• “Mark assumptions clearly.”
• “List missing inputs that would strengthen this.”
• “Flag unsupported claims.”
• “Suggest proof points we should gather.”

This makes the draft safer to use in real sales contexts.

Improve outputs with one revision pass

After the first draft, ask for one focused revision such as:

• tighten for executive readers
• adapt for a specific vertical
• convert claims into ROI language
• reduce feature detail and increase business impact
• make objections more credible and less defensive

Focused revision beats “make it better.”

Watch for these failure modes

Common weak outputs include:

• opening with product features instead of buyer pain
• objections answered with denial instead of reframing
• demo scripts that sound like monologues
• decks with no cost-of-doing-nothing logic
• one-pagers with claims but no proof

These are fixable if you re-anchor the prompt to the repo’s reference patterns.

Use evals to self-check quality

evals/evals.json is worth reading because it shows what good execution includes, such as:

• checking for product marketing context first
• using the right framework for the asset
• tailoring to audience and use case
• including proof and talk tracks

If your output misses those elements, your prompt is probably underspecified.

Improve sales-enablement for Proposal Writing outputs

For better proposal results, provide:

• customer goals in their language
• scope boundaries
• implementation constraints
• stakeholder concerns
• success metrics for 30/60/90 days
• decision criteria already mentioned by the buyer

Then ask the skill to map each proposal section to a buyer concern. That makes the proposal more persuasive and easier for champions to reuse internally.