Using the live web, build a dossier on
these competitors: [Rival A, Rival B,
Rival C]. We are [what we do] in
[country / region].

For EACH, visit their site, pricing
page, careers page and any recent
reviews, then capture:
- Positioning & target ICP
- Core offer + top 3 features
- Pricing tiers (price + what's in)
- Proof: logos, case studies, funding
- Hiring signals — what the open roles
  say about where they're heading
- Sharpest message & weakest spot

One comparison table, a row per rival.
Cite a source URL for every fact and
flag anything you couldn't verify.

Here's us: [1-paragraph description +
our pricing + our 3 best proof points].

Using the dossier above, build a
one-page battlecard per rival:
1. Where they genuinely beat us (be
   honest — no spin).
2. Where we beat them, with the proof
   point that lands.
3. The 3 objections a buyer raises when
   they've seen that rival, and the
   exact reply — under 30 words each.
4. The trap question that exposes their
   weakness without trashing them.

Then rank the rivals by how much of our
pipeline they actually threaten.

Now tear down the pricing.

1. Lay every rival's tiers side by side
   with ours: price, what's bundled,
   what's an add-on, contract length.
2. Work out their effective price per
   [seat / outlet / transaction] — not
   the headline number.
3. Where are we over- or under-priced
   for what we deliver? Quantify it.
4. Propose 2 pricing or packaging moves
   we could make this quarter, with the
   risk of each.

Show your assumptions and cite the
pricing pages you read.

We're a [business type] in [country],
[size: revenue / headcount / outlets].

Using the live web, build the benchmark
set for our industry. Give me the 8-10
metrics that actually decide who wins —
financial, operational and commercial.

For EACH metric:
- The standard definition (state the
  formula — no ambiguity)
- Industry median and top quartile
- The source and its year
- How much it varies by company size

Flag any metric where the public data is
thin or the definitions conflict. Don't
invent a number to fill a cell.

Here are our numbers: [paste or attach
the P&L / ops sheet — last 12 months].

Score us against the benchmark:
1. Recompute each metric from our data
   using the benchmark's own formula,
   and show your working.
2. Place us in a quartile per metric —
   bottom / below / above / top.
3. For each gap, convert it to money:
   "closing this to median is worth
   ~RM[x] a year."
4. Rank the gaps by value at stake ÷
   effort to close.

End with the 3 gaps worth our attention
and the one to deliberately ignore.

Take the top 3 gaps and turn each into a
90-day plan: the owner, the weekly
leading indicator, the first move in
week one, and what "closed" looks like.

Then set the cadence. Using Cowork,
Schedule a monthly run that:
1. Re-pulls the benchmark (flag if any
   source has been updated).
2. Re-scores us on the latest actuals.
3. Shows movement vs last month.

Put a recurring "benchmark review" on my
Google Calendar for the first Monday
of each month, with the scorecard in the
invite notes.

We're [what we do] in [country]. Set up
a competitor monitoring brief.

1. List who to watch, in four buckets:
   direct rivals, adjacent players who
   could enter, key suppliers, and the
   regulators that affect our costs.
   Say why each one is on the list.
2. For each, give the specific sources
   worth checking — site, pricing page,
   careers page, newsroom, LinkedIn,
   trade press, regulator bulletins.
3. Define the signal categories we
   care about: pricing, product,
   people, capital, regulation.
4. Define what makes a signal high /
   medium / low impact for us.

Output it as a reusable brief I can
paste into every weekly run.

Using the watchlist brief above, search
the live web for everything from the
last 7 days and give me the digest.

Rules:
- Only items you can link to. No
  rumours, no "reportedly" without a
  source.
- Group by signal category, sort by
  impact on us.
- Each item: one line of what happened,
  one line of so what for us, one line
  of do what — and "no action" is a
  valid answer, say it plainly.
- Cap it at the top 5. List the rest as
  one-line mentions.
- Open with a 2-sentence "if you read
  nothing else".

Then flag anything that contradicts what
we assumed in our benchmark or plan.

Automate it. Using Cowork, Schedule
this to run every Monday at 8am:

1. Re-run the weekly digest above.
2. Diff against last week's run — mark
   each item new / developing / closed,
   and drop anything already reported.
3. Keep a running log so we can see a
   rival's pattern over months, not
   just this week's headline.

Then email me the digest via Gmail
with the "if you read nothing else"
section at the top. Draft it — don't
send.

If nothing scored high impact, say so in
one line instead of padding the email.

Here's a process we run manually:
[describe it end to end — who starts it,
what arrives, every step, where it ends
up, how often, how long it takes].

Design it as an n8n workflow:
1. The trigger (schedule / webhook /
   app event) and why that one.
2. Each node in order — name, node
   type, and what it does.
