competitor-monitor
Watch a list of competitor web pages on a cadence - snapshots each page's real signals (pricing, headings, CTAs, new/removed pages, title/description), diffs…
Skill by aeonfun
Chalk Labs
Need help deploying competitor-monitor?
Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.
Install
Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.
npx agentmarket install skill/aeonfun-competitor-monitor
Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.
Get the weekly diff
The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.
About
Reviews
Write a reviewNo reviews yet. Installed it? Reviews come from verified installers only. How reviews work
Permissions
What this skill can do and what it asks for, from its SKILL.md. Checked Oct 25, 2026.
- Tools
- No tools found
- Secrets
- None asked for
- Install scripts
- None found
Network hosts it talks to 1
codeload.github.com· found in install command
Files it touches
~/.claude/skills/competitor-monitor
What's inside
- Skill name
competitor-monitor- Description
- Watch a list of competitor web pages on a cadence - snapshots each page's real signals (pricing, headings, CTAs, new/removed pages, title/description), diffs against the last run, and reports only what actually changed.
- License
- MIT
- Metadata
- var: · mode: read-only · title: Competitor Monitor · category: productivity
- Instructions
- 269 lines in SKILL.md · view on GitHub
Agent Skills spec issues
- files: referenced but missing: scripts/competitor-monitor.mjs
Files (1)
- SKILL.md
SKILL.md (first lines)
Today is ${today}.
> **${var}** — the pages to watch, comma-separated.
> - **empty** → read the watch list from `memory/competitors.md`.
> - **`https://rival.com/pricing, https://rival.com`** → watch exactly these
> pages this run (a bare host gets `https://` prepended). Watch specific
> **pages**, not just origins: `/pricing`, `/changelog`, `/blog` are where a
> competitor's moves actually show up.
> - **`add:<url>`** → append `<url>` to `memory/competitors.md`, confirm, and end
> (the shape the Telegram force-reply sends). No monitor runs.
## What this does
Fetches each watched page, extracts the handful of signals a human would notice
if they reopened the tab — the pricing numbers, the section headings, the
call-to-action buttons, the nav/footer links, the `<title>` and meta description
— snapshots them, and diffs today's snapshot against the previous run. It reports
**only the differences**, ranked by how much they matter (a pricing change beats
a reworded button), and keeps a durable log of every change it has ever seen.
The heavy lifting is in `scripts/competitor-monitor.mjs`, which returns
machine-readable signals and a machine-computed diff, so you reason over facts
instead of eyeballing two HTML dumps. **Diffing signals, not raw HTML, is the
whole point** — raw HTML churns every deploy (build hashes, nonces, inlined
timestamps) and would fire on every run. Signals only move when the site
actually moved.
This reads what a page **serves**. A pure client-rendered SPA that ships an empty
shell will look thin — the meta tags and any server-rendered copy still diff, but
JS-injected content won't. Most marketing, pricing, blog, and changelog pages are
server-rendered enough to track; say so if a target comes back near-empty rather
than inventing signal.
## Capability notes (read before editing this skill)
This skill is `mode: read-only`, and that is load-bearing (same contract as
`seo-audit`):
- The scraper is **stdlib Node, not Python** — `Bash(node:*)` is in the read-only
capability base; `Bash(python3:*)` is write-tier. Porting to Python forces
`mode: write`.
- **No Write or Edit tool, and no shell output redirection.** Read-only mode
strips `Write`/`Edit` *and* the Bash permission layer blocks `> file` /
`>> file` as defense-in-depth. So every file this skill produces is written by
a `Bash(node:*)` command that opens the file itself — the snapshot/diff script
takes `--out FILE`, and `CHANGES.md` is written by piping its content into a
one-line `node` writer (both shown below). Do **not** use `>` — it will be
refused mid-run. The read-only guard reverts writes to code/config paths but
**preserves `memory/` and `output/`**, which is exactly where this skill writes.
- No secrets, no `requires:`. It only makes outbound HTTPS GETs.
- **Shell shape.** Each Bash call is one allowed command (pipes are fine). The
run refuses a call that sets a variable (`X=$(...)`), uses `case` / `if`,
`printf`, `sed` or `touch`, or joins commands with `;`, `&&` or `||`, and each
refusal costs a model turn. So parse `${var}` in your head (step 1), run each
`date` / `ls` / `node` as its own call, and write the value it prints in
literally where a later command shows `<STAMP>` / `<PREV>` / `<CAND>`. The one
append to `memory/competitors.md` goes through `node` too.
## Workflow
### 1. Resolve the watch list
Parse `${var}` in your head, not in a shell script (a `case`/`if` block is
refused). `RAW` = `${var}` with leading and trailing whitespace trimmed.
**Config capture (Telegram force-reply):** `var="add:<url>"` appends to the watch
list and ends. If `RAW` starts with `add:`:
1. `CAND` = the text after `add:`, leading whitespace trimmed, cut at the first
whitespace. If it does not start with `http://` or `https://`, prepend `https://`.
2. If `CAND` does not match `^https?://[a-z0-9.-]+\.[a-z]{2,}(/.*)?$`
(case-insensitive), send this (CAND written in literally) and end:
```bash
./notify "Couldn't read \"<CAND>\" as a URL. Reply with a full page URL (e.g. https://rival.com/pricing)."
```
3. Otherwise make sure the folder exists:
```bash
mkdir -p memory
```
Then check the watch list (a missing file means not watched yet):
```bash
grep -ciF "<CAND>" memory/competitors.md
```
4. If it printed a count above 0, send `./notify "Already watching <CAND>."` and end.
5. Otherwise append it with `node` (it creates the file if missing):
```bash
node -e 'require("fs").appendFileSync("memory/competitors.md", "- " + process.argv[1] + "\n")' "<CAND>"
```
Then send `./notify "Now watching <CAND> - it'll show up in the next Competitor Monitor run."` and end.
If `RAW` is non-empty, the targets are `RAW` split on commas (trim each). If
`RAW` is empty, read the watch list from `memory/competitors.md`:
```markdown
# memory/competitors.md
- https://rival.com
- https://rival.com/pricing
- https://rival.com/changelog
- https://othercompetitor.com/pricing
- https://vendor.com/security/acknowledgements/ [rows]
```
If the file is missing or empty **and** `RAW` is empty, offer to seed it via a
Telegram force-reply, but **only if no `add` prompt was already offered in the
last 3 days of `memory/logs/`** (don't nag an unconfigured fork every run):
```bash
./notify "No competitor pages on the watch list yet. Which page should I watch? Reply with a full URL." \
--force-reply --placeholder "https://rival.com/pricing" \
--context "competitor-monitor::add"
```
Then log `COMPETITOR_MONITOR_EMPTY_CONFIG` and end. The reply routes back as
`var=add:<url>`, handled above.
### 2. Snapshot every page
Write one timestamped snapshot per run — never overwrite an earlier one. The
script writes the file itself with `--out` (read-only mode blocks `>`); **neverFrom aeonfun/aeon, MIT.
Signals
- Stars
- 782
- Forks
- 292
- Open issues
- 0
- Last commit (this folder)
- Oct 1, 2026 (1 month ago)
- Last release
- Jul 9, 2026 (4 months ago)
From GitHub (fetched Oct 24, 2026).
Details
- License
- MIT
- Repository
- github.com/aeonfun/aeon
- Website
- www.aeon.fun/
- First seen
- Oct 24, 2026
- Last checked
- Oct 24, 2026
- Source
- GitHubgithub-graphql
Done for you
Rather not set it up yourself?
Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.
See how we build AI agents →Read the case studies
Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.
- launches shipped
- 50+
- launches shipped
- media placements
- 500+
- media placements
- founders on every account
- 2
- founders on every account
Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block
Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.
Get competitor-monitor running in your business
Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.
Cite this page
competitor-monitor skill. Agent Mart. https://agentmart.dev/skills/aeonfun-competitor-monitor (last updated 2026-10-24)