Agent Skills Framework Extension

Competitive Analysis Skill

When to Use This Skill

Use this skill when implementing competitive analysis patterns in your codebase.

How to Use This Skill

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

Market research, competitor analysis, SWOT frameworks, and strategic positioning for product development.

Core Capabilities

1. Competitor Identification - Market player discovery
2. Feature Comparison - Capability matrices
3. SWOT Analysis - Strengths, weaknesses, opportunities, threats
4. Market Positioning - Differentiation strategies
5. Pricing Analysis - Competitive pricing models
6. Technology Analysis - Tech stack comparisons

Competitor Intelligence Framework

# scripts/competitor-analysis.py
from dataclasses import dataclass, field
from typing import List, Dict, Optional
from datetime import datetime
import json

@dataclass
class Competitor:
    name: str
    url: str
    description: str
    founded: Optional[int]
    funding: Optional[str]
    employees: Optional[str]
    tech_stack: List[str] = field(default_factory=list)
    pricing: Dict[str, float] = field(default_factory=dict)
    features: Dict[str, bool] = field(default_factory=dict)
    strengths: List[str] = field(default_factory=list)
    weaknesses: List[str] = field(default_factory=list)

@dataclass
class CompetitiveLandscape:
    market: str
    competitors: List[Competitor]
    feature_matrix: Dict[str, Dict[str, bool]]
    positioning_map: Dict[str, tuple[float, float]]  # competitor -> (x, y)

class CompetitorAnalyzer:
    """Analyze competitive landscape"""

    def analyze_market(
        self,
        market: str,
        company_name: str
    ) -> CompetitiveLandscape:
        """Complete market analysis"""

        # Identify competitors
        competitors = self._identify_competitors(market)

        # Build feature matrix
        feature_matrix = self._build_feature_matrix(competitors)

        # Create positioning map
        positioning = self._create_positioning_map(competitors, company_name)

        return CompetitiveLandscape(
            market=market,
            competitors=competitors,
            feature_matrix=feature_matrix,
            positioning_map=positioning
        )

    def _identify_competitors(self, market: str) -> List[Competitor]:
        """Identify market competitors"""
        # In production: use WebSearch
        # Search: "{market} competitors", "{market} alternatives"

        # Example competitors
        return [
            Competitor(
                name="Competitor A",
                url="https://competitor-a.com",
                description="Leading solution in the market",
                founded=2015,
                funding="$50M Series B",
                employees="100-500",
                tech_stack=["React", "Node.js", "PostgreSQL"],
                pricing={"starter": 49, "pro": 99, "enterprise": 299},
                features={
                    "api_access": True,
                    "webhooks": True,
                    "sso": True,
                    "advanced_analytics": False,
                },
                strengths=["Market leader", "Extensive integrations"],
                weaknesses=["High price", "Complex onboarding"]
            ),
            Competitor(
                name="Competitor B",
                url="https://competitor-b.com",
                description="Affordable alternative",
                founded=2018,
                funding="Bootstrapped",
                employees="10-50",
                tech_stack=["Vue.js", "Python", "MongoDB"],
                pricing={"starter": 19, "pro": 49},
                features={
                    "api_access": True,
                    "webhooks": False,
                    "sso": False,
                    "advanced_analytics": True,
                },
                strengths=["Low cost", "Simple UX"],
                weaknesses=["Limited features", "Small team"]
            ),
        ]

    def _build_feature_matrix(
        self,
        competitors: List[Competitor]
    ) -> Dict[str, Dict[str, bool]]:
        """Build feature comparison matrix"""
        matrix = {}

        # Collect all features
        all_features = set()
        for comp in competitors:
            all_features.update(comp.features.keys())

        # Build matrix
        for feature in all_features:
            matrix[feature] = {}
            for comp in competitors:
                matrix[feature][comp.name] = comp.features.get(feature, False)

        return matrix

    def _create_positioning_map(
        self,
        competitors: List[Competitor],
        company_name: str
    ) -> Dict[str, tuple[float, float]]:
        """Create 2D positioning map (price vs features)"""
        positioning = {}

        for comp in competitors:
            # X-axis: Average price (normalized 0-1)
            avg_price = sum(comp.pricing.values()) / len(comp.pricing) if comp.pricing else 0
            price_score = min(avg_price / 300, 1.0)

            # Y-axis: Feature completeness
            feature_score = sum(comp.features.values()) / len(comp.features) if comp.features else 0

            positioning[comp.name] = (price_score, feature_score)

        return positioning

    def generate_report(self, landscape: CompetitiveLandscape) -> str:
        """Generate competitive analysis report"""
        report = f"# Competitive Analysis: {landscape.market}\n\n"

        # Competitor overview
        report += "## Competitors\n\n"
        for comp in landscape.competitors:
            report += f"### {comp.name}\n"
            report += f"- **URL**: {comp.url}\n"
            report += f"- **Founded**: {comp.founded}\n"
            report += f"- **Funding**: {comp.funding}\n"
            report += f"- **Tech Stack**: {', '.join(comp.tech_stack)}\n"
            report += f"- **Strengths**: {', '.join(comp.strengths)}\n"
            report += f"- **Weaknesses**: {', '.join(comp.weaknesses)}\n\n"

        # Feature matrix
        report += "## Feature Comparison\n\n"
        report += self._format_feature_matrix(landscape.feature_matrix)

        # Positioning
        report += "\n## Market Positioning\n\n"
        report += "Position Map (Price vs Features):\n\n"
        for name, (price, features) in landscape.positioning_map.items():
            report += f"- {name}: Price={price:.2f}, Features={features:.2f}\n"

        return report

    def _format_feature_matrix(self, matrix: Dict[str, Dict[str, bool]]) -> str:
        """Format feature matrix as markdown table"""
        if not matrix:
            return "No features to compare.\n"

        competitors = set()
        for comp_dict in matrix.values():
            competitors.update(comp_dict.keys())

        competitors = sorted(competitors)

        # Header
        md = "| Feature | " + " | ".join(competitors) + " |\n"
        md += "|" + "----|" * (len(competitors) + 1) + "\n"

        # Rows
        for feature, comp_values in matrix.items():
            row = [feature]
            for comp in competitors:
                value = comp_values.get(comp, False)
                row.append("✓" if value else "✗")
            md += "| " + " | ".join(row) + " |\n"

        return md

