Claude Skills we use everyday

---
name: frontend-design
description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
---

This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.

The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.

## Design Thinking

Before coding, understand the context and commit to a BOLD aesthetic direction:

- **Purpose**: What problem does this interface solve? Who uses it?
- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
- **Constraints**: Technical requirements (framework, performance, accessibility).
- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?

**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.

Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:

- Production-grade and functional
- Visually striking and memorable
- Cohesive with a clear aesthetic point-of-view
- Meticulously refined in every detail

## Frontend Aesthetics Guidelines

Focus on:

- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
- **Motion**: Use animations for effects and micro-interactions. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.

NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.

Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices across generations.

**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.

Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

---
name: case-study-writing
description: "B2B case study writing with STAR framework and research. Covers structure, customer quote, metrics presentation, and distribution formats."
---

# Case Study Writing

Create compelling B2B case studies using the STAR framework with research and visuals.

## Quick Start

1. Gather inputs: company name, industry, challenge, solution, results
2. Explore the referenced project codebase for context
3. Research industry benchmarks via web search
4. Write using the STAR framework (Situation -> Task -> Action -> Result)
5. Review against the checklist

## Workflow

### Step 1: Gather Information

Ask the user for:

- **Company**: name, industry, size, location
- **Challenge**: what problem they faced (quantified)
- **Solution**: what was implemented, timeline, key features
- **Results**: before/after metrics with timeframes
- **Quotes**: customer quotes with name, title, company
- **Project path**: path to the code project built for this client

### Step 2: Explore the Project

The user will reference a codebase that provides context about the client and the solution built. Explore it to understand:

- **What the product does** — read READMEs, landing pages, config files, routes, and models to understand the product from a user/business perspective
- **Scope of work** — how many apps/services, what integrations exist, what user-facing features were built
- **Problem indicators** — comments, commit messages, or docs that reveal what pain points the solution addresses

This is for **context only**. Do NOT include technical details (tech stack, architecture, code patterns) in the case study.

### Step 3: Research

Search the web for:

- Industry benchmarks (average metrics in customer's industry)
- Competitor landscape (why the customer chose this solution)
- Supporting statistics (market data reinforcing the challenge)

### Step 4: Write with STAR

- **Headline**: lead with the quantified result
- **Snapshot box**: company, industry, challenge, result
- **Situation** (100-150 words): customer context
- **Task** (100-150 words): the specific challenge, quantified
- **Action** (200-300 words): solution, timeline, key features
- **Result** (100-200 words): before/after metrics, timeframe

**Total: 800-1200 words.**

### Step 5: Review

- [ ] Headline leads with the quantified result
- [ ] Snapshot box at top
- [ ] Challenge is quantified, not vague
- [ ] max 1 customer quote with full attribution
- [ ] Before/after metrics with timeframe
- [ ] 800-1200 words total
- [ ] Skimmable (headers, bold, bullets)

---
name: linkedin-post
description: Generate marketing-oriented LinkedIn posts from codebase context — problem-solution, unexpected wins, mini-case studies for agency marketing.
allowed-tools: Read, Grep, Glob, Bash(git log *), Bash(git shortlog *)
---

# LinkedIn Post Generator

You are a LinkedIn content strategist for a development agency owner. Your job is to turn codebases into compelling marketing posts — no code, no jargon, just business storytelling.

## Step 1: Explore the Codebase for Business Context

Before writing anything, understand what this project is about. Read these files (if they exist):

- `README.md`, `CLAUDE.md` — project overview and purpose
- `package.json`, `Cargo.toml`, `pyproject.toml` — project metadata
- `CHANGELOG.md`, `HISTORY.md` — what changed and why
- Landing pages, marketing copy, or docs
- Run `git log --oneline -30` to see recent work and project trajectory

Extract:

- **What** was built (in plain English)
- **Who** it's for (the client's industry/audience)
- **Why** it was needed (the problem or pain point)
- **What changed** for the client (the outcome, the transformation)
- Any surprising discoveries, pivots, or wins during the build

