version: "1.0.1" name: "founder-sales" description: "Create a Founder Sales Sprint Pack (ICP wedge, outreach sequences, discovery script, activation plan)."

Founder Sales

Scope

Covers

• Founder-led sales for early-stage products (typically pre-seed → Series A)
• Getting initial design partners / first customers (incl. first 10–30)
• Outbound + warm intro outreach design (not high-scale automation)
• Diagnostic discovery (problem-first; demo later)
• Decision enablement (your #1 competitor is often “no decision”)
• Closing-to-activation (white-glove onboarding to prevent “yes → silence”)
• Building a simple, repeatable learning loop (message → calls → iteration)

When to use

• “Help me get my first customers / first 10 customers.”
• “Create a founder-led sales playbook.”
• “Write a discovery call script (diagnostic, no demo).”
• “Create an outreach sequence for my ICP.”
• “Prospects go dark / end in no decision—help me close with a clear next step.”
• “We close deals but onboarding stalls—create an activation/implementation plan.”

When NOT to use

• You need to define the product, ICP, or positioning from scratch (do that first; then return here)
• You’re scaling a full sales org (SDRs, AEs, quotas, forecasting, territories) rather than founder-led learning -> use building-sales-team
• You’re running a complex enterprise deal with a buying committee, procurement, and security reviews -> use enterprise-sales
• You need a lead qualification or scoring framework (MQL/SQL definitions, handoff criteria) -> use sales-qualification
• You have self-serve PLG usage and want to layer a sales-assist motion on top -> use product-led-sales
• You want scraped lead lists, spammy outreach, or anything deceptive/manipulative
• You need legal/privacy/security advice or contract language (coordinate with qualified experts)

Inputs

Minimum required

• Product: what it does, for whom, and the core “pain → outcome”
• ICP hypothesis: target roles + company type (and who pays vs who uses)
• Stage + goal: “first X customers” and timeframe (e.g., 10 customers in 8 weeks)
• Offer: pricing hypothesis (or pilot structure) + what “success” looks like in 30 days
• Proof: founder credibility and 1–3 proof points (results, prior work, early users)
• Constraints: founder time per week + preferred channels (warm intros, email, LinkedIn, communities)

Missing-info strategy

• Ask up to 5 questions from references/INTAKE.md.
• If answers aren’t available, proceed with explicit assumptions and label unknowns. Include an Assumptions & unknowns section and a short Validation plan.

Outputs (deliverables)

Produce a Founder Sales Sprint Pack in Markdown (in-chat; or as files if requested):

1) Context snapshot (stage, goal, constraints, time box) 2) ICP wedge + founder POV (who, what pain, why now, why you, what you won’t do) 3) Targeting plan + target list (criteria + initial list table + next actions) 4) Outreach kit (warm intro request + cold message + follow-ups + meeting ask) 5) Diagnostic discovery kit (agenda + question bank + call notes template; “no demo first”) 6) Decision enablement kit (reduce “no decision”: decision guide + risk reversal + mutual action plan) 7) White-glove activation plan (implementation checklist + 30-day success plan + follow-up cadence) 8) Learning loop (tracking + weekly review + message iteration plan) 9) Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md

Workflow (7 steps)

1) Intake + stage gating (founder-led focus)

• Inputs: User context; references/INTAKE.md.
• Actions: Confirm the goal (e.g., first 10 customers), time box, ICP hypothesis, and founder availability. Identify “must-not-do” constraints (ethics, brand, compliance). Decide what a successful 30-day customer outcome looks like.
• Outputs: Context snapshot + success definition + constraints list.
• Checks: The goal is measurable and time-boxed (who/what/by when). Founder involvement is explicit.

2) Craft the founder POV + ICP wedge

• Inputs: Product + founder credibility + early signals.
• Actions: Write a founder POV that leads with insight (not features): the problem, why existing approaches fail, and why now. Tighten to 1 primary ICP wedge (plus 1 secondary) with exclusion criteria.
• Outputs: ICP wedge statement + founder POV one-pager.
• Checks: A target buyer can self-identify in 10 seconds. The POV is specific enough to repel non-ICP prospects.

3) Targeting + outreach plan (warm first, then cold)

• Inputs: ICP wedge; channel constraints; any existing network.
• Actions: Define targeting criteria and build an initial target list. Create a “warm intro ask” and a cold outreach sequence designed for learning, not volume. Specify personalization hooks (“budding moments”) to test in messaging.
• Outputs: Target list table + outreach kit (warm + cold + follow-ups).
• Checks: Each message has a single clear ask and a believable reason for the recipient to respond.

