Building an efficient Content Pipeline with Claude Code: From PRs to Blog Drafts

I have a problem that I suspect a lot of developers share: I build interesting things every week but never write about them. The gap between "that was a cool technical decision" and "published blog post" is just too wide. So I built a system to close it.

The idea is simple: every Friday at 5pm, an automated process scans my GitHub PRs and commits from the past week, identifies anything that could become a blog post or portfolio project, and sends me a Slack summary. When I'm ready, I run a single command to review the ideas, generate a draft, and push it straight to my site's API as a draft post. This is actually the system that identified — and wrote — this very blog post.

The Two-Phase Pattern

I borrowed the architecture from a daily time-tracking system I'd already built with Claude Code. It follows a gather/confirm pattern:

PHASE 1 — AUTOMATED (FRIDAY 17:00) LAUNCHAGENT Cron Trigger CLAUDE CODE Scan Repos ANALYSE Score Ideas OUTPUT Ideas JSON SLACK Notify Nick Slack nudge PHASE 2 — MANUAL (WHEN READY) NICK /confirm REVIEW Pick Idea CLAUDE CODE Draft Post API POST Draft FILAMENT Publish The two-phase content pipeline — automated gathering, human-driven drafting

Phase 1 (automated): A macOS LaunchAgent triggers Claude Code every Friday at 5pm. It runs a slash command (/weekly-content-gather) that scans my key active GitHub repos, analyses the PRs and commits, scores them for content potential, and writes the results to a JSON file. Then it sends me a Slack notification with the highlights.

Phase 2 (manual): When I'm ready to write, I run /weekly-content-confirm in Claude Code. It presents the ideas, I pick one, and it fetches the full PR details, reads the actual source code, and generates a complete blog draft. I can review, iterate, or skip. If I'm happy, it POSTs to my Laravel API as a draft.

The key insight is that not every week produces content-worthy work — and that's fine. The system handles zero-idea weeks gracefully instead of pressuring me to write about nothing.

The API Foundation

Before building the pipeline, I needed API endpoints that could accept content programmatically. I added two Sanctum-authenticated POST endpoints to my Laravel backend:

public function store(StoreBlogRequest $request): JsonResponse
{
    $blog = Blog::create([
        ...$request->validated(),
        'status' => PublishStatus::Draft,
    ]);

    return response()->json([
        'data' => (new BlogResource($blog))->resolve(),
        'admin_url' => FilamentBlogResource::getUrl('edit', ['record' => $blog]),
    ], 201);
}

Two things worth noting here. First, the endpoint always forces PublishStatus::Draft regardless of what the client sends. Nothing publishes without me reviewing it in Filament first. Second, the response includes an admin_url — a direct link to the Filament admin edit page for that post. This means after the pipeline creates a draft, I get a clickable link to go add a featured image and hit publish.

Quasi-Claw: Commands + LaunchAgents

I've started calling this pattern "Quasi-Claw" — a play on "OpenClaw.” It's not as elegant as a fully autonomous agent, but it gets you 90% of the way there. I’m quite keen to experiment with OpenClaw, but my current feeling is that Anthropic itself will be able to provide similar functionality sooner rather than later. As much as I love tinkering, I’m more focused on outcomes.

The idea is simple: Claude Code slash commands are just markdown files in ~/.claude/commands/ that describe what you want done. LaunchAgents are macOS's built-in cron system. Combine the two and you get scheduled AI workflows that run unattended. I didn't find this pattern in any blog post or YouTube tutorial — it was just me identifying a problem (I never write about my work) and figuring out a solution that works with the tools I already had.

~/.claude/commands/ Slash Commands weekly-content-gather.md weekly-content-confirm.md ~/Library/LaunchAgents/ macOS Cron Friday 17:00 schedule CLAUDE CODE CLI claude -p "run /weekly-content-gather" --allowedTools Bash,Read,... Non-interactive mode OUTPUT Ideas JSON Slack Message Blog Draft The Quasi-Claw pattern — markdown commands + LaunchAgent scheduling + CLI execution

Here's the LaunchAgent plist that triggers the weekly scan:

<key>ProgramArguments</key>
<array>
  <string>/Users/nickbell/.local/bin/claude</string>
  <string>-p</string>
  <string>run /weekly-content-gather</string>
  <string>--allowedTools</string>
  <string>Bash,Read,Write,Edit,Glob,Grep,Agent,...</string>
