Back to Lab

6 Claude Code Commands Every Creator Should Install Today

I used to spend more time prompting Claude Code than actually working. Every content task started with the same routine: explain the format, re-state my voice rules, describe the output structure. Then do it again for the next task.

Slash commands fix that. They're reusable instruction sets that live as markdown files in your workspace. Type the command, provide input, and the output follows the exact structure you defined. No re-explaining. No drift.

Here are 6 commands I use almost daily, what they do, and what the output actually looks like.

1. /repurpose: One Piece Becomes Three

This is the command I use most. It takes a single piece of content (a blog post, an article, a long caption) and produces three platform-ready formats: a LinkedIn post, a Twitter/X thread, and an Instagram caption.

The problem it solves: Writing the same idea three times in three different formats takes 30-45 minutes. With /repurpose, it takes about 90 seconds.

How it works: The command file defines strict formatting rules for each platform. LinkedIn gets 150-200 words with line breaks between every sentence and a punchy opening hook. The Twitter thread gets 8-10 tweets, each with a single idea, building toward a takeaway. Instagram gets under 300 words in story format (problem, turning point, result) with 5-8 hashtags.

Real example: I wrote a blog post about debugging workflows. I typed /repurpose, pasted the article, and got back a LinkedIn post that opened with "I fixed 47 bugs last month. Only 3 of them were actually hard." The Twitter thread broke the debugging framework into one step per tweet. The Instagram caption told the story of a specific production bug and what it taught me.

If you're using Buffer or any scheduling tool, this is where it compounds. One writing session produces a week of cross-platform content. The command handles adaptation. You handle scheduling and strategy.

2. /brief: Content Planning Without the Guesswork

Before I had this command, content planning meant staring at a blank doc and hoping inspiration showed up. /brief replaces hope with structure.

The problem it solves: You know you need to create content about a topic, but you don't know the angle, the audience specifics, or the distribution strategy.

How it works: You type /brief followed by a topic, product name, or campaign idea. The command produces a full content brief: target audience (specific role, pain points, aspirations), key message (one sentence), three content angles (each with a hook, format recommendation, and distribution plan), a CTA strategy, and SEO keywords if applicable.

Real example: I ran /brief Claude Code setup tips and got back a brief targeting "solo developers who use Claude Code but haven't customized their workspace." The three angles were: a mistake-focused blog post, a step-by-step carousel, and a short-form video showing a before/after. Each came with a specific hook and the platform where it would perform best.

The brief becomes the blueprint. I pick the angle I like, run /repurpose on the finished piece, and the entire pipeline (from idea to multi-platform distribution) takes under an hour.

3. /trends: What People Actually Want Right Now

Guessing what to create is a losing strategy. /trends replaces guessing with research.

The problem it solves: You're creating content but you're not sure what topics have momentum, what gaps exist, or what formats are working.

How it works: Type /trends followed by your niche or a competitor. The command delivers the top 5 trending topics with urgency ratings, 3 content gaps nobody is covering well, and 3 viral formats worth adapting.

Real example: I ran /trends AI tools for solo creators and discovered that "Claude Code vs Cursor" comparisons had massive search volume but most articles were shallow. That gap became a comparison post that now ranks on page one.

The key detail: /trends uses web search to find real data, not AI-generated assumptions. It pulls from actual search trends, Reddit threads, and platform analytics.

4. /weekly-debrief: The Friday Review That Keeps You Honest

Solo creators don't have a team to keep them accountable. This command fills that gap.

The problem it solves: Without a structured review, weeks blur together. You ship things but don't track what moved the needle. Follow-ups slip through cracks.

How it works: Every Friday, type /weekly-debrief. The command checks your recent git history, file changes, and completed tasks, then answers five questions: Biggest win this week? What was avoided that shouldn't have been? Which task needs a follow-up? What worked well enough to become a system? What's the one priority for next week?

Real example: Last Friday, the debrief flagged that I'd been avoiding a Shopify theme update for two weeks. It also noticed I'd shipped 4 blog posts in 3 days and suggested I systematize the publishing workflow. That feedback led to the content pipeline I use now.

Five questions. One minute. Keeps the whole operation visible.

5. /seo-audit: Find What's Actually Broken

This command scans a page or URL and identifies specific SEO problems with actionable fixes.

The problem it solves: SEO tools give you a score and a list of 200 suggestions. Most of them don't matter. This command focuses on the changes that actually move rankings: missing meta descriptions, thin content flags, broken heading hierarchy, missing alt text on images, and internal linking gaps.

How it works: Type /seo-audit with a URL or page content. It returns a prioritized list: critical issues first (things that are actively hurting rankings), then improvements (things that would help), then nice-to-haves. Each item comes with the specific fix, not just the problem.

Real example: I ran it on my Shopify blog index page and it caught that 6 articles had meta descriptions under 50 characters (too short to display properly in search results). It also flagged that none of my articles had internal links to related posts. Those two fixes took 30 minutes and improved click-through rates from search within the same week.

6. The Debugging Skill: Not a Command, But It Chains With Everything

Technically this is a skill, not a slash command. But it's worth mentioning because it changes how every other tool in your setup works when something breaks.

The problem it solves: When a deploy fails, an API returns errors, or a Shopify webhook misfires, the natural instinct is to start changing things randomly. That instinct costs hours.

How it works: The debugging skill triggers automatically when Claude detects error-related language. It follows a 5-phase framework: Observe (read the error, reproduce the issue, check what changed), Hypothesize (list 3 possible causes, rank by likelihood), Test (verify the most likely hypothesis first, one variable at a time), Fix (address the root cause, add a guard to prevent recurrence), Verify (confirm the fix works and document what changed).

It sounds simple. It is simple. But having the framework embedded in Claude's behavior means it follows the process even when you're stressed, tired, or tempted to skip straight to random fixes.

How Commands Chain Together

The real power isn't any single command. It's the pipeline.

A typical content week looks like this: Monday, I run /trends to see what's moving in my niche. I pick the strongest topic and run /brief to get a content plan with three angles. Tuesday, I write the blog post. Then /repurpose turns it into LinkedIn, Twitter, and Instagram content. That goes into Buffer for the rest of the week. Friday, /weekly-debrief shows me what shipped and what needs attention next week.

Four commands. One pipeline. 6-8 pieces of content per week with about 3 hours of actual work.

How to Install Them

Each command is a markdown file that lives in your Claude Code commands directory. The structure is simple:

# commands/repurpose.md

---
description: Turn one piece of content into 3 platform formats
argument-hint: "<blog post, article, or paste content>"
---

[Instructions for the command go here]

The description field tells Claude what the command does. The body contains the actual instructions: formatting rules, output structure, voice guidelines. You can write your own from scratch. It takes about 20-30 minutes per command to get the instructions right.

All 6 commands are part of Claude Blueprint, alongside a CLAUDE.md template that works from day one, 3 production skills (debugging, content audit, session start), copywriting rules, and an interactive dashboard. The install script handles everything: platform detection, backup of existing files, and a clear summary of what was installed. 33 EUR, 2 minutes, zero configuration.

Either way, the principle is the same: stop re-explaining things to your AI. Define it once, use it everywhere.

This article contains affiliate links. If you sign up through them, I may earn a small commission at no extra cost to you. (Ad)

Back to all articles