Sales Style Guides & Prompt Templates

Overview

When AI agents generate customer-facing communications—outreach emails, follow-up messages, meeting summaries, proposals—consistency is critical. Without centralized style guides, each generation request produces output in a slightly different voice, formality level, and structure. Sales Style Guides and Prompt Templates solve this by codifying tone rules, message structures, and reusable prompt fragments into version-controlled files that agents load before generating any content.

A style guide defines the “how” of communication: preferred tone (professional but approachable), forbidden phrases (no “circle back” or “synergy”), sentence length targets, personalization requirements, and channel-specific adaptations (LinkedIn messages are shorter than emails). Prompt templates define the “what”: structured prompts with placeholders for client name, industry, pain points, and call-to-action that agents fill in from CRM data.

The agent platform stores these guides and templates as markdown and YAML files alongside CRM records. Analyst prompts—higher-level instructions that tell an LLM how to research a prospect or summarize a meeting—are stored as separate template files. This separation of concerns means updating the tone for all outreach is a single file edit, not a code change.

Core Concepts

Style Guide Structure

A style guide is a document (typically markdown) that defines communication standards. It covers voice and tone (authoritative, friendly, technical), formatting rules (max paragraph length, bullet point usage, greeting/closing conventions), vocabulary (preferred terms, banned words), and channel-specific overrides. The guide is loaded into the LLM’s system prompt or prepended to every generation request.

Prompt Template Anatomy

A prompt template is a structured text file with placeholder variables that get filled at generation time. Templates typically have three sections: a system instruction (role and constraints), context injection points (where CRM data is inserted), and output format requirements (what the response should look like). Variables use a consistent syntax like {{company_name}} or ${industry}.

Analyst Prompts

Analyst prompts are a special category of templates designed for research and analysis tasks rather than outreach. They instruct an LLM to analyze a prospect’s website, summarize their tech stack, identify pain points, or draft competitive positioning. These prompts are more complex than message templates because they require multi-step reasoning and often include few-shot examples of good analysis output.

Vertical and Channel Specialization

Different industries and communication channels require different approaches. A fintech prospect expects regulatory awareness and compliance language. A healthcare prospect needs HIPAA sensitivity. LinkedIn messages must be under 300 characters for connection requests. Email subject lines need to be under 60 characters. These constraints are encoded as channel-specific template variants and vertical-specific context blocks.

How It Works

The template system operates as a pipeline: load the base style guide, select the appropriate channel and vertical templates, merge them into a composite prompt, inject CRM data into placeholders, and send the assembled prompt to the LLM. The output is then validated against style rules before delivery.

1. Load style guide: Read the base tone/voice document from the style guides directory.
2. Select templates: Choose the channel template (email, LinkedIn, Slack) and vertical context block.
3. Compose prompt: Merge the style guide, template, and context into a single prompt with placeholders.
4. Inject data: Fill placeholders with CRM record data (company name, contact name, industry, pain points).
5. Generate: Send the assembled prompt to the LLM.
6. Validate: Check output against style rules (length limits, banned words, required elements).

# style-guides/base-tone.md
# Sales Voice Guide

## Tone
- Professional but conversational — not stiff, not casual
- Confident without being pushy
- Show genuine curiosity about the prospect's challenges

## Rules
- First sentence must reference something specific to the prospect
- Never open with "I hope this finds you well"
- Avoid jargon: no "synergy", "leverage", "circle back", "touch base"
- Keep paragraphs to 2-3 sentences max
- Always end with a specific, low-commitment ask
- Use the prospect's first name, never "Dear Sir/Madam"

## Channel Overrides
### Email
- Subject line: under 60 characters, no ALL CAPS
- Body: 3-5 short paragraphs
- Include one concrete data point or observation

### LinkedIn
- Connection request: under 300 characters
- InMail: under 150 words
- Reference a shared connection or recent post if possible

// TypeScript: Template composition and variable injection
import * as fs from "fs";
import * as path from "path";
import Mustache from "mustache";

interface TemplateContext {
  company_name: string;
  contact_first_name: string;
  industry: string;
  pain_points: string[];
  tech_stack: string[];
  recent_news?: string;
}

function loadTemplate(templatePath: string): string {
  return fs.readFileSync(templatePath, "utf-8");
}

function composePrompt(
  styleGuide: string,
  channelTemplate: string,
  verticalContext: string,
  data: TemplateContext
): string {
  // Merge templates into a composite prompt
  const composite = [
    "## Style Guide\n" + styleGuide,
    "\n## Message Template\n" + channelTemplate,
    "\n## Industry Context\n" + verticalContext,
  ].join("\n---\n");

  // Inject CRM data into placeholders
  return Mustache.render(composite, {
    ...data,
    pain_points_list: data.pain_points.join(", "),
    tech_stack_list: data.tech_stack.join(", "),
  });
}