</array>
<key>StartCalendarInterval</key>
<dict>
  <key>Weekday</key>
  <integer>5</integer>
  <key>Hour</key>
  <integer>17</integer>
  <key>Minute</key>
  <integer>0</integer>
</dict>

The --allowedTools flag is crucial — it pre-authorises the tools Claude Code needs so the process can run unattended. Without it, the agent would block waiting for permission prompts that nobody's there to approve.

The Gathering Process

The gather command scans my active repos in parallel:

# GitHub PRs merged in the past 7 days
gh pr list --repo Nicholasbell03/personal-site \
  --state merged --search "merged:>=2026-03-03" \
  --json number,title,body,url,mergedAt,files --limit 50

# Git commits by me in the past 7 days
git -C /Users/nickbell/Dev\ Pvt/nickbell.dev/personal-site \
  log --author="nickbell\|Nicholas Bell" \
  --after="2026-03-03" --before="2026-03-10" \
  --all --format="%H|%ai|%s|%D" --no-merges

Claude then evaluates each PR against criteria I defined in the command: interesting technical decisions, third-party integrations, architecture choices, problems others commonly face. Routine bug fixes, dependency updates, and config changes are explicitly filtered out. Each idea gets scored 1-5, and only ideas scoring 3+ make the cut.

The results are written to a structured JSON file:

{
  "status": "PENDING_REVIEW",
  "ideas": [
    {
      "id": "idea-1",
      "type": "blog",
      "title": "Fixing a Mermaid.js Race Condition in React",
      "interest_score": 5,
      "key_points": [
        "Race between React rendering and mermaid initialization",
        "Three iterations to solve: singleton, CSS, synchronous claiming"
      ]
    }
  ]
}

The Confirmation Flow

When I run /weekly-content-confirm, it finds the most recent pending ideas file, presents them as a numbered list, and asks me to pick one. For the selected idea, it goes deep — fetching full PR diffs, reading 5-8 key source files from the actual codebase, and using all of that context to generate a technically accurate draft.

THE CONFIRMATION FLOW 1 NICK Runs /weekly-content-confirm 2 CLAUDE CODE Reads latest ideas JSON 3 NICK ↔ CLAUDE CODE Present ideas → Pick one PARALLEL RESEARCH 4 GITHUB API gh pr view #57 — diffs + meta 5 LOCAL CODEBASE Read 5–8 key source files 6 CLAUDE CODE Generate ~1200 word draft 7 NICK ↔ CLAUDE CODE Review · Iterate · Approve iterate 8 LARAVEL API POST /api/v1/blogs → 201 9 SLACK Notify with admin_url DONE The confirmation flow — from /confirm to published draft with human review at every step

The draft gets POSTed to my API via curl with a Sanctum bearer token:

curl -s -X POST "https://api.nickbell.dev/api/v1/blogs" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"title": "...", "content": "...", "excerpt": "..."}'

After posting, it updates the ideas JSON with the outcome and sends a Slack notification with the admin URL so I can go add a featured image and publish.

Lessons Learned

The gather/confirm split is essential. I initially considered making it fully automated — scan and draft in one step. But content creation needs human judgement. Some weeks the "interesting" PR is actually boring, and sometimes a small commit hides a great story. The two-phase approach costs almost nothing (one extra command) and prevents bad content from clogging up my drafts.

Pre-authorising tools for background agents is non-obvious. LaunchAgent processes run without a terminal, so any tool that requires interactive approval will silently hang. The --allowedTools flag was the key to making this work unattended.

Forcing draft status on the API was the right call. It would be tempting to let the automation publish directly, but blog posts need featured images, final proofreading, and sometimes timing. The draft-only API plus the admin_url in the response creates a smooth handoff between automation and human review.

What's Next

The system has been running for a week and already surfaced three content ideas from work I would have otherwise forgotten about. The meta twist — that this blog post was itself identified and drafted by the system — feels like a good validation that it works.

If you're using Claude Code, the Quasi-Claw pattern — slash commands plus LaunchAgents — is a surprisingly powerful way to create semi-automated workflows. The commands are just markdown files describing what you want done, Claude handles the execution, and LaunchAgents handle the scheduling. No framework, no infrastructure, no blog post that told me to do it this way. Just a problem and a solution.