jackchuka Blog Post Mining
Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the resolver script from there:
python <skill-dir>/scripts/skillctx-resolve.py resolve p-blog-post-mining
The resolver outputs each binding as key: value (one per line). Substitute each {binding_key} placeholder below with the resolved value.
If any values are missing or the user requests changes, use:
python <skill-dir>/scripts/skillctx-resolve.py set p-blog-post-mining <key> <value>
Analyze recent development activities across multiple sources to discover blog-worthy topics, then produce structured outlines ready for writing.
When to Use
- User asks for blog ideas or content inspiration
- User wants to turn recent work into blog posts
- User says "what can I write about" or "find blog material"
- User wants to identify stories from their development activities
Prerequisites
{claude_history_path}exists (Claude Code session history)ghCLI installed and authenticated (GitHub activity)- Slack MCP server configured (Slack discussions)
- Fireflies MCP server configured (meeting recordings, optional)
Arguments
Parse from the user's invocation:
- Time range: "past N days/weeks/month" (default: past 14 days)
- Audience: "company blog", "personal blog", "tech community", "dev.to" (default: personal)
- Language: output language for outlines (default: same as user's message)
- Topic filter: optional focus area (e.g., "AI", "tooling", "architecture")
Workflow
Step 1: Gather Raw Activity (parallelize if possible)
All four sources are independent. Dispatch all four data collection tasks concurrently (parallelize if possible). If your platform supports parallel subagents, launch one per source. Otherwise, query each sequentially. Wait for all sources to return before proceeding to Step 2.
Source 1 — Claude Session History:
Read {claude_history_path} and filter entries by timestamp for the target date range.
Group by sessionId and extract:
- First prompt per session (the task goal)
- Number of messages per session (complexity indicator)
- Project path (what repo/area was involved)
Focus on sessions with 5+ messages — these represent substantial work, not quick one-offs.
Source 2 — GitHub Activity:
gh api graphql -f query='
query {
viewer {
contributionsCollection(from: "{start_date}T00:00:00Z", to: "{end_date}T00:00:00Z") {
commitContributionsByRepository {
repository { nameWithOwner description }
contributions { totalCount }
}
pullRequestContributions(first: 50) {
nodes {
pullRequest {
title body url state number
repository { nameWithOwner }
}
}
}
}
}
}'
For repos with significant commit counts, fetch commit messages:
gh api "repos/{owner}/{repo}/commits?author={user}&since={start}&until={end}" \
--jq '.[] | "\(.commit.message | split("\n") | .[0])"'
Source 3 — Slack Discussions:
Use Slack MCP tools:
- Call
slack_read_user_profile()(no args) to get the current user's ID slack_search_public_and_privatewith"from:me after:{start_date}"— find substantive messages you wrote- Focus on threads with 5+ replies (indicates discussion-worthy topics)
Source 4 — Fireflies Meetings (if available):
fireflies_get_transcriptsfor the date rangefireflies_get_summaryfor each meeting (parallelize if possible — each call is independent) — look for decisions, debates, and interesting topics discussed
SYNC: Wait for all sources to return before proceeding. If a source is unavailable (e.g., no Fireflies MCP server, gh not authenticated), skip it and note the omission — do not fail the entire gathering step.
Deduplicate: Before analysis, deduplicate across sources — the same PR may appear in both GitHub and Slack data, the same topic may surface in both Claude history and a meeting. Use PR URLs and commit SHAs as primary keys.
Step 2: Identify Blog-Worthy Stories
Analyze collected data through these lenses:
Story Types (check each against the data):
| Type | Signal | Example |
|---|---|---|
| Problem-Solution | Multiple sessions debugging the same issue, then a breakthrough | "How I debugged TUI spinner animation across 5 sessions" |
| Tool/Process Creation | New tool built from scratch (new-tool-kickoff flow) | "Building a CLI restaurant finder with Go + HotPepper API" |
| Architecture Decision | Significant design choice with trade-offs discussed | "Why we chose CQRS for our ERP module framework" |
| Failure Story | Repeated attempts, wrong approaches, eventual resolution | "What I learned from trying to mock APIs with LLMs" |
| Workflow Optimization | Creating a skill/automation that saves recurring effort | "Automating OSS releases across 13 repos with a Claude skill" |
| Team Practice | Process or convention established across the team | "Introducing spec-driven development with erp-kit" |
| Comparison/Evaluation | Research sessions comparing tools or approaches | "Comparing TUI frameworks for Git repository visualization" |
Scoring criteria (internal, don't show to user):
- Depth: How many sessions/commits were spent? More = richer story
- Novelty: Is this a common blog topic or something unusual?
- Lessons: Were there failures, pivots, or non-obvious insights?
- Audience appeal: Would others face similar challenges?
Step 3: Present Candidates
Show the top 5-8 candidates as a numbered list:
Blog Post Candidates:
1. [Title] — [1-line pitch]
Sources: [which data sources contributed]
Depth: [how much material is available]
2. [Title] — [1-line pitch]
Sources: [sources]
Depth: [depth]
...
Group by story type if there are many candidates.
Ask: "Which topics interest you? (e.g., '1, 3, 5' or suggest your own angle)"
Step 4: Create Outlines
If multiple topics are selected, generate all outlines concurrently (parallelize if possible) — each outline is independent.
For each selected topic, generate a structured outline:
# [Blog Post Title]
## Angle
[1-2 sentences: what's the unique perspective or takeaway]
## Target Audience
[Who would read this and why]
## Outline
### Introduction
- [Hook: the problem or situation that draws the reader in]
- [Why this matters]
### [Section 1: Context/Setup]
- [Key points from the gathered data]
### [Section 2: The Journey/Process]
- [What happened, what was tried]
- [Include specific details from sessions/commits — sanitized]
### [Section 3: Solution/Insight]
- [What worked and why]
- [Code snippets or architecture decisions if relevant]
### [Section 4: Lessons Learned]
- [What would you do differently]
- [Advice for others facing similar challenges]
### Conclusion
- [Key takeaway]
- [Call to action or next steps]
## Supporting Material
- [Relevant PRs/commits that could be referenced]
- [Related tools or links]
## Estimated Length
[Short (800-1200 words) / Medium (1500-2500 words) / Long (3000+ words)]
Step 5: Save Outlines
Write each outline to:
{blog_drafts_dir}/{topic-slug}.md
Create the directory if it doesn't exist. Report the file paths to the user.
Privacy and Safety
- Never include raw session content, secrets, or internal URLs in outlines
- Sanitize company-specific details unless the user confirms it's for a company blog
- Replace specific names with roles (e.g., "a teammate" instead of actual names)
- Paraphrase rather than quote verbatim from history
Examples
Example 1: General mining
User: "/blog-post-mining"
Action: Analyze past 14 days across all sources, find 5-8 candidates, present list
Example 2: Focused mining
User: "find blog material about AI tooling from the past month"
Action: Analyze past 30 days, filter for AI/tooling topics, find candidates
Example 3: Company blog
User: "any blog material for our company blog? past 2 weeks"
Action: Analyze past 14 days, focus on team-relevant topics, adjust tone for company audience
Example 4: From a specific project
User: "blog ideas from working on <project name> this month"
Action: Filter history for <project name> project sessions, analyze the build journey