Strategy Brief Generation Skill

When to Use This Skill

Use this skill when implementing strategy brief generation patterns in your codebase.

How to Use This Skill

Review the patterns and examples below
Apply the relevant patterns to your implementation
Follow the best practices outlined in this skill

Generate professional executive strategy briefs with multi-stage research, strategic framework application, and C-suite ready deliverables.

Level 1: Quick Reference

Brief Structure (8 Sections)

Section	Purpose	Token Budget
A. Executive Snapshot	Key takeaways, implications, recommendations	15K
B. Market Context	Size, growth, segments, drivers	25K
C. Trends & Threats	Industry disruptions, technology shifts	30K
D. Competitive Landscape	Top 5 competitors, SWOT per company	40K
E. Strategic Frameworks	SWOT, Porter's Five Forces	20K
F. Growth Options	3+ strategic paths with actions	25K
G. One-Page Brief	C-suite summary	10K
H. Disclaimers	Assumptions, gaps, validation plan	5K

Minimum Parameters

industry: "Required - industry name (min 3 chars)"
geography: "Global"  # default
time_horizon: "12-24 months"  # default
client_type: "Incumbent Expanding"  # or New Entrant, Investor

Quick Invocation

# Simple brief
/strategy-brief "AI-Powered Development Tools"

# With parameters
/strategy-brief --industry "FinTech" --geography "APAC" --client-type "New Entrant"

Level 2: Implementation Patterns

Research Workflow (4 Stages)

Stage 1: Foundational Research (PARALLEL)
├── Market Researcher → Market size, growth, segments
├── Competitive Analyst → Top 5 competitors
└── Trend Analyst → Key trends, threats

Stage 2: Framework Application (SEQUENTIAL)
└── Framework Specialist → SWOT, Porter's, value chain

Stage 3: Strategy Development (SEQUENTIAL)
└── Strategy Specialist → Growth options

Stage 4: Synthesis (SEQUENTIAL)
├── Synthesis Writer → Executive snapshot, one-pager
└── QA Validator → Completeness, gaps

Section Templates

A. Executive Snapshot

## A. Executive Snapshot

### Key Takeaways

1. **Bold first sentence.** Supporting detail here.
2. **Bold first sentence.** Supporting detail here.

### "So What" — Implications

- Implication with business impact
- Implication with strategic consequence

### Recommended Moves (Next 12–24 Months)

1. **Action Name:** Specific steps and timeline
2. **Action Name:** Specific steps and timeline

D. Competitive Landscape

## D. Competitive Landscape

*Competitor details based on publicly available information.*

### 1. Company Name

**Revenue Estimate**

**Positioning:** Market position description
**Business Model:** How they make money
**Strengths:** Key advantages
**Weaknesses:** Vulnerabilities
**Moat:** Sustainable competitive advantage
**Vulnerability:** How they could be attacked

E. Strategic Frameworks

### SWOT Analysis (Client Type)

**Strengths**
- Strength 1
- Strength 2

**Weaknesses**
- Weakness 1

**Opportunities**
- Opportunity 1

**Threats**
- Threat 1

### Porter's Five Forces

| Force | Intensity | Key Drivers |
|-------|-----------|-------------|
| Competitive Rivalry | High | Many players, low switching costs |
| Threat of New Entrants | Medium | Low barriers, high capital |

Quality Checklist

Level 3: Advanced Resources

Token Budget Management

TOKEN_BUDGET = {
    'executive_snapshot': 15_000,
    'market_context': 25_000,
    'trends_threats': 30_000,
    'competitive_landscape': 40_000,
    'strategic_frameworks': 20_000,
    'growth_options': 25_000,
    'one_page_brief': 10_000,
    'disclaimers': 5_000,
}
TOTAL_BUDGET = 170_000

Input Validation Schema