# Usage
analyzer = CompetitorAnalyzer()

landscape = analyzer.analyze_market(
    market="Project Management Tools",
    company_name="Our Product"
)

print(analyzer.generate_report(landscape))

SWOT Analysis Framework

# scripts/swot-analysis.py
from dataclasses import dataclass
from typing import List

@dataclass
class SWOTAnalysis:
    company: str
    strengths: List[str]
    weaknesses: List[str]
    opportunities: List[str]
    threats: List[str]

class SWOTAnalyzer:
    """Perform SWOT analysis"""

    def analyze(
        self,
        company: str,
        competitors: List[Competitor],
        market_trends: List[str]
    ) -> SWOTAnalysis:
        """Generate SWOT analysis"""

        strengths = self._identify_strengths(company, competitors)
        weaknesses = self._identify_weaknesses(company, competitors)
        opportunities = self._identify_opportunities(market_trends)
        threats = self._identify_threats(competitors, market_trends)

        return SWOTAnalysis(
            company=company,
            strengths=strengths,
            weaknesses=weaknesses,
            opportunities=opportunities,
            threats=threats
        )

    def _identify_strengths(
        self,
        company: str,
        competitors: List[Competitor]
    ) -> List[str]:
        """Identify competitive strengths"""
        # Compare features, pricing, tech stack
        return [
            "Modern tech stack",
            "Competitive pricing",
            "Strong engineering team",
            "Fast iteration speed",
        ]

    def _identify_weaknesses(
        self,
        company: str,
        competitors: List[Competitor]
    ) -> List[str]:
        """Identify weaknesses"""
        return [
            "Limited brand awareness",
            "Smaller customer base",
            "Fewer integrations",
        ]

    def _identify_opportunities(self, trends: List[str]) -> List[str]:
        """Identify market opportunities"""
        return [
            "Growing market demand",
            "Underserved SMB segment",
            "AI integration potential",
            "Remote work trend",
        ]

    def _identify_threats(
        self,
        competitors: List[Competitor],
        trends: List[str]
    ) -> List[str]:
        """Identify threats"""
        return [
            "Well-funded competitors",
            "Market consolidation",
            "Price pressure",
            "Fast-moving technology",
        ]

    def generate_matrix(self, swot: SWOTAnalysis) -> str:
        """Generate SWOT matrix"""
        md = f"# SWOT Analysis: {swot.company}\n\n"

        md += "## Strengths (Internal Positive)\n\n"
        for s in swot.strengths:
            md += f"- {s}\n"

        md += "\n## Weaknesses (Internal Negative)\n\n"
        for w in swot.weaknesses:
            md += f"- {w}\n"

        md += "\n## Opportunities (External Positive)\n\n"
        for o in swot.opportunities:
            md += f"- {o}\n"

        md += "\n## Threats (External Negative)\n\n"
        for t in swot.threats:
            md += f"- {t}\n"

        return md

