radar-scan

name	radar-scan
description	Scan external sources for AI tools, features, and techniques. Builds a discovery catalogue from dependency changelogs, HN (targeted + firehose), GitHub, YouTube, a people-to-watch list, and your inbox.

Radar Scan — Discovery Catalogue Builder

Build and maintain a catalogue of AI tools, features, and techniques from external sources.

This skill is self-contained — it does not depend on or use the Open Brain plugin, ai-brain MCP, or any external memory service.

Arguments

• $ARGUMENTS — Optional:
  • --sources <all|feeds|manual> — Which sources to scan (default: all)
  • --days N — How far back to look in time-based sources (default: 7)

Parse from $ARGUMENTS if provided. Default to --sources all --days 7.

Workflow

Step 1: Load or Initialize Catalogue

Read ~/.claude/radar/catalogue.json. If it doesn't exist:

1. Check for legacy paths and migrate if found:
   • ~/.claude/radar-catalogue.json or ~/.claude/scout-catalogue.json
   • Read the legacy file. If it uses the old schema ({ "lists": { "[Radar] ...": { "items": [...] } } }), transform it: flatten all items from all lists into a single items array, map each item's fields to the new schema (add id, status: "reviewed", notes: [], score: null, scoreBreakdown: null, reviewedAt: null, lastRecommended: null), and wrap in the new structure: { "version": "1.0", "updatedAt": "<now>", "items": [...], "insights": [] }.
   • If the legacy file already uses the new flat schema, move it directly.
   • Write the result to ~/.claude/radar/catalogue.json. Delete the legacy file after successful migration.
2. If no legacy file exists, initialize with empty structure:

{
  "version": "1.0",
  "updatedAt": null,
  "items": [],
  "insights": []
}

Create the ~/.claude/radar/ directory if it doesn't exist.

Build a set of known URLs from existing items for deduplication.

Step 2: Scan Project Dependencies

Run node "${CLAUDE_PLUGIN_ROOT}/bin/workflow-analyzer/dist/cli.js" scan-deps --since ${DAYS} --output /tmp/workflow-analyzer-deps.json. Read the output JSON. If the bundled binary is not available, fall back to npx @flippyhead/workflow-analyzer@latest scan-deps --since ${DAYS} --output /tmp/workflow-analyzer-deps.json.

If the command fails or is not available, log a warning and skip to Step 3 — dependency scanning is additive, not required.

If GITHUB_TOKEN is not set in the environment and the scan-deps output shows rateLimited > 0, print: "GitHub API rate limited — scanned [reposResolved] of [packageCount] dependencies. Set GITHUB_TOKEN for full scanning."

For each entry in the releases array:

1. Read the release.body (release notes) and repoDescription to assess relevance
2. Skip routine releases: patch version bumps, typo fixes, minor dep updates, internal refactors, CI/CD changes, documentation-only releases
3. Catalogue interesting releases: new CLI tools, MCP servers/integrations, AI/agent features, breaking changes, significant new APIs, performance improvements
4. Create catalogue items using the standard enrichment from Step 5, with source: "dependency" and tag "direct-dependency"
5. Use the release.url as the item URL for deduplication against existing catalogue

Step 3: Scan Structured Sources

Skip this step if --sources manual was specified.

Limit to 10-15 items per source after dedup/merge, where "per source" means: across all Anthropic changelog/blog entries combined, across all HN targeted queries combined, across all firehose queries combined, across all GitHub queries combined, across all YouTube queries combined, and across the entire watchlist loop combined (not per handle). When trimming to the cap: for HN, keep highest points; for repos/gists, keep most recently updated; for YouTube and Anthropic, keep most recent.

If a source fails (timeout, rate limit, format change), log a warning and continue to the next source — never fail the entire run.

When a source fails, print a clear one-line message: "Source [name] unavailable: [reason]. Continuing with remaining sources."

Anthropic changelog/blog: Use WebFetch on https://docs.anthropic.com/en/docs/about-claude/models and https://www.anthropic.com/news to find recent releases and feature announcements. Extract title, URL, and a one-line description for each.

Hacker News — targeted queries (5+ points): Use WebFetch on the Algolia API. Extract title, URL (use url field, fall back to HN comment URL), and points. Keep items with 5+ points.

• https://hn.algolia.com/api/v1/search_by_date?query=claude+code&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}
• https://hn.algolia.com/api/v1/search_by_date?query=anthropic+mcp&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}
• https://hn.algolia.com/api/v1/search_by_date?query=ai+agent+tool&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}
• https://hn.algolia.com/api/v1/search_by_date?query=llm+technique&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}
• https://hn.algolia.com/api/v1/search_by_date?query=prompt+engineering&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}
• https://hn.algolia.com/api/v1/search_by_date?query=%22show+hn%22+llm&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP}

Hacker News — firehose (high-point floor): Safety net for high-signal AI stories that don't match targeted queries (e.g. a viral LLM technique gist). Pull broad AI stories with a point floor of 100+:

• https://hn.algolia.com/api/v1/search_by_date?query=llm&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP},points>=100
• https://hn.algolia.com/api/v1/search_by_date?query=ai&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP},points>=100

Apply the same extraction as the targeted queries. Deduplicate by URL against the targeted-query results within this run. Dedup merge rule: when the same URL surfaces from multiple paths (firehose + targeted, watchlist + HN, etc.), keep the first-seen source but append every additional discovery path to the item's notes array so provenance isn't lost (see watchlist note format below). Apply this same merge rule to cross-source dedup at the end of Step 3.

People to Watch: High-signal voices in the LLM/agent space whose work often surfaces new patterns before broader discovery. Scan their recent output directly, independent of keyword queries.

Load the watchlist:

