I Built a Claude Code Slash Command to Clear 300 Unread Newsletters

Nearly 300 unread newsletters were sitting in my inbox. I built one Claude Code custom slash command, and now I process 11 newsletters in a few minutes. Here’s a three-week diary.

I subscribe to about ten AI and tech newsletters. Every one of them is worth reading — but somehow I’d let them pile up into an unmanageable backlog. Weekend catch-up sessions would run over an hour and stall halfway through. After that cycle repeated a few times, I decided to automate the triage with a Claude Code custom slash command.

The Problem: Backlog Kills the Habit

Newsletters beat social timelines for one reason: a human editor curated and filtered the information before it reached you. The problem is that a pile of unread messages is psychologically harder to open than a fresh inbox.

Running multiple projects in parallel made it worse. A single newsletter might contain something relevant to Project A, something that would make a blog post for Project B, and three things I don’t need at all. That sorting cost is surprisingly high — and “read it later” kept turning into “never read it.”

The fix: let AI handle triage before I ever open an email.

The Minimum Structure of a Custom Slash Command

Claude Code has a feature called custom slash commands — workflows you define in plain Markdown files. Drop a .md file inside .claude/commands/ and it becomes a command. The filename is the command name; the body describes the steps in natural language.

The minimal template looks like this:

# digest-newsletter

## Purpose
Triage unread emails from the Gmail "Newsletter" label and save a digest to Obsidian.

## Steps

1. Use Gmail MCP to fetch up to 20 unread emails from the "Newsletter" label
2. List subject lines, evaluate priority, and identify skip candidates first
3. Process the rest one by one (full body read → follow links → classify)
4. Save the results to Obsidian in the format below

## Output Format
...（Markdown template goes here）

No code required. You call any MCP tool — Gmail, WebFetch, Playwright — just by naming it in plain language. Claude Code handles the rest.

For more on structuring skills versus commands and when to use each, see “Claude Code skills design patterns.”

What /digest-newsletter Does

Type /digest-newsletter and five steps run automatically:

1. Fetch — pull up to 20 unread emails from the Gmail “Newsletter” label
2. Quick triage — if there are more than 10, identify skip candidates by subject line alone
3. Deep read — process each email one by one: full body read → follow up to 3 links → classify by priority
4. Save to Obsidian — write a dated Markdown file
5. Summary report — show a count of must-reads and any action items

Claude Code ships with MCP tools for Gmail, web fetching, and browser automation. Wiring them together from a plain Markdown recipe is what makes this possible.

How It Works Inside

Gmail Integration

The command fetches unread mail from my Gmail “Newsletter” label via MCP. For each message it pulls the sender, subject, date, and body (up to 8,000 characters).

If there are more than 10 emails, it skips the deep read and runs a quick pass on subject lines and opening sentences first, marking obvious non-relevant items as skip candidates to avoid unnecessary processing.

One Email at a Time

My first version threw all the emails at Claude in one batch. Summaries came out shallow and link follow-ups were often skipped. Switching to processing one email at a time made a clear difference in quality.

For each email the command:

• reads the full body and extracts the key points, arguments, and data

• fetches up to three important links from the body — using WebFetch by default, falling back to Playwright MCP if a paywall or login stands in the way

• classifies the email into one of three buckets:

• 🔴 Must-read — directly relevant to a current project, or requires immediate action

• 🟡 Worth keeping — good to stock as potential blog material

• ⚪ Skip — not relevant right now

Obsidian Output

Results are saved as a dated Markdown file in Obsidian. The file has four sections: must-reads, stockpile items, skipped, and cross-cutting observations.

Project relevance detection is built in: the command checks each item against my active projects and labels it — “this could be a blog post for amaino.me,” “this is useful for the health app.” The idea of using the filesystem as a database is covered in “Using the filesystem as a database with Claude Code.”

Designed as a Content Pipeline

/digest-newsletter isn’t a standalone tool — it’s the front door to a content production pipeline:

/digest-newsletter → digest saved to Obsidian (idea stock)
       ↓
/write-article → turn a tech item into a draft post
       ↓
my review → publish

Nothing is fully automated. I still review every digest and approve every article. But offloading the “find an idea” and “write a first draft” steps dramatically lowered the barrier to publishing.

Three Weeks of Results

Processing time improved significantly. Running 11 newsletters takes a few minutes now; reading them all myself would take over an hour. A typical run produces around 🔴 2 must-reads, 🟡 5 worth-keeping, ⚪ 4 skips.

The biggest single improvement was switching from batch to one-email-at-a-time processing. The early version gave surface-level summaries and often skipped link follow-ups entirely. Processing emails individually made the digest genuinely useful.

A side effect I didn’t expect: the stress of “I should read my newsletters” disappeared. Every morning I run the command and focus only on the must-reads. Blog post ideas accumulate naturally without any extra effort.

Remaining limitations: paywalled articles are sometimes unreachable. Pages built on dynamic content give inconsistent fetch results. A full 20-email run takes a few minutes — it’s become morning wait time rather than a problem.

When Claude Code Automation Makes Sense

Custom slash commands are the right tool for work that is “repetitive but still requires judgment.” Newsletters are one example; RSS feeds, Slack digests, GitHub watch lists, and any other information source that piles up faster than you can read it are all fair game.

The recipe is simple: drop a Markdown file in .claude/commands/, write the steps in plain language.

The core idea: let AI handle the read/skip decision before you open anything. If you have a backlog sitting somewhere right now, try delegating just the triage step — it’s more relieving than you’d expect.