Nimble

View saved version →

---
name: brand-mention-monitor
description: |
  Scans Reddit, X, LinkedIn, Instagram, TikTok, YouTube, blogs, news, and review platforms
  for brand mentions — scoring each across four dimensions (reach, velocity, sentiment, and
  risk-topic match) so teams can respond before one spirals. Sources adapt to the market: B2B
  brands weight LinkedIn, G2, and trade press; consumer brands weight TikTok, Instagram, and
  YouTube. Each is bucketed into Crisis / Watch / Engage / Log with a suggested owner and
  response window.

  Use when asked to "monitor brand mentions", "scan for brand mentions", "what are people
  saying about [brand]", "brand monitoring", "social listening", "run a brand sweep",
  "find high-risk mentions", or any variation of brand monitoring across web and social.

  Do NOT use for one-time company research or due diligence — use company-deep-dive instead.
  Do NOT use for competitor messaging/positioning analysis — use competitor-positioning instead.
  Do NOT use for funding/hiring/business signals on a competitor — use competitor-intel instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: marketing
---

# Brand Mention Monitor

Scans the web and social media for brand mentions, scores each one on reach, velocity, sentiment, and risk-topic match, and surfaces the ones that need attention — bucketed into Crisis / Watch / Engage / Log with a suggested owner.

---

## Onboarding message

When this skill is triggered for the first time in a session, send this message:

> 👋 **Brand Mention Monitor is ready.**
>
> This skill scans Reddit, X, LinkedIn, Instagram, TikTok, YouTube, blogs, news, and review platforms for mentions of your brand — scoring each one across reach, velocity, sentiment, and risk so you see what matters before it spirals, and telling you exactly who should respond and how fast.
>
> To start, just say:
> _"Monitor mentions of [brand name]"_
>
> Or try:
> - "What are people saying about [brand] this week?"
> - "Run a brand sweep for [brand] — last 30 days"
> - "Find high-risk mentions of [brand]"
> - "How does [brand] compare to [competitor] in the conversation?"
>
> Would you like me to save your preferences so I skip the questions next time?

---

## Preflight

Follow the transport selection and standard preflight from `references/nimble-playbook.md`: pick CLI vs MCP at session start, then run the parallel preflight calls (date, profile, memory index) simultaneously. Tag every Nimble CLI call: `nimble --client-source nimble-agent-skills <subcommand>`.

From the profile (`~/.nimble/business-profile.json`): load brand name, competitors, routing preferences, and `last_runs.brand-mention-monitor` for date windowing. Pre-populate setup questions so the user confirms rather than re-enters. If no profile exists, follow the first-run onboarding flow in `references/profile-and-onboarding.md` and create a stub after the first run. Check `~/.nimble/memory/index.md` to understand what mention data already exists before sweeping.

---

## How to start

**Before asking anything, do two quick research steps:**

**Step A — Resolve brand variants automatically:**
Search for the brand the user named to discover all alternate spellings, hashtags, product names, handles, and common misspellings. Do not ask the user for this. Use what you find to build a comprehensive search term list for the sweep.
- Search: `"[brand name]" official name OR handle OR "also known as" OR hashtag`
- Check the brand's main product names and any sub-brands that get mentioned independently
- For brands with common-word names, find the disambiguating terms (industry, founder, domain) so the sweep doesn't pull unrelated noise
- Add all confirmed variants to your search queries silently — the user never needs to see this step

*

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: company-deep-dive
description: |
  Use this skill ANY TIME the user asks about a specific company. Triggers:
  "tell me about [company]", "research [company]", "what does [company] do",
  "who is [company]", "look up [company]", "company deep dive", "due diligence
  on [company]", "background on [company]", "dig into [company]", "analyze
  [company]", or evaluating a company for investment, partnership, or sales.
  MUST be used instead of answering from memory — fetches real-time web data
  (funding, leadership changes, product launches, news) your training data
  lacks. Use even for well-known companies.

  Produces a sourced 360° report covering funding, leadership, product/tech,
  market position, news, and strategic outlook with dates and URLs.

  Do NOT use for multi-company competitor monitoring (use competitor-intel)
  or meeting prep with attendees (use meeting-prep).
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: business-research
---

# Company Deep Dive

360° company research powered by Nimble's web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