1. Check for ~/.claude/radar/watchlist.json. If present, use its handles array.
2. Otherwise use this seed list: ["karpathy", "simonw", "jxnl", "hwchase17", "anthropics"].

For each handle:

1. WebFetch https://gist.github.com/{handle} — parse the page for recently published gists (title + URL + date). Skip if older than ${DAYS} days.
2. WebFetch https://github.com/{handle}?tab=repositories&sort=updated — parse for repos updated within ${DAYS} days.
3. WebFetch https://hn.algolia.com/api/v1/search_by_date?query={handle}&tags=story&numericFilters=created_at_i>${DAYS_AGO_TIMESTAMP} — stories mentioning the handle (1+ point; known names are already high-signal).

Items discovered this way carry the natural source of their origin URL (github for gists/repos, hackernews for HN stories). Record the discovery path by appending { "type": "watchlist", "handle": "{handle}", "at": "<ISO timestamp>" } to the item's notes array. Do not inject watchlist provenance into tags — tags is reserved for the 3–5 workflow/goal descriptors produced by the enrichment subagent and is consumed by downstream scoring prompts (see radar-recommend).

If a handle returns no recent activity or a fetch fails, log one line and continue — never fail the run.

GitHub: Use WebSearch for:

• "new MCP server" site:github.com (last N days)
• "claude code plugin" site:github.com (last N days)

Extract repo name, URL, and description.

YouTube: Use WebSearch for:

• "claude code tutorial" (last N days)
• "anthropic MCP" tutorial (last N days)

Extract video title, URL, and channel name.

For each result across all sources: skip if the URL already exists in the catalogue (deduplication).

Also deduplicate across sources within this run — if the same URL was found by both HN and GitHub in this run, only catalogue it once.

Step 4: Process Manual Inbox Items

Skip this step if --sources feeds was specified.

Look for items in the catalogue with source: "manual" and status: "new". For each:

1. If the item has a URL, use WebFetch to get the page content
2. Summarize what it is and why it might be useful (1-2 sentences) — update description
3. Classify it (see Step 5 for category/tag schema)
4. Update category and tags on the existing item
5. Set status: "reviewed" and reviewedAt to now

Step 5: Enrich and Tag (dispatch to Haiku subagents)

The main loop has now gathered a list of candidates — { title, url, source, discoveredAt, rawContext, notes } objects from Step 2 (dependency releases) and Step 3 (structured sources). The notes array carries any provenance accumulated during discovery (watchlist entries, dedup merge paths); it may be empty. Triage (deciding whether something is worth cataloguing at all) has already happened in those steps. The work remaining — picking a category, generating tags, and writing a 1-2 sentence description — is formulaic and per-item, so dispatch it to Haiku subagents.

(Step 4 handles a different case: it processes existing manual inbox items already in the catalogue, updating them in place. Step 4 can use the same subagent pattern if desired — same prompt template, same return shape — but the main loop writes the result back onto the existing item rather than creating a new one.)

For each candidate, dispatch one subagent call. Send multiple Agent tool calls in a single assistant turn so they run in parallel. Use:

Agent({
  subagent_type: "general-purpose",
  model: "haiku",
  description: "Enrich catalogue item",
  prompt: <see template below>,
})

Subagent prompt template:

You are enriching one item for a discovery catalogue. Return a single JSON object with keys category, tags, description. No prose around the JSON.

Item:

• Title: <title>
• URL: <url>
• Source: <source> (one of: anthropic, hackernews, github, youtube, manual, dependency)
• Raw context: <release notes / HN snippet / repo description / fetched page text — whatever the main loop gathered>

Rules:

• category must be exactly one of: claude-code, mcp, api, agent-sdk, prompting, tooling, workflow, general-ai.
  • claude-code — Claude Code features, settings, shortcuts, plugins
  • mcp — MCP servers, protocols, integrations
  • api — Claude API features, SDK updates
  • agent-sdk — Agent building tools and frameworks
  • prompting — Prompting techniques, system prompts, skill design
  • tooling — Developer tools, CLI utilities, browser extensions
  • workflow — Workflow patterns, automation techniques, productivity methods
  • general-ai — Broader AI developments, models, research
• tags must be an array of 3-5 short free-text strings describing workflows or goals this helps with (e.g. ["debugging", "agent-loop", "ci-automation"]).
• description must be 1-2 sentences summarizing what it is and why someone building with Claude Code might care. No hype, no marketing copy.

Respond with ONLY the JSON object. Do not include any explanation before or after.

Once all subagents return, the main loop assembles each final item with the canonical schema:

{
  "id": "<first 12 chars of SHA-256 hash of the URL>",
  "title": "...",
  "url": "...",
  "description": "<from subagent>",
  "category": "<from subagent>",
  "tags": ["<from subagent>"],
  "source": "<one of: anthropic, hackernews, github, youtube, manual, dependency>",
  "discoveredAt": "<ISO date>",
  "status": "new",
  "notes": "<candidate.notes from Step 3 — provenance accumulated during discovery (watchlist entries, dedup merge paths), or [] if none>",
  "score": null,
  "scoreBreakdown": null,
  "reviewedAt": null,
  "lastRecommended": null
}

If a subagent response is malformed (not parseable JSON, category not in vocabulary, tags not an array), fall back to main-loop enrichment for that one item — do not drop it. Log a one-line warning: "Enrichment fallback for : <reason>".

Append each new item to the catalogue's items array. Update updatedAt to now. Write the catalogue back to ~/.claude/radar/catalogue.json.

Step 6: Report

Output a brief terminal summary:

• How many new items were catalogued, by source
• How many inbox items were processed
• How many duplicates were skipped
• The 3-5 most notable new finds (title + one-line description)
• Total catalogue size