# Usage
swot_analyzer = SWOTAnalyzer()

swot = swot_analyzer.analyze(
    company="Our Product",
    competitors=[],  # From CompetitorAnalyzer
    market_trends=["Remote work", "AI adoption", "API-first"]
)

print(swot_analyzer.generate_matrix(swot))

Pricing Analysis

# scripts/pricing-analysis.py
from dataclasses import dataclass
from typing import List, Dict
import statistics

@dataclass
class PricingTier:
    name: str
    price: float
    features: List[str]

@dataclass
class PricingAnalysis:
    market_avg: Dict[str, float]
    percentiles: Dict[str, Dict[str, float]]
    recommendations: List[str]

class PricingAnalyzer:
    """Analyze competitive pricing"""

    def analyze(self, competitors: List[Competitor]) -> PricingAnalysis:
        """Analyze pricing across competitors"""

        # Collect all pricing data
        all_tiers = set()
        pricing_by_tier = {}

        for comp in competitors:
            for tier, price in comp.pricing.items():
                all_tiers.add(tier)
                if tier not in pricing_by_tier:
                    pricing_by_tier[tier] = []
                pricing_by_tier[tier].append(price)

        # Calculate stats
        market_avg = {}
        percentiles = {}

        for tier, prices in pricing_by_tier.items():
            market_avg[tier] = statistics.mean(prices)
            percentiles[tier] = {
                'p25': self._percentile(prices, 25),
                'p50': self._percentile(prices, 50),
                'p75': self._percentile(prices, 75),
            }

        # Generate recommendations
        recommendations = self._generate_recommendations(
            market_avg,
            percentiles
        )

        return PricingAnalysis(
            market_avg=market_avg,
            percentiles=percentiles,
            recommendations=recommendations
        )

    def _percentile(self, values: List[float], p: int) -> float:
        """Calculate percentile"""
        sorted_vals = sorted(values)
        index = int(len(sorted_vals) * p / 100)
        return sorted_vals[min(index, len(sorted_vals) - 1)]

    def _generate_recommendations(
        self,
        market_avg: Dict[str, float],
        percentiles: Dict[str, Dict[str, float]]
    ) -> List[str]:
        """Generate pricing recommendations"""
        recs = []

        for tier, avg in market_avg.items():
            p25 = percentiles[tier]['p25']
            p50 = percentiles[tier]['p50']
            p75 = percentiles[tier]['p75']

            recs.append(
                f"{tier.title()} tier: Market avg ${avg:.0f} "
                f"(range: ${p25:.0f}-${p75:.0f})"
            )

            if tier == 'starter':
                recs.append(
                    f"Consider pricing at ${p25:.0f} for market entry"
                )
            elif tier == 'pro':
                recs.append(
                    f"Consider pricing at ${p50:.0f} for competitive positioning"
                )

        return recs

    def generate_report(self, analysis: PricingAnalysis) -> str:
        """Generate pricing report"""
        md = "# Pricing Analysis\n\n"

        md += "## Market Averages\n\n"
        for tier, avg in analysis.market_avg.items():
            md += f"- {tier.title()}: ${avg:.2f}\n"

        md += "\n## Recommendations\n\n"
        for rec in analysis.recommendations:
            md += f"- {rec}\n"

        return md

# Usage
pricing_analyzer = PricingAnalyzer()