4) Run diagnostic discovery (no demo first)

• Inputs: Discovery goals; references/TEMPLATES.md (Discovery kit).
• Actions: Write a diagnostic call script that keeps the first conversation problem-first. Use questions that help the buyer self-diagnose and quantify impact. Capture language verbatim for future messaging.
• Outputs: Discovery agenda + question bank + call notes template.
• Checks: The script does not default to a product demo. The call ends with a concrete next step.

5) Beat “no decision” with decision enablement

• Inputs: Common objections; buyer risk profile; desired next step.
• Actions: Create decision-enablement assets: (a) a short decision guide (options + criteria), (b) a risk-reversal / pilot framing, and (c) a mutual action plan (MAP) that makes the path forward easy and safe.
• Outputs: Decision enablement kit (decision guide + risk reversal + MAP).
• Checks: The buyer has a low-risk path to try/decide. The “do nothing” option is explicitly contrasted with its cost.

6) Close-to-activation (white-glove implementation)

• Inputs: What “implemented” means; onboarding steps; resources available.
• Actions: Define activation milestones and an onboarding plan. Prevent “yes → silence” by scheduling implementation during the close, assigning owners, and creating a follow-up cadence. Treat the sale as complete only after activation.
• Outputs: Activation/implementation checklist + 30-day success plan + follow-up cadence.
• Checks: Every “closed” customer has a scheduled kickoff and clear activation criteria.

7) Quality gate + finalize (learning loop)

• Inputs: Draft pack.
• Actions: Run references/CHECKLISTS.md and score with references/RUBRIC.md. Add a lightweight tracking + weekly review loop. Always include Risks / Open questions / Next steps and a short validation plan.
• Outputs: Final Founder Sales Sprint Pack.
• Checks: Assumptions are explicit; next steps are executable; artifacts are copy/paste ready.

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Anti-patterns

Avoid these common failure modes when producing a Founder Sales Sprint Pack:

1. ”Spray and pray” outreach — Generating high-volume, generic email blasts instead of small-batch, personalized sequences designed for learning. Founder sales is about learning velocity, not send volume.
2. Skipping discovery to demo — Jumping straight to product demos without a diagnostic discovery phase. Founders must understand the buyer’s problem before showing solutions, or they waste their credibility advantage.
3. Treating “no decision” as “no” — Giving up when prospects go silent instead of building decision-enablement assets (decision guide, risk reversal, MAP). In early-stage sales, “no decision” is the #1 competitor.
4. Closing without activating — Declaring victory at verbal “yes” or signature without a white-glove activation plan. A customer who signs but never implements is worse than a lost deal (negative reference risk).
5. Over-engineering the process — Building complex CRM workflows, lead scoring, or multi-touch automation sequences appropriate for a scaled sales team. Founder sales should be simple, manual, and fast to iterate.

Examples

Example 1 (first 10 customers, B2B SaaS): “Use founder-sales. We’re building scheduling automation for outpatient clinics. Goal: 10 paying customers in 8 weeks. ICP: clinic ops managers. Offer: $500/mo pilot. Output: a Founder Sales Sprint Pack with outreach sequences, a diagnostic discovery script, a MAP, and a white-glove onboarding plan.”

Example 2 (design partners, new category): “Use founder-sales. We’re a security workflow tool for SOC teams. Goal: 6 design partners in 6 weeks. We have strong founder credibility but no case studies yet. Output: target list criteria + outreach kit + decision enablement assets that reduce buyer risk.”

Boundary example (redirect to enterprise-sales): “We have a $200K deal stuck in procurement at a Fortune 500. The CISO wants a security review, and legal is pushing back on our terms. Help me close it.” Response: This is an enterprise deal execution problem with a buying committee, procurement, and security review -- use enterprise-sales instead. That skill produces a buying committee map, champion enablement kit, procurement/security tracker, and MAP designed for complex enterprise cycles.

Boundary example (redirect to building-sales-team): “We have 50 customers and need to hire our first 3 SDRs and build a quota/territory plan.” Response: This is about scaling a sales organization, not founder-led selling. Use building-sales-team for SDR hiring, quota design, territory planning, and sales process documentation.

Anti-pattern example: “Write a generic cold email that works for any product, and send 10,000 emails.” Response: This skill is for founder-led learning and ethical, targeted outreach. Request an ICP wedge + proof points and produce a small, testable sequence and learning plan instead.