From the results:
- CLI missing or API key unset → `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists → note it for context (company name helps frame the research). Read
  `~/.nimble/memory/companies/index.md` to check if the target company already has
  prior research. Follow `[[path/entity]]` cross-references to load related context.
  - **Prior research exists:** Load it. Run in **refresh mode** — focus on what's new
    since the last report date. Tell the user: "I have prior research on [Company]
    from [date]. Refreshing with latest data."
  - **No prior research:** Run in **full mode** — comprehensive across all dimensions.
- No profile → that's fine. Company deep dive doesn't require onboarding (unlike
  competitor-intel). Proceed directly to Step 1.

### Step 1: Identify Target Company

Parse the target company from `$ARGUMENTS` or the user's message.

**If clear** (e.g., "research Stripe", "tell me about Datadog"):
- Extract the company name
- Run two Bash calls simultaneously to confirm identity:
  - `nimble search --query "[Company] official site" --max-results 3 --search-depth lite`
  - `nimble search --query "[Company] company overview" --max-results 5 --search-depth lite`
- Confirm briefly: "Researching **[Company]** ([domain])..."

**If ambiguous** (e.g., "research Mercury" — could be bank, auto, or other):
- Ask one clarifying question with the top candidates

**If missing** — ask: "Which company would you like me to research?"

**Scope selection** — if the user hasn't specified depth, default to **full deep dive**.
If they say "quick overview", "brief", or "summary", run a **quick mode** that skips
the Deep Extraction step and produces a shorter report.

### Step 2: WSA Discovery

Discover available WSAs for the target company's domain. Run both searches
simultaneously:

```bash
nimble extract:templates list --limit 100  # then filter items for "{company-domain}"
```

```bash
nimble extract:templates list --limit 100  # then filter items for "{company-name}"
```

From the results, filter for WSAs with

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.

View saved version →

---
name: competitor-intel
description: |
  Searches the live web via Nimble APIs to monitor competitors and produce a
  structured intelligence briefing. Runs parallel searches for news, product
  launches, hiring signals, and funding — then compares against previous
  findings to highlight only what's new.

  Use this skill when the user asks about competitors, competitive intelligence,
  or what rival companies are doing. Common triggers: "what are my competitors
  doing", "competitor update", "competitor news", "competitive landscape",
  "market intel", "what's new with [company]", "track [company]", "competitor
  briefing", "who's making moves", "competitive analysis", "losing deals to
  [company]", "battlecard". Also use before board meetings or strategy sessions
  when the user wants competitive context.

  Requires the Nimble CLI (nimble search, nimble extract) for live web data.
  Do NOT use for single-company deep dives (use company-deep-dive), meeting
  prep with attendees (use meeting-prep), or non-business queries.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: business-research
---

# Competitor Intelligence

Real-time competitive intelligence powered by Nimble's web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

From the results:
- CLI missing or API key unset → `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists → read `~/.nimble/memory/competitors/index.md` to identify which
  competitor files exist and their last-updated dates. If the index doesn't exist
  (first run or upgrade), fall back to reading all `~/.nimble/memory/competitors/*.md`
  directly — the index is an optimization, not a gate. Then load the relevant
  competitor files for known signals
  (used for dedup in Steps 3 + 5). Follow cross-references (`[[path/entity]]` links)
  to load related context. Determine mode using smart date windowing
  from `references/nimble-playbook.md`:
  - **Full mode:** first run OR last run > 14 days ago
  - **Quick refresh:** last run < 14 days ago
  - **Same-day repeat:** if `last_runs.competitor-intel` is today, check if a report
    already exists at `~/.nimble/memory/reports/competitor-intel-[today].md`. If so,
    ask: "Already ran today. Run again for fresh data?" Don't silently re-run.
  - Skip to Step 2
- No profile → Step 1

**Note:** Step 2 (WSA Discovery) runs after onboarding but before any research.

### Step 1: First-Run Onboarding (2 prompts max)

**Prompt 1** — ask in plain text (NOT AskUserQuestion with options):

> "What's your company's website domain? (e.g., acme.com)"

Verify — make two Bash calls simultaneously:

- `nimble search --query "[domain]" --include-domain '["[domain]"]' --max-results 3 --search-depth lite`
- `nimble search --query "[domain] company" --max-results 5 --search-depth lite`

**Prompt 2** — confirm company + choose competitor method (use AskUserQuestion):

> I found that **[Company]** ([domain]) is [brief description].
> Is this right? And how should I find your competitors?
> - **Yes — find competitors for me**
> - **Yes — I'll list them myself**
> - **Wrong company — let me clarify**

If "find competitors", make three Bash calls

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.

View saved version →

---
name: competitor-positioning
description: |
  Tracks how competitors position themselves online — scrapes homepages,
  features, pricing, and blogs to extract messaging, value props, CTAs, and
  pricing models. Compares against previous snapshots to surface positioning
  shifts with before/after tracking. Produces messaging matrices, content gap
  analysis, white space maps, and battlecard inputs.

  Use when anyone asks about competitor messaging, positioning, website copy,
  content strategy, or how competitors present themselves. Triggers: "competitor
  positioning", "messaging comparison", "content gap", "what changed on their
  site", "competitor homepage", "landing page teardown", "marketing battlecard",
  "how do they describe their product", "share of voice", "counter-messaging".

  Do NOT use for business signals like funding/hiring (use competitor-intel),
  single-company deep dives (use company-deep-dive), or meeting prep (use
  meeting-prep).
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: marketing
---

# Competitor Positioning

Marketing-focused competitive positioning analysis powered by Nimble's web data APIs.
Built for marketing teams who need to understand how competitors present themselves —
messaging, value props, content themes, pricing — and how that evolves over time.

The output is a **marketing briefing**, not a signal feed. Every insight should answer:
"what does this mean for our messaging and positioning?"

User request: $ARGUMENTS

**Argument parsing** — determine what to do before running anything:
- No arguments → run full workflow (scope confirmation in Step 2)
- Competitor names (e.g., "Exa, Tavily") → research only those, skip scope confirmation
- "battlecard [competitor]" → skip to Battlecard Generation (see below) using
  existing snapshots from memory
- "delta" / "what changed" → force delta mode regardless of timing

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

