The Founder's Toolkit

Ask Claude Code to install all these extensions from this markdown file for your VS Code.

Drop the file at the root of your project, open Claude Code, and say:

Install every extension listed in vscode-extensions.md.

Claude reads the list, runs the code --install-extension commands, and confirms each one. Zero manual clicking through the marketplace.

These 9 articles should give you plenty of context around how to properly use Claude Code, directly from Anthropic themselves.

1. Context Engineering
2. Building Effective Agents
3. Best Practices for Agentic Coding
4. The AI Fluency Framework
5. Build with Claude
6. Claude for Work
7. Anthropic API Fundamentals
8. Real-World Prompting
9. Prompt Evaluations

Boris Cherny (the guy who BUILT Claude Code) dropped his top 10 tips on Twitter recently.

Problem? Most of them sound like this:

• "Spin up git worktrees for parallel execution"
• "Invest in your claude.md file"
• "Use subagents to offload compute"

Cool... but HOW do you actually do that?

So I spent the last week testing every single tip in my own projects and recorded exactly how to implement them.

• Parallel execution with git worktrees (3 features built at once)
• The claude.md file that trains Claude to work YOUR way
• Subagents that 10x your context window
• Using Claude for instant data analytics
• The "challenge mode" that prevents technical debt
• Learning with diagrams (so you're not just vibing blind)

Procedure Ops is a Claude Code skill that interviews you, then writes the full SOP. Five tasks ship in the box:

• /sop-build interview walks you through a guided Q&A and writes a clean SOP at the end.
• /sop-build scaffold-business sets up a new business folder with every department.
• /sop-build from-recording turns a Loom or voice note into a structured SOP.
• /sop-build audit reviews an SOP you already have and flags gaps plus automation candidates.
• /sop-build delegate-pack bundles a finished SOP for a VA or new hire (access list, training videos, first-week check-ins, escalation contact).

I've written hundreds of SOPs for my clients and my own business. Thinking through every single step is a pain. Writing it up and packaging it pretty for your team eats hours. Procedure Ops fixes both.

It acts like a COO sitting next to you. It pushes back when a step is too vague ("review the form" gets challenged to "open the form, check fields X, Y, Z, confirm they match the contract"). It flags steps that could be automated and picks the right tool: Zapier, Make, n8n, or a Claude managed agent. It only recommends installing SEED and PAUL if you don't already have them.

One command. Install with npm:

npx procedure-ops install

That drops the skill into ~/.claude/skills/sop-build/. Restart Claude Code and you're set. Now any time you need an SOP, type /sop-build interview and start talking.

My order of operations: scaffold the business folders first with /sop-build scaffold-business, then run /sop-build interview per process. The skill writes every SOP to a clean SOPs/<business>/<department>/<slug>.md path. Your team reads it in Markdown, or you pick Google Drive or Notion as the host when you scaffold the business.

Voice notes. Loom videos. Old SOP drafts. The skill transcribes the recording, pulls out the steps, flags the gotchas, and writes the SOP for you. Same quality gate as a live interview, faster intake.

• Procedure Ops on GitHub
• Procedure Ops on npm

/advertising-ops runs the whole loop a media buyer runs by hand, one command, five phases:

• Scope. Reads your brand kit if you have one, otherwise interviews you for your business, keywords, and ICP.
• Scrape. Pulls long-running winning ads from the Meta Ad Library through Apify, filtered to a minimum run time you set (2 months floor) AND still active. Started long ago plus still live equals the market already validated it.
• Teardown. For video ads it downloads the MP4, extracts frames with ffmpeg, transcribes the voiceover, and breaks down the hook, structure, and CTA. An LLM cannot watch a video, so it samples it instead.
• Brief. Acts as your CMO and pins down one CTA and the exact outcome you sell before generating anything.
• Generate. Produces 5+ aligned copy plus image/video variations through Higgsfield, each dropped into its own creative folder.

Most ad creative fails because it was made in a vacuum. No swipe file, no proof, no teardown of why the competitor's ad has been running for six months straight. You launch, you burn budget, you learn nothing.

Advertising Ops templates what already works. The core trick is the filter: it combines an old start date with an active status, so you only ever look at ads the advertiser is still paying to run. A winner, not a coin flip. Then it tags every ad back to the page that ran it, so your swipe file is fully sourced.

The Apify run returns URLs and metadata, never the actual files. So the skill downloads what it needs to see it: image ads get pulled with curl and read directly, video ads get downloaded then sliced by ffmpeg into scene-change frames plus a dense first-2-seconds hook burst, and the audio is transcribed for the spoken script. Then Claude reads the frames and the transcript and writes the teardown.

One command with npm:

npx advertising-ops install

That drops the skill into ~/.claude/skills/advertising-ops/. Restart Claude Code, then run /advertising-ops. Tell it where to put the report and the creatives once and it saves those paths, so every future run reuses them without asking.

Two MCP servers connected in Claude Code, plus ffmpeg only if you audit video ads:

• Apify MCP for the ad scrape (the brilliant_gum Facebook Ads Library actor, the only one that reports each ad's run time).
• Higgsfield MCP for the image and video generation.
• ffmpeg for video teardowns (brew install ffmpeg). Image-only runs never touch it.

• Advertising Ops on GitHub (the skill repo, MIT)
• Advertising Ops on npm
• Get Higgsfield MCP access (my affiliate link, every image + video model in one credit pool)
• Apify MCP server (@apify/actors-mcp-server, grab your token at console.apify.com)

/carousel runs an interview-first, approval-gated pipeline that turns one topic into a finished, on-brand Instagram carousel:

• Loads your framework. Reads a reference deck (shipped in the repo) so it mirrors your exact layout: two-tone headlines, one orange highlight word, glow images, CAPS-word body lines.
• Interviews the idea. Breaks your topic into 4 to 6 pillars, each doing one job, plus a CTA keyword and deliverable.
• Generates a cover (Higgsfield, 4:5). 3 to 4 options, no baked-in text. The one you pick becomes the theme anchor for every other image.
• Drafts the copy with live character counts. Every line is budget-checked against the real Canva text boxes BEFORE a single image credit is spent. You approve the draft first.
• Generates theme-locked pillar images (Higgsfield, 16:9). Each middle image is passed the cover as a reference so the whole deck shares one palette, lighting, and mood. No drift.
• Assembles the deck in Canva. Duplicates your template, replaces text span-by-span (preserving the orange highlight), and swaps images with update_fill so the frame glow survives. Nothing commits until you approve the preview.
• Writes the caption. Automatically runs the bundled /short-form-caption so the post copy and the on-slide CTA keyword match.

A carousel is three tools in a trench coat: an image generator, a copy doc, and Canva. Most people tab between them for an hour per post and the deck still drifts off-brand. This command runs the whole thing from your terminal and keeps it on-template by design.

The trick is the character budgets. Canva text boxes are sized for specific lengths. Go over and the text reflows, the slide stops matching the deck, and the carousel loses its visual unity. The command enforces the budgets on the draft, so over-length copy never reaches Canva and never burns image credits on a deck that won't line up.

/short-form-caption ships in the same package and runs as the final step of every carousel. It also works standalone on any video transcript or topic blurb. Output is a tight, copy-paste-ready IG / TikTok / Reels caption: CTA on line one, fragment rhythm, exactly 5 hashtags, 500-character hard cap, no em dashes, written in your voice from a fingerprint file you fill in once.

Two MCP servers connected in Claude Code, plus an 8-page Canva template you own (the repo ships a reference deck to recreate):

• Higgsfield MCP for the cover and pillar images (uses the Nano Banana Pro model).
• Canva MCP to duplicate your template and edit text plus image fills in place.

As a Claude Code plugin:

/plugin marketplace add charlesdove977/carousel-builder
/plugin install carousel-builder@carousel-builder

Or clone the repo and copy the two command files into ~/.claude/commands/. Then swap the placeholders (your Canva template ID, your handle, your brand voice file) per the README and you're live. The exact 8-slide reference deck ships inside the repo, so you can recreate the Canva template 1:1.

This whole workflow was built inside Charlie OS, my one-click Claude Code setup. The Canva template, the brand context file, the voice fingerprint, and Higgsfield plus Canva already wired up all ship pre-installed and pre-configured in the OS, alongside dozens of other skills. If you're starting from zero, that's the fastest path to running this carousel command on day one.

See if Charlie OS is a fit →

• Carousel Builder on GitHub (the skill repo, MIT)
• Get Higgsfield MCP access (my affiliate link, every image + video model in one credit pool)
• Canva MCP endpoint (add as an http MCP server, then authenticate via /mcp)

Reads your files (code, PDFs, markdown, images, audio, video) and builds an interactive knowledge graph of concepts and relationships. Exports as HTML, JSON, and an audit report. Every relationship is tagged extracted, inferred, or ambiguous, so you always know what was found versus guessed.

Inheriting a codebase or a research corpus is painful. Grep only finds what you already know to look for. Graphify gives you the structure behind the files: which nodes are load-bearing, which connections are surprising, which questions to ask first.

Walking into a new codebase. Processing a research folder full of PDFs and notes. Mapping a project's architecture before touching it. Understanding why past architectural decisions were made.

• Graphify repo on GitHub
• Obsidian (graph viewer of choice)

Open Design (nexu-io/open-design) is the open-source answer to Claude Design. Same idea, none of the lock-in. Local-first, Apache 2.0, runs on whatever coding-agent CLI is already on your machine. Claude Code, Codex, Cursor Agent, Gemini CLI, GitHub Copilot CLI plus 11 more.

Pick a skill (saas-landing, dashboard, mobile-onboarding, magazine-poster) and a design system (Linear, Stripe, Notion, Apple, plus 68 others). Fill the 30-second discovery form. Your CLI streams an artifact (HTML, PDF, PPTX, MP4) into a sandboxed iframe. Save it to disk. The file is yours.

Claude Design is closed-source, Anthropic-locked, and cloud-only. Two weeks after it shipped, Open Design dropped: same workflow, your laptop, your keys, your filesystem. Artifacts land as real files under .od/projects/<id>/. Git them. Ship them. Deploy them to Cloudflare Pages from the app.

If you already pay for Claude Code, this is free leverage on top of your existing subscription.

• Install on Mac and Windows with the gotchas (Apple Silicon-only binary, Windows SmartScreen bypass) on the same page as the steps.
• Build from source path for Intel Macs, Linux, and WSL2. Plus the Docker variant if you do not want to touch your local Node.
• Agent setup: wire up Claude Code (or any of 16 supported CLIs), or fall back to BYOK with Anthropic, OpenAI, Azure, or Gemini keys.
• Five day-one workflows: SaaS landing, investor deck, mobile onboarding, email plus social burst, dev handoff.
• Five gotchas that will trip you up if you read the README at 1am.

Agency owners, freelancers, and operators who charge for design deliverables. Anyone who already runs Claude Code and wants to ship landing pages, decks, mobile flows, and email campaigns from the same machine. Skip it if you only push pixels in Figma.

CC Switch (farion1231/cc-switch) is a Tauri plus Rust desktop app that lives in your menu bar. Click the icon, pick a provider, your Claude Code keeps running on the new endpoint. No terminal restart. No environment variable surgery. 50ms swap.

Supports Claude Code, Codex, OpenCode, Gemini CLI, OpenClaw, and Hermes Agent. 50 plus preset providers including Anthropic, Bedrock, OpenRouter, NIM, plus full custom config for your own proxy.

On April 21 2026, Anthropic briefly delisted Claude Code from the $20/mo Pro plan. The Reddit thread hit 2,600 upvotes in a day. The Register and XDA covered it. Half the community started routing Claude Code through Bedrock, OpenRouter, and self-hosted proxies overnight.

CC Switch became the cleanest way to do that without losing your mind. It also doubles as MCP server management and Claude Skills sync, bi-directional, so both your Claude Code config and your CC Switch config stay aligned.

If you ever burn through your Pro plan limit and want to keep coding without paying API rates, this is the tool.

• Pro plan users who hit the rate limit weekly and want a clean fallback to Bedrock or OpenRouter
• Teams managing multiple CLIs (Claude Code plus Codex plus Gemini) from one machine
• Anyone running a custom proxy (Cloudflare AI Gateway, LiteLLM, internal routing) who wants a one-click switcher
• MCP server tinkerers who want a GUI instead of editing JSON

macOS: download the latest .dmg from the GitHub Releases page. Windows: .exe installer. Linux: .AppImage.

First launch will ask for permission to read your ~/.claude/ config. Grant it. The app reads your existing Claude Code setup, lists detected providers, and lets you add new ones with a few clicks.

Shipping releases multiple times a day right now. Keep auto-update on.

• CC Switch on GitHub (72k plus stars)
• Latest release downloads

Clawdmeter (HermannBjorgvin/Clawdmeter) is a DIY ESP32-S3 desk gadget with a 2.16-inch AMOLED screen. It pairs to your Mac over Bluetooth, reads your Claude Code usage live, and displays Current and Weekly progress bars on its tiny screen. A pixel-art mascot called Clawd animates faster as you near your rate limit.

Five days old. 1,000 plus stars. TechCrunch covered it. CNX Software covered it. The first physical product built specifically for Claude Code.

If you live in Claude Code all day, you check your usage dashboard 15 times a day. That is 15 context switches that wreck your flow.

Clawdmeter puts your usage on a small object sitting next to your keyboard. Glance, see the bars, get back to coding. No browser tab. No dashboard refresh. No mental tax.

The hardware is $30 in parts from AliExpress. The firmware and Mac pairing app are open source. The whole thing was built by one developer in Iceland using Claude Code.

• ESP32-S3 dev board with built-in 2.16-inch AMOLED display (around $25 on AliExpress)
• USB-C cable for flashing and power
• Optional: 3D-printed case (STL files in the repo)

Total: $30 to $40 including shipping. Same parts the creator used.

Flash the firmware from the repo using esptool or the Arduino IDE. Download the Mac companion app from GitHub Releases. Pair over BLE, grant the app permission to read your Claude Code usage logs, mount the device on your desk.

Linux and Windows companion apps are on the roadmap.

• Clawdmeter on GitHub
• Mac companion app downloads

Most of you are running your business with 10 to 15 browser tabs open. Gmail, Drive, Calendar, Docs, Sheets. All day.

I just set up a free open-source CLI that connects Claude Code directly to all of it.

• Check my calendar for the week
• Send emails. I literally sent my business partner an email with the subject "fart head" as a test
• Browse my entire company Google Drive
• Read Google Docs without opening them
• Upload files straight to Drive

No browser. No tabs. One terminal window.

Setup took 20 minutes. The auth token never expires. Set it and forget it.

The PDF below is the full playbook: installation steps, every command you need, troubleshooting tips, and how to wire it into Claude Code.

I charged a client ten thousand dollars to build them a personal AI assistant.

It reads every document in their business. SOPs, contracts, sales call transcripts, onboarding docs. Ask it anything and it answers with exact citations. Not hallucinations. Actual references.

Today I published a full tutorial showing how to build the exact same thing for free. Two tools. No coding. No monthly fees.

• Sales recon notebooks. Feed call transcripts in and generate presentations for your next close.
• SOP notebooks. Give your team something they can chat with instead of constantly bugging you.
• Client onboarding notebooks. Keep project knowledge updated as things evolve.

The secret sauce is stacking NotebookLM, which is free from Google, with Claude Code. NotebookLM stores and processes the data. Claude Code automates the whole thing.

Together, they act like a sixty thousand dollar employee that never forgets anything.

The kicker: NotebookLM does not cost you extra tokens. You are basically getting a second AI brain for free on top of your Claude subscription.

Is it possible to use Claude Code to generate high-quality ad images, YouTube thumbnails, and social media content? Yes.

It's called the Nano Banana MCP server, and paired with Canva's Magic Layers, it might be the best image creation stack available right now.

• Generating images from scratch
• Editing existing ones
• Iterative refinement
• Style transfers
• Combining it all with Canva for scalpel-level editing on every asset you create

No more context switching between Midjourney, Google AI Studio, and your code editor. One terminal. One conversation. Production-ready images at any aspect ratio.

I also show the old way I used to do this with HiggsField and custom GPTs, so you can see exactly why this stack is a game changer.

• Nano Banana MCP server
• Go Viral Bro plugin
• Setting up Claude Code in VS Code (playlist)

Audits websites for AI search visibility (ChatGPT, Claude, Perplexity, Gemini, Google AI Overviews) with 13 specialized subskills covering citability, crawler access, llms.txt, brand mentions, schema, technical SEO, and content quality. Generates client-ready reports including PDFs with charts.

Traditional SEO still matters, but AI search is where traffic is going. If your site isn't getting cited by AI, you're invisible to a growing slice of users. This skill audits the gap and tells you exactly what to fix.

Onboarding a client website. Pre-launch checks. Auditing your own sites. Building reports you can hand off without editing.

This video is going to show you how to turn Claude Code into a real content engine, not just a script writer.

Most creators are stuck in reaction mode. Every day they wake up wondering what to post, what angle to take, what hook might work, and whether the content will land. That is not a system. That is survival mode.

Go Viral Bro fixes that.

Inside the video, I walk through the exact Claude Code workflow I built to research what is already working in your niche, break down your competitors, generate stronger content angles, write better hooks, script full videos, analyze your winners, and feed that data back into the system so it gets smarter over time.

This is the same kind of loop that used to require a team of researchers, writers, strategists, and VAs. Now you can run it through Claude Code.

• Install the Go Viral Bro plugin step by step
• Set up onboarding and training so Claude understands your brand, audience, competitors, and posting style
• Use /viral discover to scrape competitor content and trending ideas across YouTube, Instagram, Reddit, and GitHub
• Transcribe videos, study verbal hooks, and break down visual hooks so you understand why content wins
• Use /viral angle to generate stronger content ideas based on contrast, not guesswork
• Use /viral script for long-form scripts, short-form scripts, LinkedIn posts, hooks, talking points, filming cards, and CTAs
• Use /viral analyze to study your own top-performing content and see what's actually working
• Use /viral update-brain to feed winning data back into the system so your agent improves with every post

You are not just installing a plugin here. You are building a repeatable content pipeline.

• You create content for your business and want a system
• You are tired of guessing what to post
• You want Claude Code to help with growth, not just coding
• You want better hooks, angles, and scripts
• You want your content process to improve over time instead of starting from zero every day

The goal is simple: stop posting based on vibes. Start posting based on a system that learns.

Built by Hao (駱君昊). Feed it your existing posts, it learns the rhythm of how you write, then it drafts a two-week posting calendar and pushes the posts out across Facebook, Instagram, Threads, and X.

What makes this one worth pulling in is the proof. The author posted his own first auto-generated post and it broke through hard: 72K reach, 358 likes, 443 comments, and 700 new community members. Day two flopped. He wrote a postmortem about why and shipped it inside the same repo. Most "AI content" repos hide their losses. This one teaches from them.

• Voice fingerprint from your existing Facebook content
• 14-day content calendar generation
• Cross-post to Facebook, Instagram, Threads, and X
• Day-2 flop postmortem doc included as a teaching artifact

Run this after Go Viral Bro generates your script. Go Viral Bro handles the research and the script. This one handles the voice, the calendar, and the multi-platform push.

By wshuyi. If you've ever tried to publish a long-form article on X, you know the pain: copy from Markdown, paste into X, watch every bold, link, and heading disappear, then spend 20 minutes re-formatting by hand. Each image is a five-click upload. Each Mermaid diagram is impossible.

This skill kills that workflow. You point Claude Code at a Markdown file. It opens X Articles, types the content, applies the formatting, uploads the images in the right positions, renders Mermaid as images, drops the cover. Done in 2-3 minutes.

• Markdown to X Articles, end to end
• Cover image auto-upload
• Inline image upload at exact positions in the article
• Tables rendered as images for visual fidelity
• Mermaid diagrams rendered to images
• Divider support and cross-platform clipboard
• 10x time reduction per article (20-30 min down to 2-3 min)

Use Go Viral Bro to research your angle and generate the long-form script. Use this skill to ship it to X Articles in minutes. Claude Skill Social Post handles the short-form cross-post across FB, IG, Threads, and X feed. Together: research engine, long-form distribution, short-form distribution.

I've been using an unpackaged version of this in my Claude workspace to generate leads. After getting some requests to share it, I turned it into a plugin with skills.

It uses Chrome via the browser extension to run. No hidden costs, no fees, you just need a Claude Code plan.

• DM Connections. Send personalized openers to your existing connections.
• Answer DMs. Reply to unread messages with contextual, on-brand responses.
• Create Posts. Generate LinkedIn content from proven templates.
• Grow Network. Send strategic connection requests to ICP matches.

• /linkedinoutreach — Setup wizard. Configure profile, ICP, voice, schedule.
• /linkeddmconnections — DM existing connections with personalized openers.
• /linkedanswerdm — Answer unread DMs with contextual responses.
• /linkedinpost — Generate posts from templates.
• /linkedconnect — Send connection requests to ICP matches.

A pack of 15 dedicated skills that turn Claude Code into a production-ready video prompt engine for Seedance 2.0. You describe the concept. Claude handles camera control, lighting, consistency, and the full production pipeline. One prompt in, fully engineered video prompt out.

• Brand ads
• Product shots
• Cinematic scenes
• Anime
• E-commerce videos

Basically any style you can describe. The ninja scene demo was generated 20 minutes before filming. That is the speed.

You are combining the smartest LLM on the market with the best video generator and offloading the prompt engineering entirely to Claude. No more wrestling with prompt syntax. No more hunting for camera direction. The skills already know what Seedance 2.0 needs and Claude writes to spec automatically.

Wired into Playwright CLI for browser automation. Once Claude builds your prompt, Playwright logs into Higgsfield, selects Seedance, pastes the prompt, uploads reference images, and starts generation. You keep building inside Claude Code while videos render in the background.

1. Grab the repo at github.com/beshuaxian/higgsfield-seedance2-jineng
2. Paste the repo link into Claude and ask it to install the skills
3. Give Claude your video concept and style (cinematic, product, e-commerce, anime, whatever)
4. Tell Claude: "Do your magic using Playwright"

That is it. You get a production-ready video without touching Higgsfield directly.

Sign up today and Higgsfield is running 70 percent off with unlimited Seedance 2.0 access. One of the best video generation stacks on the market, cheaper and faster than almost anything else.

Higgsfield just dropped an MCP server that plugs every AI image and video model on their platform directly into Claude Code. Nano Banana Pro, Seedream 4.5, Soul, Seedance, Kling. All running from your terminal, all through one credit pool.

You write 3 words. Claude picks the right model, writes the prompt, fires the gen.

• YouTube thumbnails
• Skool community covers
• Custom characters and logos
• AI avatars for client ads
• Product ad creative
• Cinematic 16:9 hero cuts and 9:16 shorts (rendered in parallel from one prompt)

Image AND video, side by side, no tab-switching, no re-prompting from scratch every time.

Most people stack 4 to 5 separate API subscriptions to access these models. Different billing accounts. Different keys. Different docs. Different rate limits.

Higgsfield consolidates the entire stack. One platform. One credit pool. One MCP. The cost math alone is a no-brainer once you compare your current API spend to a single Higgsfield plan.

Think of MCP as a toolbox. Every model becomes a tool inside it. Claude is the brain that figures out which tool fits the job. You stop being the prompt engineer and start being the orchestrator.

Feed Claude your brand context once. Every image and video Claude generates after that lands on-brand without you re-explaining the rules.

1. Visit higgsfield.ai/mcp and grab the MCP link (free starter plan available, or get MCP access through my affiliate link here)
2. Paste it into Claude Code and ask Claude to install the MCP for you
3. Run /mcp, click the Higgsfield entry, hit Allow to authenticate
4. Start generating: ask Claude for a thumbnail, an avatar, a 16:9 hero, a 9:16 short, anything

That is it. Claude is now connected to every model on Higgsfield, no API keys to manage on your side.

Pair this MCP with the Higgsfield Seedance 2.0 Skills already in this toolkit. The skills hand Claude pre-engineered prompt templates for cinematic, brand story, motion design, e-commerce, fight scenes, and more. Combined with the MCP, Claude picks the skill, writes the prompt, fires the gen end-to-end.

Want the Higgsfield MCP wired straight into Claude with image and video models on tap? Get Higgsfield MCP access here (my affiliate link). One subscription, one credit pool, every model in this resource.

PAUL is a free, open-source Claude Code plugin built for iterative development with human checkpoints. Plan the work, apply the changes, unify the plan against reality, then loop. Keeps every project on rails without burning context on sprawling one-shot PRDs.

GSD has been the go-to Claude Code plugin since it dropped. After using it on real client builds, I found 7 structural problems that kept showing up. PAUL solves every single one of them.

In the video I break down the 7 problems from a non-technical angle, walk through installing and using PAUL at a high level, and share my honest take on when to use GSD vs PAUL. Not about pushing you to one or the other, about giving you the perspective to pick the right tool for your project.

• PAUL: iterative client builds, longer projects, anything that needs human checkpoints between phases
• GSD: tight well-defined features that fit inside one PRD and one automated Ralph loop

• PAUL plugin on GitHub (Kahler org)
• GSD plugin on GitHub
• GSD breakdown video
• CARL deep dive video

CARL (Context Augmentation & Reinforcement Layer) is a plugin for Claude Code that replaces a static CLAUDE.md with dynamic, keyword-triggered rule sets. Instead of loading every rule on every prompt, CARL organizes rules into domains and only loads what matches the task you are working on.

Result: fewer tokens, less noise, better outputs. Claude only sees rules that actually matter.

Your rules split into domain files:

• Global - always loads. Coding standards, safety, formatting
• Development - loads when you mention fix, bug, build, test
• Content - loads when you mention script, video, YouTube, post
• Clients - loads when you mention client, deliverable, proposal
• Any custom domain you create

Each domain has trigger keywords defined in a manifest file. When your prompt matches, that domain injects into context. Everything else stays out.

Prompt: Help me write a YouTube script about CARL

CARL detects YouTube and script, loads Content (19 rules) + Global (9 rules). Total loaded: 28 rules. Dev rules, client rules, outreach rules do not load because they are irrelevant.

Run in your terminal:

npx carl-core

Choose Global (applies to all Claude Code projects, recommended) or Local (current project only). Restart Claude Code. Done.

.carl/
├── manifest      Controls domains and trigger keywords
├── global        Rules that always load
├── commands      Star command definitions
├── context       Context aware rules
└── development   Example domain

Domains: a file of related rules. You name it, define keywords, write the rules. CARL decides when it loads.

Manifest: controls activation. RECALL keywords trigger loading, EXCLUDE keywords block, ALWAYS_ON loads every session, STATE is active or inactive.

Rule format: simple key-value pairs like CONTENT_RULE_0=Write in Charles's voice direct practical no BS.

Star commands: manual overrides like *carl (open interactive help) or *brief (force short output). Create your own for any workflow.

Small CLAUDE.md files are fine at first. They break once you add project rules, client preferences, content guidelines, and workflows. Static files do not scale. Everything loads every time. Tokens wasted, attention diluted.

CARL scales with you. Add unlimited domains. Claude only loads what it needs.

Claude has a context window. The longer your conversation, the more it forgets. By the time you are deep into a multi-phase project, Claude is working with degraded context and making dumb mistakes.

Most people "solve" this by starting fresh conversations (losing context), copy-pasting requirements repeatedly (tedious), or hoping it works (it will not). GSD solves it properly.

A spec-driven development system. Instead of one long conversation that degrades, GSD:

1. Extracts requirements upfront into PROJECT.md
2. Breaks work into phases via ROADMAP.md + STATE.md for tracking
3. Plans each phase atomically with detailed PLAN.md and verification steps
4. Executes with fresh subagents, each phase gets 200k clean tokens

The key insight: curated documents beat raw conversation history.

• /gsd:new-project - guided questioning to extract what you are building. Creates PROJECT.md.
• /gsd:create-roadmap - breaks the project into logical phases. Creates ROADMAP.md and STATE.md.
• /gsd:plan-phase 1 - generates atomic task plans for phase 1. Each task has clear instructions and verification criteria.
• /gsd:execute-plan - fresh subagent picks up the plan and executes. No context degradation. Clean commits per task.

Repeat plan-phase + execute-plan per phase.

• /gsd:help - shows all commands
• /gsd:progress - where am I, what is next
• /gsd:plan-phase N - plan a specific phase
• /gsd:execute-plan - run the current plan
• /gsd:add-phase - add work to the end
• /gsd:insert-phase N - slip urgent work between phases
• /gsd:pause-work - save state, pick up later
• /gsd:resume-work - continue where you left off
• /gsd:map-codebase - for existing projects, documents what is there

Use it for: new apps from scratch, multi-phase features, anything over one session, projects where you cannot afford confusion.

Skip it for: quick fixes, single-file changes, simple scripts.

Rule of thumb: if you would normally lose track of what you are building halfway through, use GSD.

• Context engineering: PROJECT, ROADMAP, STATE, PLAN files give Claude exactly what it needs, nothing it does not
• Fresh subagents: each phase starts with full context capacity
• Atomic commits: one task = one commit = clean git history you can roll back
• Built-in verification: each task has success criteria, not just instructions

npx get-shit-done-cc --global

That is it. Commands are now available in Claude Code.

GSD treats complex builds like they deserve to be treated: with structure, documentation, and fresh context for each phase. Stop hoping Claude remembers what you are building. Make the system remember for you.

An autonomous coding agent that breaks your project into milestones, slices, and tasks, then executes them one by one with fresh context windows, automatic git commits, and real-time cost tracking.

You define the work. It runs the work.

It is not locked to Claude Code either. It supports 20+ providers, including Anthropic, OpenAI, Google, OpenRouter, and GitHub Copilot. You can even assign different models to different phases, so research uses one model and execution uses another.

Built for developers who want to ship full projects overnight instead of prompting one task at a time.

• Budget ceilings
• Crash recovery
• Stuck detection

So it does not burn tokens spinning in circles.

A skill system for Claude Code created by YC President Garry Tan. Instead of one generic assistant, you get 12 specialized modes like:

• CEO-level product review
• Paranoid code review
• Automated QA against a live URL
• Release engineering

Each mode constrains Claude to think like a specific role with specific objectives.

Better instructions in, better output out.

A framework that auto-generates command-line interfaces for any desktop application so AI agents can control software that does not have an API.

Point it at GIMP, Blender, LibreOffice, or dozens of other apps, and it analyzes the codebase, builds a full CLI with testing, and publishes an installable package.

The generated CLIs make real calls to real software, not toy wrappers.

Watch the video to see how I use the n8n MCP server to build workflows for me. Claude reads the n8n node catalog over MCP, picks the right nodes, wires them together, and hands you back a working workflow JSON you can import.

Where to get it: github.com/czlonkowski/n8n-mcp

Short video from day 3 of the 90 Days Making AI Easy series. 34 marketing skills. One command to install. The real move is what you do after you install it.

• Install the plugin in one command. Literally copy and paste.
• Stack it with the built-in /frontend-design skill so your pages look good and convert.
• Get Claude to generate a brand kit PDF with your colors, fonts, tone, and audience.
• Lock it into CLAUDE.md so Claude stays on brand every single session.

You tell Claude to build a landing page and it already knows your brand. No repeating yourself. No off-brand output. No AI slop. This is the exact setup I use for client work at C&C Strategic.

In this module you will learn how to build fully configured voice agents using Claude Code and the ElevenLabs MCP server without ever touching the ElevenLabs dashboard.

• How to install and connect the ElevenLabs MCP server to Claude Code
• How to create voice agents using plain English prompts
• How to add custom knowledge bases to your agents
• How to connect a Twilio phone number so your agent can take real calls
• 3 ways to monetize voice agents for your business or clients

• Intake receptionist for a law firm
• Customer support agent for a construction company
• After-hours agent for an accounting firm

• Claude Code (Pro or Max plan)
• ElevenLabs account (free tier works to start, Creator plan for production)
• Twilio account (optional, only if you want a live phone number)

• ElevenLabs MCP Server repo

In this episode I go deep on the Ralph plugin and compare it head-to-head with my favorite Claude Code plugin, GSD (Get Shit Done). Ralph was originally designed to spawn fresh AI instances for every task to keep quality consistent. The current Ralph plugin leads to context degradation instead. I show how to use Ralph properly with my custom script, then walk through GSD's fresh-subagents-per-phase approach.

Live demo at the end: building a Kanban Pro app using Ralph the right way, with proper context management. If you enjoyed the video, thumbs up and subscribe for more Claude Code content.

• Ralph scripts (non-monorepo + monorepo)

Claude in Chrome is a browser extension that lets Claude see, click, type, and navigate websites directly. Turn Claude into a hands-on operator that uses your active browser sessions to perform tasks without API keys or complex re-authentication.

• Automating visual testing for frontend development
• Interacting with authenticated business tools through your already-logged-in browser
• Debugging live applications with real-time console and network monitoring
• The 17 specialized MCP tools for managing tabs, recording interactions, and running JavaScript for advanced automation

The PDF below is the full playbook: install steps, every tool, real workflows you can copy, and how to wire it into Claude Code.

Computer use is a built-in MCP server inside Claude Code that lets Claude take screenshots, click, type, and scroll on your real desktop. Once enabled, Claude can drive any native macOS app, the iOS Simulator, system settings, design tools, anything a CLI or browser cannot reach. The whole loop runs from the same terminal session that wrote your code.

• Enable the computer-use MCP server in three steps from /mcp
• Grant the two macOS permissions (Accessibility + Screen Recording) once and forget about it
• Per-app approval, sentinel warnings, and the three control tiers (read, click, full)
• Five copy-paste workflows: iPhone Simulator testing, native macOS build validation, layout bug repro, GUI-only tool driving, cross-app glue
• Safety model: machine-wide lock, terminal excluded from screenshots, global Esc kill switch
• Troubleshooting checklist when computer-use does not appear in /mcp

macOS only. Claude Code v2.1.85 or later. Pro or Max plan (no Team or Enterprise yet). claude.ai authentication, no third-party providers. Interactive session, the -p flag is not supported.

Nine-page PDF playbook: enable flow, permission tiers, runtime behavior, five real workflows, safety guardrails, and a troubleshooting checklist. Built from the official Anthropic docs.

A comprehensive design system engine with 67 UI styles, 96 color palettes, 57 font pairings, 13 stack presets (React, Next, SwiftUI, Flutter, etc.), and 161 reasoning rules. Generates a tailored design system for your project before you write a line of code.

Going from "build me a landing page" to "build me a landing page that matches the vibe of a beauty spa" takes a lot of upfront taste decisions. UI UX Pro Max encodes those decisions and produces a full system in seconds.

Starting a new frontend project and you want the design language locked before code. Great for client work where you need to justify choices. Also solid for avoiding the same default aesthetic on every project.

If you are using Claude Code and you have not downloaded these three repos yet, you are behind by about a week.

All three dropped in the last few days. All three are free and open source. And each one solves a different problem you are probably hitting right now.

This one is number one on the list because it ships with 68 templates that scaffold directly into Claude Design. You pick a platform on the list, ElevenLabs for example, and you can mimic that exact design inside your own Claude Code project. Color palette, fonts, button styles, the whole system from A to Z.

Stop guessing what "good" looks like. Pick a reference site from the list and clone its design language in one shot.

Repo: VoltAgent/awesome-claude-design (1.4k+ stars)

This is the open-source version of Claude Design. And the coolest part is that you are not locked into the Claude subscription to use it. It runs locally on your computer with your favorite model.

You are not stuck in the Claude ecosystem. You can run it with a local AI model if you want. And for the skeptics out there, your data stays on your machine.

Repo: OpenCoworkAI/open-codesign (2k+ stars, actively pushed)

I saved this one for last because it is completely different from the first two and a lot more dynamic.

Here is how it works. Your main agent sits as CEO. It can run a team of up to 12 agents, each with a different role and a different vantage point on your project. Every agent holds its own context window, so there is no bias bleeding between them. The agents message each other, dissect what you are building, and give you a full report. Your CEO agent makes the final call.

Use this when a technical decision has trade-offs and you want a panel of perspectives before you commit.

Repo: sjsyrek/design-council (Claude Code plugin)

If you are designing a site right now, grab Awesome Claude Design first. Fastest path to a finished look.

If you do not want to pay for Claude Design, go with Open Codesign.

If you are making a gnarly technical call (stack choice, architecture, data model) and you want a team of agents to pressure-test it, spin up Design Council.

All three live side by side in my Claude Code setup. They do not overlap.

• Awesome Claude Design (VoltAgent)
• Open Codesign (OpenCoworkAI)
• Design Council (sjsyrek)

Vibeyard is a desktop IDE built specifically for AI coding agents. It wraps Claude Code, Codex CLI, and Gemini CLI in a proper workspace with multi-session management, a per-project kanban board, swarm mode for parallel agents, real-time cost and context tracking, and session resume.

You stop juggling 8 terminal windows. You start running 8 agents from one dashboard.

If you are running Claude Code seriously, you are already running multiple sessions. One for the bug. One for the new feature. One for refactoring. One for the doc cleanup.

The terminal does not scale to that. Vibeyard does. Color-coded session status, desktop notifications when a session needs input, an embedded browser tab that lets you click any DOM element and ship the selector straight to your agent, and a kanban that spawns or resumes a session per card.

• Multi-session management with split panes and swarm grid view
• Kanban board where each card spawns or resumes a CLI session in one click
• Real-time cost, token usage, and context window monitoring per session
• P2P session sharing over encrypted WebRTC, read-only or read-write, PIN-protected
• AI Readiness Score with one-click fixes for project setup gaps
• Embedded browser tab with element inspection, sends selector + URL to your agent
• Light and dark themes, full keyboard shortcut support

Requires at least one supported CLI installed and authenticated (Claude Code, Codex CLI, or Gemini CLI).

Easiest path on any OS:

npm i -g vibeyard
vibeyard

macOS, Linux, and Windows installers are also on the GitHub Releases page. Signed and notarized on Mac.

• Vibeyard repo on GitHub
• Latest release downloads

MemPalace is a local-first AI memory system. It stores your conversation history as verbatim text, indexes it in a structured palace (people and projects become wings, topics become rooms, content lives in drawers), and returns the right context back to your next session via semantic search.

Nothing leaves your machine unless you opt in.

Every Claude Code session resets. You spend the first 10 prompts re-explaining the project, the constraints, the past decisions. MemPalace fixes that.

It hits 96.6% recall at 5 results on LongMemEval with no LLM and no API key, just semantic search and a clean index. The hybrid pipeline pushes that to 98.4% on a held-out set. Numbers are reproducible from the repo.

• Verbatim conversation storage, no summarization or paraphrasing
• Structured index: wings (projects/people), rooms (topics), drawers (content)
• Pluggable retrieval backend, default is ChromaDB
• 29 MCP tools for palace reads/writes, knowledge-graph operations, agent diaries
• Temporal entity-relationship graph with validity windows, backed by SQLite
• Two Claude Code hooks for periodic and pre-compaction auto-save
• Per-message recall via mempalace sweep on top of file-level chunks

Requires Python 3.9+, a vector store backend (ChromaDB by default), and about 300 MB of disk for the default embedding model.

pip install mempalace
mempalace init ~/projects/yourapp
mempalace mine ~/projects/yourapp
mempalace search "why did we switch to GraphQL"

For Claude Code, Gemini CLI, MCP-compatible tools, and local model wiring, see the docs site.

• MemPalace repo on GitHub
• Getting started guide
• Full MCP tool reference

ACE-Step UI is a Spotify-style frontend for ACE-Step 1.5, the open-source AI music generation model. You install ACE-Step locally, point this UI at it, and you have a free, unlimited, license-clean alternative to Suno or Udio running on your own GPU.

Full songs with vocals up to 4+ minutes. No internet required after setup. You own everything you generate.

Suno is $10 to $50 a month with restricted queues, cloud-only generation, and licensing tiers that get expensive the second you want commercial use. ACE-Step 1.5 is open-source and runs on a 4 GB GPU. The UI is what was missing, until now.

You get a clean library, prompt templates, lyrics editor, batch generation, stem extraction, video export, and album art generation. Everything you actually need to ship music.

• Full-song generation with vocals + lyrics, up to 4+ minutes
• Custom mode: BPM, key, time signature, duration, style tags
• AI Enhance: LLM enriches your tags into a detailed caption
• Reference audio, audio cover, and section repainting
• Built-in audio editor (AudioMass), stem extraction (Demucs), music video generator
• Local SQLite library with playlists, likes, and search
• LAN access so you can use it from any device on your network

Requires Node 18+, Python 3.10+, an NVIDIA GPU with at least 4 GB VRAM, and FFmpeg.

Easiest path on Windows: grab the ACE-Step 1.5 portable package, then clone this UI:

git clone https://github.com/fspecii/ace-step-ui
cd ace-step-ui
./setup.sh   # or setup.bat on Windows
./start-all.sh   # starts Gradio + backend + frontend

Open http://localhost:3000 and create.

• ACE-Step UI repo on GitHub
• ACE-Step 1.5 (the AI engine)
• Full demo on YouTube

A sliding animation on your site that plays as the visitor scrolls. Three tools do the heavy lifting. The rest is just two prompts to Claude.

Three tools, one terminal:

• Anime.js, the JavaScript library that runs the animation. Get it at animejs.com.
• Anime.js Claude skill, teaches Claude the right syntax so it doesn't write old code. Repo: github.com/charlesdove977/animejs-claude-skill.
• Higgsfield MCP, makes the starting and ending images for your slide. Install page: higgsfield.ai/mcp (or get Higgsfield MCP access through my affiliate link).

Once these three are installed, you're prompt-only the rest of the way.

Visit animejs.com and grab the install command. Open your terminal in your project and paste it:

npm install animejs

Done. Anime.js is now available in your project.

This is the skill that teaches Claude how to use anime.js v4 correctly. Without it, Claude writes outdated v3 code from training data. Repo here: github.com/charlesdove977/animejs-claude-skill

One command in the terminal:

curl -fsSL https://raw.githubusercontent.com/charlesdove977/animejs-claude-skill/main/install.sh | bash

The installer asks if you want it global or per-project. Pick whichever fits your setup.

This is what generates the two images you'll need for your sliding animation. Visit higgsfield.ai/mcp and grab the install command for the Claude CLI. Paste it into Claude and hit Enter.

Need a Higgsfield account first? Get Higgsfield MCP access here (my affiliate link, free starter plan available).

Claude now has Higgsfield connected and can generate images on demand.

Ask Claude to make a starting image and a finishing image for your slide. Paste this prompt:

Create a starting image of a brain and a finished image of a brain.
The purpose is to create a sliding animation on my website.
Use my Charlieautomates brand kit.

Swap "brain" for whatever you want to animate, and swap the brand kit reference for your own. Higgsfield generates both images. The starting one is where the animation begins, the finishing one is where it ends.

Now tell Claude to wire those images into a real sliding animation on your site. Paste this prompt:

Use the starting image and finishing image to create a sliding animation
on my Charlieautomates website. Use the anime.js package as well as
the skills to implement it.

Claude uses the skill from Step 2 to write correct anime.js v4 code, drops in the images from Step 4, and ships you a working scroll-driven sliding animation. Done.

• Download the playbook PDF
• github.com/charlesdove977/animejs-claude-skill, the repo for the Anime.js Claude skill
• animejs.com, where to grab the Anime.js package
• higgsfield.ai/mcp, where to grab the Higgsfield MCP install command
• Get Higgsfield MCP access, my affiliate link if you need the subscription

You have a Claude Code skill on your machine. It dies when you close the laptop. This tutorial shows you how to wrap that skill as an Anthropic Managed Agent, deploy it to the cloud, and trigger it from a Railway-hosted dashboard from any device, 24 hours a day. The full video walkthrough is above. The written breakdown is below.

Five steps: pick a skill, install the ant CLI, wrap the skill as an agent, push it to console.anthropic.com, wire the agent endpoint to a Railway dashboard button.

You need a skill to deploy. Open your terminal and look in ~/.claude/skills/ and ~/.claude/commands/. Every file in those folders is a skill or command you have already built. Pick one.

No skill yet? Use Skillsmith to scaffold one in two minutes. It is a free open source tool built by Christopher Kahler that walks you through skill creation with guided prompts.

• Skillsmith on GitHub — install, run, get a working skill file in minutes

Pick a skill that does one thing well. Daily analytics pull, lead qualifier, carousel maker, thumbnail generator, email triage. Single purpose works best for cloud agents.

The ant CLI is Anthropic's tool for managing cloud agents. Install it with one Homebrew command:

brew install anthropics/tap/ant

Then set your API key as an environment variable. Grab a key from platform.claude.com/settings/keys and export it:

export ANTHROPIC_API_KEY=your_key_here

Verify the install with ant --help. You should see the agent, environment, session, and vault commands.

Create a new folder for your agent. Inside the folder you need three things:

• agent.yaml — the declarative manifest. Name your agent, set the model, point to the system prompt
• prompts/system.md — the system prompt. Paste your skill's instructions here
• Any extra files the skill needs to run (templates, examples, reference data)

The fastest way to scaffold this is to copy the _template/ folder from a Claude Managed Agents starter repo, then drop your skill content into the right files.

Once the folder is ready, run:

ant beta:agents create --name "my-agent-name"

The CLI uploads the agent to Anthropic's platform and returns an agent ID.

After the create command finishes, your agent lives at console.anthropic.com under the Agents tab. You can see it, edit the prompt in the browser, and test it with a live session.

To test it from the terminal, run:

ant beta:sessions create --agent your-agent-id

This kicks off a session and gives you a session ID. You can poll the session, send messages, and read responses without ever opening Claude Code. That is your cloud agent endpoint.

This is where it gets fun. We are going to host a simple web dashboard on Railway that hits your agent's session endpoint with a button click.

The fastest way to plan and build this dashboard is to combine two free Claude Code skills:

• SEED — typed project incubator. Walk through ideation: what does the dashboard do, what buttons does it have, what does each button trigger?
• PAUL — Plan Apply Unify Loop. After SEED gives you the spec, PAUL writes the actual implementation plan and applies it

Install both from GitHub, then run /seed:seed in Claude Code to start. Walk through the prompts. When the spec is ready, run /paul:plan to plan the Next.js + Railway stack, then /paul:apply to build it. The whole thing takes about an hour for a basic 1-button dashboard.

Why Railway over Vercel? Railway gives you persistent backends, easy environment variables for your ANTHROPIC_API_KEY, and one-click deployments from GitHub. Vercel is great for static sites but Railway is cleaner when your dashboard needs to make authenticated API calls to console.anthropic.com on the user's behalf.

Once the dashboard is live on Railway, point your button at POST /api/run-agent. That endpoint creates a session against your agent ID, polls until done, and returns the result. Click button. Cloud runs skill. You never open Claude Code.

• Start with one skill, not five. Get the loop working end to end before you add more buttons
• Use the same skill prompt locally and in the cloud. If it works in your Claude Code on Tuesday, it should work in the cloud on Wednesday. Do not rewrite
• Set a budget. Cloud agents run on your API key. Set a monthly cap in platform.claude.com before you wire up automation that loops
• Log every session ID. When something breaks in production, the session ID is your only window into what the agent saw and did. Save them in your Railway database
• Add a webhook destination. Instead of polling, give your agent a webhook URL to POST back to when the job finishes. Way cleaner for dashboards
• Skip Vercel if your agent does anything async. Vercel functions timeout at 60 seconds on the free tier. Most cloud agent runs take longer. Railway has no such limit
• Add a status pill to your dashboard buttons. Idle, queued, running, done, error. Users want to know what the cloud is doing

The video above shows you the live build of the agent and dashboard end to end. For deeper breakdowns, the full Railway template repo, and a community of people shipping this exact setup, join CC Strategic AI on Skool. We have walkthroughs on managed agents, the Railway template, and the SEED + PAUL workflow already inside.

If you have been using Claude Code, you have heard about the new /goal command. You set a goal and Claude keeps working until it is achieved. The problem is nobody has shown a proper use case. This is what running /goal on a real task looks like.

• Type /goal in Claude Code, then write the goal as one paragraph.
• Give Claude the context it needs: the path to the project, screenshots of what is working versus broken, any tool or account it should reach for.
• State the success condition inside the goal itself. The goal is locked when you hit enter.
• Claude plans the work, runs the loop, calls every tool it needs, and only exits when the success condition is met.

• Problem in one line. What is happening, where, and what should happen instead.
• Project path. Absolute path to the codebase so Claude does not guess.
• Evidence. A screenshot of the working state, a screenshot of the broken state.
• Permission to use tools. If you want Claude to verify on a real device, say so. Claude Computer Use can drive iPhone Mirroring, the browser, the desktop, whatever the goal requires.
• The success condition. One sentence. The clearer the condition, the cleaner the exit.

A normal prompt finishes when Claude responds. A goal finishes when the goal is achieved. Claude self-checks every loop, spawns subagents, takes screenshots, opens iPhone Mirroring, polls the deploy, refreshes the page, and keeps going. The coolest part: you can step away and do something completely different while this is happening.

• A bug that needs verification on a device you do not want to keep picking up.
• A deploy plus production smoke test where the success signal is a real URL responding correctly.
• Anything where the work spans multiple tools (code edit, build, push, browser or device test) and you do not want to babysit each step.
• Tasks that would otherwise eat an afternoon of back-and-forth with you in the loop.

• State success in concrete terms. "Works on mobile and formats correctly" is fine. "Fix it" is not.
• Hand Claude the verification path. If the only way to know it works is opening a phone, say so and give it Computer Use access up front.
• Trust the loop. Do not jump in halfway. The whole point is that you do not have to.

Claude Code is the application. Your workspace is the operating system. If the OS is garbage, no model saves you. Better prompts will not fix it. A bigger model will not fix it either.

This drops one Python file into your ~/.claude/hooks/ folder, wires three lines into settings.json, and gives you a live statusline at the bottom of every session that breaks down exactly what your context is costing you.

• ctx:N% (Nk) — total context window usage, color-coded as it fills
• cached:Nk new:Nk — prompt cache split. When new spikes, your cache broke.
• skl:Nk mcp:Nk hk:Nk — token cost from each context source. Skills, MCP servers, hook outputs.

• 3-step install (no pip, no env vars, no node modules)
• Full Python script ready to paste, ~265 lines, stdlib only
• Customization callouts: change the @charlieautomates tag to your handle, optional caveman badge, repo marker
• Full breakdown of how to read every number on the statusline
• How to diagnose a broken cache and what to trim when one category gets heavy

If you've seen [CAVEMAN] on the statusline in any of my posts, that's a separate plugin I run that compresses Claude's communication style. It's optional. The PDF shows you exactly how to delete the caveman block if you don't use that plugin, so the script works clean either way.

Full walkthrough on using Google Stitch to design a site in minutes, then hand the output to Claude Code to turn it into production-ready code. Skip the blank-canvas paralysis and ship a clean, on-brand site without learning a design tool from scratch.

• Setting up Stitch + Claude Code handoff
• Generating the first draft from a one-line prompt
• Iterating design with screenshots and prompts
• Shipping the result as a working codebase

Anthropic released Claude Channels and I recorded the full walkthrough for you. Setup from scratch plus the use cases I'm actually using in my business right now.

• 📱 Full Telegram bot setup, step by step, nothing skipped
• 🧾 Generating branded invoices from my phone and sending them via email automatically
• 📂 Managing Google Drive folders and files without opening my laptop
• 🎨 Editing images on the go with the Nano Banana MCP
• ⚡ Stacking all of these together so one text message kicks off multiple tasks

This is not a "look what's possible" video. I set this up live on camera and ran real business tasks from my phone. If you have been looking for a way to use Claude Code without sitting at your desk, this is it.

• Google Workspace (GWS) Tutorial
• Nano Banana MCP Server

New here? Joined for the GitHub Automation playbook? It's right here. Download it, read it, build your first automation today.

• How to pick a problem worth automating
• Wiring it up with Claude Code and GitHub Actions
• Testing it before the cron fires on the wrong data
• Scaling the same pattern to the next 50 things you do by hand

One afternoon of work. Your first automation running on autopilot tonight.

Ready for the full training and every skill I use in Claude Code? Watch the video.

Just dropped a breakdown on how Claude Code + Remotion can generate videos from a prompt. No timeline. No manual keyframes. Just prompt, video, minutes.

• What it actually does (and what it does not, yet)
• The exact setup and commands
• How to iterate edits fast, even from a screenshot
• Where this fits in a real creator workflow

Question for you: would you use this to replace parts of your editing stack, or is it still "too early"?

Just tested Claude Cowork on an inbox with 3,600 unread emails and it completely cleaned the whole thing in about 5 minutes. 🤯

Not only did it clear the inbox, it also built a full label management system so every new email gets organized automatically.

Most people are still manually sorting emails or paying for tools that barely help. Meanwhile AI can literally act like a personal inbox assistant if you connect the right tools.

If you want to see exactly how I set this up step by step, watch the video. The PDF below is the full Inbox Zero playbook.

Quick update. You can feed this asset to Claude before you start to help you. I forgot to share this earlier.

Most people waste a ton of time making automation docs look good by hand. I use WeasyPrint. It turns simple HTML and CSS into clean, professional PDFs automatically.

I made a beginner playbook to use it with Claude. Cheers 🥂

One prompt. Thousands of qualified leads. Apify scrapes Google Maps for any niche in any city. Claude Code reads the JSON, cleans it, and pushes every contact into GoHighLevel through MCP. Tagged, segmented, in a workflow, in a campaign. No spreadsheets, no Zapier, no VAs.

• The 5-step setup, end to end (Apify account through first campaign fire)
• The exact prompt to feed Claude Code so it runs the Google Maps scraper for you
• The .mcp.json snippet to wire the open-source GoHighLevel MCP into Claude Code
• Three real-world plays: Local Domination, Niche Outbound, Autopilot Campaigns
• Pro tips on lead scoring, deliverability, and not torching your sender reputation

• Apify (free to start, $0.002 to $0.005 per lead at scale)
• Apify Google Maps Scraper Actor
• GoHighLevel MCP (open source on GitHub)
• GoHighLevel (affiliate, free trial)

A lead engine is the easy part. It's the trust layer that actually converts strangers into buyers, and that trust layer is your content. Paid ads or organic, doesn't matter. The content is what makes a cold lead say yes.

Without it, this stack just generates traffic that bounces. With it, every lead has a reason to believe you before the sales call.

The 70% rule. YouTube long-form video converts leads roughly 70% better than short-form on Reels, TikTok, Shorts, or Facebook. Short-form earns attention. Long-form earns the sale. Both belong in the stack, but the buying decision happens inside the 12-minute video, not the 12-second hook.

One prompt pulling thousands of leads is useless if the rest of the funnel leaks. Every piece below has to exist or you're throwing leads into a bucket with a hole in it.

• A defined offer. One thing, one outcome, one price. If you can't say it in a sentence, prospects won't buy it.
• A lead intake system. A real qualifying form on a landing page, not just an email field. Capture the data you need to route the lead.
• A qualification flow. Unqualified prospects get routed out before they waste a sales call. Your time is the most expensive resource in the stack.
• A VSL landing page. A video sales letter that walks the offer start to finish, so by the time someone books, they already know the price, the process, and the outcome.
• A nurture sequence in GoHighLevel. Most leads don't close on contact one. The GHL workflow warms them for days or weeks until they're ready.

Apify plus Claude Code plus the GHL MCP is the engine. The carousel of long-form videos, the VSL page, the intake form, and the GHL nurture sequence are the chassis. Bolt them together and the difference shows up in your calendar.

"I get leads" becomes "I close clients."

This is my most used MCP server inside Claude Code, and it is the one that has made me the most money. It connects GoHighLevel, my CRM, straight into the terminal. I have thousands of conversations running at the same time, and every morning one command goes through the whole pipeline, tells me what is high quality versus low quality, and helps me triage every prospect before I start my day.

The GoHighLevel MCP is open source, free, and exposes 269 tools across contacts, opportunities, conversations, calendars, and campaigns. You install it once, point Claude Code at your account, and from then on you talk to your CRM in plain English.

• What it is. An open-source MCP server (mastanley13/GoHighLevel-MCP) that gives Claude Code 269 GoHighLevel tools.
• What you need. A GoHighLevel account, a Private Integration token, and your Location ID. Node 18+ on your machine.
• Setup time. About 10 minutes: create the token, build the server, paste two lines into .mcp.json.
• What I do with it. Triage my lead pipeline and send my marketing, every morning, from one command.
• Cost. The MCP is free. GoHighLevel has a free trial through my link below.

Most people log into their CRM, click through tabs, and eyeball their pipeline one lead at a time. That does not scale past a few dozen conversations. I have thousands.

When the CRM lives inside Claude Code, the work changes. I do not click. I ask. "Pull every fresh lead, score them high or low quality, and tell me who is worth my time today." Claude reads the pipeline, reads each contact, reads what they actually wrote in my intake form, and hands me a ranked list. Then it drafts the outreach in my voice and waits for my yes before it sends anything.

That is the unlock. The CRM stops being a place you visit and becomes an operator you direct.

• A GoHighLevel account (free trial through my link).
• Node.js 18 or newer installed.
• A GoHighLevel Private Integration token (starts with pit-).
• Your Location ID.
• Claude Code installed and working.

You need two things from inside GoHighLevel. A Private Integration token and a Location ID. Do not use a normal API key, it will not work.

1. Log in to GoHighLevel.
2. Go to Settings → Integrations → Private Integrations.
3. Create a new Private Integration. Name it something like Claude Code MCP. Leave the webhook URL blank.
4. Select the scopes you want Claude to use. For the pipeline work I do, turn on contacts, conversations, opportunities, calendars, and locations (read and write on each).
5. Save it and copy the generated token. It starts with pit-. Keep it secret, it is a password to your account.
6. Grab your Location ID from Settings → Company → Locations.

Clone the open-source server, install, and build it. One time.

git clone https://github.com/mastanley13/GoHighLevel-MCP.git
cd GoHighLevel-MCP
npm install
npm run build

That compiles the server to dist/server.js. That file is the entrypoint Claude Code will run.

Add the server to your .mcp.json. Use the absolute path to the dist/server.js you just built, and drop in your two credentials.

{
  "mcpServers": {
    "ghl": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/GoHighLevel-MCP/dist/server.js"],
      "env": {
        "GHL_API_KEY": "pit-YOUR_PRIVATE_INTEGRATION_TOKEN",
        "GHL_LOCATION_ID": "YOUR_LOCATION_ID"
      }
    }
  }
}

The GHL_API_KEY field takes your Private Integration token, not a legacy API key. GHL_BASE_URL is optional and defaults to the GoHighLevel API endpoint, so you can leave it out.

Restart Claude Code so it picks up the new server. Then test it with something read-only:

List my GoHighLevel pipelines and how many opportunities are in each stage.

If Claude comes back with your real pipeline names and counts, you are wired in. Now you can ask it to do anything those 269 tools cover: search contacts, move opportunities between stages, read conversations, draft and send email, book appointments.

I built a single command around this MCP that runs my whole lead pipeline. It works on one GoHighLevel pipeline of inbound leads, and it walks every stage with me. The shape is the same one you can build for yourself.

• New leads. Fresh intake lands in the first stage. The command reads each one and pre-scores it high quality or low quality.
• High quality. Real buyers with budget and a clear problem get routed to a personal-outreach queue.
• Low quality. Legit responders who are not a fit yet get a lighter, batched touch instead of a one-to-one email.
• Contacted. Anyone already emailed gets checked for replies, then a follow-up or an answer drafted.
• Closed. Paying customers and dead leads get filed so the funnel math stays honest.

Every morning I run it, get clear on my leads in a few minutes, and start my day knowing exactly who to talk to.

The triage logic is just rules Claude applies while it reads. High quality means an agency or business owner above a revenue floor, or someone whose intake answer names a team, clients, or real dollar amounts. Low quality means a real human who responded but does not clear that bar yet. Spam and fake emails get filed as dead.

Claude reads the verbatim answer each lead typed into my intake form, never a paraphrase, because that one field carries the most signal. Then it hands me a ranked table: name, what they said, where it routed them, and one line on why. I approve, edit, or override. Nothing moves in the CRM without my yes.

Once leads are sorted, the same command drafts the outreach. For high-quality leads it writes a short personal email in my voice that mirrors what they wrote and points them to one next step. For the lighter bucket it batches the sends so I can review ten at a time.

Two hard rules I bake in. Draft first, always. Claude shows me every email before it sends, and only fires on my explicit "send." One clear ask. Every message ends with a single low-friction call to action, no menu of links. The MCP sends through GoHighLevel, so replies thread back into the conversation and any workflow listening for an email-sent event still fires.

You do not need my exact command. You need the pattern. Build one pipeline in GoHighLevel for inbound leads, give it clear stages from new to closed, and capture an open-ended intake question on your form. That open-ended answer is your highest-signal field.

Then point Claude Code at it through the MCP and describe the job in plain English: read the new stage, score each lead high or low, route them, draft outreach in my voice, and wait for my approval before sending. Save that as a reusable Claude Code command and you have your own morning operator.

One warning. Lead engines are the easy part. The trust layer that converts a stranger into a buyer is your content. Pair this CRM automation with real long-form video and a clear offer, or you are just moving cold leads around faster. See the Unlimited Leads playbook for the front half of this same stack.

• GoHighLevel MCP on GitHub (open source, 269 tools)
• Start a GoHighLevel free trial (affiliate link)
• Unlimited Leads: Apify + Claude Code + GHL (the lead-gen half of the stack)

In this video, I show how to level up your Claude Code projects by stacking research, planning, and building processes. Using the Get Shit Done plugin and Anthropic's frontend design skill, we skip the generic AI look and produce a professional UI that stands out.

• Reviewing and polishing different law firm website templates
• Choosing color palettes
• Design enhancements to produce a clean, functional, aesthetic UI
• Tips for achieving a top-notch UI on every project

Follow along for the full approach, key insights, and tips.

Most people use Claude Code like a single brain. That's the mistake.

Subagents let you split work into clean, specialized units so you get speed without losing accuracy.

• You are the orchestrator
• Subagents are contractors
• Main context stays clean
• Work runs in parallel when possible

• Use Explore for all codebase questions
• Parallel execution for independent tasks
• Sequential execution when order matters
• One message = parallel, multiple messages = sequential
• Background agents for slow tasks

If you're not orchestrating subagents intentionally, you're leaving Claude Code's biggest advantage on the table.

This playbook teaches how to think, not just which buttons to press.

Most people think they're using agents. They're not. They're just chatting harder.

1. Treating Claude like a solo worker. One long session. One brain. Context rots. Output drops. The fix is orchestration, not more prompting.
2. Using subagents for everything. Subagents are invisible and sequential. They're fine for lookup and research. They break down when tasks interact.
3. Avoiding agent teams because setup feels complex. If the process matters as much as the answer, agent teams win. Parallel execution beats faster typing every time.
4. Letting agents overwrite each other. No task sizing. No file boundaries. Chaos. Clear scopes and directories are non-negotiable.
5. Staying in build mode instead of lead mode. If you're still writing code alongside agents, you're the bottleneck. Your job is coordination, review, and decisions.

Claude isn't the problem. How you run it is.

This playbook shows how to run AI like a real team, not a chat box.

Charles J Dove here. I wrote this playbook the week Claude Design shipped. It is what I handed the CC Strategic team on day one so nobody wastes another client call pretending Figma is still the fastest path.

Eight pages, zero fluff. The three features that matter, the exports that kill the design-to-code MCP layer, and the agency play that turns one subscription into three deliverables in an afternoon.

• The 3-feature breakdown: web capture, direct handoff to Claude Code, pricing that undercuts Figma and Stitch on the same invoice.
• Agency client-work play: prototype, export, approve, ship, in one afternoon.
• 60-second setup: how to start your first project from a text prompt, a sketch photo, a DOCX, or any live URL.
• Refine and export: every way to iterate (chat, inline comments, sliders) and every way to ship (URL, Canva, PDF, standalone HTML).

Agency owners, freelancers, and operators who charge for design deliverables. Anyone on a Claude Pro, Max, Team, or Enterprise plan already owns this tool and should be using it this week at Charlie Automates we run every client landing page through it now.

Skip it if you do not ship design work for money.

Open claude.ai/design in a new tab, sign in with your Claude account, and accept the research-preview disclaimer. Two panes, chat on the left, canvas on the right. Download the playbook first so you know which three features to test before the novelty wears off.

PHP backend (Laravel) with Vue 3 frontend. Inertia bridges them so you feel like you're writing a SPA, but you're really writing server-side controllers that return "pages" like traditional server-rendered apps.

Dodges the usual SPA complexity tax. No separate API to maintain, no state sync headaches, no JWT juggling. Ship features fast because the backend drives everything.

laravel.com, inertiajs.com

Monolithic SaaS. Admin-heavy apps. Internal tools. Any time you want the shipping speed of server-rendered apps with the UX of a modern frontend.

The default modern React stack. File-based routing, server components, streaming, built-in API routes. Pairs with Vercel for zero-config deploys.

React owns the biggest frontend ecosystem. Next.js is the least-painful way to ship production React without assembling five tools yourself.

nextjs.org

SaaS apps, dashboards, marketing sites, most "I need a modern web app" jobs. If you're hiring or your team already knows React, this is the path of least resistance.

Ships zero JavaScript by default. "Islands" architecture lets you drop in React, Vue, or Svelte components only where interactivity is actually needed. Built-in content collections for markdown-heavy workflows.

Next.js is overkill for content sites. Astro is faster, lighter, and framework-agnostic in the components you do need.

astro.build

Blogs, documentation sites, marketing pages, portfolios. Any site that's 80% static content with a few interactive pieces.

Desktop app framework with a Rust backend and a web frontend (React, Vue, Svelte, whatever you already know). Uses the OS's native webview instead of bundling Chromium, which is the thing that makes Electron so heavy.

Electron ships a full browser with every app. Tauri doesn't. Result: 10MB binaries instead of 150MB, less memory, better performance, stronger security model. You keep writing UI in web tech.

tauri.app

Desktop apps for your own workflows (dashboards, local AI agents, pipeline controllers). Cross-platform tools that need native-feeling performance. Anywhere Electron is overkill for what you're actually shipping.

Frameworks for building rich terminal interfaces with keyboard navigation, layouts, tables, forms, and real-time updates. Three picks by language:

• Ratatui (Rust)
• Bubble Tea (Go, from Charm)
• Textual (Python, CSS-styled)

Pick based on which language you're already fluent in.

Terminals are where developers live. A well-made TUI (Claude Code itself is one) is faster than a GUI for power users, works over SSH, and ships as a single binary. The three frameworks above own their respective ecosystems.

ratatui.rs, charmbracelet/bubbletea, textual.textualize.io

CLI tools that need more than flags and stdout — interactive installers, dashboards, wizards, REPLs, log viewers, admin tools for yourself or your team.

I gave Claude Code access to my Google Analytics last week. The first thing it told me was that less than 3% of my traffic comes from Google search. Two of my biggest blog posts have never been clicked on from a search result. And every conversion on my site was being tracked as a zero, because I'd never told Google what a "win" looks like.

That's the honest read on charlieautomates.com from data I'd been staring at for a year and somehow missing.

This resource gives you the same view of your own business. Once it's wired in, you stop staring at dashboards. You ask questions in plain English and your AI tells you what's working, what's leaking, and what to fix this week. Setup takes about fifteen minutes once and then works forever.

Two free MCP servers that run side by side inside Claude Code on your laptop.

• analytics-mcp by Google's official analytics team. Reads everything in your GA4 property: traffic, sessions, engagement, conversions, real-time visitors, funnels. GitHub.
• search-console-mcp by Charles J Dove (me). Reads everything in your Search Console: the keywords people search to find you, your rankings, your page-2 opportunities, your low-CTR fixes. MIT licensed, free. GitHub.
• A ready-to-paste /seo-snapshot Claude Code skill bundled inside the search-console-mcp repo. Runs a full SEO read in one prompt.

I built the second one this week because Google's official MCP only covers Google Analytics 4, and GA4 hides organic search keywords. They're stored as "(not provided)" inside GA4. The actual keywords live in Search Console, which is a totally separate Google product with its own API. Without a Search Console MCP, your AI literally cannot see your keywords.

Six things, all free.

If you do not have gcloud or pipx yet, install both with Homebrew on Mac:

brew install --cask google-cloud-sdk
brew install pipx
pipx ensurepath

On Windows, Google has installers for both.

Open console.cloud.google.com and either pick a project you already have or click "New Project". Name it anything. I called mine mcp-analytics. Cost: zero, as long as you stay inside the free API quota. You will.

Inside your new project, you need to enable three APIs. Search Console is the one most people forget.

1. Google Analytics Data API
2. Google Analytics Admin API
3. Google Search Console API

For each one, paste this URL pattern into your browser, replace YOUR_PROJECT_ID with your project ID, and click the big "Enable" button when it loads:

https://console.cloud.google.com/apis/library/analyticsdata.googleapis.com?project=YOUR_PROJECT_ID
https://console.cloud.google.com/apis/library/analyticsadmin.googleapis.com?project=YOUR_PROJECT_ID
https://console.cloud.google.com/apis/library/searchconsole.googleapis.com?project=YOUR_PROJECT_ID

Three pages, three clicks. Done.

Open your terminal and paste this as one line. Do not let your terminal split it across multiple lines or it will break:

gcloud auth application-default login --scopes=openid,https://www.googleapis.com/auth/userinfo.email,https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/analytics.readonly,https://www.googleapis.com/auth/analytics.edit,https://www.googleapis.com/auth/webmasters.readonly

A browser window opens. Sign in with the Google account that owns your Analytics and Search Console. You will see a consent screen listing the permissions. Approve all of them.

This creates a token on your computer that lets Claude Code authenticate as you forever after. You only do this step once.

In your terminal:

pipx install analytics-mcp
pipx install search-console-mcp

Both servers install in clean, isolated environments. They do not fight with anything else on your machine.

In your Claude Code project, open or create the file .mcp.json at the project root. Add this block:

{
  "mcpServers": {
    "ga4": {
      "type": "stdio",
      "command": "analytics-mcp",
      "env": { "GOOGLE_PROJECT_ID": "YOUR_PROJECT_ID" }
    },
    "search-console": {
      "type": "stdio",
      "command": "search-console-mcp",
      "env": { "SC_SITE": "sc-domain:yourdomain.com" }
    }
  }
}

Replace YOUR_PROJECT_ID with your Google Cloud project ID. Replace yourdomain.com with your actual domain. Use sc-domain: if you have a domain property in Search Console, or paste the full https://www.yourdomain.com/ if you have a URL property.

Close Claude Code completely. Open it back up. The MCPs load at startup, so a restart is required.

That is it. You are done. Total time including the OAuth screen, about 15 minutes.

These are the prompts I use every Monday morning. Copy and paste them straight into Claude Code.

Quick wins to start

• "Show me my top 10 pages by sessions for the last 30 days, with engagement rate and conversion rate. Flag any page where engagement is above 60% but sessions are below 100. Those are hidden winners I should promote."
• "Pull my top 25 organic search keywords from Search Console for the last 30 days. For each one, tell me which page is ranking and whether the position is page 1, page 2, or worse. Sort by impressions."
• "What pages got organic search traffic last month but had less than 30% engagement rate? Those are pages where Google is sending visitors who do not like what they see."

The leaky-funnel scan

• "Compare last 7 days to the prior 7 days. Show me which pages saw sessions drop more than 20%, and which sources sent fewer visitors. Flag anything that looks like a leak."
• "For each of my top 10 traffic sources last month, what was the average engagement rate and conversion rate? If any source has high traffic but engagement under 30%, tell me what to fix."

The hidden SEO opportunities

• "Find Search Console queries where my page ranks position 11 to 20 (page 2 of Google). Sort by impressions. Tell me which page is ranking for each one. These are my fastest possible SEO wins."
• "Find Search Console queries with more than 50 impressions but a click-through rate under 3%. My title tag or meta description is probably weak. Tell me which page ranks for each and suggest a sharper title."

The cross-data join (the magic)

• "For each of my top 10 landing pages from Google Analytics, also pull the Search Console queries that drove organic traffic to that page. Combine them so I can see this page gets X sessions from these specific keywords."
• "Find pages with strong engagement in Google Analytics (above 50%) but zero impressions in Search Console. Those are good pages Google has never seen. They need internal links and a sitemap push."

The conversion truth-check

• "Look at every page that received a key event (conversion) in the last 30 days. Group by page. Tell me which pages are driving 80% of my conversions. Then tell me how much traffic each one gets so I can calculate conversion rate per page."

I am going to save you a few hours by listing every wall I hit in real time.

Wall 1: Google blocks the default scopes during login. You will see a screen that says "This app is blocked." Google's default gcloud OAuth client is no longer allowed to request "sensitive" scopes like analytics.edit. The fix: create your own OAuth client inside your Google Cloud project, download the JSON, and pass it to gcloud with --client-id-file. Full walkthrough lives in the search-console-mcp repo at docs/SETUP.md. About 20% of users hit this.

Wall 2: Your terminal splits the gcloud command across multiple lines and breaks it. Zsh and Bash will sometimes wrap long commands and treat each wrapped piece as a separate command. If you see errors like zsh: no such file or directory: --scopes=..., that is what happened. Paste the command as one long line, with no backslashes, no spaces in the middle.

Wall 3: GA4's Property Access Management refuses to add a service account email. The error says "This email does not match a Google Account." If you tried to set this up with a service account, that is why. Skip the service account path entirely and use Application Default Credentials (ADC) instead. That is what the setup above does. Your own Google login becomes the authentication, and you already have GA4 admin access on your own account.

Wall 4: Your organization blocks service account JSON key creation. If you work inside a Google Workspace organization with hardened security defaults, you may see a popup that says "Service account key creation is disabled." Again, ADC bypasses this entirely. You do not need a service account.

Wall 5: The token works but tools return 403 "insufficient scopes." The token is real but does not include the scope the tool needs. Check what is on your token:

TOKEN=$(gcloud auth application-default print-access-token)
curl -s "https://oauth2.googleapis.com/tokeninfo?access_token=$TOKEN" | python3 -m json.tool

If webmasters.readonly is missing, rerun the gcloud login command with that scope in the --scopes flag.

Wall 6: Empty results. If a tool returns no data, two things are usually true. Either your site is too new for Google to have aggregated enough searches yet (Search Console has a privacy threshold and hides queries with fewer than 10 monthly impressions), or your time window is too short. Try 90 days instead of 30. The data will be richer.

A "leaky funnel" is anywhere visitors fall out of your sales process. Here is how to find each pattern using the MCPs.

Leak 1: High-traffic page with low engagement. Use the GA4 MCP to find pages that get lots of sessions but where most people leave fast. These are pages that promise something the visitor does not find. The fix: rewrite the headline, add a clear above-the-fold hook, or improve the page-to-source match.

Leak 2: High-intent page with weak conversion path. Look at pages people land on with clear buying intent (pricing page, comparison page, case studies). If they have low conversion rate, your CTA is invisible or weak. The fix: one clear CTA above the fold, repeated halfway down, repeated at the end.

Leak 3: Search clicks with no follow-through. Pull Search Console queries that drive clicks but where engagement on the landing page is under 30%. These are people who searched, clicked, and immediately left. Your page does not match what they expected. The fix: rewrite the first 50 words of the page to address the exact thing they searched for.

Leak 4: Sources that send traffic but never convert. Group GA4 data by source/medium and look at conversion rate per source. If Facebook is sending you 500 clicks a month and your conversion rate from Facebook is 0%, that is a leak. The fix: install link tagging so you can prove which campaigns convert, then kill the dead ones.

Leak 5: The "(not set)" rows. GA4 sometimes shows "(not set)" or "Unassigned" rows that bounce at 100%. That is almost never real human behavior. It is broken tracking, missing UTM tags, or a redirect stripping data. Find these by asking Claude to surface any traffic-source row with bounce rate above 95%. The fix: audit your tag setup, check your redirects, make sure every campaign link has proper UTM parameters.

This one is going to save you more than the setup itself. If you take only one action from this whole resource, take this one.

Most Google Analytics setups have zero conversion events configured. Zero. That means your dashboard says you got 4,500 visits last month but it has no idea how many of those visits turned into anything. Sign-ups, downloads, purchases, calls booked. All invisible.

Without conversion events, every page on your site shows a conversion rate of zero, every traffic source shows a conversion rate of zero, every campaign shows ROI of zero. You are flying blind.

To fix it, mark these as "key events" in GA4 (this is GA4's word for "conversion"):

1. Form submissions on your lead magnet
2. Clicks on your primary CTA button (book a call, buy now, sign up)
3. Pageviews of your thank-you page
4. Outbound clicks to your Skool, Discord, or Stripe checkout
5. Scroll depth past 90% on your sales pages

You can set these up manually in GA4 Admin then Events then Create event, then mark them as key events. Or, since you just gave Claude Code write access via the analytics.edit scope, just ask Claude:

Create a GA4 key event called book_call_clicked that fires when someone clicks an outbound link to charlieautomates.com/charlie-os-vs/ on any page of my site.

If you do not have conversion events configured, do this before you do anything else with the MCPs. Otherwise the "find my leaky funnels" prompts will tell you everything has a conversion rate of zero, which is technically accurate but useless.

Do I have to be a developer to set this up? No. If you can paste a command into a terminal and click through a Google sign-in screen, you have what you need. The terminal commands are copy-paste. The Google steps are clicking enable buttons.

Does this cost anything? Both MCP servers are MIT licensed and free. Google's Analytics Data API and Search Console API are both free up to quotas that no solo business will ever hit. Total cost: zero dollars per month.

Will my data leave Google? No. The MCP servers run on your laptop. When Claude Code asks them a question, they call Google's APIs directly using your login, get the data, and pass it to the conversation in your terminal. Nothing gets uploaded anywhere.

Can I use this with Cursor or another AI tool, not Claude Code? Yes. Both MCP servers speak the standard Model Context Protocol, which Cursor, Continue, and other modern AI tools also support. The setup is identical.

I gave Claude write access. Can it break my Analytics setup? Technically yes. The analytics.edit scope can create or modify GA4 properties, events, audiences, and custom dimensions. In practice, Claude only does what you ask it to do, and you can always undo changes through the GA4 admin UI. If you want a safer setup, drop analytics.edit from your scope list and only use analytics.readonly.

Full long-form version of this walkthrough lives on the blog at /blog/claude-code-google-analytics-mcp-tutorial/ if you want a single-page read.