// Usage
const styleGuide = loadTemplate("style-guides/base-tone.md");
const emailTemplate = loadTemplate("templates/cold-outreach-email.md");
const fintechContext = loadTemplate("verticals/fintech.md");

const prompt = composePrompt(styleGuide, emailTemplate, fintechContext, {
  company_name: "Acme Payments",
  contact_first_name: "Sarah",
  industry: "fintech",
  pain_points: ["PCI compliance overhead", "slow onboarding"],
  tech_stack: ["React", "Node.js", "PostgreSQL"],
  recent_news: "Series B funding announced last week",
});

Practical Applications

Automated Outreach Campaigns

The agent platform uses prompt templates to generate personalized outreach at scale. An agent iterates over a filtered segment from the CRM summary index (e.g., “mid-market fintech companies not contacted in 60 days”), loads each record’s data, composes a personalized prompt using the appropriate templates, generates the message, and queues it for human review before sending.

Meeting Summary Standardization

After a sales call, an analyst prompt instructs the LLM to extract key information from meeting notes or transcripts: decision makers mentioned, pain points discussed, next steps agreed, and competitive mentions. The template ensures every summary follows the same structure, making it easy to scan across dozens of client interactions.

Competitive Positioning Research

Analyst prompts guide LLMs through structured research: “Visit the prospect’s website, identify their current tech stack, find their job postings for clues about technical challenges, and draft three talking points that position our product against their likely alternatives.” The few-shot examples in the template show the expected depth and format.

Implementation Patterns

Template Directory Layout

Organize templates by function, channel, and vertical:

crm-data/
  style-guides/
    base-tone.md           # Core voice and tone rules
    formal-override.md     # For enterprise/regulated prospects
  templates/
    cold-outreach/
      email.md             # Cold email template
      linkedin.md          # LinkedIn InMail template
    follow-up/
      post-meeting.md      # Post-meeting follow-up
      re-engagement.md     # Re-engagement after silence
  verticals/
    fintech.md             # Fintech-specific context and terms
    healthcare.md          # Healthcare/HIPAA awareness context
    saas.md                # General SaaS context
  analyst-prompts/
    prospect-research.md   # Research a new prospect
    competitive-analysis.md # Competitive positioning
    meeting-debrief.md     # Summarize meeting transcript

Output Validation

After generation, validate the output programmatically: check word count against channel limits, scan for banned words from the style guide, verify that required elements (personalization, CTA) are present, and flag outputs that need human attention. This catches the majority of style violations before review.

// TypeScript: Post-generation style validation
interface ValidationResult {
  passed: boolean;
  violations: string[];
}

function validateOutput(
  output: string,
  channel: "email" | "linkedin" | "slack"
): ValidationResult {
  const violations: string[] = [];
  const bannedWords = [
    "synergy", "leverage", "circle back",
    "touch base", "ping", "no-brainer"
  ];
  const wordCount = output.split(/\s+/).length;

  // Channel-specific length checks
  const limits = { email: 300, linkedin: 150, slack: 100 };
  if (wordCount > limits[channel]) {
    violations.push(
      `Word count ${wordCount} exceeds ${channel} limit of ${limits[channel]}`
    );
  }

  // Banned word check
  for (const word of bannedWords) {
    if (output.toLowerCase().includes(word)) {
      violations.push(`Contains banned phrase: "${word}"`);
    }
  }

  // Must include personalization (not generic)
  if (output.includes("Dear Sir") || output.includes("To Whom")) {
    violations.push("Contains generic salutation — must personalize");
  }

  return { passed: violations.length === 0, violations };
}

Common Pitfalls

• Over-prescriptive templates: Templates that are too rigid produce robotic, formulaic output. The LLM needs room to adapt to each prospect’s context. Leave the template flexible enough for natural variation while constraining the structure and tone.
• Stale examples in analyst prompts: Few-shot examples that reference outdated products, pricing, or competitive landscape cause the LLM to generate anachronistic content. Review and update examples quarterly.
• Template sprawl: Creating a new template for every minor variation leads to dozens of near-identical files. Use composition (base + channel + vertical) instead of creating standalone templates for every combination.
• Ignoring channel limits: A beautifully crafted 500-word email template that consistently generates messages exceeding LinkedIn’s character limits wastes generation tokens and review time. Validate output length programmatically.
• No feedback loop: Templates that never get updated based on response rates or reviewer corrections stagnate. Build a process where reviewer edits to generated messages are analyzed and incorporated back into templates.