## Step 2: Determine Post Type

| Post Type          | Focus                                                     |
| ------------------ | --------------------------------------------------------- |
| `problem-solution` | Client had X problem, here's what we built and the result |
| `unexpected-win`   | Something surprising happened during or after the project |
| `lesson-learned`   | An insight from the build process that applies broadly    |
| `before-after`     | Contrast the client's situation before vs. after          |
| `client-win`       | Celebrate a client's success enabled by the work          |
| `numbered-list`    | 3 concise takeaways or observations from the project      |
| `hot-take`         | A contrarian or unpopular opinion grounded in the project |

## Step 3: Write the Posts

### Voice & Tone

- First person, agency owner perspective ("We worked with a client who...")
- Conversational, not corporate. Write like you're telling a friend about an interesting project
- Confident but not boastful. Let the results speak
- Never name the client unless explicitly told to

### Structure

- **Hook** (first 1-2 lines): Must stop the scroll. Ask a question, state something counterintuitive, or lead with a result
- **Body**: Tell the story — setup, tension, resolution. Keep paragraphs to 1-3 lines max
- **Takeaway/CTA**: End with a reflection, lesson, or soft call-to-action
- Use line breaks generously — LinkedIn rewards white space
- 150-250 words per post

### What to Avoid

- "We're proud to announce..." — boring opener
- Listing tech stack or features
- Generic motivational fluff
- Sounding like a press release
- Making up specific numbers that aren't in the codebase
- Banned phrases: "real power", "wake-up call", "fundamentally changes", "key benefit", "cut through the noise", "key insight", "the irony", "the good news", "the reality", "hard truth", "uncomfortable truth"

# Simplify: Code Review and Cleanup

Review all changed files for reuse, quality, and efficiency. Fix any issues found.

## Phase 1: Identify Changes

Run `git diff` (or `git diff HEAD` if there are staged changes) to see what changed. If there are no git changes, review the most recently modified files that the user mentioned or that you edited earlier in this conversation.

## Phase 2: Launch Three Review Agents in Parallel

Launch all three agents concurrently in a single message. Pass each agent the full diff so it has the complete context.

### Agent 1: Code Reuse Review

For each change:

1. **Search for existing utilities and helpers** that could replace newly written code. Look for similar patterns elsewhere in the codebase — common locations are utility directories, shared modules, and files adjacent to the changed ones.
2. **Flag any new function that duplicates existing functionality.** Suggest the existing function to use instead.
3. **Flag any inline logic that could use an existing utility** — hand-rolled string manipulation, manual path handling, custom environment checks, ad-hoc type guards, and similar patterns are common candidates.

### Agent 2: Code Quality Review

Review the same changes for hacky patterns:

1. **Redundant state**: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls
2. **Parameter sprawl**: adding new parameters to a function instead of generalizing or restructuring existing ones
3. **Copy-paste with slight variation**: near-duplicate code blocks that should be unified with a shared abstraction
4. **Leaky abstractions**: exposing internal details that should be encapsulated, or breaking existing abstraction boundaries
5. **Stringly-typed code**: using raw strings where constants, enums (string unions), or branded types already exist in the codebase
6. **Unnecessary JSX nesting**: wrapper Boxes/elements that add no layout value — check if inner component props (flexShrink, alignItems, etc.) already provide the needed behavior

### Agent 3: Efficiency Review

Review the same changes for efficiency:

1. **Unnecessary work**: redundant computations, repeated file reads, duplicate network/API calls, N+1 patterns
2. **Missed concurrency**: independent operations run sequentially when they could run in parallel
3. **Hot-path bloat**: new blocking work added to startup or per-request/per-render hot paths
4. **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the error
5. **Memory**: unbounded data structures, missing cleanup, event listener leaks
6. **Overly broad operations**: reading entire files when only a portion is needed, loading all items when filtering for one

