opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/competitor-profiling/references/tool-reference.md

@@ -0,0 +1,179 @@
+# MCP Tool Reference for Competitor Profiling
+
+Quick reference for the Firecrawl and DataForSEO MCP tools used in competitor profiling.
+
+## Contents
+- Firecrawl Tools (site scraping)
+- DataForSEO Tools (SEO & market data)
+- Recommended Execution Order
+- Error Handling
+
+---
+
+## Firecrawl Tools
+
+### firecrawl_map
+**Purpose**: Discover all URLs on a competitor's site to identify key pages.
+**When to use**: First step for every competitor — before scraping individual pages.
+**Key output**: List of URLs with their page types/paths.
+**Tip**: Look for paths containing `/pricing`, `/features`, `/about`, `/customers`, `/integrations`, `/blog`, `/changelog`.
+
+### firecrawl_scrape
+**Purpose**: Extract content from a single page as clean markdown.
+**When to use**: After mapping, scrape each key page individually.
+**Key output**: Page content in markdown format — headlines, body text, structured data.
+**Tip**: Scrape homepage first — it reveals positioning, audience, and social proof in one shot.
+
+### firecrawl_search
+**Purpose**: Search the web for specific content about a competitor.
+**When to use**: Finding review pages, press coverage, or competitor mentions not on their own site.
+**Example queries**:
+- `"[Competitor Name]" site:g2.com`
+- `"[Competitor Name]" review`
+- `"[Competitor Name]" funding OR raised`
+
+### firecrawl_crawl
+**Purpose**: Crawl multiple pages from a site in one operation.
+**When to use**: Deep profiles where you want to analyze many pages (e.g., all feature pages, all blog posts). More expensive — use selectively.
+**Tip**: Set page limits to avoid crawling entire sites. Target specific URL patterns.
+
+### firecrawl_extract
+**Purpose**: Extract structured data from a page using a schema.
+**When to use**: When you need specific data points in a consistent format (e.g., pricing tier details, feature lists).
+**Tip**: Define a clear schema for what you want extracted — more reliable than parsing raw markdown.
+
+---
+
+## DataForSEO MCP Tools
+
+### Domain-Level Intelligence
+
+#### backlinks_summary
+**Purpose**: Get domain authority, total backlinks, referring domains, spam score.
+**Input**: Target domain (e.g., `competitor.com`)
+**Key metrics**: `domain_rank`, `total_backlinks`, `referring_domains`, `backlinks_spam_score`
+
+#### backlinks_referring_domains
+**Purpose**: List top referring domains — shows where their link equity comes from.
+**Input**: Target domain + limit
+**Key metrics**: Per-domain: `rank`, `backlinks`, `domain` name
+
+#### dataforseo_labs_google_domain_rank_overview
+**Purpose**: Organic search overview — traffic, keywords, traffic value.
+**Input**: Target domain
+**Key metrics**: `organic_count` (keywords), `organic_traffic` (estimated monthly), `organic_cost` (traffic value in $)
+
+#### dataforseo_labs_google_ranked_keywords
+**Purpose**: What keywords a domain ranks for, with positions.
+**Input**: Target domain
+**Key metrics**: Per-keyword: `keyword`, `position`, `search_volume`, `url` (ranking page)
+**Tip**: Sort by traffic to find their highest-value keywords.
+
+#### dataforseo_labs_google_keywords_for_site
+**Purpose**: Keywords relevant to a domain — broader than ranked keywords, includes opportunities.
+**Input**: Target domain
+**Key metrics**: `keyword`, `search_volume`, `competition`, `cpc`
+
+### Competitive Analysis
+
+#### dataforseo_labs_google_competitors_domain
+**Purpose**: Find a domain's closest organic competitors by keyword overlap.
+**Input**: Target domain
+**Key metrics**: `domain`, `avg_position`, `intersections` (shared keywords), `full_domain_rank`
+**Tip**: May reveal competitors the user hasn't considered.
+
+#### dataforseo_labs_google_domain_intersection
+**Purpose**: Find keywords where two domains both rank — shows direct competition.
+**Input**: Two target domains
+**Key metrics**: `keyword`, position for each domain, `search_volume`
+**Tip**: Use this to compare the user's domain vs. each competitor.
+
+#### dataforseo_labs_google_relevant_pages
+**Purpose**: Find a domain's most important pages by organic traffic.
+**Input**: Target domain
+**Key metrics**: `page`, `metrics` (traffic, keywords per page)
+**Tip**: Reveals their content strategy — which pages drive the most value.
+
+### Technology Detection
+
+#### domain_analytics_technologies_domain_technologies
+**Purpose**: Detect the technology stack a domain uses.
+**Input**: Target domain
+**Key metrics**: Technologies grouped by category (CMS, analytics, marketing, payments, etc.)
+
+### Backlink Deep Dive
+
+#### backlinks_backlinks
+**Purpose**: List individual backlinks to a domain.
+**Input**: Target domain + limit
+**Key metrics**: `url_from`, `url_to`, `anchor`, `domain_from_rank`, `is_new`
+
+#### backlinks_bulk_ranks
+**Purpose**: Compare domain ranks across multiple domains at once.
+**Input**: Array of target domains
+**Key metrics**: `domain_rank` per domain
+**Tip**: Use this for the summary comparison table.
+
+---
+
+## Recommended Execution Order
+
+### Quick Scan (per competitor)
+
+```
+1. firecrawl_map → get site URLs
+2. In parallel:
+   a. firecrawl_scrape → homepage
+   b. firecrawl_scrape → pricing page
+   c. dataforseo_labs_google_domain_rank_overview → organic metrics
+   d. backlinks_summary → domain authority
+3. Synthesize into abbreviated profile
+```
+
+### Deep Profile (per competitor)
+
+```
+1. firecrawl_map → get site URLs
+2. In parallel (batch 1 — scraping):
+   a. firecrawl_scrape → homepage
+   b. firecrawl_scrape → pricing page
+   c. firecrawl_scrape → features page(s)
+   d. firecrawl_scrape → about page
+   e. firecrawl_scrape → customers/case studies page
+   f. firecrawl_scrape → integrations page
+3. In parallel (batch 2 — SEO data):
+   a. dataforseo_labs_google_domain_rank_overview
+   b. dataforseo_labs_google_ranked_keywords
+   c. backlinks_summary
+   d. backlinks_referring_domains
+   e. dataforseo_labs_google_relevant_pages
+   f. dataforseo_labs_google_competitors_domain
+4. In parallel (batch 3 — optional extras):
+   a. domain_analytics_technologies_domain_technologies
+   b. firecrawl_search → G2/Capterra reviews
+   c. dataforseo_labs_google_domain_intersection (vs. user's domain)
+5. Synthesize into full profile
+```
+
+### Multi-Competitor (3+ competitors)
+
+```
+1. Map all competitor sites in parallel
+2. Scrape all homepages in parallel, then pricing pages in parallel
+3. Pull domain_rank_overview for all in parallel
+4. Pull backlinks_bulk_ranks for all at once
+5. Build profiles in sequence (synthesis requires focus)
+6. Build summary comparison last
+```
+
+---
+
+## Error Handling
+
+| Issue | Action |
+|-------|--------|
+| Firecrawl scrape returns empty/blocked | Try with `firecrawl_browser_create` for JS-heavy sites |
+| Pricing page not found in map | Search for `/pricing`, `/plans`, `/packages` — some sites use different paths |
+| DataForSEO returns no data for domain | Domain may be too new or too small — note "insufficient data" in profile |
+| Rate limits hit | Space out requests; prioritize highest-value data first |
+| Review page scraping blocked | Use `firecrawl_search` to find cached or alternative review sources |