analysis = pricing_analyzer.analyze(competitors)
print(pricing_analyzer.generate_report(analysis))

Usage Examples

Competitor Analysis

Apply competitive-analysis skill to analyze project management tool market with feature comparison

SWOT Analysis

Apply competitive-analysis skill to perform SWOT analysis for new SaaS product launch

Pricing Research

Apply competitive-analysis skill to analyze competitive pricing and recommend pricing tiers

Integration Points

• research-patterns - Technical comparison
• claude-research-patterns - Market research
• content-marketing-patterns - Positioning content

---

Success Output

When successful, this skill MUST output:

✅ SKILL COMPLETE: competitive-analysis

Completed:
- [x] {competitor_count} competitors identified and analyzed
- [x] Feature matrix built with {feature_count} features across {company_count} companies
- [x] Market positioning map created ({positioning_dimensions} dimensions)
- [x] SWOT analysis completed ({strength_count} strengths, {weakness_count} weaknesses)
- [x] Pricing analysis done (market avg: ${avg_price}, range: ${min_price}-${max_price})

Outputs:
- Competitive analysis report: {report_path} ({report_size}KB)
- Feature comparison matrix: {feature_matrix_path}
- SWOT document: {swot_path}
- Pricing recommendations: {pricing_count} actionable insights
- Market opportunity score: {opportunity_score}/100

Completion Checklist

Before marking this skill as complete, verify:

• Minimum 3 major competitors identified and researched
• Feature matrix includes all critical features (API, SSO, integrations)
• Competitor data complete (pricing, tech stack, strengths, weaknesses)
• Market positioning map calculated with normalized axes (0-1 scale)
• SWOT analysis covers all 4 quadrants with specific examples
• Pricing analysis includes percentiles (p25, p50, p75)
• Recommendations actionable and specific (not generic advice)
• Report formatted correctly (markdown tables, valid URLs)
• All data sources cited and verifiable

Failure Indicators

This skill has FAILED if:

• ❌ < 3 competitors identified (insufficient market coverage)
• ❌ Feature matrix empty or all False (no data collected)
• ❌ Competitor data incomplete (missing pricing or features)
• ❌ Market positioning produces negative coordinates (invalid normalization)
• ❌ SWOT analysis generic ("great product", no specifics)
• ❌ Pricing analysis returns NaN or negative prices
• ❌ TAM < SAM or SAM < SOM (market sizing logic error)
• ❌ Report generation throws exceptions or produces empty output
• ❌ No sources cited (data not verifiable)

When NOT to Use

Do NOT use this skill when:

• Internal-only product (no external market)
• Market not yet defined (pre-product-market fit stage)
• Competitors identical to yours (no differentiation possible)
• Academic research needed (use research-patterns)
• Customer satisfaction analysis (use customer-feedback-patterns)
• Technical architecture comparison only (use architecture-analysis)
• Real-time pricing monitoring (use price-monitoring-patterns)

Use alternative skills:

• For technical comparison → architecture-analysis
• For market research → claude-research-patterns
• For customer analysis → customer-feedback-patterns
• For product strategy → product-strategy-patterns

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
Analyzing only direct competitors	Misses disruptive threats	Include indirect and emerging players
Static one-time analysis	Data becomes stale	Schedule quarterly updates
Feature checklist only	Misses quality differences	Include user satisfaction and performance
Ignoring market trends	Analysis out of context	Research market growth, adoption trends
Cherry-picking data	Biased analysis	Use systematic competitor selection criteria
No pricing context	Wrong price positioning	Analyze pricing relative to features and market
Generic SWOT items	Not actionable	Use specific examples with evidence
Missing tech stack details	Can't assess moat	Research and document technology choices

Principles

This skill embodies:

• #2 First Principles - Understand market dynamics before feature comparison
• #5 Eliminate Ambiguity - Specific metrics (price, feature count) not vague "better"
• #6 Clear, Understandable, Explainable - Visual positioning maps show relationships
• #8 No Assumptions - Research actual competitor data, don't guess
• #9 Progressive Disclosure - Start with competitor list, expand to deep analysis
• #10 Research When in Doubt - Use web search for latest competitor information

Full Standard: CODITECT-STANDARD-AUTOMATION.md