analyze-prompts

analyze-prompts

What you do

You analyze the user's real prompt history across up to three AI coding agents — Claude Code, Codex, and OpenCode — to produce a single structured markdown report describing how they actually write, decide, and work. You are the data-grounding layer behind build-me-md: everything in the final ME.MD must be traceable to something you surface here.

The procedure: detect which tools are installed → dispatch one prompt-analyzer subagent per source in parallel → aggregate results into a combined report → write to /tmp/me-md-prompt-analysis-<timestamp>.md → return the path.

You never summarize raw prompts back to the user in chat. You never copy prompt contents outside of the report file. The report is the only output.

Source detection

Check each source with a single Bash probe. Do not read large files during detection — only test existence.

# Claude Code
test -f ~/.claude/history.jsonl && echo "claude-code-history: yes" || echo "claude-code-history: no"
test -d ~/.claude/projects && echo "claude-code-projects: yes" || echo "claude-code-projects: no"

# Codex
test -f ~/.codex/history.jsonl && echo "codex-history: yes" || echo "codex-history: no"
test -d ~/.codex/sessions && echo "codex-sessions: yes" || echo "codex-sessions: no"

# OpenCode
test -d ~/.local/share/opencode/storage && echo "opencode-storage: yes" || echo "opencode-storage: no"
test -f ~/.local/state/opencode/prompt-history.jsonl && echo "opencode-history: yes" || echo "opencode-history: no"

A source counts as "installed" if either of its two probes returns yes. Print one line listing the detected sources and move on. Do not ask the user anything — build-me-md has already collected consent; this skill is dispatched with a pre-approved source list.

If the skill is invoked standalone (not by the orchestrator), accept the source list as the first argument, e.g. "claude-code,codex", or default to "all detected" if no argument is given.

Dispatching

For each installed source in the approved list, dispatch exactly one subagent using the Task tool with subagent_type: "prompt-analyzer" (this plugin ships a custom agent by that name under agents/prompt-analyzer.md). Dispatch all subagents in a single assistant message so they run in parallel — this is the whole point of the skill. Never serialize these calls.

Resolve reference files using ${CLAUDE_PLUGIN_ROOT} so paths work regardless of where the plugin is installed. In a skill, ${CLAUDE_PLUGIN_ROOT} expands to the directory containing .claude-plugin/plugin.json. Reference files live at:

• ${CLAUDE_PLUGIN_ROOT}/skills/analyze-prompts/references/claude-code-paths.md — for the Claude Code subagent
• ${CLAUDE_PLUGIN_ROOT}/skills/analyze-prompts/references/codex-paths.md — for the Codex subagent
• ${CLAUDE_PLUGIN_ROOT}/skills/analyze-prompts/references/opencode-paths.md — for the OpenCode subagent

Expand ${CLAUDE_PLUGIN_ROOT} via Bash before dispatching (echo "${CLAUDE_PLUGIN_ROOT}/skills/analyze-prompts/references/claude-code-paths.md"), then load the reference file using the Read tool, then pass its body as the subagent's task prompt. The reference files already contain the full prompt template — including which paths to read, which jq filters to apply, which noise to skip, and which output sections the subagent must return. Your job is only to pick the right reference file per source and dispatch.

When dispatching, tell each subagent:

1. Its source (claude-code, codex, or opencode).
2. The paths to read (from the reference file).
3. The critical filters to apply (from the reference file).
4. The output shape (from the reference file).
5. The 2500-word output limit — hard cap. A subagent that returns more than 2500 words has failed and should be re-dispatched with a tighter brief.

Critical filters

Some filters are load-bearing. Do not skip them.

Claude Code — always filter /rate-limit-options

The file ~/.claude/history.jsonl contains harness telemetry lines with display: "/rate-limit-options". On most machines these are 80–95% of the file. Any analysis that does not filter them will produce garbage ("the user's most common prompt is /rate-limit-options"). The jq filter is:

jq -c 'select(.display != "/rate-limit-options")' ~/.claude/history.jsonl

This filter is already in references/claude-code-paths.md — make sure the Claude Code subagent applies it.

Codex — inspect rollout format before parsing

Codex rollout files (~/.codex/sessions/<year>/<month>/<day>/rollout-*.jsonl) have event-stream format that varies across Codex versions. The subagent must read one sample file first with head -n 20, identify which field holds user turns, and only then write the extraction jq. Do not hardcode a schema.

OpenCode — do not touch the SQLite

There is a 2 GB SQLite database at ~/Library/Application Support/opencode/opencode.db. Never read it. The real, cheap data lives in ~/.local/share/opencode/storage/ as JSON files. The reference file makes this explicit — the subagent must stay inside the storage directory.

Aggregation

When all subagents return, combine their reports into a single markdown file with this shape:

# Prompt Analysis Report
Generated: <ISO timestamp>
Sources analyzed: <list>

## Claude Code
<subagent 1 output verbatim>

## Codex
<subagent 2 output verbatim>

## OpenCode
<subagent 3 output verbatim>

## Cross-source synthesis
<your own short synthesis, 400-600 words>

The cross-source synthesis section is critical — it is where the signal gets multiplied. Look across all three subagent reports for:

• Consistent signature typos — the same misspellings appearing across tools (e.g. haev, teh, thsi). These are load-bearing identity markers.
• Consistent opening moves — how the user kicks off a session in each tool.
• Consistent frustration patterns — the same complaint showing up in multiple tools means it is a real value, not a one-off.
• Time-of-day alignment — do all three tools show the same active hours?
• Tool specialization — does the user route specific kinds of work to specific tools? (e.g., debugging in Claude Code, review in Codex, fan-out in OpenCode).
• Volume asymmetry — one tool dominating tells you where the user actually lives.

Do not invent a synthesis insight that is not supported by at least two subagent reports. If only one source was analyzed, skip this section and note "single-source analysis — no cross-tool synthesis possible".

Output

Write the combined report to /tmp/me-md-prompt-analysis-<timestamp>.md where <timestamp> is the current Unix epoch in seconds (use date +%s in Bash). Return only the absolute path as a single line. Example:

"Wrote /tmp/me-md-prompt-analysis-1760115600.md"

Do not summarize the report contents in chat. The orchestrator (or the user, if run standalone) will Read the file when they want the content. Keeping analysis output off the chat surface preserves context and privacy.

Rules

• One subagent per source. Dispatched in parallel in a single message.
• Never serialize subagents "to be safe" — the whole point is speed.
• Never read a file larger than a few megabytes into context. Use jq, head, and wc -l via Bash first.
• Never bypass the Claude Code /rate-limit-options filter.
• Never touch the OpenCode SQLite database.
• Never write prompt content anywhere except the report file under /tmp/.
• Never ask the user a follow-up question — this skill is non-interactive. Any decisions are made from the passed argument or the detection results.
• Hard cap each subagent at 2500 words of output.
• If a subagent errors out, note the failure in the report (e.g., "## Codex\n\nError: . Source skipped.") and continue with the others. A partial report is better than no report.

Reference files

• references/claude-code-paths.md — Claude Code log paths, jq recipes, full subagent prompt template.
• references/codex-paths.md — Codex log paths, rollout schema inspection, full subagent prompt template.
• references/opencode-paths.md — OpenCode storage layout, JSON walking strategy, full subagent prompt template.