package/bundled-skills/competitor-tracking/README.md

@@ -0,0 +1,40 @@
+# Competitor Tracking
+
+Systematic competitor analysis for developer tools. Track features, pricing, positioning, content strategy, and developer sentiment across your competitive landscape.
+
+## What This Skill Covers
+
+- Competitor identification (direct, indirect, DIY alternatives, platforms)
+- What to track: features, pricing, positioning, content, community signals
+- GitHub/npm/PyPI monitoring for traction signals
+- Developer sentiment monitoring
+- Building and maintaining competitive battlecards
+- When and how to respond to competitor moves
+
+## Recommended Tools
+
+- **Social listening tools** — Monitor competitor sentiment across developer platforms
+- **GitHub/npm monitoring** — Track competitor traction signals
+
+## Quick Start
+
+1. Map your competitive landscape (direct, indirect, DIY, platform)
+2. Set up monitoring keywords for each competitor
+3. Create initial battlecards for top 3-5 competitors
+4. Establish review cadence (monthly for major, quarterly for minor)
+5. Build response playbooks for common scenarios
+
+## Battlecard Template
+
+1. Competitor Overview
+2. When We Win (scenarios, customer types, proof points)
+3. When We Lose (watch-outs, mitigation strategies)
+4. Common Objections + Responses
+5. Competitive Differentiation
+6. Landmines to Set
+
+## Related Skills
+
+- developer-listening
+- alternatives-pages
+- positioning

package/bundled-skills/competitor-tracking/SKILL.md

