Reverse-engineer any company’s marketing machine: hands-on with REM
REM turns one link into an evidence-cited teardown of how a company gets customers — paid ads, pixels, SEO, founders, funnel. This tutorial installs it from source, runs the no-key teardown on Linear, and wires it into your agent over MCP.
npx one-liner fails (the package is unpublished on npm; install from source), and rem diff <domain> finds no CLI runs (diff the evidence.json files instead).- The project: dansugc/reverse-engineer-marketing, 948 stars, 124 forks, 6 commits, MIT, v0.1.0; created October 18, 2026; the fastest-accelerating marketing tool in the November 19 weekly star report.
- The free tier: no keys — website, pixels + GTM, SEO/sitemaps, AI-crawler stance, Wayback history, App Store/Play, Hacker News. A ScrapeCreators key unlocks ad libraries, social stats, founders, and Reddit.
- The verified run: Linear, no keys, 12.0 seconds, 12 evidence items, 14 unknowns; a 452-line report with positioning history back to 2019.
- The rough edges: the
npxinstall is unpublished;rem diff <domain>is blind to CLI runs; weak founder matches are flagged, not asserted. - The cost: a full keyed run is about 25–50 ScrapeCreators credits plus one Claude call (default claude-opus-5); responses cache for 24 hours.

Every company leaves its growth strategy in public. The ads it has run for six months straight, the pixels on its homepage, the pricing page it rewrote last spring, the founders posting their playbook in the open — all of it is sitting in ad libraries, sitemaps, app stores, and the Wayback Machine. The hard part was never access. It was collection: pulling all of it together, with a citation for every claim, before the trail goes stale.
That is what REM does. Reverse Engineer Marketing — dansugc/reverse-engineer-marketing on GitHub — takes one link and returns an evidence-cited teardown of how a company gets customers: paid ads, organic social, SEO, founders, funnel, and positioning history. It is MIT-licensed, it runs from your terminal with no API keys for the core sources, and it is accelerating fast: from 1 star a day in the week of November 6 to 135 stars a day in the week of November 11, a 135-fold jump that put it on the fastest-accelerating list in the November 19 weekly report, with 948 stars, 124 forks, and a v0.1.0 release that is exactly one month old. This tutorial installs it, runs a real no-key teardown of Linear, wires it into a coding agent over MCP, and shows where the free tier ends — including two rough edges I found while verifying it, one in the README and one in the diff command.
What you will need#
Node.js 22 or later and npm. That is the whole requirement for the core workflow — no API keys, no account, no GPU, no Docker. I ran everything below on Node v24.22.1. Two keys are optional and unlock more: a ScrapeCreators key (SCRAPECREATORS_API_KEY) for ad libraries, social statistics, founders, and Reddit, and an Anthropic key (ANTHROPIC_API_KEY) if you want the CLI to write the strategy narrative itself instead of the evidence report. Without either key, the tool still collects the website, pixels, SEO and sitemaps, AI-crawler stance, Wayback history, App Store and Play data, and Hacker News — and it lists everything it could not see as unknowns with a link to check each one by hand. A full run with keys costs about 25–50 ScrapeCreators credits plus one Claude call (default model claude-opus-5, overridable with REM_MODEL); responses are cached for 24 hours in ~/.cache/reverse-engineer-marketing so re-runs do not pay twice.
Step 1: Install it — skip the README's one-liner#
The first thing to know: the README's quick start does not work yet. It tells you to run npx reverse-engineer-marketing, but the package is not published on npm — npm view returns 404, and npx fails the same way. I verified this on November 19, 2026. The working install is from source, and it is short:
git clone https://github.com/dansugc/reverse-engineer-marketing.git
cd reverse-engineer-marketing
npm install
npm run build
The build compiles TypeScript to dist/ and marks dist/cli.js executable. The repository is small — six commits, four runtime dependencies (@anthropic-ai/sdk, @modelcontextprotocol/sdk, node-html-parser, zod) — and the install took under ten seconds here. Its own test suite passes too: npm test runs 23 unit tests on the parsers, scorecard, and validator, all green. Once built, the binary is node dist/cli.js, with rem as its command name. Confirm it with the help text, which I verified verbatim:
node dist/cli.js --help
reverse-engineer-marketing v0.1.0
Reverse engineer any company's marketing from one link.
Usage
rem <url> website, App Store or Google Play link
rem web open the local web app (uses your Claude Code / Codex plan)
rem mcp run the MCP server (stdio) for Claude Code, Codex, Cursor…
rem doctor show which sources your keys unlock
rem setup connect REM to Claude Code / Codex (shows the plan, asks first)
rem diff <domain> what changed since the previous run (or: rem diff <runA> <runB>)
rem demo open a recorded Cal AI teardown in the web app — no keys needed
The options worth knowing now: --no-ai skips the written strategy and returns the evidence report only; --json prints the evidence bundle to stdout; --out <dir> sets the output folder (default ./rem-reports/<domain>-<date>); --only takes a comma list of areas (website,seo,history,apps,paid,social,founders,community); --handle overrides a discovered social handle; --max-credits caps the ScrapeCreators budget per run (default 50).
Step 2: Check what the free tier unlocks#
Before running anything, ask the tool what it can do with the keys you have — or do not have:
node dist/cli.js doctor
reverse-engineer-marketing v0.1.0 · node v24.22.1
✓ free sources website, pixels + GTM, SEO/sitemaps, AI-crawler stance, Wayback history, App Store/Play, Hacker News
· SCRAPECREATORS_API_KEY not set — paid/social/founders become manual-check links (https://scrapecreators.com)
· ANTHROPIC_API_KEY not set — CLI writes the evidence report; via MCP your agent writes the strategy
This is the honest boundary of the no-key run, stated by the tool itself. The free sources are the structural ones: what the site says, what it loads, how it is organized, how it has changed, and what Hacker News thought of it. The keyed sources are the human ones: which ads are running, how the social accounts perform, who the founders are, and what Reddit says. Both halves are useful; the free half alone is enough to answer "what is this company's engine?" for most sites.
Step 3: Your first teardown — no keys, twelve seconds#
Run it on a company you know. Linear is a good first target: a well-known site, no app-store presence to confuse the results, and a homepage that has visibly repositioned itself toward AI agents this year. The --no-ai flag keeps it to the evidence report:
node dist/cli.js linear.app --no-ai
→ website https://linear.app
→ seo
→ wayback
→ appstore + apple search ads + hacker news
→ ad libraries
→ social accounts
→ founders
→ community
! appstore: fetch failed
! wikidata: fetch failed
✓ 12 evidence items, 14 unknowns in 12.0s
./rem-reports/linear.app-2026-11-19/report.md
Twelve seconds, no keys, exit code 0. The run writes two files: report.md (452 lines) and evidence.json (the raw bundle, about 26 KB). Two warnings appeared — the App Store and Wikidata fetches failed — and they are worth a note: both endpoints answer fine from this machine when curled directly, so the failures look transient or tool-side rather than a network block, and a second run minutes later collected 13 evidence items instead of 12. Treat a warning line as a signal to re-run, not as a verdict on the source.

Step 4: Read the report like an analyst#
Open rem-reports/linear.app-2026-11-19/report.md. It starts with a one-line verdict — "Likely engines: Launches (HN / PH) (Hacker News: 136 submissions, best 491 points)" — then a channel scorecard, then a section per area, then unknowns. The Linear scorecard is a useful example of what the free tier can and cannot see:
| Channel | Status | What the report found |
|---|---|---|
| Launches (HN) | active, strong | 136 Hacker News submissions; best 491 points ("Linear – A fast issue tracker", June 2020) |
| AI search (GEO) | active | llms.txt published; no AI bots blocked |
| Sales-led motion | active | Contact-sales tier on the pricing page |
| SEO | none | No readable sitemap found; 0 indexed URLs, 0 programmatic families |
| App stores | none | No App Store or Play app found |
| Affiliate / referral | none | No affiliate program found |
Three details in the body are worth reading closely. First, the homepage data is real and current: the H1 is "The product development system for teams and agents", the page is 4,592 words, the CTAs are Product, Sign up, Get started, Contact sales, and the linked socials are X, GitHub, and YouTube. Second, the funnel read is structural, not guessed: the pricing page shows a usage-based model with a contact-sales tier, and no ad pixels were detected on the homepage — the site is not the funnel, launches and word of mouth are. Third, the positioning history is the most interesting section for a competitor: the Wayback data shows the homepage title moving from "Linear – Plan and build products" (November 2024) to "Linear – The system for product development" (May 2026), with the description rewritten around AI agents. First archived snapshot: April 18, 2019; 92 monthly snapshots in total.
Then read the report critically, because the tool asks you to. Its founders section for Linear names Tom Moor as a "weak match" at low confidence, sourced only from a site link. The actual founders — Karri Saarinen, Jori Lallo, Tuomas Artman — do appear in the report's own LinkedIn data from the about page, but the tool did not connect them. That is the evidence contract working as designed: every item is an observation (seen at a URL) or a derivation (computed), weak matches are flagged rather than asserted, and anything not checked is listed as an unknown, never as "they don't do it". The 14 unknowns in this run each carry a manual-check link — the Meta ad library, Google's ad transparency center, the LinkedIn ad library, Reddit search — so the report tells you exactly where to look next. The one rule the harness enforces throughout: a pixel means intent, not current spend, and dollar figures are never invented. Spend proxies are ad counts, ad longevity, and launch rate.
The bundled example shows what the full report looks like when the keyed sources are unlocked. The repository ships a recorded Cal AI teardown (examples/calai.app.md): 894 ads in the Meta library, 692 active, every ad in the sample video, the longest-running winners at 184–185 days with up to 12 variants each, and 371,236 App Store ratings at 4.80 stars. The rule of thumb the skill file teaches: ads running 60+ days are the proven winners. Lead with them and quote their hooks exactly.
Step 5: Watch a competitor over time — and one diff quirk#
The README's monitoring flow is simple: run REM on the same company again next week, then rem diff <domain> for the deltas — new ads, killed ads, follower growth, sitemap growth, repositioning. I tested this, and the domain form does not work after CLI-only runs:
node dist/cli.js linear.app --no-ai -q
node dist/cli.js linear.app --no-ai -q
node dist/cli.js diff linear.app
error: Need two saved runs of linear.app to diff (found 0). Run `rem linear.app` again later.
The cause is in the source: the CLI writes its bundle only to the rem-reports/ folder and never registers the run in the shared run store (~/.cache/reverse-engineer-marketing/runs/). Only the MCP server and the web app save runs there, so rem diff <domain> can only see runs those two paths created. The workaround is in the same code — diff also accepts paths to evidence bundles — and it works:
node dist/cli.js diff rem-reports/linear.app-2026-11-19/evidence.json rem-reports/linear.app-2026-11-19/evidence.json
That returns a proper diff document (in my case, two runs minutes apart, correctly reporting "No measurable changes"). For real monitoring, keep each run's evidence.json — the file is the unit of comparison — and diff the two files, or run your recurring teardowns through the MCP server or web app, which register runs automatically. If you re-run weekly, keep the outputs in dated folders; the report header already stamps the harness version and SHA, so a diff a month later is still comparable.
Step 6: Give it to your agent over MCP#
The CLI is the quick path; the MCP server is where REM earns its keep. It exposes seven tools, and I verified all seven over a live stdio handshake: reverse_engineer_marketing (collect everything for a URL), get_evidence (full data for specific evidence ids), get_content (the actual ads, videos, and posts to quote), get_playbook (the analyst role, evidence rules, report template, and lesson library), validate_report (checks citations resolve, sections exist, and the playbook is grounded), write_report (REM writes the strategy itself with Claude), and compare_runs (diff two saved runs). With MCP, your agent writes the report — no Anthropic key needed in the CLI itself — and the guided prompts cover investigate_company, compare_competitors, what_changed, steal_the_playbook, and audit_unknowns.
Register it with the built binary, not the npx form. The README's setup command writes npx -y reverse-engineer-marketing mcp into the client config, which fails the same way the quick start does while the package is unpublished. Point the client at the clone instead:
{
"mcpServers": {
"reverse-engineer-marketing": {
"command": "node",
"args": ["/absolute/path/to/reverse-engineer-marketing/dist/cli.js", "mcp"],
"env": { "SCRAPECREATORS_API_KEY": "..." }
}
}
}
Then ask: "Reverse engineer the marketing of linear.app and give me a playbook I can copy." The skill file bundled in the repo (skills/reverse-engineer-marketing/SKILL.md) teaches the workflow: one collection call, read the scorecard, pull the channel playbook for the channel that matters, fetch the evidence you will quote, write the report with every fact cited [E#], label inferences "Likely…", put unknowns in their own section, and run validate_report before answering. Copy that skill folder into ~/.claude/skills/ (or your agent's skills folder) to install it. The setup command automates the same registration — node dist/cli.js setup --dry-run prints the plan and changes nothing; I verified it reports Claude Code as not installed and shows the Codex registration line.
Step 7: The web app and the zero-setup demo#
If you prefer a UI, or you want the written strategy without an Anthropic key, the local web app runs the report through your Claude Code or Codex subscription instead of an API key:
node dist/cli.js web
It opens at http://localhost:4321, listens on 127.0.0.1 only, and runs the CLIs you are already logged into in a scratch folder with your MCP servers and hooks disabled; it strips ANTHROPIC_API_KEY and OPENAI_API_KEY from their environment so your plan is used, not a key. The Posts & ads tab is a review library of everything collected — Meta ads active and paused, Google and LinkedIn ads, TikTok and Instagram videos, YouTube, X and LinkedIn posts, Reddit threads — filterable by platform, with the brand logo and founders in the rail.
Before running anything on a real company, try the demo, which needs no keys at all:
node dist/cli.js demo --no-open
I verified the server answers HTTP 200 on / and its /api/runs endpoint lists the bundled Cal AI run (23 evidence items, written report included). It is the same teardown as examples/calai.app.md in the repo, opened in the web app — the fastest way to see what a complete report looks like before you spend anything.
Step 8: Unlock the paid layer#
The free tier answers "what is the engine?" The paid layer answers "which ads, exactly?" Set a ScrapeCreators key and the same commands unlock the Meta, Google, and LinkedIn ad libraries, TikTok, Instagram, YouTube, X, and LinkedIn statistics, founder enrichment, and Reddit and Product Hunt coverage. Export it before running:
export SCRAPECREATORS_API_KEY=...
export ANTHROPIC_API_KEY=... # optional: CLI writes the strategy narrative
node dist/cli.js calai.app
With the Anthropic key set, the CLI writes the full strategy report with Claude (default claude-opus-5), then validates it — citation resolution, required sections, grounding — and prints the validation score. Without it, you get the evidence report and the MCP path instead. Keep --max-credits 50 (the default) until you know what a run costs on your targets; the README's estimate is 25–50 credits per full run, and the 24-hour response cache means a second look at the same company is free.

Two things to know before you pay for anything. First, the honest limits, from the README's own list: Apple Search Ads are only visible for the EU (Apple's DSA repository); TikTok and X have no global public ad library, so REM reports the pixel and gives you the manual library link; Reddit's ad library was shut down; ad-library counts come from samples and the report says "in the sample"; founder, TikTok-handle, and Product Hunt matches come from search and can be wrong, with weak matches flagged; server-side tracking and email tooling are invisible from the browser and reported as unknown. Second, the vendor tie: REM is built by DansUGC, a UGC ads company, and the README, the CLI output, and the generated reports all carry DansUGC calls-to-action with tracking parameters. The tool is MIT-licensed and the data it collects is public; the CTAs are promotion, not a paywall — but you should know they are there before you paste a report into a client deliverable.
When to use REM vs alternatives#
| Tool | Use it when | It is not |
|---|---|---|
| REM | You want one evidence-cited teardown of how a company acquires customers — ads, funnel, SEO, founders — from a single link | A code investigator; it never looks at source or binaries |
REA (morluto/rea) | You want to know how a feature works inside an app or a binary, down to the code | A marketing tool; it says nothing about ads or growth |
| open-seo-mcp-skills | You want SEO work grounded in your own Search Console and GA4 data inside Claude | A standalone tool; the MCP server is hosted, and it needs your Google accounts connected |
| Manual ad libraries | You need one ad, once, and you already know where to look | A system; there is no scorecard, no history, and no report |
REM and REA are siblings by design — REM's README says it was inspired by REA, "but for marketing instead of binaries" — and they complement rather than overlap. If your question is "how does this product work", use REA. If it is "how does this company get customers", use REM. And the same clean-room rule applies to both: study the strategy, ship your own. Learn which angles, offers, channels, and page templates work, then make your own creatives and copy. Do not republish a competitor's ads, footage, copy, or brand assets; respect each site's terms and your local laws. REM reads public information only — public pages and public ad transparency libraries — and never logs in as anyone or touches private data.
The takeaway#
REM is a month old, 948 stars, and already the fastest-accelerating marketing tool on GitHub's trending lists — because it solves a real collection problem with a strict evidence discipline. Install it from source (the npx one-liner is not published yet), run doctor, and tear down one competitor with no keys: twelve seconds gets you a cited scorecard, a positioning history, and a list of exactly what you still need to check by hand. Add the ScrapeCreators key when you need the ads themselves, and the MCP server when you want your agent to do the teardown. The diff command has one sharp edge — CLI runs are not registered for rem diff <domain>, so diff the evidence.json files directly — but the core loop works, the evidence is real, and the unknowns are labeled as unknowns. That is the whole point: a teardown you can defend, because every claim carries its citation.
How this tutorial was verified#
Every command in this tutorial was executed before publishing, against the repository as cloned on November 19, 2026 (commit 5b78198, v0.1.0, 948 stars, 124 forks). The npx failure was confirmed against the npm registry (404 for reverse-engineer-marketing and [email protected]); the clone, install, and build were then run from source and the --help output above is verbatim. doctor was run with no keys set. The Linear teardown ran twice with --no-ai (12.0 seconds, 12 then 13 evidence items, 14 unknowns, exit code 0), producing a 452-line report.md and a 26 KB evidence.json; every figure quoted from it — the H1, the 4,592 words, the 136 Hacker News submissions, the 2019 first snapshot — comes from those files. The App Store and Wikidata warnings on the first run were checked by curling both endpoints directly from the same machine (both HTTP 200), and the second run collected the missing item. rem diff linear.app was run after two CLI runs and failed as quoted ("found 0"); the evidence-file form of diff was run and returned "No measurable changes" with exit code 0. The MCP server was verified over a live stdio handshake (initialize plus tools/list returned all seven tools named in the README). The unit suite passed 23 of 23 tests. The demo server was started with --no-open and answered HTTP 200, with /api/runs listing the bundled Cal AI run. setup --dry-run printed its plan and changed nothing. Star-acceleration figures come from the whatstrending.ai weekly report of November 19, 2026 (1.0 star a day for November 6–11, 135 a day for November 11–16, +673 stars). No ScrapeCreators or Anthropic key was available in the sandbox, so the keyed paths — ad-library contents, social statistics, and the Claude-written narrative — are documented from the README, the skill file, and the bundled Cal AI example report, not from a live run; the tutorial says so wherever that applies.