competitive-intel-engine

The Always-On Competitive Intel Engine

A Claude Code system that keeps your competitive battle cards current on their own.

Point it at a competitor's public sources (changelog, pricing page, review profile, newsroom). It grounds every claim in a cited source, generates a rep-ready battle card, then watches those sources and regenerates the card the moment one of them changes.

Static battle cards are wrong within a quarter. This turns a card into a living asset that maintains itself.

Why static battle cards rot

Most battle cards get built once, in a doc, from a cold web search. Three things break them:

1. They're ungrounded. "They're weak on security" is an opinion until it quotes the competitor's own words. Reps get caught out when the claim is stale, or was never true to begin with.
2. They're static. The competitor ships a feature, drops a price, or lands a marquee logo, and the card still says the old thing. Nobody re-opens the doc.
3. They're centralized. One person owns the doc, so every update waits behind that person's attention.

The fix is to treat a battle card the way you'd treat monitored infrastructure: grounded in cited sources, watched for change, regenerated automatically.

What this is

Three parts working together:

• A battle-card skill - .claude/skills/battlecard/SKILL.md - turns a competitor profile plus its live sources into a 6-section, rep-ready card, with every "where they win / where you win" claim cited to a specific source.
• A source-monitor agent - .claude/agents/source-monitor.md - fetches each tracked source and reports exactly what changed since the last snapshot.
• A weekly refresh script - scripts/weekly-refresh.py - runs the monitor across every competitor you track, flags the cards whose sources moved, regenerates them, and posts you the diff.

How it works

competitors/<slug>/competitor.yaml     you define: sources, your differentiators
        |
        v
scripts/weekly-refresh.py  -- fetch each source --> hash + diff vs last snapshot
        |                                                   |
        |                                          no change | changed
        |                                                   v
        |                                          flag card STALE
        v                                                   |
/battlecard <slug>  <---------- regenerate -----------------+
        |
        v
competitors/<slug>/battlecard.md   6 sections, every claim cited
        |
        v
Slack/stdout diff  -- "Northwind changed pricing; card rebuilt"

Repo structure

competitive-intel-engine/
|-- README.md
|-- LICENSE
|-- REPO-RULES.md
|-- requirements.txt
|-- .claude/
|   |-- skills/
|   |   `-- battlecard/
|   |       `-- SKILL.md          # generates a 6-section cited battle card
|   `-- agents/
|       `-- source-monitor.md     # sub-agent: fetch sources, report what changed
|-- schema/
|   `-- competitor.yaml           # the schema, documented field by field
|-- scripts/
|   `-- weekly-refresh.py         # orchestrator: diff sources, flag + rebuild stale cards
`-- competitors/
    |-- _template/
    |   `-- competitor.yaml        # copy this to track a new competitor
    `-- example-northwind/
        |-- competitor.yaml        # a worked example
        `-- battlecard.md          # the card the skill produces

Install

1. Clone and enter the repo.

   git clone https://github.com/tga-cheetung/competitive-intel-engine.git
   cd competitive-intel-engine
   

2. Install the one dependency (the refresh script uses only the standard library plus PyYAML):

   pip install -r requirements.txt
   

3. Make sure Claude Code is installed and can see the skill. The .claude/ folder ships with the repo, so opening the repo in Claude Code registers /battlecard automatically.
4. Add your first competitor (see below), then run:

   python scripts/weekly-refresh.py
   

The 6-section card

Every card the skill writes has the same scannable shape. A rep should be able to read it in 90 seconds before a call:

1. What they are - one sentence.
2. Where you win - three specific, verifiable advantages, each cited.
3. Where they win - two honest advantages. A card that pretends the competitor has no strengths gets ignored.
4. Objections they create + your calibrated response - the top three.
5. Landmine questions - three questions a rep can ask that expose the competitor's weak spots.
6. Competitive verdict - one or two sentences a rep can actually say out loud.

Add a competitor

cp -r competitors/_template competitors/northwind

Edit competitors/northwind/competitor.yaml:

• name, domain, category
• your_product and your_differentiators - the case you want the card to make
• sources - the URLs worth watching (changelog, pricing, a review profile, the newsroom)

Then generate the first card:

claude -p "/battlecard northwind"

From then on, weekly-refresh.py keeps it current.

Keep it fresh (the whole point)

Run the refresh on a schedule. On macOS/Linux, a weekly cron entry:

0 9 * * 1  cd /path/to/competitive-intel-engine && python scripts/weekly-refresh.py --auto-regen

Set SLACK_WEBHOOK_URL in your environment and the script messages you a summary whenever a card gets rebuilt, so competitive moves reach your reps the week they happen, not the quarter after.

License

MIT. Built by The GTM Architects, 2026.