Skip to main content
Captures capability gaps as they occur. When Claude hits a wall — can’t fetch a URL, can’t read a database, can’t access a repo — it logs exactly what was needed and why, rather than just saying “I can’t.” Over time this builds a prioritised integration roadmap written by the agent itself. Use this skill when you want to track integration needs, record where Claude hits walls, or build a roadmap from blocked requests.

​
Two modes

Capture mode

Activated at the start of a session. Logs every capability gap to a JSONL file as work proceeds. Claude continues all tasks normally — the only change is that every “I can’t” also writes a structured log entry.

Review mode

Summarises an existing gap log into a ranked integration roadmap. Groups gaps by capability type, scores by frequency and impact, and outputs the highest-leverage integrations to build first.

​
Invocation

/magic-fetch
With a custom log path: 
/magic-fetch ./logs/gaps.jsonl
Review mode (summarise an existing log): 
/magic-fetch review ./magic-fetch.jsonl
The default log file is ./magic-fetch.jsonl in the current working directory.

​
Capture mode workflow

1

Activate

Confirm the log file path (default: ./magic-fetch.jsonl). Create it if it doesn’t exist. Claude announces: Magic fetch active. I'll log every capability gap to {path}.
2

Proceed normally

Claude carries out all tasks as usual. The only change is that every capability gap now also writes a log entry. No tasks are blocked or deferred.
3

Log every gap

Whenever Claude cannot perform a requested action due to a missing tool, access, data, or permission, it appends one JSON entry to the JSONL file before or alongside explaining the limitation.Each entry contains:
FieldDescription
tsISO 8601 timestamp
session_taskWhat the user was trying to accomplish
requestedThe specific action Claude attempted
missingThe exact capability, data, or permission that was absent
capability_typeCategory (see below)
would_needConcrete solution: MCP server name, API name, permission scope
impacthigh / medium / low — how much this blocked the user’s goal
notesOptional context about frequency, workarounds, priority signals
After writing, Claude outputs inline: [gap logged: {would_need} — {capability_type}]
4

Never skip a gap

If Claude said “I can’t”, “I don’t have access”, “I’m unable to”, or “I don’t know the current…”, a log entry is required. No exceptions — including cases where Claude silently worked around a gap by asking the user to paste something in.

​
Capability types

Every gap entry is assigned exactly one of these capability_type values:
TypeExamples
code_repositoryGitHub, GitLab, Bitbucket: PRs, commits, branches, issues
code_executionRunning code in a remote env, container, or specific runtime
external_apiAny third-party API (Datadog, Sentry, Stripe, Slack, etc.)
file_systemFiles outside the working directory, remote paths, cloud storage
databaseQuerying a database, data warehouse, or cache
observabilityMetrics, logs, traces, dashboards (Grafana, Datadog, etc.)
web_fetchFetching a URL, scraping a page, calling a public endpoint
authenticationCredentials, secrets, tokens, OAuth flows
internal_toolCompany-internal system with no public API
realtime_dataLive data: stock prices, weather, current status, deploys
human_approvalRequires a human decision or sign-off
otherAnything that doesn’t fit above

​
Gap log format

Each gap is one line of JSONL (newline-delimited JSON): 
{
  "ts": "2026-03-08T14:23:01Z",
  "session_task": "Review the open PRs for the auth service",
  "requested": "List open pull requests for github.com/acme/auth-service",
  "missing": "GitHub API access — no tool available to query repository PRs",
  "capability_type": "code_repository",
  "would_need": "GitHub MCP server or PAT with repo:read scope",
  "impact": "high",
  "notes": "User would use this constantly — almost every debugging session involves PRs"
}

​
Review mode workflow

1

Load and parse the log

Read the JSONL file line by line. If the file is empty or missing, inform the user no gaps have been captured yet.
2

Cluster by capability type

Group all entries by capability_type. Count frequency per type. Within each cluster, collect all unique would_need values.
3

Score by frequency and impact

For each capability_type cluster, compute a priority score:
score = (high_count × 3) + (medium_count × 1) + (low_count × 0)
Sort clusters descending by score.
4

Output the roadmap

Produce a ranked table of integrations followed by per-integration details (top 5, or all if ≤10 total):
RankIntegrationTypeGaps loggedImpactExample use case
1GitHub MCP servercode_repository128 high, 4 medList open PRs, view commits
2Datadog MCP serverobservability87 high, 1 lowError rates, service latency
Each integration detail includes: gap count, sessions affected, specific actions that were blocked, a concrete install path, and estimated complexity (low / medium / high).

​
Self-review checklist

Before delivering, verify all of the following:
  • Log file path was confirmed with the user or defaulted to ./magic-fetch.jsonl
  • Every gap entry contains: ts, session_task, requested, missing, capability_type, would_need, impact
  • No gap was silently dropped — every “I can’t” has a corresponding log entry
  • [gap logged: ...] confirmation shown for each entry
  • Review mode produces a ranked table, not a raw log dump
  • Review mode ends with: “Based on X gaps across Y sessions, the highest-leverage first integration is: Z.”

​
Golden rules

Write the gap entry to the file before or alongside telling the user you can’t do something. Never explain first and forget to log.
“No internet access” is useless. “GitHub API access to list commits for repo X” is useful. Every entry must name the specific data, endpoint, or permission needed.
The log must capture what the user was trying to accomplish, not just what Claude couldn’t do. This is what makes the roadmap actionable.
If a single turn has 3 capability walls, log 3 entries.
If it would embarrass Claude to log it, that’s exactly when to log it.
Gaps must be clustered, ranked, and presented as integration candidates with concrete next steps — not a raw log dump.

​
Reference files

FileContents
CAPTURE.mdJSON schema for gap entries, detection patterns, impact scoring guide, examples
REVIEW.mdClustering strategy, priority scoring formula, roadmap output format