Menu
Perform competitive market analysis with feature comparisons, positioning, and strategic recommendations.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Design static ad creatives for social media and display advertising campaigns.
Source and evaluate candidates with job analysis, search strategies, specific candidate profiles, outreach templates, CV screening, and Gmail-based candidate communication.
Find relevant companies and leads for B2B sales with ICP definition and qualification frameworks.
Draft emails, manage calendar scheduling, prepare meeting agendas, track tasks, manage contacts, coordinate travel, and organize productivity
Create brand identity kits with color palettes, typography, logo concepts, brand naming, and brand guidelines.
Create social media posts, newsletters, and marketing content calibrated to your voice and platform.
| name | competitive-analysis |
| description | Perform competitive market analysis with feature comparisons, positioning, and strategic recommendations. |
Identify competitors, analyze positioning, and deliver actionable recommendations. Skip textbook frameworks (Porter's, PESTLE) unless specifically requested — they're MBA artifacts, not operator tools.
Skip Porter's Five Forces. Operators use these four:
1. April Dunford's Positioning (from "Obviously Awesome") — the most-used positioning method in B2B SaaS. Five inputs in strict order:
2. Wardley Mapping (Simon Wardley, free book at medium.com/wardleymaps) — plot components on two axes: visibility-to-user (y) vs evolution Genesis → Custom → Product → Commodity (x). Reveals: where competitors overinvest in commoditizing components, where to build vs buy, what's about to become table stakes. Tool: onlinewardleymaps.com (free). Best for platform/infra competition.
3. Feature comparison matrix — the unglamorous workhorse. Rows = capabilities, columns = competitors, cells = ✓/✗/partial. Battlecards for sales teams are this + "trap-setting questions." Key: weight features by how often they appear in lost-deal notes, not by what engineering thinks matters.
4. Kano mapping applied to competitors — categorize each competitor feature as Basic (expected, table stakes), Performance (more = better), or Delighter (unexpected). Kano's insight: today's delighters become tomorrow's basics. Competitors' delighters tell you where the bar is moving.
| Need | Tool | How to use |
|---|---|---|
| Find competitors | webSearch("[product] alternatives site:g2.com") | G2's "alternatives" pages are crowdsourced competitor lists |
| Verified user complaints | webSearch("[competitor] site:g2.com"), Capterra, TrustRadius | Filter reviews to 1-3 stars. Look for repeated phrases — those are exploitable weaknesses |
| Enterprise IT buyers | PeerSpot (formerly IT Central Station) | More technical, less marketing-gamed than G2 |
| Pricing (often hidden) | webFetch competitor /pricing page, Wayback Machine for historical, webSearch("[competitor] pricing reddit") for leaked enterprise quotes | |
| Tech stack | webFetch("https://builtwith.com/[domain]") — 673M+ sites, 85k+ technologies. Wappalyzer similar. | Reveals: are they on legacy stack? What vendors? Switching cost signals |
| Traffic/channel mix | SimilarWeb (reliable for large sites, unreliable <50k visits/mo) | See which channels drive competitor traffic |
| Funding/team size | Crunchbase free tier, webSearch("[competitor] raises TechCrunch") | |
| Strategic direction | webSearch("[competitor] site:linkedin.com/jobs") — hiring = roadmap. 5 ML engineers = AI features in 6mo. | |
| Historical messaging | webFetch("https://web.archive.org/web/2024*/[competitor].com") | Shows positioning pivots — what they tried and abandoned |
| SEO/content strategy | Ahrefs (paid, $129+/mo) or webSearch("site:[competitor].com") to map content | |
| Regional competitors (non-US) | App Store: curl -sL "https://apps.apple.com/us/search?term=[name]" · Play Store: webSearch("[name] site:play.google.com") · Search in local language | G2/Product Hunt have near-zero coverage outside US/EU |
Many early-stage competitors build their site as a React/Vue/Svelte SPA. webFetch and webSearch return empty results for these — the HTML shell has nothing but <div id="root"></div>. Always try curl via bash first:
Step 1 — Get meta tags from the HTML shell (works even on SPAs):
curl -sL --max-time 10 "https://competitor.com/" | head -100
# → Reveals: title, meta description, OG tags, and the JS bundle filename
Step 2 — Extract readable strings from their JS bundle:
# Get the bundle filename from Step 1 output (e.g. /assets/index-AbCd1234.js), then:
curl -sL "https://competitor.com/assets/index-[hash].js" \
| grep -oE '"[^"]{10,200}"' \
| grep -iE "(price|plan|free|gratis|feature|bank|sync|categor|budget|presupuest)" \
| sort -u | head -80
Step 3 — Check static files for site structure:
curl -sL "https://competitor.com/robots.txt"
curl -sL "https://competitor.com/sitemap.xml"
curl -sL "https://competitor.com/manifest.json"
This approach can reveal pricing plans, feature descriptions, FAQ content, legal disclaimers, and marketing copy — all embedded in the compiled JS. For example, this technique on novia.com.do surfaced: their two pricing tiers ("Plan Cita" = free, "Plan Compromiso" = premium coming soon), their exact value proposition copy, a disclaimer that they have no real-time bank connection, and their full FAQ structure.
If the user tells you a competitor exists by name, believe them immediately. Do not attempt to verify through web searches first — that costs multiple failed rounds. Instead:
The user naming a competitor is the highest-confidence intelligence you will receive. Don't waste rounds trying to independently confirm what they already know.
When webSearch and webFetch both return empty results for a competitor, follow this decision tree in order — do not repeat the same failed approach with different keywords:
apps.apple.com and play.google.com directly for the app name; the store listing contains descriptions, screenshots text, and reviewswebSearch("[name] instagram OR twitter OR linkedin") — even tiny startups have social profilesEmpty results ≠ no competition. In niche, regional, or non-English markets (Latin America, Caribbean, Southeast Asia, MENA), G2/Capterra/Product Hunt have near-zero coverage. An app can have 10,000 active users and zero English web presence.
Standard tools (G2, Capterra, Product Hunt) are US/English-centric. For non-US markets use these instead:
| Market type | Where to look |
|---|---|
| Latin America | App Store regional search (apps.apple.com/[country-code]/), Google Play with hl=es, local tech blogs (Contxto, Startup Genome LatAm), AppFollow for store rankings |
| Caribbean / Emerging | Instagram/Facebook pages (startups in these markets often exist only on social), local chambers of commerce, fintech-specific databases (Finnovista, IDB Fintech census) |
| Any niche market | Search in the local language — always try Spanish/Portuguese/French/etc. queries, not just English. A Dominican app will not appear in English results. |
| App stores (universal) | curl -sL "https://apps.apple.com/[country]/search?term=[query]" and Play Store search — app descriptions contain features and positioning that web searches miss |
Rule: Always run at least one search in the target market's primary language before concluding no local competitors exist.
Step 1: Frame — Get from user: their product, target customer, and who THEY think competes. Their list is always incomplete — but treat every name they give you as a confirmed lead, not a hypothesis to verify.
Step 2: Expand the competitor set — Run webSearch("[known competitor] alternatives") and webSearch("[category] vs"). Check G2 category pages. Add indirect competitors (different product, same job) and the "do nothing" option. Also search in the local market language if the product targets a non-English market.
Step 3: Per-competitor dossier — For each (limit to 5-7 for depth):
If a competitor is a direct local rival (same market, same core use case, same pricing model): flag them separately as "Direct Competitor" and add a dedicated head-to-head comparison section — don't just include them as one row in the matrix. Make clear: what does the user's product do that this one doesn't, and vice versa?
Step 4: Synthesize — Build the feature matrix. Plot on a 2×2 (pick the two axes the buyer cares about, not the ones that make user look good). Identify white space.
Step 5: Recommend — Not "monitor the threat." Specific: "Competitor X's reviews mention slow support 23 times — lead with your SLA in sales calls."
Competitive landscapes shift constantly — pricing changes, features launch, funding rounds close. The analysis you just delivered is a snapshot. This section defines monitoring as a second deliverable the agent offers immediately after the report, not optional advice.
At the end of every competitive analysis, always ask:
"Would you like me to set up ongoing monitoring for these competitors? I'll generate your alert links, a bookmark bundle, and a monthly ritual checklist — takes about 2 minutes to activate. Where do you want alerts to land?"
Do not skip this offer. Present it as a distinct, activatable package — not a footnote.
Ask the user which channel they prefer, then follow the matching setup path. Priority order: Slack → Teams → Email → Manual file.
Does the user have Slack?
YES → Set up Slack RSS feeds + optional webhook
NO → Does the user work in a Microsoft org (Teams)?
YES → Set up Teams RSS connector
NO → Set up Google Alerts (email)
Always: also save competitor-monitoring.md to the project regardless of channel chosen.
If the user is unsure or doesn't answer, default to Google Alerts (zero-friction, universally available) plus the project file.
Option A — RSS feeds (native, free, no admin required):
/feed subscribe https://[competitor].com/changelog/rss
/feed subscribe https://[competitor].com/blog/rss
Run these commands in a dedicated #competitive-intel channel. The agent should generate the exact feed URLs for each competitor and give the user the ready-to-paste commands.
Option B — Google Alerts → Slack (via Zapier or Make, free tier):
#competitive-intelOption C — Incoming webhook (advanced): When the user runs the monthly ritual on demand, the agent can post a summary to a Slack webhook URL. The user provides the webhook URL; the agent stores it in the monitoring brief for future use.
RSS connector (native, free):
... → Connectors → RSSPower Automate (for Microsoft 365 orgs): Trigger: new email matching subject pattern → Post message in Teams channel. The agent describes the exact flow when this option is chosen.
For each competitor, generate a ready-to-click alert URL:
https://www.google.com/alerts?q=[COMPETITOR+NAME]&hl=en&gl=us&source=web&hl=en
Replace [COMPETITOR+NAME] with the URL-encoded competitor name. The user clicks once to activate. Recommend setting delivery to "As it happens" for major competitors, "At most once a week" for minor ones.
Also generate alerts for: "[competitor] pricing", "[competitor] raises", "[competitor] launches".
Regardless of which channel is chosen, always save a competitor-monitoring.md file to the project root. This file is the source of truth and last-checked log. Structure:
# Competitor Monitoring Brief
Last updated: [date]
## Competitors tracked
- [Name] — [URL] — Alert channel: [Slack/#channel | Teams/#channel | Email]
## Bookmark bundle
Per competitor: pricing page, changelog/blog, App Store listing, LinkedIn jobs, G2 reviews page
## Change log
| Date | Competitor | What changed | Action taken |
|------|------------|-------------|--------------|
When the user activates monitoring, the agent generates and delivers four items:
competitor-monitoring.mdA structured, timed sequence the user (or agent, on demand) runs once per month per competitor:
| Minutes | Task | What to look for |
|---|---|---|
| 0–5 | Check Google Alert digest (or Slack/Teams channel) | Any press coverage, blog posts, or product announcements since last month? |
| 5–10 | Open App Store listing | Any version updates? Read the 3 most recent reviews for new complaint patterns |
| 10–15 | Open their changelog or blog | Any feature launches? Note the category (pricing, UX, integrations, AI) |
| 15–20 | Scan their jobs page | Any new roles? 3+ ML/AI roles = AI feature coming. Enterprise Sales hire = moving upmarket |
| 20–25 | Check pricing page (compare to Wayback Machine if needed) | Any tier changes, price increases, or new plan names? |
| 25–30 | Update competitor-monitoring.md | Log date + what changed. Flag anything that warrants a response |
Output of each ritual: one row added to the change log in competitor-monitoring.md. If a change is significant (new pricing tier, major feature launch, funding round), escalate: "[Competitor] launched [X] — this affects [specific recommendation from the original report]. Consider [specific response]."
The user can trigger the ritual at any time by telling the agent:
"Run my monthly competitive check for [competitor name]" "What's changed with [competitor] since last month?" "Update my competitive monitoring"
The agent reads competitor-monitoring.md to get the last-checked date and bookmark list, runs through the ritual checklist, and appends findings to the change log.
Before building any deliverable, ask the user how they want the analysis presented using the query tool:
"How would you like your competitive analysis presented — as a slide deck or a written report?"
Then follow the appropriate path below. Do not default to one format without asking.
Load the slides skill and build a Replit slide deck. Follow the slides skill's conventions for manifest, components, and design. Structure the deck as:
Do not output a markdown summary. Build a polished competitive analysis report as a professional PDF using jsPDF, with a React web preview that visually matches page-by-page. The report should look like a strategy consulting deliverable.
Build order: Generate the PDF first and present it to the user. Then build the web preview. The PDF is the primary deliverable — the web app is a visual complement.
Use jsPDF to generate the PDF with explicit point-based layout:
new jsPDF({ unit: "pt", format: "letter" }) — US Letter: 612×792ptPAGE_H - MARGIN, call doc.addPage() and reset Y to the top margin. Never let content silently overflow — always check before rendering.doc.addImage() — scale to fit content width while respecting remaining page height.isNewPage flag). Only add a page if you're not already on a fresh one.The React web artifact renders the same report data as an HTML version that visually mirrors the PDF page-by-page. Each "page" should be a fixed-size container (816×1056px — US Letter at 96dpi) with the same margins, typography, and chart placement as the PDF.