From the results:
- CLI missing or API key unset → `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists → load prior data from two sources:
  - `~/.nimble/memory/positioning/*.md` — prior positioning snapshots (used for
    delta detection in Steps 4 + 5)
  - `~/.nimble/memory/competitors/*.md` — business signals from competitor-intel
    runs (provides context for *why* positioning may have shifted, e.g., a funding
    round or leadership change that preceded a messaging pivot)
  Determine mode:
  - **Full snapshot:** first run OR no prior positioning data OR last run > 14 days ago
  - **Delta mode:** last run < 14 days ago — only surface what changed
  - **Same-day repeat:** if `last_runs.competitor-positioning` is today, check for
    existing report at `~/.nimble/memory/reports/competitor-positioning-[today].md`.
    If found, ask: "Already ran today. Run again for fresh data?" Don't silently re-run.
  - Skip to Step 2
- No profile → Step 1

### Step 1: First-Run Onboarding (2 prompts max)

This skill shares the competitor list from `competitor-intel`. If a profile already
exists with competitors, skip onboarding entirely.

If no profile exists, follow `references/profile-and-onboarding.md` for the full
onboarding flow

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: healthcare-providers-enrich
description: |
  Fills gaps in existing healthcare practitioner lists — adds missing phone numbers,
  credentials, specialties, contact info, education, reviews, and regulatory data.

  Triggers: "enrich my provider list", "fill in missing data", "add phone numbers
  to these doctors", "complete this practitioner database", "enrich CRM export",
  "fill gaps in my provider data", "supplement this healthcare list".

  Accepts CSV, Google Sheet URL, or pasted data. Searches for each provider's
  practice website, extracts missing fields, and enriches with reviews, clinical
  trials, and accreditation via WSAs.

  Do NOT use for extracting providers from practice URLs — use healthcare-providers-extract instead.
  Do NOT use for validating credentials — use healthcare-providers-verify instead.
  Do NOT use for discovering practices — use market-finder or local-places instead.
  Do NOT use for general extraction — use nimble-web-expert instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Bash(wc:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: healthcare
---

# Healthcare Providers Enrich

Fill gaps in existing practitioner lists with verified web data, powered by Nimble's
web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight + WSA Discovery

**Sibling handoff check:** Before running full preflight, check if
`healthcare-providers-extract` ran earlier in this session by following the Sibling
Handoff pattern from `references/nimble-playbook.md`. If same-day extract output
exists, skip CLI check and profile load, and reuse WSA Layer 1/3 inventory. Only
re-run Layer 2 if the specialty changed.

**Otherwise, run full preflight** from `references/nimble-playbook.md` (5 simultaneous
Bash calls: date calc, today, CLI check, profile load, index.md load).

**Also simultaneously** — run WSA discovery and setup:
- `mkdir -p ~/.nimble/memory/{reports,healthcare-providers-enrich/checkpoints}`
- `ls ~/.nimble/memory/healthcare-providers-enrich/checkpoints/ 2>/dev/null`
- Run Layer 1 (vertical) and Layer 3 (general tools) WSA discovery from
  `references/wsa-reference.md`. Layer 2 (session-specific) runs after Step 1 when
  you know the user's specialty.

Classify discovered agents into phases and validate with `nimble extract:templates get` per
`references/wsa-reference.md`.

From the preflight results:
- CLI missing or API key unset -> `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists -> note it for context. Determine mode using smart date windowing
  from `references/nimble-playbook.md`:
  - **Full mode:** first run OR last run > 14 days ago
  - **Quick refresh:** last run < 14 days ago (re-enrich only records with gaps)
  - **Same-day repeat:** if `last_runs.healthcare-providers-enrich` is today, check
    for existing report at `~/.nimble/memory/reports/healthcare-providers-enrich-*[today].md`.
    If found, ask: "Already ran today. Run again for fresh data?"
- No profile -> that's fine. This skill doesn't require onboarding. Proceed to Step 1.

### Step 1: Parse Input + Starting Questions

**Chained-from-extract shortcut:** Check for a same-day extract report:
```bash
ls ~/.nimble/memory/reports/healthcare-providers-extract-*$(date +%Y-%m-%d).md 2>/dev/null
```
If a same-day report exists, parse the `{slug}` from the filename and load
`~/.nimble/memory/healthcare-providers-extract/{slug}/providers.json`. The practice

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: healthcare-providers-extract
description: |
  Extracts structured practitioner data from healthcare practice websites.
  Returns names, credentials, specialties, contact info, and education for
  every provider on a practice's site.

  Use when user asks to extract, pull, or list doctors, providers, or staff
  from practice websites. Triggers: "extract doctors from", "pull providers
  from", "who are the providers at", "build a provider database", "list all
  doctors at", "scrape the team page", "get practitioner data from".

  Accepts practice URLs (pasted, CSV, Google Sheet) or discovers practices
  via Google Maps when given specialty + location. Single sites or 100+ URLs.

  Do NOT use for filling data gaps — use healthcare-providers-enrich instead.
  Do NOT use for credential validation — use healthcare-providers-verify instead.
  Do NOT use for discovering practices — use market-finder or local-places instead.
  Do NOT use for general extraction — use nimble-web-expert instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Bash(wc:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: healthcare
---

# Healthcare Providers Extract

Structured practitioner extraction from healthcare practice websites, powered by
Nimble's web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight + WSA Discovery

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

**Also simultaneously** — run WSA discovery and setup:
- `mkdir -p ~/.nimble/memory/{reports,healthcare-providers-extract/checkpoints}`
- `ls ~/.nimble/memory/healthcare-providers-extract/checkpoints/ 2>/dev/null`
- Run Layer 1 (vertical) and Layer 3 (general tools) WSA discovery from
  `references/wsa-reference.md`. Layer 2 (session-specific) runs after Step 1 when
  you know the user's specialty.

Classify discovered agents into phases and validate with `nimble extract:templates get` per
`references/wsa-reference.md`.

From the preflight results:
- CLI missing or API key unset -> `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists -> note it for context. Determine mode using smart date windowing
  from `references/nimble-playbook.md`:
  - **Full mode:** first run OR last run > 14 days ago
  - **Quick refresh:** last run < 14 days ago (re-extract only new/changed pages)
  - **Same-day repeat:** if `last_runs.healthcare-providers-extract` is today, check
    for existing report at `~/.nimble/memory/reports/healthcare-providers-extract-*[today].md`.
    If found, ask: "Already ran today. Run again for fresh data?"
- No profile -> that's fine. This skill doesn't require onboarding. Proceed to Step 1.

### Step 1: Parse Input & Starting Questions

Parse `$ARGUMENTS` for input type using the Input Parsing Pattern from
`references/nimble-playbook.md`. Key routing:
- **URLs detected** -> proceed to Step 3
- **Specialty + location** (no URLs) -> proceed to Step 2 (practice discovery)
- **Unclear** -> ask (counts as 1 of max 2 prompts)

**If input is clear**, confirm and ask one shaping question (plain text, not
AskUserQuestion):

> "Extracting providers from **N practice sites**. Quick questions:
> 1. Healthcare vertical? (ophthalmology, dental, dermatology, general, or other)
> 2. Quick scan (names + credentials only) or full extraction (

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: healthcare-providers-verify
description: |
  Validates practitioner credentials and license status against the NPI registry.
  Cross-references specialties, credentials, and practice addresses against
  official records. Returns Verified / Partially Verified / Unverified / Flagged
  per practitioner with mismatch details and source URLs.

  Triggers: "verify these doctors", "check provider credentials", "validate
  licenses", "verify NPI numbers", "cross-check credentials against NPI",
  "compliance audit on providers", "are these practitioners still licensed",
  "validate my provider list". Accepts CSV, Google Sheet URL, or pasted data.

  Do NOT use for extracting providers from practice URLs — use healthcare-providers-extract instead.
  Do NOT use for filling data gaps — use healthcare-providers-enrich instead.
  Do NOT use for discovering practices — use market-finder or local-places instead.
  Do NOT use for general extraction — use nimble-web-expert instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Bash(wc:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: healthcare
---

# Healthcare Providers Verify

Validate practitioner credentials against the NPI registry and authoritative
sources, powered by Nimble's web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight + WSA Discovery

**Sibling handoff check:** Before running full preflight, check if
`healthcare-providers-extract` or `healthcare-providers-enrich` ran earlier in this
session by following the Sibling Handoff pattern from `references/nimble-playbook.md`.
If same-day output exists, skip CLI check and profile load, and reuse WSA Layer 1/3
inventory. Only re-run Layer 2 if the verification focus changed.

**Otherwise, run full preflight** from `references/nimble-playbook.md` (5 simultaneous
Bash calls: date calc, today, CLI check, profile load, index.md load).

**Also simultaneously** — run WSA discovery and setup:
- `mkdir -p ~/.nimble/memory/{reports,healthcare-providers-verify/checkpoints}`
- `ls ~/.nimble/memory/healthcare-providers-verify/checkpoints/ 2>/dev/null`
- Run Layer 1 (vertical) and Layer 3 (general tools) WSA discovery from
  `references/wsa-reference.md`. Layer 2 (session-specific) runs after Step 1 when
  you know the user's specialty and verification focus.

Classify discovered agents into verification categories and validate with
`nimble extract:templates get` per `references/wsa-reference.md`.

From the preflight results:
- CLI missing or API key unset -> `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists -> note it for context. Determine mode using smart date windowing
  from `references/nimble-playbook.md`:
  - **Full mode:** first run OR last run > 14 days ago
  - **Quick refresh:** last run < 14 days ago (re-verify only previously
    Unverified/Flagged practitioners)
  - **Same-day repeat:** if `last_runs.healthcare-providers-verify` is today, check
    for existing report at `~/.nimble/memory/reports/healthcare-providers-verify-*[today].md`.
    If found, ask: "Already ran today. Run again for fresh data?"
- No profile -> that's fine. This skill doesn't require onboarding. Proceed to Step 1.

### Step 1: Parse Input + Starting Questions

**Chained-from-sibling shortcut:** Check for same-day extract or enrich output:
```bash
ls ~/.nimble/memory/reports/healthcare-providers-extract-*$(date +%Y-%m-%d).md 2>/dev/null
ls ~/.nimble/memory/reports/hea

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 6 — file references are metadata, not package contents.

View saved version →

---
name: launch-monitor
description: |
  Monitors press, social, developer communities, and competitor channels from any point around
  a product launch — tracking sentiment, flagging mischaracterizations, surfacing competitor
  responses, and recommending actions in real time. Covers press, Reddit, LinkedIn,
  JavaScript-heavy pages, and live community forums, triaging every signal by urgency.
  Delivers a Response War Room dashboard with a live signal feed, mischaracterization tracker,
  competitor response panel, and sentiment velocity chart.

  Use when asked to "monitor this launch", "track the launch", "what's being said about the
  launch", "flag any mischaracterizations", "competitor response to the launch", "post-launch
  coverage", "check press coverage for the launch", or "what's the reaction to the
  announcement".

  Do NOT use for ongoing brand monitoring unrelated to a launch — use brand-mention-monitor
  instead. Do NOT use for ongoing competitor intelligence unrelated to a specific launch
  window — use competitor-intel instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(claude:*)
  - Bash(grep:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.7.0
  category: marketing
---

# Launch Monitor

Monitors press, social, and community forums from launch day — tracking sentiment, flagging mischaracterizations, surfacing competitor responses, and recommending actions so you can respond fast.

---

## Onboarding message

When this skill is triggered for the first time in a session, send this message. Send it exactly once per session, before asking any setup questions. Do not skip it even when the user's opening message already names a product — the onboarding sets expectations for what the skill collects and how it works.

> 👋 **Launch Monitor is ready.**
>
> This skill monitors press, social media, developer communities, and competitor channels around a product launch — tracking sentiment, flagging mischaracterizations, surfacing competitor responses, and telling you exactly what to respond to and how.
>
> To start, just say:
> _"Monitor the launch of [product name]"_
>
> Or try:
> - "Track coverage since we announced [product] yesterday"
> - "What's the reaction to our [product] launch?"
> - "Flag any mischaracterizations in our [product] press coverage"
> - "How are competitors responding to our [product] launch?"
>
> Would you like me to save your preferences so I skip the questions next time?

---

## Preflight

Follow the transport selection and standard preflight from `references/nimble-playbook.md`: pick CLI vs MCP at session start, then run the parallel preflight calls (date, profile, memory index) simultaneously. Tag every Nimble CLI call: `nimble --client-source nimble-agent-skills <subcommand>`.

From the profile (`~/.nimble/business-profile.json`): load product/brand context and `last_runs.launch-monitor` for date windowing. Pre-populate setup questions so the user confirms rather than re-enters. If no profile exists, follow the first-run onboarding flow in `references/profile-and-onboarding.md` and create a stub after the first run.

---

## How to start

**Before asking anything, do two quick research steps:**

**Step A — Resolve alternate names automatically:**
Search for the product the user named to discover all alternate names, codenames, version names, and related search terms. Do not ask the user for this. Use what you find to build a comprehensive search term list for Step 1.
- Search: `"[product name]" official name OR "also known as" OR codename OR version`
- For Apple products, always check for internal codename, model number, and marketing name variants
- For software: check GitHub repo names, API names, and SDK names
- Add all confirmed variants to your search queries silently — the user never needs to see this step

**Step B — Con

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: local-places
description: |
  Discovers, enriches, and scores local businesses in any neighborhood using
  Nimble Web Search Agents (WSAs) and web data. Returns a structured, ranked
  list with confidence scores, reviews, social presence, and an interactive map.

  Use this skill when the user asks about local businesses, places, or
  neighborhood discovery. Common triggers: "find all coffee shops in",
  "map every bar in", "local businesses in", "discover gyms near",
  "what restaurants are in", "neighborhood guide for", "local places in",
  "find places near", "list all [business type] in [area]", "best [type]
  near [location]", "build a neighborhood guide", "local place search".

  Requires the Nimble CLI (nimble extract:templates run, nimble search, nimble extract)
  for live web data via WSAs and fallback search.
  Do NOT use for competitor analysis or monitoring (use competitor-intel),
  company research or deep dives (use company-deep-dive), general web search
  or extraction (use nimble-web-expert).
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Bash(open:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: productivity
---

# Local Places

Location intelligence powered by Nimble Web Search Agents and web data APIs.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

Also simultaneously:
- `mkdir -p ~/.nimble/memory/{reports,local-places/checkpoints}`
- Check for existing checkpoints: `ls ~/.nimble/memory/local-places/checkpoints/ 2>/dev/null`

From the results:
- CLI missing or API key unset -> `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists -> note the user's location preferences if any. Determine mode
  using smart date windowing from `references/nimble-playbook.md`:
  - **Full mode:** first run OR last run > 14 days ago
  - **Quick refresh:** last run < 14 days ago (skip social enrichment, reviews only
    for new places)
  - **Same-day repeat:** if `last_runs.local-places` is today, check if a report
    already exists at `~/.nimble/memory/reports/local-places-*[today].md`. If so,
    ask: "Already ran today for this area. Run again for fresh data?" Don't silently
    re-run.
  - Skip to Step 1
- No profile -> that's fine. Local places doesn't require onboarding. Proceed to Step 1.

### Step 1: Parse Request & Starting Questions

Parse `$ARGUMENTS` for place type and location. Extract:

| Field | Required | Source |
|-------|----------|--------|
| Place type | Yes | User input ("coffee shops", "gyms", "restaurants") |
| Location | Yes | User input ("Williamsburg", "downtown Austin", "Park Slope") |
| Filters | Optional | User input ("with good reviews", "open late", "cheap") |
| Output preference | Optional | User input ("map", "list", "guide") |

**If both place type and location are clear** from `$ARGUMENTS`, confirm briefly and
proceed: "Searching for **coffee shops** in **Williamsburg, Brooklyn**..."

**If partial or ambiguous**, ask one combined question in plain text:

> "What type of places are you looking for, and where? (e.g., 'coffee shops in
> Williamsburg' or 'gyms near downtown Austin')"

**If the user provided both but you want to scope further**, use AskUserQuestion
(counts as 1 of max 2 prompts):

> *

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.

View saved version →

---
name: market-finder
description: |
  Discovers all businesses of a given type in any geography using Nimble
  WSAs. Two modes: Discovery finds businesses from scratch; Audit compares
  a user's existing list (Google Sheet, CSV, inline) against fresh
  discovery, categorizing entries as matched, discovered-only, or
  reference-only. Vertical presets (Healthcare, SaaS, Restaurants, Legal,
  Auto/Home) auto-select WSA routing.

  Triggers: "find all X in Y", "build a list of", "market sizing",
  "account universe", "how many X in Y", "TAM for", "discover all",
  "audit my list", "compare against", "what am I missing", "gap analysis",
  "verify my business list", "prospect list".

  Do NOT use for competitor monitoring — use competitor-intel instead.
  Do NOT use for company deep dives — use company-deep-dive instead.
  Do NOT use for neighborhood-level exploration with social enrichment
  — use local-places instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: business-research
---

# Market Finder

Market intelligence powered by Nimble Web Search Agents.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

Also simultaneously:
- `mkdir -p ~/.nimble/memory/{reports,market-finder/checkpoints}`
- Check for existing checkpoints: `ls ~/.nimble/memory/market-finder/checkpoints/ 2>/dev/null`

From the results:
- CLI missing or API key unset -> `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists -> note industry keywords if any. Apply smart date windowing from
  `references/nimble-playbook.md`. Market-finder tweak: in quick refresh mode,
  skip enrichment and only discover new metros.
- No profile -> fine. Market-finder doesn't require onboarding. Proceed to Step 1.

### Step 1: Parse Request & Detect Mode

Parse `$ARGUMENTS` for business type, geography, qualifiers, and **mode detection**.

#### Mode detection

Check `$ARGUMENTS` for a reference list. Read `references/audit-mode.md` for the
full detection signals and parsing rules.

| Signal | Mode |
|--------|------|
| Google Sheet URL, CSV path, or inline list of 3+ businesses | **Audit** |
| Explicit audit language ("audit my list", "compare against", "gap analysis") | **Audit** |
| No reference list provided | **Discovery** (default) |

If a reference list is present but intent is ambiguous, ask: "Want me to **audit**
your list against fresh discovery, or use it as a starting point?"

If audit language is detected but no reference list is provided, ask: "You mentioned
auditing — please provide your list (Google Sheet URL, CSV file path, or paste inline)."
Do not proceed with Audit mode until a reference list is received.

#### Extract fields

| Field | Required | Source |
|-------|----------|--------|
| Business type / vertical | Yes | User input ("dentists", "SaaS CRM tools") |
| Geography | Yes (except SaaS) | User input ("Florida", "Austin TX", "nationwide") |
| Reference list | Audit mode only | Google Sheet URL, CSV path, or inline |
| Qualification criteria | Optional | User input ("must have website", "10+ reviews") |
| Output preference | Optional | User input ("quick summary", "full dataset") |

**If both type and geography are clear** from

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

View saved version →

---
name: meeting-prep
description: |
  Researches meeting attendees and their companies before any meeting using
  real-time web data. Surfaces roles, recent activity, company context, and
  talking points — then maps cross-attendee relationships.

  Use this skill when the user asks to prepare for a meeting, research someone
  they're meeting, or wants context on attendees. Common triggers: "prepare me
  for my meeting", "who am I meeting with", "research this person", "meeting
  prep", "brief me on [person]", "I have a meeting with [person/company]",
  "get me ready for my call", "what should I know about [person]",
  "background on [person] before our meeting", "attendee research".

  Requires the Nimble CLI (nimble search, nimble extract) for live web data.
  Do NOT use for multi-company competitor monitoring (use competitor-intel)
  or single-company deep dives without attendees (use company-deep-dive).
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: productivity
---

# Meeting Prep

Research-powered meeting preparation with attendee intelligence and company context.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

From the results:
- CLI missing or API key unset → `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists → read `~/.nimble/memory/people/index.md` to identify existing
  person profiles. Load relevant `~/.nimble/memory/people/` files for attendees
  before — skip redundant searches, surface prior meeting notes. Follow
  `[[path/entity]]` cross-references in person files: if an attendee's file links
  to `[[competitors/widgetco]]`, load that competitor file for richer context (e.g.,
  recent intel from competitor-intel runs). Also check `~/.nimble/memory/companies/`
  for cached company research.
  **No same-day report check** — meeting-prep is per-meeting, not per-day. Users
  may prep for multiple meetings in one day. Instead, check entity freshness:
  if a person/company profile was updated within the last 24 hours, offer to reuse
  it: "I have a recent profile for **[Name]** from earlier today. Use it, or refresh?"
- No profile → that's fine. Meeting prep doesn't require onboarding. Proceed to Step 1.

### Step 1: Gather Meeting Context

Parse the meeting details from `$ARGUMENTS` or ask the user.

**Calendar shortcut:** If the user didn't specify attendees and a calendar connector
is available — either a calendar MCP tool (look for `list_events` in the tool list)
or the `gws` CLI (`gws calendar +agenda --today`) — offer to pull today's meetings
so they can pick one. If neither is available, skip this silently.

**If clear** (e.g., "prep me for my meeting with Alex Kim at WidgetCo tomorrow"):
- Extract: attendee name(s), company, meeting date/time (if given)
- Confirm briefly: "Preparing briefing for your meeting with **Alex Kim** at **WidgetCo**..."

**If partial** (e.g., "prep me for my meeting tomorrow"):
- Ask one clarifying question in plain text:
  > "Who are you meeting with? (names, titles, and company if you have them)"

**If just a person** (e.g., "research John Smith"):
- Proceed with the person. Try to infer their company from search results.

**Extract these fields:*

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 4 — file references are metadata, not package contents.

View saved version →

---
name: nimble-databricks-data-products
description: |
  Builds Databricks data products from live web data, end to end: discovers the right Nimble
  web-data agents, scrapes into Delta tables, and produces an AI/BI dashboard and/or a deployed
  Databricks App — a table → dashboard → app workflow, for production data products or quick demos.
  Use whenever a request pairs live or scraped web data WITH a Databricks destination — e.g. "scrape
  Amazon/Walmart prices into a Delta table and build a dashboard", "load Zillow/Instagram/Maps/search
  results into Databricks and build a dashboard or app", "showcase Nimble + Databricks to a prospect".
  Prefer it over nimble-web-expert or competitor-intel when the data lands in Databricks. Do NOT use
  for one-off web fetches or CSV exports with no Databricks destination — use nimble-web-expert
  instead. Do NOT use for competitor or company research briefings — use competitor-intel or
  company-deep-dive instead. Do NOT use for generic Databricks work with no Nimble/web-data angle —
  use the official databricks-* skills instead.
allowed-tools:
  - Bash(databricks:*)
  - Bash(python3:*)
  - Bash(bash:*)
  - Bash(jq:*)
  - Bash(npm:*)
  - Read
  - Write
  - Edit
  - AskUserQuestion
  - Skill
metadata:
  author: Nimbleway
  version: 1.6.1
  category: data-platforms
---

# Nimble on Databricks — data products builder

Turn a natural-language brief like
`pricing analysis on dog products from walmart and amazon` into working Databricks data products:
**discover agents → ingest live web search data into Delta → build dashboard and/or app → deliver links.**
Equally at home for a quick demo or a real, reusable data product.

You are the orchestrator. Databricks mechanics are delegated to the official `databricks-*`
skills (see `references/databricks-skills.md`); this skill owns the **Nimble glue and the gaps**
(agent discovery, ingestion-from-agents, the AI/BI dashboard JSON, branding).

## Golden rules

- **Discover, don't assume.** Read agent names via `nimble_agent_list()`, input params via
  `nimble_agent_describe('<agent>')`, and output fields by probing one call (`to_json(parsing[0])`) —
  never hardcode from memory (Amazon search takes `keyword`, not `query`).
- **Probe before fanning out.** Run one call per source first to learn its localization flag, field
  names, and value formats — sources differ (some return numeric prices, others currency strings).
- **One statement per Statements API call.** Multiple `;`-separated statements in one call are a parse error.
- **Each Bash call is a fresh shell.** Env vars and `cd` don't persist — set them inline. See `references/preflight.md`.
- **Fail fast, then confirm.** Run Phase 0 preflight first; recommend a warehouse + writable schema, then confirm before writing.
- **Always ask the deliverable.** Table / +dashboard / +app is a per-run choice.
- **Branding is always on, neutral.** "Powered by Nimble" + light theme + yellow accent. See `references/branding.md`.
- **Leave artifacts in place.** No teardown.
- **Show your work and the headline.** End with URLs and the one-sentence insight (e.g. the price gap).

## Workflow

Track these as todos so nothing is skipped.

### Phase 0 — Preflight (read-only, fail fast)
Lean on the **`databricks-core`** skill for the generic checks.
1. `databricks current-user me` → confirm auth; capture the username (for the default schema).
2. Find a **RUNNING** SQL warehouse: `databricks warehouses list`. Prefer one already RUNNING; if none, offer to start one.
3. **Integration gate** — confirm these exist:
   `nimble_integration.tools.{nimble_search, nimble_extract, nimble_agent_run, nimble_agent_list, nimble_agent_describe}`.
   Quick check: `databricks functions list nimble_integration tools`.
   **If missing → STOP** and walk the user through `references/install-nimble-integration.md`
   (Nimble cookbook). Do not try to auto-install.
4. **Recommend + confirm** the target: a warehouse and a writable `catalog.s

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 10 — file references are metadata, not package contents.

View saved version →

---
name: nimble-web-expert
description: |
  Get web data now — fast, incremental, immediately responsive to what the user needs.
  The only way Claude can access live websites.

  USE FOR:
  - Fetching any URL or reading any webpage
  - Scraping prices, listings, reviews, jobs, stats, docs from any site
  - Running Extraction Templates — reusable, site-specific structured scrapers
  - Running Web Search Agents — open-ended research, enrichment, and dataset building with citations
  - Discovering URLs on a site before bulk extraction
  - Calling public REST/XHR API endpoints
  - Web search and research (8 focus modes)
  - Bulk crawling website sections

  Must be pre-installed and authenticated. Run `nimble --version` to verify (>= 1.2.0).
allowed-tools:
  - Bash(nimble:*)
  - Bash(claude:*)
  - Bash(mkdir:*)
  - Bash(cat:*)
  - Bash(head:*)
  - Bash(ls:*)
  - Bash(grep:*)
  - Bash(echo:*)
  - Bash(python3:*)
  - Bash(uv:*)
  - Bash(npm:*)
  - Bash(open:*)
  - Bash(export:*)
  - Bash(wait:*)
  # MCP fallback (used when shell isn't available — Cowork, IDE-only hosts):
  - mcp__plugin_nimble_nimble__nimble_search
  - mcp__plugin_nimble_nimble__nimble_extract
  - mcp__plugin_nimble_nimble__nimble_extract_async
  - mcp__plugin_nimble_nimble__nimble_map
  - mcp__plugin_nimble_nimble__nimble_crawl_run
  - mcp__plugin_nimble_nimble__nimble_crawl_status
  - mcp__plugin_nimble_nimble__nimble_crawl_list
  - mcp__plugin_nimble_nimble__nimble_crawl_terminate
  - mcp__plugin_nimble_nimble__nimble_task_results
  - mcp__plugin_nimble_nimble__nimble_extract_templates_list
  - mcp__plugin_nimble_nimble__nimble_extract_templates_get
  - mcp__plugin_nimble_nimble__nimble_extract_templates_run
  - mcp__plugin_nimble_nimble__nimble_extract_templates_run_async
  - mcp__plugin_nimble_nimble__nimble_agents_list
  - mcp__plugin_nimble_nimble__nimble_agents_get
  - mcp__plugin_nimble_nimble__nimble_agent_templates_list
  - mcp__plugin_nimble_nimble__nimble_agent_templates_get
  - mcp__plugin_nimble_nimble__nimble_agents_run
  - mcp__plugin_nimble_nimble__nimble_agents_run_status
  - mcp__plugin_nimble_nimble__nimble_agents_run_result
  - mcp__plugin_nimble_nimble__nimble_agents_runs_list
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Task
  - AskUserQuestion
license: MIT
metadata:
  version: 1.7.0
  author: Nimbleway
  repository: https://github.com/Nimbleway/agent-skills
  category: web-search-tools
---

# Nimble Web Expert

Web extraction, search, and URL discovery using the Nimble CLI. Returns clean structured data from any website.

User request: $ARGUMENTS

## Core principles

- **Route by intent first** (see [Analyze & Route](#analyze--route) for the full decision model). Named site with a matching Extraction Template + a direct item to look up → run the template. Site with no template, or a need that requires discovery/reasoning across pages → a Web Search Agent. One-off single URL → `nimble extract`. Raw results to work from ("find pages/articles about…") → `nimble search`; a synthesized deliverable (report, brief, comparison, recommendation) → a Web Search Agent. Discover/crawl URLs → `nimble map` or `nimble crawl`.
- **Web Search Agent runs: pick a run mode before building the command.** Default to named create-or-reuse — `nimble agents run --agent-name <stable-name>` — so a repeat session lands on the same agent. `agents:runs create` is the explicit-agent-ID route only and requires `--agent-id`. `references/nimble-agents/reference.md` has the mode table, `use_case` locking, and the one-time `skill` override.
- **One command → present results → done.** Run once, show the data immediately as a table. Do NOT experiment, loop, or write Python to parse output.
- **Multiple inputs → always parallel.** 2+ URLs/keywords/ASINs → `&`+`wait`. 6–20 → `xargs -P`. 20+ → Python asyncio script. See `references/batch-patterns.md`.
- **Escalate render tiers silently on empty or truncated content.** Tier 1 → 2 → 3 → … without asking. Surface a decision only

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 19 — file references are metadata, not package contents.

View saved version →

---
name: seo-intel
description: |
  SEO intelligence toolkit covering the full lifecycle via live web data:
  keyword research, rank tracking, site audits, content gap analysis,
  competitor keyword reverse-engineering, AI visibility across five platforms
  (ChatGPT, Perplexity, Google AI, Gemini, Grok), and GitHub repo SEO.
  Crawls real sites and SERPs via Nimble CLI — no fabricated metrics.

  Triggers: "SEO", "keywords", "rank tracker", "site audit", "content gap",
  "competitor keywords", "AI visibility", "GitHub SEO", "SERP analysis",
  "keyword research", "technical SEO", "keyword difficulty", "topic
  clusters", "ranking delta", "on-page SEO", "AI citation audit".

  Do NOT use for competitor business signals — use `competitor-intel`
  instead. Do NOT use for competitor messaging — use
  `competitor-positioning` instead. Do NOT use for general web scraping
  — use `nimble-web-expert` instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Bash(gh:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: seo
---

# SEO Intelligence Toolkit

All-in-one SEO intelligence: keyword discovery, rank tracking, technical audits,
content gaps, competitor analysis, AI visibility, and GitHub SEO.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).
Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.

---

## Workflow Router

Detect the user's SEO intent from `$ARGUMENTS` and route to the appropriate
workflow. If the intent is ambiguous or generic ("help me with SEO"), ask which
workflow to run.

### Available Workflows

| Workflow | Triggers | Reference |
|----------|----------|-----------|
| **Keyword Research** | keyword opportunities, topic clusters, difficulty, what to rank for | `references/wf-keyword-research.md` |
| **Rank Tracker** | track rankings, keyword positions, ranking delta, position check | `references/wf-rank-tracker.md` |
| **Site Audit** | SEO audit, technical SEO, meta tags, schema, crawl for issues, CWV | `references/wf-site-audit.md` |
| **Content Gap** | content gap, keyword gap, compare coverage, missing topics | `references/wf-content-gap.md` |
| **Competitor Keywords** | competitor keywords, reverse-engineer SEO, competitor title tags | `references/wf-competitor-keywords.md` |
| **AI Visibility** | AI visibility, ChatGPT presence, Perplexity, AI Overview, GEO | `references/wf-ai-visibility.md` |
| **GitHub SEO** | github seo, repo discoverability, optimize readme, repo audit | `references/wf-github-seo.md` |

### Intent Detection

Map the request to one workflow:

- **Keywords / topics / difficulty / clusters / "what to rank for"** → Keyword Research
- **Rankings / positions / tracking / delta / monitoring** → Rank Tracker
- **Audit / crawl / technical / meta / schema / links / CWV** → Site Audit
- **Gap / missing topics / coverage comparison / "what should I write"** → Content Gap
- **Competitor site crawl / reverse-engineer / on-page at scale** → Competitor Keywords
- **AI visibility / ChatGPT / Perplexity / AI Overview / GEO** → AI Visibility
- **GitHub / repo / README / discoverability** → GitHub SEO

If unclear, present the options with AskUserQuestion:

> Which SEO workflow should I run?
> - **Keyword Research** — discover keyword opportunities and topic clusters
> - **Rank Tracker** — check and track keyword positions over time
> - **Site Audit** — full technical SEO crawl with JS rendering
> - **Content Gap** — compare content coverage against competitors
> - **Competitor Keywords** — reverse-engineer competitor on-page SEO at scale
> - **AI 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 19 — file references are metadata, not package contents.

View saved version →

---
name: talent-sourcing
description: |
  Finds qualified candidates for a role by searching LinkedIn, Indeed, GitHub,
  and other professional platforms using Nimble Web Search Agents. Accepts a
  job description, role title, or freeform request and returns a ranked
  candidate list with profiles, skills, and contact signals.

  Use this skill when the user wants to find, source, or recruit candidates for
  a role. Common triggers: "find candidates for", "source engineers in",
  "who can I hire for", "find me a [role]", "recruiting for", "talent search",
  "find a [role] in [city]", "build a candidate list", "sourcing for [role]",
  "who's available for", "find potential hires". Also triggers on a pasted job
  description followed by a sourcing request.

  Do NOT use for job market research or salary benchmarking — use
  market-finder instead. Do NOT use for researching a single known person
  — use company-deep-dive or meeting-prep instead.
allowed-tools:
  - Bash(nimble:*)
  - Bash(date:*)
  - Bash(cat:*)
  - Bash(mkdir:*)
  - Bash(python3:*)
  - Bash(echo:*)
  - Bash(jq:*)
  - Bash(ls:*)
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Agent
  - AskUserQuestion
metadata:
  author: Nimbleway
  version: 1.6.1
  category: human-resources
---

# Talent Sourcing

Candidate discovery powered by Nimble Web Search Agents.

User request: $ARGUMENTS

**Before running any commands**, read `references/nimble-playbook.md` for Claude Code
constraints (no shell state, no `&`/`wait`, sub-agent permissions, communication style).

---

## Instructions

### Step 0: Preflight

Follow the transport selection + standard preflight from `references/nimble-playbook.md` — pick CLI or MCP at session start, then run the standard preflight calls (date calc, today, profile, memory index) in parallel.

Also simultaneously:
- `mkdir -p ~/.nimble/memory/{reports,talent-sourcing}`

From the results:
- CLI missing or API key unset → read `references/profile-and-onboarding.md`, stop
- Tag all `nimble` CLI calls: `nimble --client-source nimble-agent-skills <subcommand>`. MCP requests are attributed at the transport level — see `references/nimble-playbook.md`.
- Profile exists → note industry keywords if any; proceed to Step 1
- No profile → fine, talent-sourcing doesn't require onboarding; proceed to Step 1

### Step 1: Parse Request & Confirm Search Parameters

Parse `$ARGUMENTS` for:
- **Role** — job title or function (e.g. "Senior React Engineer", "Head of Sales")
- **Location** — city, metro, region, or remote (e.g. "New York City", "remote US")
- **Skills / requirements** — specific technologies, years of experience, domain expertise
- **Seniority** — junior, mid, senior, staff, director, VP, C-level
- **Source preference** — specific platforms (LinkedIn, GitHub, Indeed, etc.) or "all"

If a full job description was pasted, extract the above fields from it.

If **role** is missing or ambiguous, ask with `AskUserQuestion`:

> "What role are you hiring for, and where? (e.g. 'Senior ML Engineer, remote US'
> or paste a job description)"

Once parameters are clear, confirm with the user using `AskUserQuestion`:

> "Searching for: **[Role]** | Location: **[Location]** | Key skills: **[Skills]**
> | Seniority: **[Seniority]**
>
> Platforms to search: LinkedIn, Indeed, GitHub (for technical roles), AngelList /
> Wellfound, and professional communities.
>
> - **Start search**
> - **Adjust parameters first**"

### Step 2: WSA Discovery

Discover available Web Search Agents for candidate-sourcing platforms. Run
simultaneously:

```bash
nimble extract:templates list --limit 100  # then filter items for "linkedin people"
nimble extract:templates list --limit 100  # then filter items for "indeed resume"
nimble extract:templates list --limit 100  # then filter items for "github profile"
nimble extract:templates list --limit 100  # then filter items for "wellfound talent"
```

Filter results for `entity_type: SERP` or `entity_type: PDP`. Prefer
`managed_by: "nimble"`

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.