3. Where a decision is needed: is it a
   rule (IF / Switch) or genuine
   judgement (AI node)? Justify each.
4. The data shape passed between nodes.
5. Failure handling: what happens on a
   bad input, an API timeout, or a
   low-confidence AI answer.
6. What stays manual — and why.

Then estimate hours saved per month.

Write the system prompt for the AI node
in that workflow. Its job: [classify /
extract / summarise / decide].

It must:
- State the role and the one job. No
  chit-chat, no preamble.
- Return strict JSON only, with this
  schema: [fields + types].
- Include a "confidence" 0-1 and a
  "needs_human" boolean.
- Say exactly what to do when the input
  is unclear or a field is missing —
  never guess, flag it instead.
- Handle the 3 edge cases we hit most:
  [list them].

Then give me 5 test inputs — 3 normal,
2 nasty — and the exact JSON each should
produce, so I can verify before I switch
the workflow on.

Now produce the importable n8n workflow
JSON for the blueprint above — nodes,
parameters and connections — so I can
paste it straight into a new workflow.

Use placeholders for every credential
and ID; never inline a secret.

Then give me:
1. A go-live checklist: what to test
   with real data before switching the
   trigger on.
2. The 3 most likely ways this breaks in
   production, and the node to add to
   catch each.
3. A human-in-the-loop step for
   anything below the confidence
   threshold, routed to [Slack / email /
   a review sheet].
4. What to log on every run so we can
   audit a decision 6 months later.

Design an n8n workflow that runs our
competitor watch every Monday 08:00.

Watchlist: [rivals + the URLs from
Example 03 — pricing pages, newsrooms,
careers pages, RSS feeds].

Specify:
1. Schedule trigger + how to fan out
   over the list without hammering any
   one site.
2. Fetch & extract nodes per source
   type (HTML page, RSS, news search).
3. A diff step: compare to the stored
   version and pass on only what
   changed — so we don't re-analyse
   unchanged pages.
4. Where each result is stored, and the
   dedupe key so nothing is reported
   twice.
5. Retries, timeouts, and what happens
   when a site blocks us.

Write the system prompt for the AI node
that scores each change we detect.

Context to bake in: we are [what we do],
our rivals are [list], and what matters
to us is [pricing / product / people /
capital / regulation].

For each item it must return strict JSON:
- category, headline, source_url
- impact: high / medium / low, and the
  one-line reason
- so_what (effect on us)
- do_what (the move — or "no action")
- is_material: true only if a person
  should read it this week

Rules: never infer a fact that isn't in
the source text; if the change is
cosmetic, mark it low and move on; be
blunt, no marketing language.

Finish the workflow with the routing.

1. Switch node on impact:
   - high → alert me immediately on
     [Slack / Telegram / email]
   - medium & low → hold for the
     Monday digest
2. Build the digest: "if you read
   nothing else" at the top, then items
   grouped by category, capped at 5,
   with the rest as one-line mentions.
3. Email it via [Gmail / SMTP]. If
   nothing was material, send one line
   saying so — never pad it.
4. Append every scored item to [Google
   Sheets / Postgres] with the date, so
   we build a history.
5. On any node error, post the failure
   to [ops channel] — a silent broken
   watcher is worse than none.

Then give me the importable JSON.

I'm not technical. Here's a problem in
our business: [describe it — who suffers,
what they do today, the workaround,
how often, what it costs us].

Act as my product partner:
1. Ask me the 5 questions you need
   answered before anything is built.
   Wait for my answers.
2. Then write a one-page spec: the
   user, the job to be done, the 3
   screens, and the single success
   metric.
3. Cut it to a v1 we can build today —
   list what we're deliberately leaving
   out and why.
4. Flag anything that touches customer
   data, payments or PII so we get a
   technical review before go-live.

Build the v1 from that spec. I want
something I can open on my phone and
hand to a colleague today.

Rules:
- Work in small steps and show me the
  result after each one — I'll steer.
- Keep it simple: one page where you
  can, plain language in the UI, no
  jargon on screen.
- Use [our brand colours / logo].
- Sample data first so I can click
  through it before we connect anything
  real.
- After each step, tell me in plain
  English what you just did and what
  I should test.

Then deploy it to a link I can share.

We've tested v1 with [n] real users.
Here's what broke and what they asked
for: [paste the feedback].

1. Fix those, smallest change first.
2. Now be the sceptic: what would break
   this with 50 users, a bad input, or
   someone hostile? Fix what matters,
   list what doesn't.
3. Add the boring essentials: input
   validation, an error message a human
   understands, and a backup of the data.
4. Connect it to [Google Sheets /
   our n8n workflow / email].
5. Write a one-page handover for
   whoever maintains this: what it does,
   where it lives, how to change the
   common things.