@dataclass
class BriefParameters:
    industry: str  # Required, min 3 chars
    geography: str = "Global"
    time_horizon: str = "12-24 months"
    client_type: str = "Incumbent Expanding"
    focus_areas: List[str] = field(default_factory=list)
    exclude_topics: List[str] = field(default_factory=list)
    competitor_count: int = 5  # 3-10
    trend_count: int = 8  # 5-12
    require_data_validation: bool = True
    require_financial_metrics: bool = True

    def validate(self) -> tuple[bool, Optional[str]]:
        if not self.industry or len(self.industry) < 3:
            return False, "Industry must be specified (min 3 characters)"
        if self.competitor_count < 3 or self.competitor_count > 10:
            return False, "Competitor count must be between 3-10"
        return True, None

Research Agent Prompts

Market Researcher Prompt

ROLE: Market Researcher
OBJECTIVE: Research {industry} market size, growth, segments, and demand drivers
GEOGRAPHY: {geography}

TOOLS AVAILABLE: web_search, web_fetch
MAX TOOL CALLS: 15

SUCCESS CRITERIA:
- Market size with credible sources (industry reports, analyst firms)
- Growth rates with timeframe
- Customer segments identified
- Demand drivers articulated

OUTPUT FORMAT: Return JSON with:
- findings: Dict[str, Any]
- sources: List[str]
- confidence: float (0-1)
- gaps: List[str]
- notes: str

Competitive Analyst Prompt

ROLE: Competitive Analyst
OBJECTIVE: Identify and analyze top {competitor_count} competitors in {industry}
GEOGRAPHY: {geography}

TOOLS AVAILABLE: web_search, web_fetch
MAX TOOL CALLS: 20

SUCCESS CRITERIA:
- Top {competitor_count} competitors identified
- Revenue/positioning for each
- Business models documented
- Strengths/weaknesses/moats analyzed

OUTPUT FORMAT: Return JSON with competitor profiles

Wave Execution Algorithm

def get_execution_order(agents: List[AgentAssignment]) -> List[List[AgentRole]]:
    """Group agents by execution wave for parallel processing."""
    waves = []
    assigned = set()

    while len(assigned) < len(agents):
        wave = []
        for agent in agents:
            if agent.role in assigned:
                continue
            # Dependencies satisfied?
            if all(dep in assigned for dep in agent.dependencies):
                wave.append(agent.role)

        if not wave:
            break  # Circular dependency

        waves.append(wave)
        assigned.update(wave)

    return waves

Quality Metrics Calculation

def calculate_quality_metrics(findings: Dict) -> Dict[str, Any]:
    return {
        'completeness': len(findings) / 8,  # 8 sections
        'avg_confidence': sum(f.confidence for f in findings.values()) / len(findings),
        'source_diversity': len(set(source for f in findings.values() for source in f.sources)),
        'data_gap_severity': sum(len(f.data_gaps) for f in findings.values()) / len(findings),
    }

Markdown Styling Guidelines

Element	Format
Key Takeaways	Numbered, bold first sentence
Tables	Left-aligned, consistent columns
Competitor Names	H3 with rank number
Metrics	Right-aligned in tables
Confidence	Percentage with % suffix
Sources	Inline citations or footnotes

Agent: agents/strategy-brief-generator.md
Command: commands/strategy-brief.md
Scripts: scripts/strategy-brief-generator.py, scripts/strategy-brief-templates.py
Similar Skills: competitive-intelligence/, market-research/

Source File Reference

Adapted from: ANALYZE-REVIEW/extracted-consulting/

strategy_brief_system.py - Core workflow engine
brief_templates.py - Section template engine

Success Output

When successful, this skill MUST output:

✅ SKILL COMPLETE: strategy-brief-generation

