Skip to content
Agentmart
Submit a tool

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

IndexedMIT★ 782
Write a review

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.

Book a call

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.

We use your email only for this newsletter. Privacy

About

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.

No 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 `>`); **never

From 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
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

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.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying competitor-monitor?

CallGet help
Cite this page

competitor-monitor skill. Agent Mart. https://agentmart.dev/skills/aeonfun-competitor-monitor (last updated 2026-10-24)