## Phase 3: Fix Issues

Wait for all three agents to complete. Aggregate their findings and fix each issue directly. If a finding is a false positive or not worth addressing, note it and move on — do not argue with the finding, just skip it.

When done, briefly summarize what was fixed (or confirm the code was already clean).

---
name: humanize-text
description: Rewrite AI-generated text to sound natural, human, and engaging. Use this skill whenever the user pastes text that reads like typical AI output and wants it to sound more human — or when they ask to "humanize", "de-AI", "make this sound natural", "rewrite to not sound like AI", "remove AI slop", or similar.
---

# Humanize Text

You're turning AI-generated text into something that reads like a real person wrote it. The goal is to preserve the original meaning and information while stripping away the patterns that scream "a language model wrote this."

## Core Philosophy

AI text fails because it's **predictable**. It leans on the same rhetorical tricks, the same cadence, the same filler phrases. Real writing has texture — it varies sentence length, skips the throat-clearing, and trusts the reader to keep up without signposts at every turn.

Your job is to keep the message intact while making the writing feel like it came from someone who actually cares about what they're saying, not a model trying to sound impressive.

## What to Strip Out

### Em Dashes — Kill Them

AI models massively overuse em dashes. Replace them with periods, commas, parentheses, or just restructure the sentence. An occasional em dash in a long piece is fine, but default to removing them.

### Banned Phrases

These phrases are AI fingerprints. Remove or replace them every time:

- "real power" → just state what it does
- "wake-up call" → drop it or say what actually happened
- "fundamentally changes" → say what changed, specifically
- "key benefit" / "key insight" / "key takeaway" → just state the benefit or insight directly
- "cut through the noise" → remove entirely
- "the good news" / "the bad news" → just say the thing
- "the reality" / "the reality is" → delete, say the thing
- "hard truth" / "uncomfortable truth" → state the fact plainly
- "it's worth noting" / "it's important to note" → just say it
- "at the end of the day" → remove
- "in today's [anything]" / "in an era of" / "in a world where" → cut these openers
- "game-changer" / "game-changing" → describe why it matters instead
- "navigate" (used metaphorically) → say what you actually mean
- "landscape" (used metaphorically) → be specific
- "leverage" (as a verb meaning "use") → say "use"
- "dive deep" / "deep dive" / "let's dive in" → remove
- "unpack" (metaphorical) → "explain" or just do it
- "robust" → usually means nothing, cut it or be specific
- "seamless" / "seamlessly" → say what makes it smooth, or cut it
- "elevate" → say how it improves things
- "empower" → say what people can now do
- "moreover" / "furthermore" / "additionally" → restructure or use "and" / "also"
- "delve" → never use this word
- "tapestry" → no

### Structural Patterns to Break

- **Colon-list openers.** AI loves "Here's the thing:" — just write the sentence naturally.
- **Triple-structure listings.** "It's fast, efficient, and reliable" appears constantly. Vary it.
- **Sycophantic openers.** Remove "Great question!" or "That's a really interesting point."
- **Summary restating.** Don't end by restating everything you just said. Trust the reader.
- **Overly parallel structure.** Real writing isn't perfectly balanced. Let some sentences be short. Let others run.

## What to Do Instead

### Vary Sentence Length

Mix short punchy sentences with longer ones. AI text tends to hover around the same medium length. Break that up.

### Be Direct

If something is important, say it. Don't wrap it in "It's worth noting that..." — just state it.

### Use Plain Language

"Utilize" → "use." "Facilitate" → "help." "Commence" → "start."

### Preserve the Author's Voice

If the original text has a specific tone (casual, professional, technical), keep it. You're removing AI patterns, not imposing a new voice.

## Process

1. Read the full text first to understand the message and intended tone.
2. Identify AI patterns: banned phrases, em dashes, structural clichés.
3. Rewrite, preserving every piece of information and the overall structure.
4. Check that the rewrite is roughly the same length.
5. Read it once more — does it sound like a person wrote it? If any sentence still triggers your "AI detector," fix it.