Completed:
- [x] Market research completed ({source_count} sources)
- [x] Competitive analysis finished ({competitor_count} companies profiled)
- [x] Trends & threats identified ({trend_count} trends)
- [x] Strategic frameworks applied (SWOT, Porter's Five Forces)
- [x] Growth options developed ({option_count} paths)
- [x] Executive snapshot synthesized
- [x] One-page brief created

Outputs:
- Strategy Brief: {output_path}
- Word Count: {word_count} (~{page_count} pages)
- Token Usage: {token_count}/{token_budget}
- Confidence Score: {avg_confidence}%
- Data Gaps: {gap_count} identified with validation plan

Sections Complete: 8/8
- A. Executive Snapshot ✅
- B. Market Context ✅
- C. Trends & Threats ✅
- D. Competitive Landscape ✅
- E. Strategic Frameworks ✅
- F. Growth Options ✅
- G. One-Page Brief ✅
- H. Disclaimers ✅

Completion Checklist

Before marking this skill as complete, verify:

Failure Indicators

This skill has FAILED if:

❌ Less than 8 sections completed
❌ Market size claims without sources
❌ Less than 5 competitors profiled
❌ Generic SWOT not tailored to client type
❌ Porter's Five Forces missing intensity ratings
❌ Growth options lack specific actions or timelines
❌ No data gaps documented (unrealistic - every brief has gaps)
❌ No validation plan provided
❌ One-page brief exceeds 1 page (> 500 words)
❌ Token budget exceeded (> 170K tokens)
❌ Research agents failed to find any sources
❌ Competitor analysis returned no companies

When NOT to Use

Do NOT use this skill when:

Deep technical analysis needed - This is strategic overview, not technical deep-dive
Industry requires specialized expertise - Regulated industries (pharma, finance) need experts
Confidential/proprietary data required - Relies on public information only
Immediate tactical decisions - This is strategic planning, not operational
Single product focus - Better suited for market-level strategy, not product details
Academic research paper - This is executive brief, not scholarly work
Legal/compliance requirement - Not a substitute for professional due diligence

Use alternative approaches instead:

Technical analysis → Use technical-deep-dive skill or domain experts
Regulated industries → Engage industry consultants with credentials
Proprietary data → Commission custom research from firms with access
Tactical decisions → Use operational-planning skill or project management
Product strategy → Use product-strategy-brief skill
Academic → Use research-paper-generation skill
Legal → Engage legal counsel and compliance specialists

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
No source citations	Unverifiable claims	Cite 3+ sources per major claim
Generic SWOT	Not actionable for client	Tailor to client type (Incumbent/New Entrant/Investor)
Obvious insights only	No strategic value	Include non-obvious "So What" implications
Single-source data	Unreliable estimates	Cross-reference multiple sources
No confidence scoring	Unclear reliability	Score every estimate (HIGH/MEDIUM/LOW)
Ignoring data gaps	False confidence	Document gaps with validation plan
Copy-paste competitor profiles	Missing vulnerabilities	Analyze each competitor's specific weaknesses
Action-free recommendations	Not implementable	Every recommendation needs 90-day action plan
Token budget exceeded	Incomplete generation	Monitor token usage per section
Research tool failures ignored	Incomplete analysis	Retry failed searches, document missing data

Principles

This skill embodies CODITECT principles:

#5 Eliminate Ambiguity - Confidence scores, source citations, clear definitions
#6 Clear, Understandable, Explainable - "So What" implications for every finding
#8 No Assumptions - Document data gaps, provide validation plan
First Principles - Strategic frameworks (SWOT, Porter's) provide reasoning structure
Separation of Concerns - Research → Analysis → Synthesis (4 sequential stages)
Token Efficiency - Budget allocation per section (170K total)

Related Standards:

Created: December 21, 2025 Compliance: CODITECT-STANDARD-SKILLS v1.0

When to Use This Skill​

How to Use This Skill​

Level 1: Quick Reference​

Brief Structure (8 Sections)​

Minimum Parameters​

Quick Invocation​

Level 2: Implementation Patterns​

Research Workflow (4 Stages)​

Section Templates​

A. Executive Snapshot​

D. Competitive Landscape​

E. Strategic Frameworks​

Quality Checklist​

Level 3: Advanced Resources​

Token Budget Management​

Input Validation Schema​

Research Agent Prompts​

Market Researcher Prompt​

Competitive Analyst Prompt​

Wave Execution Algorithm​

Quality Metrics Calculation​

Markdown Styling Guidelines​

Related Components​

Source File Reference​

Success Output​

Completion Checklist​

Failure Indicators​

When NOT to Use​

Anti-Patterns (Avoid)​

Principles​