@@ -0,0 +1,322 @@
+---
+name: competitor-tracking
+description: 'Systematic competitor analysis for developer tools. Track features, pricing, positioning, content strategy, and community sentiment for direct and indirect competitors. Trigger phrases: "competitor analysis", "track competitors", "competitive intelligence", "competitor research", "what...'
+risk: unknown
+source: https://github.com/jonathimer/devmarketing-skills/tree/main/skills/competitor-tracking
+source_repo: jonathimer/devmarketing-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/jonathimer/devmarketing-skills/blob/main/LICENSE
+---
+
+# Competitor Tracking
+## When to Use
+
+Use this skill when you need systematic competitor analysis for developer tools. Track features, pricing, positioning, content strategy, and community sentiment for direct and indirect competitors. Trigger phrases: "competitor analysis", "track competitors", "competitive intelligence", "competitor research", "what...
+
+
+Systematic framework for tracking competitors in the developer tools space, from identification through ongoing monitoring and battlecard creation.
+
+## Overview
+
+Competitor tracking for developer tools requires monitoring multiple dimensions: product features, pricing, developer sentiment, content strategy, community growth, and funding/trajectory. Unlike consumer products, developer tools compete on technical merit, documentation quality, and community trust.
+
+Effective competitor tracking helps you:
+- Understand your competitive positioning
+- Anticipate competitor moves
+- Arm sales and marketing with accurate battlecards
+- Identify market gaps and opportunities
+- Learn from competitor successes and failures
+
+## Competitor Identification
+
+### Types of Competitors
+
+**Direct Competitors:**
+- Same category, same target developer
+- Solve the same core problem
+- Would appear in the same "best X tools" lists
+- Example: If you're a CI/CD tool, other CI/CD tools
+
+**Indirect Competitors:**
+- Adjacent categories that overlap with your use case
+- Might be expanding into your space
+- Developers might use instead of your category
+- Example: GitHub Actions competing with standalone CI tools
+
+**DIY Alternatives:**
+- Open source tools developers self-host
+- Custom scripts and internal tooling
+- "Just use bash scripts" or "build it yourself"
+- Often your biggest competitor by volume
+
+**Platform Alternatives:**
+- Cloud provider native services (AWS, GCP, Azure equivalents)
+- All-in-one platforms that include your functionality
+- Enterprise suite solutions
+
+### Competitive Landscape Mapping
+
+Create a competitive landscape document with:
+
+1. **Competitor profiles** - Company, product, target market, positioning
+2. **Feature matrix** - Core features compared across competitors
+3. **Pricing comparison** - Tiers, pricing model, enterprise pricing signals
+4. **Strengths/weaknesses** - Honest assessment of each competitor
+5. **Trajectory** - Funding, growth signals, strategic direction
+
+## What to Track
+
+### Product and Features
+
+**Track weekly/monthly:**
+- Changelog and release notes
+- New feature announcements
+- Pricing changes
+- Integration announcements
+- API changes
+- SDK/library updates
+
+**How to track:**
+- Subscribe to competitor newsletters
+- Follow their GitHub releases
+- Monitor their Twitter/blog
+- Set up monitoring alerts for "[competitor] launch" "[competitor] announces"
+
+### Pricing and Packaging
+
+**Key signals:**
+- Pricing page changes (use archive.org to track history)
+- New tier introductions
+- Enterprise/custom pricing signals
+- Free tier changes
+- Usage-based vs seat-based shifts
+
+**Competitive pricing intelligence:**
+- What's included in free tier?
+- Where are the upgrade triggers?
+- How do they handle overages?
+- What's the enterprise motion?
+
+### Positioning and Messaging
+
+**Track changes in:**
+- Homepage headline and hero
+- "Who it's for" positioning
+- Primary use cases emphasized
+- Comparison pages (how they position against others)
+- Case studies and social proof
+
+**Analyze:**
+- What problem do they lead with?
+- What audience are they targeting?
+- What's their unique angle?
+- How are they different from 6 months ago?
+
+### Content Strategy
+
+**Monitor:**
+- Blog post frequency and topics
+- Documentation quality and coverage
+- Video/tutorial content
+- Conference talks and sponsorships
+- Developer education initiatives
+
+**Look for:**
+- SEO plays (what keywords are they targeting?)
+- Content gaps you can exploit
+- Successful content formats to learn from
+
+### Community and Traction
+
+**GitHub signals:**
+- Stars/forks growth rate
+- Issue volume and response time
+- Contributor growth
+- Release frequency
+
+**Community signals:**
+- Discord/Slack member counts
+- Forum activity
+- Stack Overflow tag activity
+- Reddit mention frequency
+
+## Developer Sentiment Monitoring
+
+### Setting Up Competitor Monitoring
+
+Use social listening tools to track developer sentiment toward competitors across platforms. Set up alerts for:
+
+- Competitor brand mentions
+- Negative sentiment toward competitors (opportunity signals)
+- Comparison queries ("[competitor] vs")
+
+### Key Sentiment Signals
+
+**Churn signals:**
+- "Migrating away from [competitor]"
+- "Looking for [competitor] alternative"
+- "Frustrated with [competitor]"
+- "Canceling [competitor]"
+
+**Praise signals (learn from them):**
+- "Love [competitor]'s [feature]"
+- "[Competitor] just works"
+- "Best part of [competitor] is..."
+
+**Feature gaps:**
+- "Wish [competitor] had..."
+- "[Competitor] doesn't support..."
+- "Waiting for [competitor] to add..."
+
+### Competitive Sentiment Analysis
+
+Use your monitoring tool's analytics for trend analysis:
+
+- Mention volume for competitors over 90 days
+- Sentiment distribution: positive vs negative
+- Co-mentions where competitor and your brand appear together
+
+## Building Competitive Battlecards
+
+### Battlecard Structure
+
+Create battlecards for sales and marketing teams:
+
+**1. Competitor Overview**
+- Company background
+- Target market
+- Key value proposition
+- Recent news/trajectory
+
+**2. When We Win**
+- Scenarios where you have advantage
+- Customer types that prefer you
+- Use cases you excel at
+- Proof points and case studies
+
+**3. When We Lose**
+- Scenarios where competitor has advantage
+- What to watch out for
+- How to mitigate their strengths
+
+**4. Common Objections**
+- "But [competitor] has [feature]"
+- "[Competitor] is cheaper"
+- "[Competitor] is more established"
+- Response frameworks for each
+
+**5. Competitive Differentiation**
+- Key technical differences
+- Pricing comparison
+- Support/service differences
+- Community/ecosystem differences
+
+**6. Landmines to Set**
+- Questions to ask that favor you
+- Requirements that highlight your strengths
+- Evaluation criteria that matter
+
+### Keeping Battlecards Fresh
+
+**Update triggers:**
+- Competitor launches major feature
+- Competitor changes pricing
+- You ship something that changes the comparison
+- Sales team reports new objections
+- Win/loss analysis reveals new patterns
+
+**Review cadence:**
+- Major competitors: monthly review
+- Minor competitors: quarterly review
+- Emerging competitors: as needed
+
+## Responding to Competitor Moves
+
+### When to Respond
+
+**Always respond:**
+- Competitor makes false claims about you
+- Competitor targets your specific customers
+- Major market shift that affects positioning
+
+**Consider responding:**
+- Competitor launches feature you have
+- Competitor enters your core market
+- Competitor's crisis creates opportunity
+
+**Usually don't respond:**
+- Minor feature parity announcements
+- Competitor's internal issues (unless affects their customers)
+- Petty competitive shots
+
+### Response Playbooks
+
+**Feature launch response:**
+1. Assess: Do we have parity? Better? Gap?
+2. Internal communication to sales/support
+3. Update battlecards if needed
+4. Consider content response (blog, comparison page update)
+5. Monitor developer conversations for context
+
+**Pricing change response:**
+1. Analyze impact on competitive positioning
+2. Update pricing comparison materials
+3. Brief sales team
+4. Consider if pricing adjustment needed
+5. Monitor churn/acquisition impact
+
+**Crisis opportunity response:**
+1. Don't be sleazy or pile on
+2. Be helpful to affected users if appropriate
+3. Create migration content if there's genuine demand
+4. Let your product speak for itself
+
+## Tools
+
+### Social Listening
+
+Use monitoring tools to set up alerts for these patterns:
+- Competitor sentiment overview (last 30 days, by sentiment)
+- Churn signals: "alternative OR migrating OR switching" + competitor name
+- Feature gaps: "wish OR need OR missing" + competitor name
+- Comparison mentions: "[competitor] vs"
+
+### Other Tools
+
+**GitHub Monitoring:**
+```bash
+# Track competitor repo activity
+gh api repos/[competitor]/[repo] --jq '.stargazers_count, .open_issues_count'
+
+# Search for competitor mentions in issues
+gh search issues "[competitor]" --limit 50
+```
+
+**npm/PyPI Monitoring:**
+- Track download trends for competitor packages
+- Monitor version release frequency
+- Watch for new packages in their ecosystem
+
+**Archive.org:**
+- Track historical changes to competitor websites
+- Document pricing changes over time
+- Capture positioning shifts
+
+**LinkedIn/Careers:**
+- Track hiring patterns
+- Identify strategic direction from job postings
+- Monitor team growth signals
+
+## Related Skills
+
+- **developer-listening** - Broader monitoring beyond just competitors
+- **alternatives-pages** - Turn competitive intelligence into content
+- **positioning** - Differentiate based on competitive insights
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.