## Important Boundaries

- Don't change facts, data, or claims.
- Don't add opinions or information that wasn't in the original.
- Don't make it significantly longer or shorter.
- Don't make it less clear in pursuit of sounding casual — clarity always wins.

---
name: outreach-campaigns
description: Create cold email campaigns in Instantly from a client description and offers. Use when setting up outreach campaigns, cold email sequences, or automated email marketing.
allowed-tools: Read, Grep, Glob, Bash
---

# Cold Email Campaign Creator — Instantly Integration

## Goal

Take a client description and a few words about their offers, then create 3 cold email campaigns in Instantly. The script finds the 3 closest existing campaigns in your Instantly account, then minimally rewrites them for the new brand (5-10 word changes per email).

## Inputs

- **Client name**: The business name
- **Client description**: What they do, who they serve, their value proposition
- **Offers** (optional): Up to 3 distinct offers. If not provided, generates them from the description.
- **Target audience** (optional): Who we're emailing
- **Social proof** (optional): Credentials, results, experience to mention

## Process

### Step 1: Fetch Source Campaigns

The script fetches all existing campaigns from Instantly (via v2 API), then uses Claude to pick the 3 closest analogues based on offer structure, industry, and specificity.

### Step 2: Fetch Sequences

Full email sequences are pulled from the 3 selected source campaigns.

### Step 3: Minimal Rewrite

Claude rewrites each source campaign with **5-10 word changes only**:

- Swap brand name, industry noun, offer noun
- Keep same sentence structure, paragraph count, tone, and pacing
- Do NOT add new sentences, rephrase, or get creative

### Step 4: Run

Execute the script instantly_create_campaigns.py with the following arguments:
--client_name "ClientName"
--client_description "What the client does..."
--offers "Free audit|Demo session|Revenue share"
--target_audience "Agency owners, service businesses"
--social_proof "Built AI systems generating $1M+ in revenue"

### Step 5: Review (Dry Run)

Execute the script instantly_create_campaigns.py with the following arguments:
--client_name "Test"
--client_description "Test company"
--offers "Free thing"
--dry_run

## Campaign Structure

Each campaign (3 total) has exactly 2 steps:

**Email 1 (2 A/B variants):**

- Icebreaker
- Who you are + what you do (1-2 sentences)
- Clear offer with specifics
- Soft CTA, easy to reply to

**Email 2 (follow-up, day 3):**

- 2-3 sentences max
- Restate the offer
- Low-pressure ask, easy to reply to

## Hard Rules

- **No links or URLs in cold emails** — they get flagged as spam. Never use `{{web_site}}` or any URL variable.
- **Every email must state the offer** — no vague "would love to chat" without saying what you're offering.
- **Minimal rewrites only** — find-and-replace industry nouns, don't rewrite sentences.
- **Preserve source HTML** — keep `<p>`, `<div>`, `<br />` tags exactly as they are from the source.
- **2 steps only** — opener + 1 follow-up. No breakup emails.

## Available Variables

From Instantly's lead data:

- `{{firstName}}`, `{{lastName}}`, `{{email}}`
- `{{companyName}}`, `{{casualCompanyName}}`
- `{{icebreaker}}` — AI-generated opener
- `{{sendingAccountFirstName}}` — sender's name

## Environment

Requires in `.env`:

INSTANTLY_API_KEY=your_api_key
ANTHROPIC_API_KEY=your_anthropic_key

Both keys are always required (even for dry runs, since source campaigns are fetched from Instantly).

## Edge Cases

- **No offers provided**: Generates 3 distinct offers from client description
- **API rate limits**: Handled with retry after 30s
- **Missing API key**: Exits early with helpful error
- **Source campaign has 3+ steps**: Drops everything after step 2
- **Source campaign has links/URLs**: Claude removes them during rewrite