Free Resources

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)

If you are still pasting video links into Claude and expecting it to watch the whole thing, it is not watching. It is reading.

Claude gets the transcript, so it knows what was said. It has no idea what was shown. Every caption, every cut, every sticker, every number burned onto the screen, gone. Then it summarizes the video back to you like it sat through the whole thing.

For a podcast that barely matters. For a competitor reel where the entire hook is a text card, you just threw away the part you were trying to study.

watchvideo downloads the video, takes actual frames off the screen, transcribes the audio on your own laptop, and hands Claude both halves at once. Then it writes the whole thing to a folder you can read later.

Four free tools, no API key, no account, no per-minute billing:

• yt-dlp pulls the file down
• ffmpeg extracts the audio and the visual frames
• Whisper transcribes locally, so nothing gets uploaded anywhere
• Claude reads the frames with its own eyes, inside the session you already have open

Nothing here talks to a paid service. A run costs you CPU time and that is it.

Here is the part that makes it usable instead of theoretical.

The obvious way to give Claude a video is to rip a frame every second and hand over the pile. A ten minute video is 600 separate images. That does not fit in a context window. It does not fit in anything.

So watchvideo tiles them. Thirty frames get stitched into one storyboard image, laid out in a grid, with each cell still wide enough that you can read the burned-in captions. Those same 600 frames become 20 images instead of 600.

That one decision is the difference between analyzing a single clip and analyzing an entire competitor roster in one sitting. It saves your context and it saves your tokens.

You pick the mode at the start of every run. It is the first thing the skill asks.

• Hook mode. First 20 seconds only, one frame per second, and the audio gets trimmed to match. One storyboard per video, flat, no matter how long the video is. This is the competitor sweep mode: point it at fifteen reels and you get fifteen images and a scoreboard comparing every hook side by side.
• Condensed mode. The whole video, one frame every three seconds. This is the default, and it is what you want for one reel or for getting the shape of a longform.
• Forensic mode. The whole video, one frame every single second. Use it when you want to go deep on one particular video and see the edit rhythm cut by cut.

Sheets per video, measured:

45s reel   hook 1  condensed 1  forensic 2
3 min      hook 1  condensed 2  forensic 6
10 min     hook 1  condensed 7  forensic 20
40 min     hook 1  condensed 27  forensic 80

And it will not quietly eat your window. Before it cuts a single frame it checks the duration and does the math. If a run would go over 15 storyboards it stops, shows you the real numbers, and offers you the cheaper mode.

Run /watchvideo, drop in the link, pick your mode, and tell it what you want out of the run. What lands is a dated folder:

video-analytics/2026-08-18-your-video/
  transcript.md
  analysis.md
  hook-rewrites.md  (whatever you asked for)
  media/ audio/ frames/

• transcript.md keeps the source link and the full transcript in the same file, with real timestamps, so a transcript is never orphaned from the video it came from.
• analysis.md is the breakdown: the spoken hook quoted word for word, the visual hook, whether those two actually agree, the format, the topic, a beat sheet, and web research on whether the person is even right.
• The third file is yours. Every run it asks what you want out of this one. Ask for hook rewrites, a list of every claim they made, a shot list, a comparison against your own video, and that becomes its own file in the same folder.

The hook report breaks the opening down second by second: what was spoken, what text was on screen, any stickers, and what the person's body language was doing the whole way through.

One command:

npx watchvideo install

That puts the skill in ~/.claude/skills/watchvideo/. Restart Claude Code, type /watchvideo, and you are in.

A few others if you need them:

• npx watchvideo install --with-commands also drops a /watchvideo command stub.
• npx watchvideo install --project installs into just the current project.
• npx watchvideo update pulls the newest version over an older copy.
• npx watchvideo doctor checks your machine and tells you exactly what is missing.

You need three free things installed once. On a Mac:

brew install yt-dlp ffmpeg
pip install -U openai-whisper

No API key, no account, no subscription. Run npx watchvideo doctor and it will tell you if anything is missing and how to fix it.

I would rather tell you the limits now than have you find them later.

• It samples, it does not see every frame. Even forensic mode is one frame per second on 30fps footage, so it sees one frame in thirty. Every run stamps the real percentage in the file instead of claiming it watched the whole thing.
• Hook mode only knows the first 20 seconds. Not the middle, not the CTA. So it drops the beat sheet and the topic research rather than making them up.
• It cannot tell you why a video performed. Retention and traffic source are not in the file, and it says unverified instead of guessing.
• Public video only. No login walls, no age-gate workarounds. Analyze, do not repost.
• YouTube blocks some downloads. Keep yt-dlp current. When one fails anyway, the skill says so instead of pretending.

The obvious use is competitor research. Point hook mode at every creator in your niche, go to bed, and read the scoreboard in the morning. That is what I built it for.

If you want help wiring this into an actual content system instead of running it one-off, join CC Strategic AI on Skool. Post what you tried and what broke and you will get a real answer.

I am Charles J Dove, and I run Charlie Automates. At my agency CC Strategic we build these systems for clients, and everything I test lands free on charlieautomates.com first.

Not sure what to fix first? The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, no call required. Take the free AI Bottleneck Finder →

• watchvideo on GitHub
• watchvideo on npm
• yt-dlp, the downloader it runs on
• ffmpeg, the frame and audio extractor
• openai-whisper, the local transcription model
• CC Strategic AI on Skool, master Claude Code with us

Every link below goes straight to the source. Nothing here costs money.

• 1. herdr — github.com/herdrdev/herdr · run a whole team of agents at once. Free, open source.
• 2. Graphify — github.com/safishamsi/graphify · gives your agents a memory that does not reset. Free, open source. Not my tool, I just use it daily.
• 3. OmniRoute — github.com/diegosouzapw/OmniRoute · keeps you working after you hit your Claude limit. Free, MIT license.
• 4. Claude Code Setup — github.com/anthropics/claude-plugins-official · Anthropic's own plugin. It tells you what to install for each project. Free.
• 5. Task Observer — github.com/rebelytics/one-skill-to-rule-them-all · makes your other skills better while you work. Free, CC BY 4.0.

Two of these already have a full walkthrough in this toolkit. If you want the step by step instead of the summary, use those:

• Run Claude Code For Free With OmniRoute · the full install, screen by screen.
• Graphify: Codebase Knowledge Graphs · what the graph shows you and how to read it.

Claude Code out of the box is one assistant, in one window, that forgets your project every time you close it. That is the version most people are paying for.

These five plugins change that. You get a team of agents instead of one. The team remembers your project. It keeps working after you hit your usage limit. And it gets a little better every week without you doing anything.

None of them cost money. The only thing they cost is the twenty minutes it takes to set them up once.

The problem it fixes: you can only babysit one Claude window at a time. Close your laptop and whatever it was doing dies with it.

What it does: herdr is a background server that your terminals live inside. Each agent gets its own terminal, and they all keep running on the server even if you close the lid, lose wifi, or restart the machine. When you come back, they are still there, still working.

It also watches each agent and figures out on its own whether that agent is working, blocked and waiting on you, done, or idle. When one finishes or gets stuck, it plays a sound so you know to look. You are not tabbing between windows guessing who needs you.

Agents can also talk to each other through it. One agent can start another one, send it a message, and wait until it is actually blocked before stepping in.

Install:

curl -fsSL https://herdr.dev/install.sh | sh

It runs Claude Code, Codex, Cursor, OpenCode and others, so you are not locked to one tool. Written in Rust, which is why it is fast and does not eat your battery.

The problem it fixes: Claude reads your files fresh every session. You pay for that reading every single time, and it still does not understand how your project fits together.

What it does: Graphify reads a folder of stuff and builds a map of it. Not a list of files, an actual map: which pieces exist, and which pieces are connected to which. Then your agent asks the map instead of reading everything again.

It works on more than code. Point it at PDFs, markdown notes, images, audio, or video and it maps those too. I stack mine with Obsidian so I can see the map with my own eyes instead of trusting that it is in there.

The part I like most: every connection it makes is labeled extracted, inferred, or ambiguous. So you always know the difference between something it actually found and something it guessed.

To be clear, this is not my tool. It is safishamsi/graphify. I use it on every project and I am recommending someone else's work.

Full walkthrough here.

The problem it fixes: you hit your Claude usage limit in the middle of something and just sit there.

What it does: OmniRoute is a small program that runs on your own computer, in between Claude Code and the internet. Normally Claude Code talks straight to Anthropic. With OmniRoute running, it can talk to hundreds of other AI companies instead, and a lot of those have free plans.

So when your Claude limit runs dry, OmniRoute hands the work to a free model and you keep going. When that one runs out, it hops to the next. You do not do anything, it just keeps switching.

Last count it reaches 330 or so providers and 1,200 or so models, including Kimi, GPT, Gemini, GLM and DeepSeek. Its own dashboard tracks roughly 1.6 billion free tokens a month across those free tiers. It is MIT licensed and built by 320 plus contributors.

One honest note: "free" here means other companies' free tiers, not infinite. Free tiers change and sometimes disappear. The reason this still works is that OmniRoute keeps moving you to whichever one is up.

Full step by step install here.

The problem it fixes: there are thousands of hooks, skills, subagents and MCP servers out there. You have no idea which ones matter for the project in front of you.

What it does: this one is from Anthropic themselves. You run it on a project and it reads your codebase, then hands you a list of the hooks, skills, subagents and MCP servers that fit that project.

Think of it like a contractor walking your house before you go buy tools. Same advice everyone gives, except it looked at your actual house first.

Run it once on every new project, take the recommendations, and move on. It is not a daily thing.

One correction to what you may have heard elsewhere: it recommends. It does not delete anything or clean anything out for you. You still decide what to install.

It lives in Anthropic's official plugin marketplace at anthropics/claude-plugins-official, and about 179,000 people have it installed.

The problem it fixes: you correct Claude the same way over and over, and that lesson dies when the session ends.

What it does: Task Observer sits in the background while you work and takes notes. Every time you correct it, or make a judgement call, or something works unusually well, it writes that down in a log file.

Later, on a review cycle, it goes back through those notes, compares them against every skill you own, and writes up the improvements. Then it hands you the changes to look at.

That last part matters: nothing goes live by itself. It gives you a diff and you decide whether to install it. So it is not silently rewriting your setup behind your back, which is exactly what you should want from a tool with this much reach.

It is called "One Skill To Rule Them All" on GitHub, and Task Observer is the skill inside it that does the watching.

They stack. Each one removes the ceiling the one before it runs into, so this order saves you time:

• OmniRoute first. No point setting anything else up if you are going to run out of usage an hour in.
• Graphify second. Now you can work as long as you want, so make it stop forgetting what you are working on.
• herdr third. One agent that remembers everything is still one agent. Now go wide.
• Claude Code Setup fourth. More agents means more ways to set it up wrong. Let Anthropic's plugin tell you what belongs.
• Task Observer last. It improves the other four, so it should be watching a setup that is already worth improving.

Total time: about twenty minutes if you go in this order. Longer if you skip around, because you will end up redoing steps.

If you get stuck on any of the five, bring it to the community. We run weekly calls and this exact stack comes up constantly.

Join CC Strategic AI on Skool and ask in the feed. Post what you tried and what broke, and you will get a real answer instead of a link to documentation you already read.

Meta runs an official MCP server for ads at https://mcp.facebook.com/ads. An MCP is a link that gives Claude real controls inside another tool. Hand Claude this one and it can work inside your ad account instead of telling you where to click.

Once it is connected you stop building campaigns by hand. You describe the campaign, and Claude builds it. Campaign, ad sets, targeting, budget, creatives, copy.

Setup takes about ten minutes. Most of it is Meta paperwork, not code. Follow the steps in order and you only do this once.

• A Facebook account you use for business.
• A Meta Business Manager (also called a business portfolio) with your ad account and Page inside it.
• Claude Code installed on your computer.
• A privacy policy URL you can paste. Your website's privacy page is fine.

Go to developers.facebook.com. Click My Apps, then Create App.

Give the app a name you will recognize later, like "Charlie Ads". Nobody else sees it.

On the Use cases screen, check these two boxes:

• Create & manage ads with Marketing API
• Create & manage app ads with Meta Ads Manager

On the next screen, pick your business portfolio. If you do not have one yet, create it here. Then finish creating the app.

A brand new app is in development mode, and Meta will not let it touch a live ad account until you publish it.

In the left menu of your app, open Publish. Meta asks for a Privacy Policy URL. Paste your privacy page and fill in whatever else it asks for. Then click publish.

That is the step most people skip, and then nothing works later. Do it now.

Now switch to your Meta Business Manager settings.

In the left menu go to Accounts, then Apps. Click Add and paste the App ID of the app you just made. You will find the App ID on your app's dashboard on developers.facebook.com.

Your app is now owned by your business, which is what lets it reach your ad account.

A system user is a robot account. It is how you give Claude access without handing over your personal login.

Still in Business Manager settings, go to Users, then System users. Click Add, name it anything you like, and set the role to Admin.

Open the system user you just made and click Assign assets. The robot can only touch what you hand it, so give it everything the ads need:

• Your ad account, with full control.
• Your Page, with full control.
• The app you created in step 1. This one is easy to forget and nothing works without it.
• Your Instagram account and catalog, if you run ads on either.

On the same system user, click Generate new token. Pick the app you created, then tick these permissions:

• ads_management
• ads_read
• business_management
• pages_show_list
• instagram_basic
• catalog_management
• ads_mcp_management

Copy the token the moment it appears. Meta shows it once and never again. If you lose it, generate a new one.

Open Claude Code in your project and say this:

Set up the Meta Ads MCP for me.
Server URL: https://mcp.facebook.com/ads
Token: [paste your token]

Claude adds the server, connects with your token, and confirms it can see your ad account. If it cannot, the usual cause is a missing asset from step 5 or an app that never got published in step 2.

Now you just describe what you want in plain English:

Build a lead generation campaign for my agency.
Budget $40 a day, United States, ages 28 to 55,
business owner interests. Write three ad variations
with different hooks and set them all live paused
so I can review them first.

Claude builds the campaign, the ad sets, the targeting, the creatives and the copy. Then you open Ads Manager and it is all sitting there.

Ask it to leave new campaigns paused until you have seen them. That way you review before a dollar moves.

• Fix what is losing money. "Show me every ad set over a $40 cost per lead this week and pause them."
• Scale what is working. "Find my best ad by cost per lead and raise its budget 20%."
• Test more copy. "Clone my top ad and write five new hooks for it."
• Report without logging in. "Give me last week's spend, leads and cost per lead by campaign."

This is the part clients pay agencies a monthly retainer for. It is now a sentence.

That token can spend your money. Treat it like a credit card, not a password reset link.

• Never paste it into a chat, a document, a screenshot or a public repo.
• Never give it to a client or a contractor. Make them their own system user instead.
• If you think it leaked, delete the system user in Business Manager. That kills the token instantly.
• Test on a small budget first. Claude follows what you asked for, so a typo in a budget is still a typo in a budget.

• Meta Ads MCP server URL (paste this into Claude, it is not a page you browse)
• developers.facebook.com (create and publish the app)
• Meta Business Manager settings (apps, system users, assets, token)
• CC Strategic AI on Skool, master Claude Code with us

github.com/drleadflow/ghl-automation-builder by DrLeadFlow. It ships 95 actions, 93 triggers, and the full schemas Claude needs to build a real workflow.

You installed the GoHighLevel MCP and found out it cannot build workflows. That is not a bug. GoHighLevel's public API has no endpoint for writing a workflow at all.

Check the official SDK and you find two workflow methods: read one, and remove a contact from one. There is no create. So the MCP cannot build automations, and it never will on the public API.

Which leaves you paying for their AI builder to do the one thing you wanted your own AI to do.

GoHighLevel's own web app builds workflows every day. It does that by calling an internal API that is not in the public docs.

This repo documents those calls. Give that documentation to Claude Code, and Claude can make the same calls the GoHighLevel interface makes. That is the whole trick.

This is the honest part, and it matters more than the setup.

• The key you copy is your account password. Not a scoped API key. Anyone holding it can mint fresh access to your GoHighLevel account until you revoke it. Never commit it, never post it, never send it to a client or a contractor.
• Use a throwaway sub-account first. Point this at a test location until you have seen it work. Never test on a client's sub-account.
• It can break without warning. This is an internal API. HighLevel does not support it. Any front-end update on their side can change the call shapes and stop it working mid-build.
• HighLevel has not blessed this. Depending on how you read their terms, using an undocumented internal API may sit outside them. Your call, your account.
• No license on the repo. That means no permission is formally granted for use or modification. Fine for personal testing, worth thinking about before you build a product on it.

None of that means do not use it. It means use it with your eyes open, on your own account, not a client's.

Copy the repo link and paste it into Claude Code:

Install this for me: https://github.com/drleadflow/ghl-automation-builder

Claude clones it and reads the schemas. Let it finish while you do step 2.

Open GoHighLevel in Chrome, then:

• Right-click anywhere on the page and choose Inspect.
• In the panel that opens, click the arrows at the top and choose Network.
• Set the filter to Fetch/XHR.
• Click your Automation tab. The list fills with requests.
• Right-click any row with the orange icon, hover Copy, then click Copy as cURL.

You now have a full request on your clipboard, and your login key is inside it.

Back in Claude Code:

I want to use the automation builder. Here is my request:
[paste]

Claude pulls the key and the location ID out of that request and is ready to build.

Now describe what you want in plain English. Because Claude Code already knows the pages and code in your project, you can point at them:

Build a lead intake workflow in GoHighLevel that connects to the
opt-in page we just built. Tag the contact, send a welcome text,
wait 10 minutes, then email me if they have not booked.

Claude builds the step graph, attaches the trigger, and publishes it. Open GoHighLevel and it is sitting there on the canvas.

The value is not one workflow. It is that you can now build the complicated ones without clicking through a builder for an hour.

• Page and workflow in one sitting. Build the landing page with Claude Code, then have Claude build the intake automation that matches the exact fields on that page. No mismatched field names.
• Client onboarding you can clone. Build one onboarding automation properly, then have Claude clone it per client with the names and offers swapped.
• Speed-to-lead. New lead comes in, text goes out in under a minute, sales rep gets a task, no-response leads roll into a follow-up branch after an hour.
• Recovery flows. Booked but no-showed, started checkout but did not pay, opened three emails but never replied. These are the branch-heavy ones nobody wants to build by hand.
• Reporting nudges. A weekly workflow that fires a webhook at your own dashboard so you get a summary instead of logging in.

This is where it stops being a CRM and starts being infrastructure. Workflows can talk to anything you build.

Going out. Add a Custom Webhook action and the workflow sends the contact's details to any URL you choose. Ask Claude for it directly:

Add a custom webhook step that POSTs the contact name, email,
phone and the form answers to https://myapp.com/api/new-lead

Your own app receives that and can score the lead, write to your database, or ping Slack.

Coming in. GoHighLevel workflows can also start from an inbound webhook. So your app, your site, or another automation can kick off a GoHighLevel sequence whenever you want.

Both directions. Claude Code builds the endpoint on your site and the workflow that calls it, in the same session, using the same field names on both ends. That is the part that usually breaks when a developer and a CRM person build the two halves separately.

Keep both. They do different jobs and neither replaces the other.

• This repo: building, cloning and publishing workflows. That is all it does.
• The GoHighLevel MCP: everything else. Contacts, opportunities, conversations, calendars, invoices, products, notes, tasks, custom fields.

Ask for an automation, use this. Ask for anything else, use the MCP.

Building one workflow is easy. Running an agency where every client's automations, pages and follow-up are built and maintained by Claude Code is a different skill, and it is the one that actually pays.

That is what we work on inside the community: real builds, real client systems, and the Claude Code workflows behind them.

Join CC Strategic AI on Skool and learn to build out an agency's entire workflow stack with Claude Code.

• GHL Automation Builder on GitHub (95 actions, 93 triggers, full schemas)
• Get GoHighLevel (my affiliate link, if you are not on it yet)
• CC Strategic AI on Skool, master Claude Code with us

github.com/virgiliojr94/book-to-skill, MIT licensed, 17,500+ stars and one of the fastest climbing repos on GitHub right now.

You point it at a book, a PDF, or a folder of documents. It reads the whole thing once and builds a Claude Code skill out of it.

From then on, the book is a command you can call in any session. You ask a question, Claude opens the right chapter, and answers from the real text.

You have probably already tried dropping a PDF into Claude and asking about it. Two things go wrong.

• It makes things up. The model skims, loses the thread, and fills the gaps with something that sounds right.
• It burns tokens. Every question makes it hunt through the file again. The repo measures this at 24x to 51x more tokens than asking a proper skill.

Book to Skill fixes both by doing the hard reading once, up front, and saving the structure.

This is the part most people miss. You are not building a search box for a PDF. You are giving your agent a working method it can apply while it does real work.

Turn a book on offers into a skill, then tell Claude to write your sales page using that skill. It runs the author's framework on your business instead of quoting the book back at you.

Same move works for:

• Your own docs. Runbooks, onboarding guides, architecture notes. Fold a whole docs/ folder into one skill and ask it while you build.
• Brand and voice guides. Turn a 60 page brand book into a skill your agent checks before it writes a single line.
• Specs and standards. API contracts, compliance rules, RFCs. The stuff you look up constantly and never memorize.
• Research. A stack of papers plus your notes, merged into one skill you can add to later.

If you keep reopening a document, it belongs in a skill.

One conversion gives you five files in your skills folder:

• SKILL.md, the core ideas plus a chapter index. Roughly 4,000 tokens.
• chapters/ch01-*.md, one file per chapter. These only load when you ask about that topic, so they cost nothing until you need them.
• glossary.md, every key term in alphabetical order with chapter references.
• patterns.md, the techniques and methods pulled out on their own.
• cheatsheet.md, decision tables and quick rules.

It pulls out frameworks, principles, techniques, and anti patterns. It is not a book summary. It is a toolkit.

PDF, EPUB, DOCX, HTML, Markdown, plain text, and RTF out of the box. MOBI and AZW work too if you have Calibre installed.

One command in your terminal:

git clone https://github.com/virgiliojr94/book-to-skill.git ~/.claude/skills/book-to-skill

Or paste this into a Claude Code session and let it handle the install:

Install book-to-skill: https://raw.githubusercontent.com/virgiliojr94/book-to-skill/master/SKILL.md

Restart Claude Code so it picks up the new skill.

Point it at a book you own:

/book-to-skill ~/path/to/your-book.pdf

It asks you a few questions about how you want the book used, then builds the skill. Give it a folder or a wildcard instead of one file and it merges everything into a single skill.

After that, call the book by name in any session:

/your-book-slug pricing

Claude opens the chapter that covers pricing and answers from it.

• Full conversion. The default. Give it a path, get a finished skill.
• Analyze only. Say "analyze" and it shows you the frameworks it found before it writes anything.
• Generate from analysis. Hand it notes you already have and skip straight to building.
• Update and fold in. Point it at new sources plus an existing skill and it merges them.

Use books you actually bought. This reads a file you already own and turns it into a private skill on your own machine. It is not a way to get around buying the book, and it does not put anything on the internet.

It follows the open Agent Skills standard, so the same install works in GitHub Copilot CLI and Amp as well as Claude Code. There is also a pip install book-to-skill option, but that only gives you the text extractor, not the slash command. Use the git clone above.

• Book to Skill on GitHub (MIT, 17,500+ stars)
• Usage docs, every mode with examples
• Install docs, Claude Code, Copilot CLI, and Amp
• Performance docs, how the 24x to 51x token number is measured

This Chrome extension helps you save any webpage as clean markdown for Claude Code to read. And the coolest part? You can add it directly into your Obsidian vault.

Here's why that matters. Claude works best when it can read a file sitting on your machine. A webpage is the opposite of that: it's locked in a browser, wrapped in ads, menus, and popups. The old way was to copy-paste the text into your chat or hand Claude a link and hope it grabs the right stuff. Now you don't have to do either. Clip the page once, it lands in your vault as a clean markdown file, and Claude can read it any time. Just reference the file and have a conversation about it.

• One click, clean markdown. It strips out the ads, nav bars, and junk, and keeps the actual content.
• Saves straight into Obsidian. Your vault is just a folder of markdown files on your computer, which is exactly the format Claude Code loves.
• Clip the whole page or just a piece. Grab the full article, a selection, or highlights.
• Free. The extension is free, and Obsidian is free for personal use.

1. Download Obsidian (free) at obsidian.md/download and create a vault. A vault is just a folder where your notes live. Name it something like research.
2. Install the extension from the Chrome Web Store.
3. Point it at your vault. Open the extension's settings and set your vault name and the folder where clips should land (I use a clippings folder).
4. Clip something. Go to any article, hit the extension icon, and save. Open Obsidian and the page is sitting there as a markdown file.

This is where it gets good. Open Claude Code in (or pointed at) your vault folder and the clips become context Claude can actually use.

• Research a topic. Clip 5 articles on a subject, then ask Claude: "Read everything in my clippings folder and give me the 5 big takeaways with sources."
• Steal what works. Clip a competitor's landing page, then: "Read this clip and break down the offer, the hooks, and what I should test on my own page."
• Save docs that keep moving. Clip the docs page of a tool you use, then reference the file whenever you ask Claude to build with that tool. No more hoping Claude's memory of the docs is current.
• Turn reading into content. Clip an article that fired you up, then: "Read this file and draft my take on it as a LinkedIn post in my voice."
• Build a swipe file. Every good email, ad, or hook you see, clip it. Ask Claude to pull patterns from the whole folder when you write something new.

The pattern is always the same: clip it once, then just reference the file and talk about it. No copy-paste, no link-grabbing.

Once your vault has real research in it, level it up. Graphify turns the whole vault into a knowledge graph Claude can query instead of re-reading every file, and it's the same brain-building move I use in my own agentic OS. Pair it with NotebookLM for deep research and Understand Anything when the thing you're mapping is a codebase instead of articles.

• Obsidian Web Clipper on the Chrome Web Store (free)
• Download Obsidian (free for personal use)

Install it first, read after: github.com/zachlatta/freeflow. Grab the FreeFlow.dmg from that repo and you are running in under three minutes. Apple Silicon and Intel both work.

The mouse I use: Logitech MX Master 4. Asked about it constantly, so it is up here with the download instead of buried at the bottom.

FreeFlow is a free, open source Mac dictation app built by Zach Latta and maintained by Marc Bodea. It does what Wispr Flow, Superwhisper, and Monologue do: you hold a key, you talk, and clean text lands in whatever field your cursor is sitting in. The difference is you are not paying a monthly bill for it.

I talk my prompts into Claude Code now instead of typing them. A prompt I would have typed in ninety seconds takes fifteen seconds to say, and the long ones actually get written instead of getting cut short because my hands got tired.

1. Download the app. Pull FreeFlow.dmg from the repo and drag it into Applications.
2. Get a free Groq API key at groq.com and paste it into FreeFlow's settings. Groq is what runs the transcription, and the free tier covers normal daily use.
3. Give it accessibility permission when macOS asks. That is how it pastes into other apps.
4. Hold Fn and talk. Let go and the text appears. Tap Command-Fn instead if you want hands-free mode that stays on until you tap again.

• Context-aware cleanup. It reads what is on screen in the app you are dictating into, so names, product terms, and file paths get spelled right instead of turned into mush.
• Custom vocabulary. Feed it your client names, your repo names, your jargon. It stops mangling them.
• Edit Mode. Highlight text you already wrote, hit your shortcut, and say "make this shorter" or "turn this into bullets." It rewrites the selection in place.
• Your own shortcuts. Hold-to-talk and toggle are both remappable. If the toggle shortcut extends the hold shortcut, you can start holding and add the extra modifier to latch it without breaking the recording.
• Any OpenAI-compatible provider. Groq by default, or point it at your own model and API URL. Ollama and LM Studio work, which means you can run the whole thing local.
• No server in the middle. There is no FreeFlow backend. The only thing leaving your Mac is the API call to the provider you configured.

The bottleneck in agentic coding is not Claude. It is how much context you are willing to type before you get bored and send a lazy prompt. Short prompts get short thinking.

Dictation kills that. You describe the whole problem out loud, the constraints, the files involved, what you already tried, and FreeFlow hands Claude a paragraph instead of a sentence. Three things I use it for every day:

• Long prompts in the terminal. Talk the full spec into Claude Code instead of typing four lines and hoping it guesses the rest.
• Voice notes into CLAUDE.md. Say the rule out loud, paste it into the file, done. Your project instructions actually get maintained.
• Rewriting on the fly. Edit Mode on a paragraph beats deleting it and starting over.

Pair it with the token-saving playbook so those longer prompts do not cost you more than they are worth.

People ask about my desk setup every time I record. The mouse is the Logitech MX Master 4. Ultra-fast scrolling for ripping through long files and terminal output, side buttons I map to workspace switching, and it is comfortable enough that a six-hour build session does not wreck my wrist. Not required for FreeFlow, just the thing on my desk.

• FreeFlow on GitHub (free, MIT licensed)
• Direct download: FreeFlow.dmg
• Groq (free API key for transcription)
• Logitech MX Master 4 (the mouse on my desk)

If you cannot seem to rank on Google no matter what you do, this is the piece you are missing.

Claude Code is great at building. It is not great at knowing what people search for. It has never seen your search volume, your competition, or the exact phrases that bring buyers to a site like yours. So it writes nice pages about the wrong words.

OpenSEO fixes that. It is an open-source alternative to Ahrefs and Semrush, and it connects directly to your AI agents. Claude asks it for the top keywords, gets real numbers back, and then builds the site around those words instead of guessing.

It also costs a fraction of what Semrush costs. Usage-based, no big monthly bill, and you can start free with no credit card.

Go to openseo.so and create your account. No credit card needed to start.

Take two minutes to click around the dashboard first. Keyword research, domain overview, backlinks, rank tracking, site audit, AI visibility. Everything the MCP can do, you can also see in the web app. Knowing what the buttons do makes it much easier to tell Claude what you want.

Once you are logged in, find the AI and MCP section. That page gives you the exact setup command for whichever agent you use.

Pick your agent from the list. Claude Code, Claude Desktop, Cursor, Codex, whatever you run. The page hands you a command. You copy it. That is the whole idea.

If you are on the CLI like I am, you paste the command into your terminal and hit enter. That is it.

For Claude Code, the command is one line in your terminal:

claude mcp add --transport http --scope user openseo https://app.openseo.so/mcp

The --scope user part matters. It installs OpenSEO for every project on your machine instead of just the folder you happen to be standing in.

On other tools the destination is the same, only the wrapper changes:

• Codex CLI: codex mcp add openseo --url https://app.openseo.so/mcp
• Cursor: add { "mcpServers": { "openseo": { "url": "https://app.openseo.so/mcp" } } } to your mcp.json
• Claude Desktop: Settings, then Connectors, then Add custom connector, and paste https://app.openseo.so/mcp

The MCP gives Claude the data. The skills teach it what to do with the data. You want both.

Grab the command the same way, from the same page, and paste it in:

npx skills add every-app/open-seo --skill '*' --agent claude-code

Hit enter. That installs all seven OpenSEO skills at once.

Restart Claude Code, then type /mcp.

You should see openseo in the list with a connected status. If it is sitting there unauthenticated, select it and approve the login. It uses OAuth, so it opens your browser, you click approve, and you are done.

Quick sanity check: ask Claude to run whoami on OpenSEO. If it returns your account, the pipe is open.

Worth knowing, because Claude will only use what you know to ask for. Everything below is a real tool it can call for you:

• Find keywords: research keywords from a seed topic, pull volume, difficulty and CPC on any list, and get keyword suggestions for a whole domain.
• Read the competition: pull the live Google results page for any keyword, find who really competes with you across a keyword set, see a competitor's organic footprint, and pull the full list of keywords a competitor already ranks for.
• Local: local search results by location, local business lookups near a set of coordinates, and the questions people ask on Google Business profiles.
• Track: save keywords into a working set, list what you saved, and read rank tracker positions over time.
• Fix the site: run a full technical site audit, check its status, then pull the issues and the affected pages.
• Links: backlink overview and full referring-domain profile for you or anyone else.
• Truth from Google itself: Google Search Console performance data, plus URL inspection for index status, crawl, and canonicals, up to ten URLs per call.

The seven skills wrap those tools into jobs you can run by name: /seo-project-setup, /seo-coach, /keyword-research, /keyword-clustering, /competitive-landscape, /competitor-analysis, and /link-prospecting.

If you are not sure which one to run, run /seo-coach. That is literally what it is for. If you are starting something new, run /seo-project-setup first so everything after it has a home.

This is the part most people get backwards. They build the site, then try to bolt SEO on at the end. Do it the other way around. Words first, then build.

Here is my exact order, using tools that are already in this free resource library:

• 1. SEED, to shape the idea. Run /seed and talk through what the site is, who it serves, and what it needs to do. You end up with a real plan instead of a vibe. Grab it here: SEED in my free resources.
• 2. OpenSEO, to find the words. Before a single page gets written, run /keyword-research on your topic, then /competitive-landscape to see who you are up against, then /keyword-clustering to group the winners into page-sized buckets. One cluster equals one page. Save the set so it sticks around.
• 3. Feed the words back into the plan. Tell Claude to update the SEED plan so every page maps to a keyword cluster, with the main keyword in the page title, the URL, and the first paragraph.
• 4. PAUL, to build it. Now let PAUL run the build in plan, apply, unify loops with checkpoints, so you approve each phase instead of watching one giant prompt go off the rails. Grab it here: PAUL in my free resources.
• 5. The anti-slop stack, so it does not look like every other AI site. Keywords get you found. Design gets you trusted. Run the four free design tools alongside PAUL: the anti-slop design stack.
• 6. OpenSEO again, to check the build. After it ships, run a site audit, pull the issues, and hand them straight back to Claude to fix.

SEED decides what. OpenSEO decides which words. PAUL builds it. The anti-slop stack makes it look like a real company made it.

The single most useful instruction to give Claude before a build:

Use the OpenSEO MCP to pull the top keywords for this niche, then interview me on the results before you build anything.

That one sentence does two things. It forces Claude to go get real data instead of inventing keywords. And it stops it from sprinting into code before you have agreed on the target.

Answer its questions. Kill the keywords that do not fit your buyer even if the volume looks great. Then let it build.

This is the fastest win in the whole tool, and it takes about five minutes.

• Give Claude a competitor's domain and ask it to pull their ranked keywords and their domain overview.
• Ask it to filter that list down to keywords with real volume and difficulty low enough that a new site can compete.
• Ask it to check which of those you already rank for using your Search Console data, and flag anything sitting on page two. Those are the cheapest wins you will ever get, because you are already close.
• Ask it to cluster what is left into page ideas, and save the set.

You now have a content plan built from words that are already proven to send traffic to somebody in your market.

This is the part people are sleeping on. More and more buyers ask ChatGPT, Claude, Perplexity, and Google's AI answers instead of scrolling ten blue links. OpenSEO tracks AI visibility and has a prompt explorer so you can compare what different models say about your topic.

Ranking in AI answers is a slightly different game. What works:

• Write the question, then answer it in the next sentence. AI engines quote clean, short answers. Bury it in paragraph six and you do not get quoted.
• Use question keywords. Ask OpenSEO for the question-shaped phrases in your niche, and the questions people ask on local business profiles. Those map perfectly to how people talk to a chatbot.
• Name real things. Say the actual tool names, product names, city names, and your own brand name. AI engines connect entities, not vibes.
• Get indexed. Most AI search still leans on a search index underneath. Use OpenSEO's URL inspection to confirm Google actually has your pages before you wonder why no model mentions you.
• Get mentioned elsewhere. Run /link-prospecting. Links and mentions on other sites are still how these systems decide you are real.
• Check your work. Use the AI visibility tracking to see whether you show up when someone asks a model about your category. If you do not, you now know what to fix instead of guessing.

You do not need an SEO routine that eats your Monday. This takes about fifteen minutes.

• Weekly: ask Claude to pull rank tracker positions and Search Console performance, and tell you only what moved.
• Weekly: ask for anything sitting in positions 8 through 20. Improve one of those pages instead of writing a brand new one. It is far less work for far more traffic.
• Monthly: run a site audit, pull the issues, and let Claude fix them in one pass.
• Monthly: re-run the competitive landscape to catch new keywords your competitors just started ranking for.

That is the whole loop. Find words, build around them, check what moved, fix the closest thing to a win.

The tools are the easy part. Knowing which keywords are worth a page, when to ignore a big volume number, and how to turn a cluster into a page that converts, that is the part nobody puts in a docs site.

That is what we work through inside CC Strategic AI on Skool. Real builds, real critiques, and the exact setups I run on my own sites and client work.

• OpenSEO, the open-source Ahrefs and Semrush alternative
• OpenSEO MCP setup docs
• OpenSEO agent skills setup docs
• SEED, turn a raw idea into a build plan
• PAUL, the plan apply unify build loop
• The anti-slop design stack, so the site does not look AI-made
• CC Strategic AI on Skool, master Claude Code with us

ADHD is a free, MIT-licensed Claude Code skill built by Udit Akhouri. You install it with one command and then type /adhd plus your problem.

The name is not a joke and it is not a medical tool. It is named after the way an ADHD brain actually thinks: 30 directions at once, no filter, weird connections nobody asked for. That part is a superpower. The part that hurts is the second half, sorting the 30 ideas down to the 2 worth doing.

This skill gives Claude the first half on purpose, then adds the second half as a separate step. You get the scatter AND the sort.

There is a name for what goes wrong when you ask Claude an open question. It is called premature convergence.

Claude writes one word at a time, and every word is shaped by the words before it. So the very first sentence it commits to becomes the frame for everything after. Ask it "how should I handle retries in my app" and it locks onto exponential backoff in the first line, then spends 800 words defending that lane. The answer is correct. It is also the answer any senior engineer gives in 30 seconds, and you did not need an AI for that.

Asking Claude to "think of more options" does not fix it, because those extra options are written in the same chat, downstream of the first idea. They are variations, not alternatives.

ADHD treats this as a plumbing problem instead of a prompting problem. If the branches can see each other, they copy each other. So it makes sure they cannot see each other.

Two phases, with a hard wall in the middle. Phase 1 is not allowed to judge. Phase 2 is not allowed to generate.

YOUR PROBLEM
     |
     v
 PHASE 1: DIVERGE  (no critic allowed)
     |
     +--> Agent 1  [frame: biology]        --> 6 ideas
     +--> Agent 2  [frame: speedrunner]    --> 6 ideas
     +--> Agent 3  [frame: 3am on-call]    --> 6 ideas
     +--> Agent 4  [frame: inversion]      --> 6 ideas
     +--> Agent 5  [frame: $0, 1 hour]     --> 6 ideas
              (parallel + isolated, ~30 raw ideas)
     |
=====WALL===== branches never see each other =====
     |
     v
 PHASE 2: FOCUS  (critic on)
     |
     +--> SCORE     novelty / viability / fit, 0-10 each
     +--> TRAP FLAG "looks great, here is why it breaks"
     +--> CLUSTER   group by underlying angle, not keywords
     +--> DEEPEN    top 3 survivors get a full sketch
     |
     v
 BRIEF -> WIDE SET -> SHORTLIST (with a starred pick) -> 3 DEEP DIVES -> PROVOCATION

The important detail is that the generator and the critic are different Claude calls with opposite instructions. It is not one prompt promising to be creative and fair at the same time. The generator is literally forbidden to evaluate. That is why the weird ideas survive long enough to be considered.

A frame is a costume Claude has to wear while it thinks. Each of the 5 parallel agents gets a different one, so they physically cannot arrive at the same answer.

The skill ships 15 of them:

• hardware engineer, thinks in latency, memory, and physical limits
• regulator, asks what has to be provable, traceable, or refusable
• 10-year-old, has never seen software, ignores every convention
• competitor trying to break it, attacks the obvious solution, then flips the attacks into ideas
• biology, steals a mechanism from immune systems, evolution, or cell signaling
• logistics, steals queues, batching, just-in-time, hub-and-spoke, last-mile
• game design, looks for loops, rewards, friction, save states, speedrun tricks
• markets, turns it into buyers, sellers, auctions, and clearing houses
• inversion, asks how to guarantee the opposite, then negates each answer back
• extreme: $0 budget, 1 hour, the crudest thing that still works
• extreme: infinite budget, 10 years, the maximalist version
• remove the load-bearing assumption, deletes the thing everyone treats as fixed
• speedrunner, hunts glitches, skips, and the abusive-but-legal path
• ant colony, no central planner, dumb agents and local rules only
• 3am on-call, designs so nobody ever gets paged

For code problems it picks 4 practical frames plus 1 wild one, so you always get range without the whole run going silly. It also varies the picks between runs, which means running /adhd twice on the same question gives you two different idea pools.

Open a terminal and run:

npx skills add UditAkhourii/adhd

That auto-detects your agent. It works with Claude Code, Cursor, Codex, Cline, Windsurf, Gemini CLI, Antigravity, and around 50 more. Restart Claude Code and the skill is live.

If you are on Codex and the universal command does not register it, force the target:

npx skills add UditAkhourii/adhd -a codex -g

There is also a standalone command line version and a Node library, if you want the same loop outside of Claude Code or in a batch job:

npm install -g adhd-agent     # CLI
npm install adhd-agent        # library

Nothing is required for the skill itself, though. No API key, no config file, no dependencies. Claude runs the loop by itself.

Type the slash command with your problem in quotes:

/adhd "design a retry and timeout strategy for a CLI that sometimes hangs for 90 seconds"

Or from the CLI version, with knobs:

adhd "design a rate limiter that survives a leader election"
adhd "name this function" --frames 3 --ideas 8 --top 2

Three things worth knowing before your first run:

• Typing /adhd skips the gate. The skill has a pre-flight check that normally aborts on questions with one right answer. Explicit invocation means you opted in, so it goes straight to work without arguing with you.
• Certain words turn it off. If you say "quick", "standard", "canonical", "textbook", "just", or "one-line" in your prompt, the skill reads that as "give me the normal answer" and steps aside. Leave those words out when you want the wide version.
• Give it the real constraints. Every branch only sees your problem plus its frame. Budget, deadline, stack, and team size belong in the prompt, or the branches will invent their own.

The output has a fixed shape, and the shape is half the value:

• Brief. One or two lines confirming the problem it heard.
• Wide set. All ~30 ideas, grouped into 3 to 6 clusters by underlying angle, not by keyword. Each idea carries a score chip like [N7 V8 F9] for novelty, viability, and fit.
• Converge. A 2 to 4 idea shortlist with reasons, and one idea marked with a star as the non-obvious-but-viable pick.
• Traps. Listed separately, each with a one-line reason it is a trap. This is the part nobody else gives you.
• Focus. The top 3 get a real sketch: how it works, the load-bearing risk, the first concrete step, and 3 to 5 spin-off ideas.
• Provocation. One wildcard question, in case nothing landed.

Here is the difference in practice. On the hanging-CLI problem, a normal single answer walks through progressive timeouts and exponential backoff and lands on a sensible hybrid. ADHD surfaced 30-plus ideas and starred this one instead: a rage-quit button that glows hotter the longer you wait, and one click cancels and re-sends the prompt to a cheaper, faster model. It also flagged 20 traps. The obvious answer never questions the assumption that you should wait for the slow model. Maybe the slow model was just the wrong model for that prompt.

The author ran 6 open-ended engineering problems, same model both ways, judged by a separate AI told to act like a skeptical staff engineer, with the A and B order shuffled so the judge could not tell which was which. Scores out of 10:

• Breadth: 9.00 vs 4.83
• Novelty: 7.83 vs 2.67
• Trap detection: 9.50 vs 1.83
• Actionability: 9.50 vs 6.50
• Builder usefulness: 7.67 vs 6.83

ADHD won 5 of the 6 problems. The biggest gap by far is trap detection, because a normal answer almost never names the idea that looks great and quietly breaks.

Read the numbers with your eyes open. The judge is an AI, the sample is 6 problems, and it is the author's own benchmark. An independent blind test by another developer reproduced the direction of the result on 2 problems, at roughly 2.3x the time and 1.9x the output. The method also picked up a feature in The New Stack and has been adopted by other open source projects.

This is not a skill you leave running. It is a skill you reach for at a fork in the road.

Use it for: architecture and design decisions, API or CLI surface design, naming a product or a function, migration and refactor plans, bugs where you have no idea what the root cause is, code review when you want to know what else could go wrong, and any pricing, positioning, or strategy question.

Skip it for: lookups, syntax, bugs where you already know the cause, anything one search away, and anything inside a tight loop where you need an answer in two seconds.

The one-sentence test from the docs is good: if a junior would Google it and find the answer, the normal answer wins. If a senior would say "hm, let me think about this differently for a minute", that is the moment ADHD replaces.

A default run is about 10 Claude calls: 5 to diverge, 1 to score, 1 to cluster, 3 to deepen. Roughly 30 to 90 seconds of waiting.

Call count is not what you pay for, though. Every branch is a fresh, isolated context, and that isolation is the entire point. Which means each branch re-loads your whole base context, your CLAUDE.md, your project state files, your tool definitions, before it produces a single new idea.

cost =  N x (base_context + branch_output)   <- diverge
      + critic_context                       <- score + cluster
      + K x deepen_context                   <- focus

If your session carries a 26,000 token base, 5 branches burn about 130,000 tokens of setup before the interesting part starts. So the standalone CLI is much cheaper than the in-Claude skill, because the CLI branch only carries the problem and the frame.

Practical framing: a few cents to a few dollars to widen a decision that would cost you a week if you got it wrong. Do not run it on every keystroke. Run it at decision points.

Plenty of us building with Claude Code think in exactly this shape. Twelve tabs open, six half-built ideas, and a real gift for spotting the connection nobody else saw. The generating part was never the problem. The problem is that everything feels equally interesting, so nothing gets picked, and nothing ships.

What this skill quietly does is split those two jobs apart and put a wall between them.

• You stop paying the tab tax. The 30-directions-at-once phase runs in parallel, in Claude's context, not in your head at 1am. You read the map instead of building it.
• Something else does the converging. The critic pass scores, clusters, and picks. That is the exact executive-function step that costs the most and gets skipped the most.
• The shiny trap gets named out loud. Twenty traps flagged with reasons is a guardrail against the idea that feels amazing at midnight and eats two weeks.
• It ends with one concrete first step. Not 30 options. Each deepened idea comes with the literal next action, which is the difference between a great idea and a shipped one.
• It refuses to sit on the fence. "Here are 20 ideas, you decide" is listed in the skill as an anti-pattern. It has to take a position and star a pick.

Read it as external executive function. Your brain does divergence for free. The skill rents you the convergence.

• ADHD on GitHub
• SKILL.md, the runnable skill itself
• adhd-agent on npm
• The preprint: Parallel Divergent Ideation for Coding Agents
• Frames documentation, and how to write your own
• Evals: methodology and limitations
• The New Stack feature on ADHD for Claude Code

Built by Udit Akhouri. MIT licensed. I did not build this one, I just use it and think you should too.

I Need Cruise is a free Claude Code skill. You tell it roughly what you want, like "somewhere warm and cheap this winter," and it comes back with real sailings and the real total.

You do not need to pick a destination. Not picking one is the whole point. The cheapest trips are the ones you would never have searched for.

A cruise advertised at "from $389" is not $389. There are two costs stacked on top, and most sites show you neither.

• Taxes and port fees. These are in the data, but buried. On a real sailing we tested, they added $92 to a $389 fare.
• Gratuities. These are the daily tips the ship charges you automatically. They run $16 to $25 per person, per day. They show up in no price you will find online. On a 7-night trip for two people, that is $252 nobody told you about.

Add it up and the real number looks like this:

Fare $389 + Taxes $92 + Gratuities $252 = $733

That is 88% more than the price on the ad. The skill does that math every time and shows you every line of it, so you can see exactly where the money went.

Here is the part that surprised me most. Cruise sites do not sell flights, and flight sites do not know about ships. So nobody adds them together.

We measured a real example. A round-trip flight from Newark to Miami for two people came to $478. The cruise it paired with was $414. The flight cost more than the boat.

So the skill prices the flight too, and ranks on the two of them combined. A cheap cruise from a far-away port is not a cheap trip.

It also checks that the flight actually works. Ships sail in the early evening and do not wait. On one real search, three of the five flights offered were useless at any price because they landed after the ship left. The skill filters those out first, then picks the cheapest one that is left. If it skips a cheaper flight, it tells you why.

Twice a year, cruise lines have to move their ships. In spring they sail from the Caribbean over to Europe. In autumn they come back. Those crossings are called repositioning cruises.

Almost nobody books them, so the lines dump them at $40 to $70 a night. A two-week crossing of the Atlantic can cost less per night than a hotel room.

The reason they are cheap is simple: it is a one-way trip, so you end up in the wrong country. That is exactly why pricing the flight home matters, and it is the step the skill was built around.

This is the one thing you have to set up, and I want to be straight with you: it is not free. There is no free cruise data anywhere. Every official cruise API is locked behind a travel agency license. That lock is the reason no free tool does this.

Instead, the skill uses Apify, a service that runs small scraper programs for you.

• Step 1: make an account. Sign up at Apify here. The free plan gives you $5 in credit every month and does not ask for a card. That is enough to run this.
• Use code CHARLIE20 for a discount if you decide to upgrade later.

Step 2: connect Apify to Claude Code. This is the part I show in the video, and it is how I run it myself. You are installing something called an MCP, which is just a way to plug an outside service into Claude Code so Claude can use it directly.

Open your terminal and run this one line:

claude mcp add --transport http apify https://mcp.apify.com

Then open Claude Code, type /mcp, and log in when it asks. That is it. Once Apify is connected, the skill finds it on its own and there is no key or token for you to manage.

Not sure if it worked? Type /ineedcruise setup. It checks your setup, runs a small live test, and tells you plainly what is working and what is not.

Every search spends a little of your Apify credit. Here is the honest breakdown:

• Searching for cruises: about $0.50 to $0.80
• Pricing the flights: about $0.03 to $0.05
• Total per search: roughly $0.55 to $0.85

On the free $5 plan that is about 6 to 9 searches a month.

The skill never spends your money without asking. It shows you the plan and the exact cost first, and waits for you to say go. When it finishes, it tells you what the search actually cost.

Open a terminal and run one command:

npx ineedcruise install --with-commands

That puts the skill in ~/.claude/skills/ineedcruise/ and creates the /ineedcruise command. Restart Claude Code, type /ineedcruise, and you are in.

A few other commands if you need them:

• npx ineedcruise install --project installs it into just the current project instead of everywhere.
• npx ineedcruise update replaces an older copy with the newest version.
• npx ineedcruise uninstall --with-commands removes it cleanly.

Type /ineedcruise, then say what you want in plain English. Any of these work:

"Cheapest cruise out of Florida this winter"
"Repositioning crossing to Europe, two weeks, under $1500"
"Somewhere warm, 7 nights or more, as cheap as possible"
"I want to get to Europe cheap"

It will ask which airport you fly out of. Answer that one, because flights are part of the ranking. Leave it out and the answer is not just incomplete, it is wrong.

What comes back is a short brief: the best trip with every cost broken out, two runners-up, a table of everything else that qualified, and a booking link on every single one.

I would rather tell you the limits up front than have you find them later.

• It does not book anything. It finds the trip and hands you the link. You book it yourself.
• It does not pretend to see everything. The cruise data source returns only 5 results per query, no matter what you ask. The skill works around that by running several narrow searches, and it always tells you how many it ran.
• It does not guess a fee. If a cruise line is not in its tip table, it says so instead of making up a number.
• It does not invent flight prices. Flights are only published about 11 months out. Past that you get a clearly labeled estimate, never a fake price.
• It will not do the shady stuff. No hidden-city ticketing, no Skiplagged tricks, no fuel dumps. It will explain them if you ask. It will not build them, because airlines catch it, close accounts, and wipe out your miles.

One more honest note: the tip rates are estimates, last checked on July 25, 2026. Cruise lines change them about once a year. Every result prints that date and reminds you to confirm when you book.

• I Need Cruise on GitHub
• I Need Cruise on npm
• Sign up for Apify (free $5/month credit, code CHARLIE20 for a discount)
• Apify MCP endpoint (use with the claude mcp add command above)

ZenMillionaire is a free Claude Code skill that counsels you on money like you have a board of billionaire advisors sitting at your table.

It runs on something called persona counseling. Instead of one AI voice giving you one flat answer, the skill splits into separate advisors. Each advisor is built from one real book, and each one is only allowed to argue using ideas from that book. Then they talk to each other about your actual situation.

Two rules make it different from asking a chatbot about money:

• Every claim gets a citation. If an advisor tells you something, it names the source, like (Rich Dad Poor Dad, p.42). If an idea is not in the library, the advisor has to say "that's not in the library, here's my own read." No made-up financial doctrine dressed up as fact.
• It is built for augmentation, not automation. It does not move your money or run your budget. It helps you make a better decision, then hands the decision back to you.

Each advisor pulls from its own source, so they naturally disagree. That disagreement is the whole point.

• The Zen Master — Ken Honda, Happy Money
• The Definite Thinker — Napoleon Hill, Think and Grow Rich
• The Realist — Morgan Housel, The Psychology of Money
• The Life-Energy Guide — Robin & Dominguez, Your Money or Your Life
• The Ancient Sage — George Clason, The Richest Man in Babylon
• Rich Dad — Robert Kiyosaki, Rich Dad Poor Dad
• The Quiet Millionaire — Stanley & Danko, The Millionaire Next Door
• The Operator — Alex Hormozi, $100M Offers and $100M Leads
• The Angel Philosopher — Naval Ravikant, The Almanack of Naval Ravikant
• The Persuader — Robert Cialdini, Influence

MJ DeMarco's The Millionaire Fastlane is in the library too, so the blended advisor can pull from it.

The advisors sit on three poles: mindset-zen (peace, meaning, "how much is enough"), mechanics-iq (assets, saving, investing), and modern-leverage (offers, selling, earning more). The skill picks advisors from different poles on purpose so you hear the other side.

You type /zenmillionaire, it shows the menu, asks you a few quick questions, then suggests the right mode. It always confirms before it locks anything in.

• 1. Talk to one advisor — pick a single voice and have a normal back-and-forth in that style.
• 2. Council / roundtable — the best one. Claude spins up subagents, one per advisor, and they debate your question. You get each opinion plus a synthesis at the end.
• 3. Blended advisor — one voice that pulls from all twelve sources at once.
• 4. Diagnose me — a money-blueprint survey that saves a profile, so later advice is personalized to how you actually think about money.
• 5. Create a persona — build your own advisor.
• 6. Add a source — add a book PDF or a YouTube video to the library.

Open a terminal and run one command:

npx zenmillionaire install --with-commands

That drops the skill into ~/.claude/skills/zenmillionaire/ and writes the /zenmillionaire slash command. Restart Claude Code, type /zenmillionaire, and you're in.

Other commands if you need them:

• npx zenmillionaire install --project installs into the current project's ./.claude/ instead of globally.
• npx zenmillionaire update overwrites an existing install with the newest version.
• npx zenmillionaire uninstall --with-commands removes it and the slash command.

1. Pressure-test a decision. Type /zenmillionaire, pick council, and ask something real:

"I'm thinking about dropping a $4,000/mo retainer client to free up time for my own product. Challenge me on this."

Rich Dad argues about building an asset instead of trading hours. The Realist argues about how long your runway really is. The Operator argues about whether the product offer is even good enough yet. You end up seeing the parts of the decision you were skipping.

2. Have the council review a document. Paste in notes from a coaching call, a business plan, or a budget, and say:

"Have the council review this consulting conversation and tell me where the advice is weak."

The subagents each read the document through their own lens, then come back with feedback from ten angles instead of one.

3. Work on a money belief, not a money number. Run mode 4, "Diagnose me," and let it survey your money blueprint. It stores a profile, so the next time you ask whether to spend or save, the advice already knows how you're wired.

Nothing is locked in code. Every advisor, framework, and citation is plain Markdown you can open and edit.

Want a new advisor? Run mode 5, hand it a book you already own, and ask it to build a persona from that book. Want to grow the library? Run mode 6 and feed it a PDF or a YouTube link. It distills the ideas, tags them with page numbers or timestamps, and adds them to the citation index so every advisor can quote it.

One honest note on copyright: the public repo ships the distilled, cited frameworks only. The actual book PDFs are not included, because owning a book does not give anyone the right to redistribute it. You bring your own copies.

• ZenMillionaire on GitHub
• ZenMillionaire on npm

Understand Anything (Egonex-AI/Understand-Anything, the #1 repo of the day with 200,000+ users) is a Claude Code plugin that turns a codebase into an interactive knowledge base anyone can actually understand. One command runs a multi-agent pipeline over your project:

• /understand scans the whole project, extracts every file, function, class, and dependency, and builds a knowledge graph saved to .understand-anything/knowledge-graph.json.
• /understand-dashboard opens a local web dashboard where the codebase is drawn as a clickable graph, color-coded by architectural layer (API, service, data, UI, utility). Click any node to see its code, its relationships, and a plain-English explanation of what it's for.
• It auto-generates guided tours ordered by dependency, so you learn the codebase in the right order instead of grepping blind.
• It runs incrementally after the first pass, only re-analyzing files that changed, so day-two runs are cheap.

Here's the uncomfortable truth for the Claude Code era: most of us are shipping apps we didn't hand-write and can't fully explain. The AI built it, it works, and the mental model lives nowhere. The day something breaks, or a client asks how it works, or you want to hand it off, you're reading your own project like a stranger.

Understand Anything fixes the exact gap. It's the difference between "the AI made this" and "I understand what the AI made." It splits the work the smart way: Tree-sitter deterministically parses the real structure (imports, call sites, inheritance) so the edges are reproducible, and an LLM layer reads that structure to write the summaries, layer assignments, and tours a parser never could. Same code always yields the same graph, but you still get intent, not just syntax.

Where this actually earns its keep, especially if you run an agency or ship AI-built software:

• Understand your own vibe-coded app. You built it with Claude Code across ten sessions. Now graph it and finally see how the pieces fit before you scale it, sell it, or debug it under pressure.
• Inherit a client's or legacy codebase. Walk into 200,000 lines you've never seen, run /understand, and get an onboarding tour instead of a week of blind exploration. Use /understand-onboard to generate a new-hire guide.
• Scope a client project before you quote it. Graph the existing system first so your proposal is based on the real architecture, not a guess. Fewer surprise hours, tighter estimates.
• Review changes before you commit. /understand-diff shows which parts of the system your current changes ripple into, so you catch blast radius before it ships.
• Answer "how does X work?" instantly. /understand-chat How does the payment flow work? queries the graph in plain English. /understand-explain src/auth/login.ts deep-dives a single file.
• Onboard a team or VA without a meeting. The graph is just JSON. Commit it once and teammates skip the whole pipeline, they open the dashboard and explore. Docs-as-code that never goes stale (wire up /understand --auto-update for a post-commit refresh).
• Map a business's logic, not just its files. /understand-domain extracts domains, flows, and process steps, so a non-engineer stakeholder can see how the software maps to the actual business.

Two commands, straight into Claude Code. First add the marketplace, then install the plugin:

/plugin marketplace add Egonex-AI/Understand-Anything
/plugin install understand-anything

Restart Claude Code, then point it at a project and run /understand. When it finishes, run /understand-dashboard to open the visual graph. Scope a huge monorepo with /understand src/frontend, or generate non-English output with /understand --language zh (supports en, zh, zh-TW, ja, ko, ru).

The initial /understand reads your entire codebase, so on a large project it can burn a meaningful number of tokens. Run it on a subscription / token plan, or point it at a local model (Ollama) for the first pass if you're cost-sensitive. Every run after that is incremental by default, only changed files get re-analyzed, so ongoing use is cheap. Worth knowing before you aim it at a 200k-line repo.

The /understand command orchestrates five specialized agents: a project-scanner (detects files, languages, frameworks), a file-analyzer (extracts functions, classes, imports into graph nodes and edges, running up to 5 in parallel), an architecture-analyzer (assigns each file to a layer), a tour-builder (writes the guided walkthroughs), and a graph-reviewer (validates completeness). /understand-domain adds a sixth for business-logic mapping. It's MIT-licensed and open source, an Egonex project originally created by Lum1104.

• Understand Anything on GitHub (the plugin repo, MIT)
• Live interactive demo (pan, zoom, and search a real graph in your browser, no install)
• Understand Anything homepage

RE Walkthrough Pro is a Claude Code skill that turns a Zillow listing into a cinematic, room-by-room walkthrough video. One command runs the whole pipeline:

• /re-walkthrough-pro takes a Zillow listing link (or finds you listings: "find 5 single-family homes in Montclair NJ").
• It pulls every photo plus the address, price, beds/baths, and agent through an Apify Zillow actor (Zillow blocks naive scraping, so the actor is the reliable source).
• It curates the hero rooms, then animates each one with the Higgsfield MCP, a camera move matched to the room: drone approach on the exterior, steadicam down the hall, orbit in the great room, a rising reveal on the backyard.
• It stitches the clips with ffmpeg into a 16:9 master for the agent, plus an optional 9:16 cut for social.

Agents pay for media, and the bottleneck is production time. A walkthrough that looks like a $1,000 to $3,000 shoot can be built from the listing photos in minutes, for sub-cents of scraping plus a handful of Higgsfield credits. Drop it into a real estate marketing service as a video line item, or batch tours across a farm area and pitch the listing agents.

The architecture is the actual unlock. AI video models work clip-by-clip (around 5 seconds of image-to-video), so a whole-house walkthrough has to be per-room clips stitched together on your side. This skill does exactly that, with a camera move per room type so the stitched result reads like walking through the home.

This produces a cinematic walkthrough, per-room camera-move clips stitched into a tour, not a true 3D or Matterport reconstruction. It looks premium and it is impossible without an AI video engine, but do not promise a walkable dollhouse. The skill is honest about this on purpose, so you sell it right.

One command with npm:

npx re-walkthrough-pro install

That drops the skill into ~/.claude/skills/re-walkthrough-pro/. Restart Claude Code, run /re-walkthrough-pro, and paste a Zillow link. Use --project to install into the current repo only.

Two MCP servers connected in Claude Code, plus ffmpeg:

• Higgsfield MCP for the per-room animation and the social reframe (Seedance 2.0 / Kling 3.0 image-to-video).
• Apify for the listing scrape (the Zillow detail scraper pulls photos plus specs in one call).
• ffmpeg for stitching (brew install ffmpeg).

• RE Walkthrough Pro on GitHub (the skill repo, MIT)
• RE Walkthrough Pro on npm
• Get Higgsfield MCP access (my affiliate link, every image + video model in one credit pool)
• Apify account (my referral link, the actor marketplace + MCP for the Zillow scrape)
• Apify MCP server (@apify/actors-mcp-server, grab your token at console.apify.com)

If you're still struggling to build an AI agent in 2026, here's the unlock: an agent is just a skill. Anthropic has publicly told builders to focus on skills over agents, and a Claude skill is nothing more than a named worker with access to its own tools and routing. It knows what it can touch and when to load what. It's packaged in plain Markdown, which is just a text file you can read yourself, not custom code.

The old way of building agents meant n8n workflows or custom scripts, both far harder to assemble than a skill. I've built 40+ skills now, and this is 10x easier than the old way.

A skill is a folder with files inside. Open one of mine and you'll find the same five parts every time:

• The entry point (skill.md). The beginning of everything: the triggers, the persona, and the commands. It lives outside the subfolders.
• Context. Everything the skill needs to know to operate, like the details about your business it should load.
• Frameworks. The playbooks and methods the skill follows.
• Tasks. The workflows that tell Claude how to put the frameworks, context, and entry point together into one cohesive run.
• Templates. How the output should look when the skill is done running.

SkillSmith formalizes this into seven file types, each with a syntax spec: entry points, tasks, templates, frameworks, context, checklists, and rules. Consistent structure is what makes a skill portable, so someone else can install it and not get lost.

There's a single command, /skillsmith, with four routes:

• /skillsmith discover: a guided interview that turns an idea into a skill spec.
• /skillsmith scaffold: builds the compliant skill directory from that spec.
• /skillsmith distill: takes a long-form YouTube video or an SOP and distills it into framework chunks you can turn into a skill.
• /skillsmith audit: reviews skills and frameworks you already have and improves them over time.

I used SkillSmith to build a "Creative Director" skill, a simpler version of my Viral Audit. The prompt: make a slash command that pulls my YouTube and Instagram data from the last 30 days, acts as a creative director, ranks my videos best to worst in a Markdown file, then interviews me on what to do with the top performers and closes with a coaching brief.

SkillSmith generated the whole folder: a channels.md context for which handles to log into, frameworks for the performance signals to rank on, a task for the ranking workflow, and a template for how the report should look. Then it ran: scraped both platforms, ranked my reels, carousels, top 10 shorts, and top 10 long-form pieces, and wrote a full coaching brief telling me what to do better. Building it felt easy once the structure was right.

To pull the social data, that skill used Apify, a marketplace of "actors" that take actions on your behalf (in this case an Instagram Post Scraper and a YouTube scraper). Apify recently shipped its own MCP, a bridge that lets Claude Code walk into the marketplace and pick the right actor for the workflow you described.

Important: you do not need API connectors or an MCP to start. Your skills can be simple at the core and you can layer bridges to other software on as you grow. Apify was just the data layer for this particular example.

One command in a fresh terminal:

npx @chrisai/skillsmith

That installs the skill to ~/.claude/commands/skillsmith/, available in every workspace. Restart Claude Code, type /skillsmith, and pick a workflow. Use --local to install to the current project only.

Right now these skills run on a manual slash command, which is totally fine to start. Part two covers making them autonomous, on a schedule or triggered from Telegram or Slack. Three paths I like: Hermes (self-hosted on a VPS, my pick over OpenClaude), Claude managed agents (the easiest), and wiring an n8n MCP to run the workflow on its own.

• SkillSmith on GitHub (the meta-skill, by Chris AI Systems)
• Read the full walkthrough on the blog (anatomy + live build, written up)
• Apify account (my affiliate link, the actor marketplace + MCP used for the social-data layer)
• Apify MCP server (@apify/actors-mcp-server, grab your token at console.apify.com)

SEED (ChristopherKahler/seed, 270+ stars, by Chris AI Systems) is an AI project incubator for Claude Code. It takes a raw idea through a type-aware guided conversation and produces a structured PLANNING.md, ready for a PAUL-managed build. The point: stop answering the same setup questions every time you start something.

• /seed begins the guided ideation, shaped by what kind of thing you are building.
• /seed graduate moves a finished plan into apps/ with its own git repo.
• /seed launch graduates AND initializes PAUL in one command, so you go straight to building.
• /seed status shows your ideation pipeline; /seed add-type creates a custom project type.

SEED does not run one generic interview. It adapts the rigor and the sections to the project type, so a throwaway script does not get grilled like a full app:

• Application (deep rigor, 10 sections): software with UI, data model, and API.
• Workflow (standard, 8 sections): Claude Code commands and skills.
• Client (standard, 7 sections): client websites.
• Utility (tight, 6 sections): small tools, built to resist scope creep.
• Campaign (creative, 7 sections): content and marketing initiatives.

Rigor levels change the behavior: tight moves fast and resists expansion, standard stays balanced, deep goes thorough, creative goes generative. You can also write your own type with /seed add-type.

Most builds go sideways at the start, not the middle. You skip planning because it feels slow, then you are three hours into the wrong architecture. SEED makes planning the fast part. The interview is collaborative, it checkpoints so you can resume a half-finished idea, and it gates on quality so the plan is actually PAUL-ready before it graduates.

It is the front of the same build system the rest of my stack uses: SEED shapes the idea, PAUL runs the Plan to Apply to Unify loop on it, and SkillSmith builds any skills the plan calls for. SEED works standalone too, no PAUL required.

One global install with npm:

npm i -g @chrisai/seed

Zero runtime dependencies, pure Markdown skill install to ~/.claude/commands/seed/. Needs Claude Code and Node 16+. Restart Claude Code, type /seed, and start talking through the idea.

• SEED on GitHub (the incubator, by Chris AI Systems, MIT)
• @chrisai/seed on npm

UGC Factory is a Claude Code skill that turns a product, offer, and topic into a finished UGC video ad. One command runs the whole pipeline:

• /ugc-factory interviews you on product, offer, topic, the on-screen creator, length, and aspect ratio.
• It casts the creator as a multi-angle Higgsfield Element so the same person turns and moves believably across every clip.
• It routes to one of 15 built-in Seedance genre skills (ecommerce, food, fashion, SaaS, real estate, and more) so each clip gets genre-correct prompt craft.
• It writes a full script for every Seedance 2.0 clip (never blank, which is what makes AI video come out as gibberish), then stitches the clips into one ad with ffmpeg.

Two things break almost every AI UGC ad: the creator's face changes every cut, and the video model hallucinates because the prompt was left thin. UGC Factory fixes both. The creator and product are built once as reusable Elements and referenced in every clip, so there is zero drift between cuts. And the skill always writes a full scene script: who is on screen, what they say, the camera, the motion. Nothing is ever left blank.

It is stateless on purpose. Every run starts blank and casts a brand-new creator. There is no saved avatar locking you into the same face forever.

One command. Install with npm:

npx ugc-factory install

That drops the skill into ~/.claude/skills/ugc-factory/. Restart Claude Code, run /ugc-factory, and answer the interview. It returns the finished ad plus every source asset in one dated folder.

You need the Higgsfield MCP for the image, Elements, and Seedance 2.0 generation, plus ffmpeg for stitching. Grab the MCP here: install the Higgsfield MCP.

The package is self-contained. It bundles all 15 Seedance 2.0 genre style skills so the genre router works out of the box, with no separate installs: cinematic, 3D CGI, cartoon, comic-to-video, fight scenes, motion-design ad, ecommerce ad, anime, product 360, music video, social hook, brand story, fashion lookbook, food and beverage, and real estate.

• UGC Factory on GitHub
• UGC Factory on npm
• Higgsfield MCP (required)

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

Compliance Ops is an interview-driven compliance guardrail for Claude Code. It loads the matching framework (HIPAA, SOC 2, GDPR, PCI-DSS) into your conversation before Claude builds or automates anything, so every website, workflow, and agent is designed correct by default. Three commands ship in the box:

• /compliance-ops finds out what you're building and what you're worried about, loads the right framework, and flags you the moment a build heads in a non-compliant direction.
• /compliance-ops-audit reviews an existing build or data flow for gaps, anywhere protected data touches an uncovered vendor or the AI.
• /compliance-ops-document generates a data-flow map plus a vendor BAA checklist you can hand straight to a compliance officer.

Businesses in medical, legal, and financial spaces handle PHI, protected health information, the kind of data that gets you sued or fined if it leaks. And right now most owners don't know how to bring AI agents into the room safely. So they freeze. Stuck in digital limbo while their competitors automate and pull ahead.

The fix isn't bolted on after you build. It's baked in from line one. Compliance Ops gives the AI awareness of the rules up front, so protected data never gets routed through a non-compliant flow in the first place.

Important, and the skill says this itself: Compliance Ops is a seatbelt and a paper trail, not a compliance certificate. It does not make a Claude consumer subscription able to process protected data, and it does not replace your lawyer or a signed BAA. What it does is keep your builds inside the lines and document the entire process so you have a record of the decisions you made.

One command in a fresh terminal:

npx compliance-ops install --with-commands

That drops the skill into ~/.claude/skills/compliance-ops/ and writes the three slash-command stubs. Restart Claude Code, type /compliance-ops, and feed it what you're building and what you're worried about. Use --project to install into the current project's ./.claude/ instead of globally.

• Compliance Ops on GitHub
• Compliance 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 account (sign up free, then use code CHARLES20 for 20% off, capped at the first 100 signups, so grab it before it runs out)
• Apify MCP server (@apify/actors-mcp-server, grab your token at console.apify.com)

Cold Outbound Skills (growthenginenowoslawski/coldoutboundskills, 400+ stars) is 29 interconnected Claude Code skills that run the entire cold email engine, from zero to a campaign hitting 100s of leads. You start with one command and it chains the whole thing:

• /cold-email-kickoff is the guided orchestrator: ICP, lead magnet, strategy, and plan in one flow.
• /cold-email-starter-kit is the 14-step tutorial version if you want to learn the moves as you build.

From there the skills cover five tracks: strategy, infrastructure, list building, copy and send, and iteration.

• Strategy. ICP development, lead-magnet brainstorming, campaign ideation, copywriting workflows.
• Infrastructure. Domain and inbox setup (Dynadot, Zapmail), warmup config, deliverability audits, incident response.
• List building. This is the 100s-of-leads engine: Prospeo exports, Google Maps scraping, domain-to-contact discovery via Blitz, competitor research, list-quality scoring.
• Copy and send. Email composition, spam-word detection, spintax variation, Smartlead campaign uploads.
• Iteration. Reply scoring, A/B experiment design, autonomous research agents, weekly operating rhythm.

Most cold outreach dies at the list. You buy a stale CSV, blast it, torch your domain, learn nothing. This flips it. The skills BUILD the list from live sources (Google Maps and Prospeo), score it for quality before you send, then run deliverability and spam checks so your inbox survives. It is the part of lead gen nobody packages, done in plain Markdown skills you can read and edit yourself.

It pairs with the rest of the leads stack: this finds and emails the leads, Advertising Ops builds your paid-ad creative from proven winners, and UGC Factory ships the AI-creator video. Three layers, zero overlap.

The skills are free and open source. The tools they drive are not: budget roughly $360 for your first 2,000-lead campaign and about $130/month recurring across domains, Zapmail, Prospeo, Smartlead, and verification. You are paying the sending stack, not the brain.

Clone the repo, drop the skills into your ~/.claude/ commands directory per the README, and add your API keys (Prospeo, Smartlead, your domain provider). Restart Claude Code, then run /cold-email-kickoff and answer the interview. It scaffolds the strategy, sources the list, writes the copy, and queues the send.

• Cold Outbound Skills on GitHub (29 skills, 400+ stars)

/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.

Most people don't need another AI tool. They need to know which thing is actually costing them the most.

The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, free, no call required.

Take the free AI Bottleneck Finder →

• 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)

• Install BASE from GitHub

Built by Chris Kahler. Install it first, then work through the steps below.

BASE turns your rules into a graph instead of a document. You group rules into domains like DEV, CONTENT, or BRAND. Each domain has trigger words and folder paths attached to it.

When you type a prompt, BASE checks it. If you say the word "carousel", only your carousel rules load. If you open a file inside your website folder, only your website rules load. Everything else stays quiet.

They solve two different halves of the same problem, and you can run both at once.

• Graphify graphs what you know. Your code, your PDFs, your notes. It answers "what is in this project and how does it connect?"
• BASE graphs how you work. Your rules, your standards, your projects. It answers "how should Claude behave right now?"
• Graphify is something you query. You ask it a question and it gives you an answer.
• BASE is something that fires on its own. A hook reads your prompt before Claude sees it and injects the rules that match.
• Graphify does not stop your context from filling up. BASE does, because unmatched rules never get sent.

Short version: Graphify is memory for your data. BASE is memory for your behavior.

It does not replace CLAUDE.md. It takes the load off it.

CLAUDE.md is always on. Every line in it gets sent with every prompt you write, even when the prompt has nothing to do with those lines. Coding rules ride along while you write an email. That is wasted context, every time.

BASE domains are triggered. They cost nothing until they match. So the split is simple:

• Keep in CLAUDE.md: where things live in your repo, and anything you need before you know what you are doing.
• Move into BASE: every behavior rule. "Always do X." "Never do Y."

Doing this on my own setup cut my always-on context from 381 lines to 217, and nothing was lost. The rules still arrive, they just arrive only when they apply.

Paste these into Claude Code after you install BASE.

Show me every BASE domain I have, with its trigger words and how many rules each one holds.

Read my CLAUDE.md. Tell me which sections are behavior rules that belong in a BASE domain, and which sections have to stay always-on.

Check every rule in my BASE domains. Does the folder, file, or tool it points at still exist?

Find rules that say the same thing twice across my domains, and tell me which copy to keep.

My rules are not firing when I expect them to. Show me the trigger words for that domain and what is missing.

1. Read it out loud, section by section. For each one ask: could a keyword or a file path reliably tell Claude to load this?
2. If yes, it belongs in a BASE domain. Brand rules, tool rules, writing rules. All of it.
3. If no, leave it. Your folder layout is the main one. You need it before any keyword could match.
4. Replace what you moved with one pointer line so you can still find it later. Something like: "Coding rules live in the BASE DEV domain. Run base domain get DEV."
5. Check the trigger words first. Before you delete a section, make sure the domain actually fires on the words you really type. A rule that never triggers is worse than a rule that is always on.

1. See what you have: base domain list shows every domain, its triggers, and its rule count.
2. Look inside one: base domain get DEV prints that domain's rules.
3. Add a trigger word: base domain add-trigger --domain DEV --keyword typescript
4. Make a new domain: base domain create --name PDF --keyword pdf --keyword invoice
5. Check your work: base doctor should say HEALTHY. Run it after every change.

Two habits that will save you real time:

• Audit by asking what still exists, not by asking whether the rule sounds smart. Dead rules read perfectly fine and only fail when they fire.
• Check for overlap before you add. If a rule already lives somewhere else, merge it instead of writing it twice. Two copies drift apart and you will not notice.

• BASE repo on GitHub
• Graphify repo (the other half)

Humanizer is an agent skill that rewrites AI-generated text so it stops reading like AI, without touching the facts. It works off 35 documented patterns pulled from Wikipedia's Signs of AI writing, maintained by WikiProject AI Cleanup. Inflated language, em dashes, forced word pairs, passive voice, chatbot sign-offs like "I hope this helps," all of it goes.

Every email, post, and landing page you hand to Claude comes back grammatically perfect and instantly recognizable. Your prospects have read a thousand of those. The moment they clock the rhythm, the message stops being from you and starts being from a tool, and that is the whole ballgame when you are trying to sell something.

Two passes, and that second pass is the part most rewriters skip.

• Pass one: rewrites the text without treating the original structure as fixed. It is allowed to break the shape, not just swap synonyms.
• Pass two: checks the new draft against all 35 patterns AND against the original claims, then makes final adjustments.

Feed it your own writing samples and it matches your voice instead of a generic human one. On files it preserves code, data, and frontmatter, so you can point it at a real document without it mangling the parts that are not prose.

I gave it 36 of my own YouTube transcripts, so it learned how I actually talk. Now anything going in front of a client or a prospect runs through it first. It is also wired into my bottleneck report workflow: that pulls a prospect out of the pipeline, drafts the email, then fires the humanizer skill and the subject line skill so the output sounds like me every single time instead of once in a while.

One command, global:

npx skills add blader/humanizer --global

On Claude Code 2.1.142 and newer you can also run /plugin marketplace add blader/humanizer. Claude Desktop needs the repo downloaded as a ZIP and uploaded as a skill.

It does not invent facts. Names, dates, quotes, and citations have to come from your source material or from you. It cleans how the thing reads, it does not fill in what the thing does not know. MIT licensed, 37,200+ stars.

• Humanizer repo on GitHub
• Signs of AI writing (the 35 patterns it enforces)

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

ccGlass (jianshuo/ccglass) is a free, open-source local proxy that sits between Claude Code and the model. Every request your agent makes passes through it, and a live web dashboard shows you exactly what was sent: input tokens, output tokens, cache hits, cost, latency, and the full payload of every single call.

It works with Claude Code, Codex, and Kimi. One command to start, and a browser tab streams every turn as it happens.

Most people think their AI bill comes from what Claude writes. It does not. I ran 10 requests and watched it live: 1,707,749 tokens going in, 4,341 tokens coming out, $11.57 spent. That is roughly 393 tokens sent for every 1 token Claude wrote back. You pay for the send, not the answer.

The hidden leak ccGlass exposed on my own setup: over 500 tool definitions loaded on every single call. Every MCP server you connect and forget about re-sends its entire tool menu into context on every request, whether you use it or not. You cannot fix what you cannot see. ccGlass makes it visible.

• You pay for input, not output. The cost is dominated by what you send the model, not what it returns.
• Connected MCP servers are your biggest leak. Each one injects 100s of tool definitions into every call. ccGlass shows the exact count per request.
• Your cache hit rate is money. A 65 to 70 percent hit means a third of your context is re-processed at full price every turn. Watch it climb as you trim.
• Failed calls still cost you. ccGlass flags errors (like a 404 on a model variant) so you stop paying for round-trips that never landed.

Once you can see the leak, the fix is simple: disconnect the MCP servers you are not actively using. Your tool count drops, your input tokens collapse, your cache hit rate climbs, and the same work costs a fraction. ccGlass lets you re-run and watch the numbers move in real time, so you can prove the savings instead of guessing.

• Anyone burning through their Pro plan limit weekly who wants to know where the tokens actually go
• Heavy MCP users (GoHighLevel, Slack, Canva, Apify, and the rest) whose context is quietly bloated by unused tool menus
• Agency operators running Claude Code on client work who need to control and explain their AI spend
• Anyone whose agent "feels dumb" and wants to see what context it actually received

Grab it from the repo and start the proxy, then point Claude Code at the local endpoint. Open the dashboard in your browser and run a normal session. Every request streams in live with its full token breakdown.

Free and open source. It reads your traffic locally, nothing leaves your machine beyond the calls you were already making.

• ccGlass on GitHub (the local token proxy + dashboard)

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.

Claude Code plus the Higgsfield MCP now builds full browser games end to end. You describe the game in plain English, Claude plans it, generates every sprite, tileset, texture, and sound with Higgsfield's models (including Fable 5), writes the game code, and deploys it to a live URL you can share or drop on your site. No Unity, no game engine, no boilerplate you have to touch.

The whole thing runs from your terminal through one credit pool. You are not the programmer or the pixel artist here. You are the director.

This is the part nobody shows you, and it is the single biggest quality unlock. The game pipeline accepts reference images, mood boards, character art, screenshots of existing games, and locks their look into a single STYLE FORMULA that gets stamped byte-identical into every asset it generates. That is why a game built from references reads like one coherent world instead of a pile of mismatched AI art.

So do not describe the art style in words. Show it. Where to pull references:

• Pinterest. Search "pixel art platformer", "isometric game art", "GBA RPG tileset", or the name of a game plus "art style". Pinterest boards are the fastest way to assemble a 6-image mood board in one look.
• Google Images. Search "[game name] screenshot" or "[game name] gameplay" and grab 4 to 6 frames that capture the palette, lighting, and mood you want. Steam store pages and press kits are clean, high-res sources.
• Your own favorite games. Screen-grab a game you already own while you play (a Celeste run, a Hollow Knight cave, a Vampire Survivors wave). Your own screenshots are the most honest reference for "make it feel like this."
• One character, many angles. If you have a hero you want, give it front, side, and back so Higgsfield can register it as a consistent element across every scene.

Then say: "Build me a game that plays like Vampire Survivors but looks like these," and attach the images. The reference speeds up every decision without replacing a single step of the build.

Under the hood the game skill runs a fixed three-phase pipeline, and knowing it helps you steer:

• Plan. Claude fixes the game profile (genre, players, controls, platforms), writes an asset manifest (one row per sprite, tile, texture, sound), and derives the STYLE FORMULA from your references. If your brief does not pin a style, it stops and asks you to approve the formula first. Approve it, because that one line governs the entire look.
• Build. It fires every asset generation in parallel while it writes the game code from proven skeletons, wiring each asset in as it lands. Desktop and mobile browsers with gamepad support are the default target, so your game works on a laptop, a phone, and a Steam Deck out of the box.
• Deliver. It deploys the finished game and hands back a real, shareable play URL (and lists it in the Higgsfield games catalog). That link is the deliverable, live the same day.

Honest framing: these are browser games built from generated 2D/3D assets and hand-written game logic, not AAA engine titles. That is exactly why one person with a good reference board can ship one in an afternoon.

1. Grab the MCP link from higgsfield.ai/mcp (my link, includes a 3-day free trial)
2. Paste the command into Claude Code and ask Claude to install the MCP for you
3. Run /mcp, click the Higgsfield entry, hit Allow to authenticate
4. Assemble your reference images, then say: "Build me a game like [favorite game] but [your twist], matched to these screenshots"

Within that same day you can have a deployed game with a link you can send anyone.

1. Pick the feeling, not the clone. Choose one game whose vibe you want (Vampire Survivors' escalation, Flappy Bird's one-tap tension, Stardew's cozy loop). Name it to Claude as the reference; it pre-fills the mechanics questions.
2. Build the mood board. Pull 4 to 6 reference images from Pinterest, Google, or your own screenshots. Aim for one consistent palette and art style across all of them, mixed styles produce mixed output.
3. Give the twist. One sentence on what makes it yours: the theme, the character, the setting. "Vampire Survivors, but you are a barista and the enemies are Monday-morning customers."
4. Approve the STYLE FORMULA. When Claude posts the derived style, read it and confirm. This is your one lever on the whole look, so use it.
5. Let it run, then playtest. Assets generate while the code is written. Open the delivered URL, play it, and send back specific fixes ("enemies too fast", "make the jump floatier"). Iterate in plain English.
6. Ship the link. Post the play URL to your community, embed it, or use it as a lead magnet. A game people can actually play beats another PDF.

• Claude Code as the builder (it plans, codes, and orchestrates the whole run).
• Higgsfield MCP for the game pipeline and every image, video, 3D, and audio asset (one credit pool, models including Fable 5).
• A reference board of 4 to 6 images. This is optional but it is the difference between "fine" and "how did you make that."

• Get Higgsfield MCP access + 3-day free trial (my affiliate link, every image, video, 3D, and audio model in one credit pool)
• Higgsfield MCP resource (the full setup walkthrough, already in this toolkit)
• RE Walkthrough Pro (another Higgsfield MCP build: Zillow listings into cinematic video)

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.

These two are a pair, and I never run one without the other. Anthropic ships /frontend-design built into Claude Code, no install needed. It handles the execution: production-grade components, spacing, motion, the parts that make a page feel built instead of generated.

UI UX Pro Max handles the decisions. Style, palette, type pairing, the system your project is going to live inside.

Run them in tandem and each covers the other's blind spot. The system skill has taste but no hands. The design skill has hands but picks the same safe defaults every time. I have this wired as a standing rule in my BASE domains so it is never optional on design work, which means Claude activates both any time a project touches the front end.

If you want the full picture on why Claude Code sites come out looking generic and what fixes it, that breakdown lives here: Why Your Claude Code Websites Look Like Slop (And The 4 Tools That Fix It). It covers this pair plus the animation and quality-check layers that sit on top.

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

A 30 second action film where you are the one falling off a Manhattan rooftop and web swinging between towers. Your real face, your real clothes, one continuous scene with a new camera angle every two to three seconds.

It takes one selfie and about 20 minutes. The whole thing is three moves:

1. Take a selfie with your front camera. That is your only source material.
2. Turn it into character sheets on Higgsfield, one full body turnaround and one face grid, so the model learns your face from every angle instead of guessing.
3. Feed the sheets into Seedance 2.5 with the action prompt at 30 seconds, and it holds your face the whole way through.

The character sheets are the step people skip, and skipping them is why AI videos drift into someone else's face halfway through. Sheets first, video second.

• A phone with a front camera. Face lit from the front, plain background, no filter.
• A Higgsfield account made through this link, which attaches the 33 days of unlimited Seedance 2.5 to your account.
• Optional but better: the 15 free Seedance video skills plus the Higgsfield MCP, so Claude Code writes and fires prompts like these for you instead of you pasting by hand.

Everything below works on the Higgsfield website alone, on your phone, with no Claude Code required. The skills just make the next hundred videos faster than this one.

Front camera, arm's length, face straight on, even light. No sunglasses yet if you want the model to learn your eyes, or wear them if the sunglasses are part of your look like they are in mine.

One photo is enough. You are not trying to make this photo good. You are giving the model a face to copy.

Go to higgsfield.ai on your phone, tap Create Image, and upload the selfie you just took as the reference image.

You are about to run two prompts against that one selfie. The next two steps are those prompts, word for word.

This prompt makes a four view turnaround: front, three quarter, side profile, back. It is what teaches the model your build, your clothes, and where your tattoos actually are, so they do not wander between shots.

Copy this into the prompt box with your selfie attached. Edit the physical description to match you, the skin, hair, facial hair, clothing, tattoos, and glasses. Leave the structure and the negative list alone, that is the part doing the work.

Character turnaround model sheet, four consistent full-body views of the same man in a row, evenly spaced left to right: front view, 3/4 front view, side profile view, and back view. The man is exactly the same person as the reference image in all four views, preserving his exact facial identity, bone structure and proportions. Single subject only, exactly one person per view. Pure white seamless studio background, professional character sheet presentation. The same man in his late twenties with light olive skin, oval-to-square face with a defined jawline, mature adult bone structure and adult facial proportions, straight nose, medium-full lips with a natural matte finish, wearing round dark matte-black frame SUNGLASSES with deep smoke-tinted lenses, eyes not visible behind the tinted lenses, subtle realistic reflection across the lens surface with no blown-out specular glare, a dark full mustache with a short trimmed chin beard and light stubble along the jaw and cheeks, dark brown short hair mostly covered by a washed pale sage-grey cotton baseball cap with a curved brim worn forward. Completely clean bare unmarked neck with no tattoos, no ink and no markings anywhere on the neck or throat. Visible fine skin texture with natural pores, fine lines, subtle asymmetries and texture irregularities, slight natural sheen rather than a glossy or dewy retouched finish, no digital smoothing, no beauty filter, no AI-airbrushed look, skin free of artificial glare shine or highlight blooms, matte-to-natural complexion. Lean athletic build with medium-broad shoulders and balanced proportions, dense dark blackwork tattoo sleeve covering the left forearm only, from just below the elbow down over the wrist and onto the back of the left hand, plain gold band ring on the left ring finger. Wearing a charcoal heather grey short-sleeve crew neck t-shirt, light heather grey knit athletic shorts with a drawstring waist ending just above the knee, black rubber slide sandals worn barefoot, no bag. Standing upright in a neutral relaxed pose, arms relaxed at the sides, both feet flat on the ground, full head-to-toe framing with the entire body and both feet visible in every single view, identical outfit, identical sunglasses and identical lighting across all four views. Natural anatomy, high-end but unretouched commercial photography style, soft diffused studio lighting without harsh reflections, cinematic realism, clean white seamless background, sharp focus on skin texture detail. Single subject only, only this one man in frame, no neck tattoo, no throat tattoo, no chest tattoo, no clear or transparent eyeglasses, no other people, no duplicate mismatched faces, no mannequin, no reflections of other objects, no props, no furniture, no background objects, empty seamless studio, all four views standing full-body head-to-toe not cropped not sitting, no text, no watermark, no logos, no frame borders, no labels, no distorted anatomy, no extra fingers, no beauty filter, no digital smoothing, no airbrushing, no plastic skin, no glossy skin, no babyface, no overly youthful rounded proportions.

This is what comes back:

The body sheet holds your build. This one holds your face. Six tight head and shoulders portraits in a grid: front, both three quarter turns, both full profiles, and a raised chin angle.

Same selfie attached, same edits to the physical description, new prompt:

Character face reference sheet, a clean even grid of six tight head-and-shoulders close-up portraits of the same man, three across the top row and three across the bottom row, evenly spaced on a pure white seamless studio background. Top row: straight front-facing neutral expression, 3/4 turn to his left, full left side profile. Bottom row: 3/4 turn to his right, full right side profile, and a slightly raised chin three-quarter view. The man is exactly the same person as the reference image in every panel, preserving his exact facial identity, bone structure and proportions, identical face in all six panels. Single subject only, exactly one person per panel. The same man in his late twenties with light olive skin, oval-to-square face with a defined jawline, mature adult bone structure and adult facial proportions, straight nose, medium-full lips with a natural matte finish, wearing round dark matte-black frame SUNGLASSES with deep smoke-tinted lenses, eyes not visible behind the tinted lenses, subtle realistic reflection across the lens surface with no blown-out specular glare, a dark full mustache with a short trimmed chin beard and light stubble along the jaw and cheeks, dark brown short hair mostly covered by a washed pale sage-grey cotton baseball cap with a curved brim worn forward. Completely clean bare unmarked neck with no tattoos, no ink and no markings anywhere on the neck or throat in any panel. Wearing a charcoal heather grey short-sleeve crew neck t-shirt. Visible fine skin texture with natural pores, fine lines, subtle asymmetries, individual facial hair strands and texture irregularities, slight natural sheen rather than a glossy or dewy retouched finish, no digital smoothing, no beauty filter, no AI-airbrushed look, skin free of artificial glare shine or highlight blooms, matte-to-natural complexion. Identical sunglasses, identical lighting and identical crop scale across all six panels, natural anatomy, high-end but unretouched commercial portrait photography style, soft diffused studio lighting without harsh reflections, cinematic realism, clean white seamless background, extremely sharp focus on skin texture and facial detail. Every panel is a tight close-up, no full body shots, single subject only, no neck tattoo, no throat tattoo, no chest tattoo, no clear or transparent eyeglasses, no other people, no duplicate mismatched faces, no mannequin, no props, no furniture, no background objects, empty seamless studio, no text, no watermark, no logos, no frame borders, no labels, no distorted anatomy, no beauty filter, no digital smoothing, no airbrushing, no plastic skin, no glossy skin, no babyface, no overly youthful rounded proportions.

This is what comes back:

Run both prompts two or three more times. You are unlimited during the window, so there is no reason to accept the first result.

Keep the sheets where your face is unmistakably yours and the details hold across every panel, the same cap, the same glasses, the tattoo on the correct arm. Throw out any sheet with a drifting face, a bonus person, or a tattoo that jumped sides. Download every sheet you keep.

Three good sheets beats ten mediocre ones. Garbage in the sheets becomes a stranger in your video.

Back on Higgsfield, start a new video and upload all of the character sheets you just downloaded as references. Seedance 2.5 takes up to 50 reference files in one render, so use every good sheet you have.

1. Upload every character sheet.
2. Paste the action prompt below.
3. Pick the Seedance 2.5 model. Say it out loud to yourself, because picking the wrong model is the single most common way people waste a render.
4. Drag the duration all the way to 30 seconds.
5. Generate.

This is the full prompt, unedited. Shot list first, then physics rules, then look, then audio, then negatives. That order matters, and the physics and negative blocks are why the webs behave instead of turning into a random cable across the frame.

Fast-paced 30s action sequence, 16:9, MULTIPLE DYNAMIC CAMERA CUTS, a new angle every 2 to 3 seconds, constant motion, nothing static. Same man as all three reference sheets: identical face, dark round sunglasses, pale sage-grey cap worn forward, charcoal grey crew tee, light grey knit shorts, black slide sandals, blackwork tattoo sleeve on LEFT forearm only. Same face in every shot.

SHOT 1 (0-2s): Tight low shot on his black slide sandals at the concrete parapet edge, toes over the drop, Manhattan 40 storeys below, wind whipping.
SHOT 2 (2-3.5s): CUT to low-angle wide, him against the golden hour skyline, tipping straight backwards off the edge, arms opening.
SHOT 3 (3.5-5s): CUT to bird's eye directly overhead looking straight down, he falls away from camera shrinking fast, street grid far below.
SHOT 4 (5-7s): CUT to tight on his face falling, cheeks rippling in the airflow, cap pinned, sunglasses steady, dead calm.
SHOT 5 (7-9s): CUT to wide freefall alongside him, tower facade ripping past, pigeons scattering off a ledge.
SHOT 6 (9-10.5s): CUT to extreme close on his right wrist as he snaps his arm UP, a thin white strand ejecting from the wrist.
SHOT 7 (10.5-12s): CUT to follow the strand tip flying UPWARD through open air toward the top of a tall tower far ABOVE him, the tip hits high on the upper facade and splats, sticking.
SHOT 8 (12-14s): CUT to wide, line taut running steeply UP from his hand to that high anchor, his body snapping out of the fall into an arc beneath it.
SHOT 9 (14-18s): Swinging pendulum beneath the anchor, camera orbiting hard with him, city rotating, sun strobing between buildings.
SHOT 10 (18-20s): CUT to street level looking straight up as he rips past overhead, traffic and steam vents in the foreground.
SHOT 11 (20-22s): CUT to him releasing at the top of the arc, tumbling, then snapping his other arm UP and firing a second strand upward to a further tower.
SHOT 12 (22-27s): Fast swing between towers, camera whipping laterally, city smearing, a helicopter crossing the background.
SHOT 13 (27-30s): CUT to a wide hero frame, him small against the canyon, sun blazing down the avenue.

WEB PHYSICS: every web fires UPWARD from his wrist and anchors HIGH on a tower ABOVE his body, so he hangs and swings BENEATH it. The web always stays attached to his hand. NEVER a web coming from below him, NEVER anchored at street or ground level, NEVER a long horizontal cable across the frame, NEVER both ends off screen, NEVER an existing wire he grabs, NEVER sliding along the line. Always show the strand travelling before it connects.

LOOK: 24mm wide, deep focus, late golden hour, warm key from the low western sun, cool sky fill, haze, restrained teal-orange, 35mm grain, heavy motion blur on the fast moves.

AUDIO DIEGETIC ONLY, NO MUSIC: no score, no soundtrack, no instruments, no melody at any point. Real sound only: dominant wind roar, distant street ambience, horns, a siren, clothing hammering, a sharp pneumatic thwip on each web fire, a wet splat as each tip sticks, rope tension creak, heavy swing whoosh with doppler, helicopter rotor, ending on wind.

NEGATIVE: no zipline, no tightrope, no pre-existing cable, no line unattached to his hand, no superhero costume, no mask, no spandex, no chest emblem, only his own clothes. No music. No other people falling, no face drift, no clear eyeglasses, no neck tattoo, no text, no watermark, no slow motion.

Four blocks are doing all of the heavy lifting, and they transfer to any 30 second scene you write next.

• Timestamped shot list. Thirteen shots with second ranges is what stops a 30 second render from becoming one slow drifting camera move. You are directing the edit, not describing a vibe.
• A physics block. Video models have no idea how a web works. Spelling out that the strand fires upward, anchors above him, stays attached to the hand, and never crosses the frame horizontally is the difference between web swinging and a man holding a random cable.
• An audio block. Seedance 2.5 generates sound with the picture, so if you do not say what you want you get generic score. Naming diegetic sound only, wind, horns, the thwip, the splat, is what makes it read as footage.
• A negative block. No costume, no mask, no emblem, no face drift. That is what keeps it you in your own clothes instead of a copyright-shaped man in spandex.

The character sheets are reusable forever. Once your face is captured, the sheets work for any video you make after this. You only rewrite the action prompt.

• Parkour chase: keep the shot list shape, change the action to rooftop running and vaults, drop the web physics block, keep the audio block.
• Founder brand film: thirteen shots becomes six slower ones, golden hour becomes window light, and the audio block becomes room tone and keyboard.
• Product ad with you in it: use your sheets plus photos of the product, and let the 07-ecommerce-ad skill from the free pack write the shot list.

If you want Claude Code writing these instead of you, install the 15 free Seedance video skills and describe the video in one sentence. The skills already carry the camera, lens, and lighting language.

• Skipping the character sheets. Feed a raw selfie straight into the video and your face changes halfway through. The sheets exist to stop exactly that.
• Keeping a bad sheet. A drifting face or a tattoo on the wrong arm in the reference becomes a drifting face in every single shot.
• Leaving the model on default. Pick Seedance 2.5 explicitly, or you get a shorter render on a different model.
• Writing a vibe instead of a shot list. "Me swinging through New York" gives you eight seconds of nothing. Timestamps and cuts give you a film.

I am Charles J Dove, and I run Charlie Automates. At my agency CC Strategic we build these systems for clients, and everything I test lands free on charlieautomates.com first.

Not sure what to fix first? The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, no call required. Take the free AI Bottleneck Finder →

• Get 33 days of unlimited Seedance 2.5, my affiliate link, the offer this playbook runs on
• The 15 free Seedance video skills, free on GitHub, no email, the prompt pack Claude picks from
• The Seedance 2.5 playbook, what changed in 2.5 and when to use 2.0 instead
• Higgsfield MCP setup guide, how to connect Higgsfield to Claude Code so it fires renders for you
• CC Strategic AI on Skool, where we build this stuff together

Seedance 2.5 is the new video model from ByteDance, and it is live on Higgsfield right now with 33 days of unlimited use. The reason people are paying attention is length: Seedance 2.5 generates a single 30 second shot in one pass, where every model before it made you build a scene out of short clips and glue them together.

Five things changed from the last version:

• 30 seconds in one shot. Not four clips stitched. One continuous take, so the light, the room, and the person stay the same from the first frame to the last.
• Up to 50 reference files per render. Photos, video clips, audio, and text, all in one request. You can hand it your real product from ten angles and it keeps that product.
• Region editing. Change one thing in a finished clip, like a shirt color or a label, without regenerating the whole video.
• Sound made with the picture. Footsteps, voices, and background noise come out already lined up with the motion instead of being added later.
• Better prompt following. Roughly 20% closer to what you asked for, and it holds small details like hair, text, and fabric across frames.

Seedance 2.0 renders in 4K. Seedance 2.5 trades on length, references, and control. Both are live, so the honest answer is that each one wins at something different and you pick per job.

Pick per job. Reach for 2.0 when you need maximum sharpness in a short shot. Reach for 2.5 when you need length, a pile of references, or sound that lands with the picture.

Seedance 2.5 is built for finished work, not test clips. A 30 second shot is a whole ad, a whole product demo, or a whole scene, which means you stop editing and start publishing. Below is what to make, and which of the 15 free skills writes the prompt for it.

The other six skills in the pack cover 3D, cartoon, comic panels, fight scenes, anime, and fashion lookbooks. Same idea, different look.

The 15 video skills are free Claude Code files that already know how Seedance wants a prompt written: camera move, lens, lighting, pacing, and shot order. Without them you type a sentence and get soft, floaty footage. With them you type the same sentence and Claude turns it into a full production prompt before it renders.

This is the step most people skip, and it is the reason their videos look generated instead of shot. Use the skills. They are the difference.

The pack is labelled Seedance 2.0, and it works with 2.5 the same way. The skills write prompts, and prompt writing did not change between the two, so nothing in the pack is out of date. You just have more room to use it now that scenes run to 30 seconds. Grab it here: the 15 free Seedance video skills on GitHub. Free, no email, nothing to buy. There is also a full write up of the pack here on charlieautomates.com.

Setup is four steps and takes about 20 minutes, and most of that is Claude installing files while you watch. Do them in this order, because the skills cannot render anything until the Higgsfield connection is live.

1. Claim the 33 days. Open this link and make your Higgsfield account through it. The 33 days of unlimited Seedance 2.5 attach to the account you land on.
2. Install the 15 skills. Copy this repo link, paste it into Claude Code, and say: "Install every skill in this repo into my skills folder." Claude does the rest.
3. Install the Higgsfield MCP. The MCP is the bridge that lets Claude fire the render itself instead of handing you a prompt to paste somewhere. Full walkthrough here: Higgsfield MCP setup guide.
4. Check it. In Claude Code, type /mcp and read the list. If higgsfield says connected, you are done. If it does not, the MCP did not install, and nothing after this will work.

You give Claude three things in one message: what the video is, which skill to use, and which model to run. Name the model every time. If you leave it out, Claude picks a default and you waste a free render on the wrong setting.

Copy this shape:

Make me a 10 second product video for [product].
Use the [skill name] skill from the Seedance skill pack.
Use Seedance 2.5.

Scenes now run to 30 seconds, so raise the length when the shot needs it. Want maximum sharpness on a short clip instead? Change the last line to Use Seedance 2.0 in 4K. Everything else stays the same.

Change the bracketed part and send it. Swap the model line any time you want 2.0 in 4K instead.

• Product commercial: "Make a 10 second product ad for my [matte black water bottle]. Use the 07-ecommerce-ad skill. Seedance 2.0 in 4K. Studio lighting, slow push in, product centered, no text."
• Product spin: "Make a 6 second 360 turntable of [this sneaker] on a plain white background. Use the 09-product-360 skill. Seedance 2.0 in 4K."
• Brand story: "Make a 12 second brand story opener for [my coffee roasting company]. Use the 12-brand-story skill. Seedance 2.0 in 4K. Warm morning light, hands working, no faces."

Claude reads the skill, writes the full production prompt, sends it to Higgsfield through the MCP, and hands the finished file back to you. You keep working while it renders.

It costs $0 to run this playbook for the next 33 days. Seedance 2.5 is unlimited during the window, the 15 skills are free on GitHub, the Higgsfield MCP is free to connect, and Claude Code runs on the plan you already pay for. The only spend is the Higgsfield subscription you start through the link, which is what turns the 33 days on.

Compare that to hiring it out. One product video from an agency runs $2,000 to $3,000 and takes 2 to 3 weeks, because you are paying a videographer, a lighting setup, an editor, and a colorist. One render on this setup takes about 3 to 5 minutes. That gap is the entire reason to learn this now.

Most people who try this get a weak result and blame the model. It is almost always one of these three, and all three take one minute to avoid.

• Not picking the model. If you never say which model to use, Claude picks a default and you burn a render on the wrong setting. Name Seedance 2.5 in the prompt every time.
• Skipping the skills. Hand written prompts produce soft, drifting footage. The 15 skills carry the camera and lighting language that makes a clip look shot instead of generated.
• Not checking /mcp first. If Higgsfield is not connected, Claude will write you a beautiful prompt and render nothing at all.

This setup is one example of a bigger pattern: you give Claude Code a specialist file for every job you repeat, then let it run those jobs on request. That pattern is what an agentic OS is. Video is the easiest place to see it pay off, because the before and after is a $3,000 invoice turning into a 5 minute render.

I am Charles J Dove, and I run Charlie Automates. At my agency CC Strategic we build these systems for clients, and everything I test ends up free on charlieautomates.com first. For the full breakdown of how the pieces fit together, read the 3-step system to build an agentic OS, or watch the walkthroughs on the Charlie Automates YouTube channel @charlieautomates.

Not sure what to fix first? The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, no call required. Take the free AI Bottleneck Finder →

• Get 33 days of unlimited Seedance 2.5, my affiliate link, the offer this playbook runs on
• The 15 free Seedance video skills on GitHub, the prompt pack Claude picks from
• The official Seedance 2.5 explainer, what ByteDance showed at launch
• Seedance 2.0 in 4K playbook, when to reach for 2.0 instead
• Higgsfield MCP setup guide, how to connect Higgsfield to Claude Code
• CC Strategic AI on Skool, where we build this stuff together

Seedance 2.0 in 4K is now free to run on Higgsfield through Friday, 08/07/26. Seedance 2.0 is the video model most of the good AI product ads you have seen this year were made with, and 4K is its top output tier. Until this week, 4K was the setting people skipped because it burned credits the fastest.

Free here means unlimited. You are not counting a balance, so you can render the ugly first version, the better fifth version, and the one you actually ship, and pay nothing for the practice in between. If you subscribe during the window, Seedance 2.5 is also unlimited for 7 days after it launches.

A single product video from an agency costs $2,000 to $3,000 because you are paying for four people, not for footage. A shoot needs a videographer, a lighting setup, an editor, and a colorist, plus a studio day. That is the real invoice, and it takes 2 to 3 weeks.

Seedance 2.0 replaces the shoot. The 15 skills replace the person who knows how to talk to it. You still supply the taste and the product. What disappears is the $3,000 and the three weeks.

The 15 video skills are Claude Code skill files that already know how Seedance 2.0 wants a prompt written: camera moves, lens, lighting, pacing, and shot order. You describe the video in plain English, Claude picks a skill, and the skill turns your sentence into a full production prompt.

Five of the 15 are built specifically for commercial and marketing work. Those are the ones that pay for themselves.

Grab the pack here: the 15 free Seedance 2.0 video skills. It is free, and there is no email gate on the repo.

Setup is four steps and takes about 20 minutes, most of which is Claude installing files while you watch. Do them in this order, because the skills are useless until the MCP is connected.

1. Turn on the free 4K window. Open this link and make your Higgsfield account through it, so unlimited Seedance 2.0 in 4K is attached to that account.
2. Install the 15 skills. Open the free skills pack, copy the repo link, paste it into Claude Code and say: "Install every skill in this repo into my skills folder." Claude does the rest.
3. Install the Higgsfield MCP. The MCP is the bridge that lets Claude actually fire the render instead of just writing a prompt you paste somewhere. Full walkthrough here: Higgsfield MCP setup guide.
4. Verify it. In Claude Code, type /mcp and scroll the list. If higgsfield shows connected, you are done. If it does not, the MCP did not install and nothing after this will work.

You give Claude three things in one message: what the video is, which skill to use, and the words "Seedance 2.0 in 4K". That third part matters. If you leave the model and resolution out, Claude picks a default and you burn the free 4K window on a 1080p render.

Copy this shape:

Make me a 6 second product video for [product].
Pick the right skill from the Seedance skill pack.
Use Seedance 2.0 in 4K.

These are the three that cover most small business work. Change the bracketed part and send it.

• E-commerce ad: "Make a 6 second e-commerce ad for my [matte black water bottle]. Use the 07-ecommerce-ad skill. Seedance 2.0 in 4K. Studio lighting, slow push in, product centered, no text."
• Product 360: "Make a 5 second 360 turntable of [this sneaker] on a plain white background. Use the 09-product-360 skill. Seedance 2.0 in 4K."
• Brand story: "Make an 8 second brand story opener for [my coffee roasting company]. Use the 12-brand-story skill. Seedance 2.0 in 4K. Warm morning light, hands working, no faces."

Claude reads the skill, writes the full production prompt, sends it to Higgsfield through the MCP, and hands you back the finished file. You keep working in Claude Code while it renders.

Right now it costs $0. During the free window, every Seedance 2.0 render in 4K is unlimited, the 15 skills are free on GitHub, the Higgsfield MCP is free to connect, and Claude Code runs on the plan you already pay for.

Compare that to the alternative. One agency product video is $2,000 to $3,000 and 2 to 3 weeks. One render on this setup is about 3 to 5 minutes. That is the entire pitch.

Most people who try this get a mediocre result and blame the model. It is almost always one of these three, and all three are avoidable.

• Not saying "4K". Claude defaults to a cheaper tier. Say the model and the resolution in the message, every time.
• Skipping the skills. Raw prompts written by hand get soft, floaty footage. The skills carry the camera and lighting language that makes it look shot instead of generated.
• Not checking /mcp first. If Higgsfield is not connected, Claude will happily write you a beautiful prompt and never render anything.

This setup is one skill inside a much larger pattern: giving Claude Code a specialist file for each job you repeat, then letting it run those jobs on request. That pattern is what an agentic OS is, and video is one of the easiest places to see it pay off, because the before and after is a $3,000 invoice.

I am Charles J Dove, and I run Charlie Automates. At my agency CC Strategic we build these systems for clients, and everything I test ends up free on charlieautomates.com first. If you want the full breakdown of how the pieces fit, read the 3-step system to build an agentic OS, or watch the walkthroughs on my YouTube channel @charlieautomates.

Not sure what to fix first? The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, no call required. Take the free AI Bottleneck Finder →

• Unlimited Seedance 2.0 in 4K on Higgsfield, my affiliate link, the offer this guide runs on
• The 15 free Seedance 2.0 video skills, the prompt pack Claude picks from
• Higgsfield MCP setup guide, how to connect Higgsfield to Claude Code
• Higgsfield free unlimited playbook, the $1,700 day I ran on the last free window
• CC Strategic AI on Skool, where we build this stuff together

My honest answer is about 60% yes.

You are not replacing a human executive. You are building something that reads your real data and tells you what to do next, every day, without you asking. That is the 60%. The judgment call at the end is still yours.

95% of people are nowhere near using AI at full capacity. The thing you have been picturing is almost certainly possible right now. The hard part was never the model. It is knowing where to start, what data to feed it, and how to give it access to your tools without handing it the keys to everything.

This build is a CMO. Same process works for any officer you want.

Most people try to automate a process they have never written down. That is why their automations break.

Quick test: can you name your five highest ROI processes right now, out loud, in order? If you cannot, forget automation for a minute. Build for augmentation instead, which means AI that helps you make better decisions with the data you already have.

The CMO in this build has some automation in it. But its main job is to read the numbers and hand you a decision.

• An agentic coding tool. I use Claude Code inside VS Code. I would not build this anywhere else. New to it? Start with my Claude Code crash course before this one.
• Clarity on what it builds and what it can touch. The deliverable, the data, the access. This is the part people skip, and it is why their agent comes out useless.
• The right frameworks. Without structure, it does not matter how good your idea is. The output will miss. I use two: SEED to shape the idea, and SkillSmith to build the agent.

Strip away the hype and an executive officer is a Markdown file. Plain text a model can read, holding clear instructions for how the worker should operate.

Open one of mine and you find the same parts every time: the entry point that holds triggers and commands, context about your business, frameworks it follows, tasks that string the run together, templates for how the output should look, and checklists that gate risky actions.

That is the whole trick. Skills, commands, agents, they are the same thing wearing different names.

Run /seed and describe the officer you want. Do not write a spec. SEED does the heavy lifting through a guided interview.

My prompt named four things, and yours should too:

• What it is. A CMO officer, packaged with SkillSmith once the idea is shaped.
• What data it may pull. Apify to scrape my Instagram and YouTube.
• What commands it may call. My existing /viral discover pipeline for competitor and self content audits.
• What systems it may read. GoHighLevel for CRM, prospects, and deals. GA4 for site analytics.

I also told it plainly: focus on augmentation, not full automation. That one line changes the whole build.

SEED writes the plan out to a file in your project. Read it before you move on.

Hand the SEED plan to SkillSmith and run /skillsmith discover. It interviews you again, tighter this time, then scaffolds the skill folder.

Two questions it asked me that matter more than they look:

• Is this a consultant or an operator? I picked consultant. A consultant reads and recommends. An operator takes action, and it gets complicated and convoluted fast. Start as a consultant.
• How should it be invoked? One front door. Just /cmo. Not fifteen commands you will forget by Thursday.

Model routing, since people ask: I ran Opus 5 for the ideation and switched to Fable 5 for the build.

Inside the skill there is a checklist file, and this is your safety layer.

Mine reads: consult, recommend, draft, and stop. The CMO can write a campaign. It cannot send one. Nothing leaves my hands without me looking at it.

Decide this before you wire anything up. Fully autonomous, fully manual, or a blend. Write it into the checklist so the agent cannot quietly drift past it later.

MCPs and CLI tools are the bridges between Claude Code and your software. No bridge, no data, and the agent is guessing.

• GoHighLevel MCP for pipelines, contacts, and deals.
• Apify for scraping your Instagram and YouTube performance.
• GA4 MCP for site analytics.

Only connect what the officer actually needs. Every bridge you add is another door, so keep the list short and keep the gates on.

Your agent is only as good as what it knows about you. If your context has been living in ChatGPT or Claude chats, go get it.

Open settings and pull your saved memories, or open a fresh session and ask: what are the core things you know about me? I am building a CMO officer. Put it into one document I can hand to another setup.

Read what comes back, cut what is stale, and drop the rest into the skill as context. You can skip the onboarding interview entirely if your operator profile is already solid.

Type /cmo and let it work. I asked for a full audit of my channels and an HTML report I could open in the browser.

• YouTube. Three months of performance, key insights, every video linked so I could go back and rewatch the winners.
• Instagram. Reels and carousels scored, including which posts landed off my ideal customer and underperformed because of it.
• GoHighLevel. A full pipeline read that showed me exactly which two stages had gone stale and needed a campaign.

Then it updated its own brain with the audit, so the next run starts smarter than this one did.

This part is slow and boring to watch. The boring things are the ones that get results.

Manual slash commands are a fine place to start. When you want it running on its own, you have two paths.

• Routines and cron. Cron is a time trigger. Schedule /cmo for every Monday at 9am. The catch on a local setup: your computer has to stay on.
• Send the skill to a host. Hermes on a VPS, or Claude managed agents. Both run 24/7 without your machine. I have full walkthroughs for these.

Every officer you are thinking about building is this same process. The only two questions that change are what it can access and what data you train it on.

If you want to learn to build these yourself at your own pace, that is what we do inside CC Strategic AI on Skool. The zero to dangerous Claude Code course, the templates, and weekly calls where you show me what you built.

Not sure what to fix first? The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, no call required. Take the free AI Bottleneck Finder →

• SkillSmith playbook, the plugin that builds the agent, with the install command and the skill anatomy
• SkillSmith video walkthrough: https://youtu.be/FOvN28l_q9s
• SEED playbook, the idea incubator that writes the plan, with the skill link inside it
• GoHighLevel MCP, the CRM bridge this build reads pipelines through
• Claude skills to cloud agents, how to run the officer 24/7 without your machine on
• CC Strategic AI on Skool, where we build these officers together

You film yourself. You talk, you move your hands, you walk across the room, the camera pans. Normal video.

Then you give Claude two things: that video, and one still picture of a character. Could be an anime character. Could be a cartoon version of you. Could be a completely different person.

Claude sends both to Higgsfield, and Higgsfield rebuilds the video with that character in your place. Same movements. Same timing. Same camera moves. Same background.

You are not typing a description of a video and hoping the AI guesses right. You are handing it a performance you already recorded and telling it to repaint the actor. That is why it comes out so accurate.

The whole thing takes about 5 to 10 minutes of waiting, and you do it from a Claude chat. No editing software, no green screen, no motion capture suit.

• A Claude subscription. Any paid plan works. This runs in Claude Code or the Claude desktop app.
• The Higgsfield MCP. Free to connect. Claim the 24 hours of unlimited usage here so the runs cost you nothing while you learn it.
• One video of you. Short. Think 5 to 10 seconds per shot.
• One picture of the avatar you want to become. Just a still image. One file.

That is the entire shopping list. No API keys to manage, no other tools to install.

MCP stands for Model Context Protocol. Skip the name. Here is what matters: an MCP is a toolbox you hand to Claude. Once it is connected, Claude can reach into that toolbox and use the tools inside it on its own.

The Higgsfield MCP puts every top image and video model into that toolbox. So instead of you logging into a website, uploading files, picking a model, and clicking generate, you just tell Claude what you want and it does all of that for you.

This takes about a minute and you only do it once.

1. Open this link and create your account so the free unlimited window is attached to it.
2. Go to higgsfield.ai/mcp and copy the MCP connection link they give you.
3. Paste that link into Claude and say: install this MCP for me. Claude handles the setup.
4. In Claude Code, run /mcp, click the Higgsfield entry, and hit Allow so it can log into your account.

Ask Claude "what Higgsfield tools do you have?" to confirm it worked. If it lists things like generate video and motion control, you are connected. If you want the deeper walkthrough of the MCP itself, that is in Higgsfield AI MCP: Every AI Image + Video Model Inside Claude Code.

Your reference video is the performance. Whatever you do in it, the avatar does. So a few rules keep the results clean:

• Keep each shot short. 5 to 10 seconds. If you have a 60 second video, that is fine, but it works best broken into separate shots.
• Stay in frame. If you walk out of the shot and back in, the model has to guess what happened in between.
• Good light on your face and body. The model reads your pose from the pixels. Dark footage gives it less to read.
• One person on camera. Two people in frame means the model has to decide which one to replace, and it will not always pick right.
• Shoot it in the aspect ratio you want to post. Vertical for Reels, TikTok, and Shorts. Horizontal for YouTube.

Save the file somewhere you can find it. You are going to give Claude the file path.

This is one still picture. Not a video, not five photos. One image of the character you want to become.

Where people get them:

• Make one on Higgsfield. Ask Claude to generate the character first. "Make me a full body image of a silver haired anime swordsman in a dark hoodie, plain background." Then use that image as your avatar.
• Use an existing character image you have the right to use.
• Use a stylized version of yourself. Feed Claude a photo of you and ask it to redraw you as a 3D animated character, then swap yourself with that.

What makes a good avatar image: the whole body visible if your video shows your whole body, facing the camera, clean and uncluttered background, and sharp enough that the face is clear.

Start a fresh Claude chat, then paste this in. Replace the two paths at the bottom with wherever your files actually live on your computer.

If you would rather do it the way it looks in the video, drop the reference video in first, send the prompt, then follow up with the avatar image and one line: use this character. Same result, it just splits into two messages.

Claude uploads the files, splits the video, and fires one job per shot. Then it waits.

Expect 5 to 10 minutes. A single short shot can land in 2 or 3 minutes. A longer video with six shots takes longer because they run in batches.

Do not close the chat and do not re-send the prompt because it feels slow. Re-sending starts the whole thing over and burns the runs twice. If you want a status check, just ask: what is the job status?

When the jobs finish, you have two ways to collect them:

• Straight from the chat. Claude hands you the finished video links. Ask it to show your recent generations any time and it pulls them through the MCP.
• From the Higgsfield website. Everything you generate lands in your account, so log in and download from there if you would rather have the files in a folder.

Then stitch the shots back together in whatever editor you already use. You now have the same video you filmed, performed by somebody else.

Most bad results come from one of these three being wrong. This is the part nobody explains.

• scene_control. This picks where the background comes from. Set it to video and you keep your real room and your real camera move, which is what you want when you are replacing yourself in your own footage. Set it to image and the background comes from the avatar picture instead, which is what you want if you are trying to teleport the whole scene somewhere else.
• resolution. 720p is cheaper and faster. 1080p is what you post. During the free unlimited window, there is no reason to run anything but 1080p.
• Shot length. The single biggest quality lever. Short shots hold the character steady. Long shots give the model more chances to drift, and drift is what makes an avatar's face slowly stop looking like the avatar.

• You do not want to be on camera. Film it yourself in your kitchen, post it as a character. Your delivery, none of your face.
• One video, many versions. Film the script once, then run it with four different avatars and test which one people watch longest.
• Client ads. Record the performance yourself, then swap in a character that matches the client's brand. You never have to hire and schedule talent.
• Doing what you cannot film. Your movement, a character and a world you could never have shot in real life.

• Do not paste the video into the chat and expect Higgsfield to see it. The MCP runs on Higgsfield's side, so the file has to get uploaded there first. Give Claude the file path and let it handle the upload, or use the upload widget when it offers you one.
• Do not fire ten jobs at once. Higgsfield caps how many run at the same time and you will get rate limited. Three at a time is the safe number, which is why it is in the prompt.
• Hands are the hard part. Fast, complicated hand movement is where these models still struggle. Slow your gestures down a notch when you film.
• Your audio does not come along automatically. Keep the original audio from your reference video and lay it back over the finished clips in your editor.
• Only swap characters you have the right to use. Somebody else's face or a studio's character is their property. Your own likeness, an original character, or one you generated is yours.

Getting one avatar video is easy. Knowing which shots to film so the swap holds up, how to keep a character consistent across a whole series, and how to charge for this instead of just playing with it, that is the part no help doc covers.

That is what we work through inside CC Strategic AI on Skool. Real builds, real client work, and the exact setups I run in my own business.

• Higgsfield, 24 hours unlimited MCP usage (my affiliate link), the offer this tutorial runs on
• higgsfield.ai/mcp, where you copy the MCP connection link
• Higgsfield AI MCP: Every AI Image + Video Model Inside Claude Code, the full MCP walkthrough
• Higgsfield Seedance 2.0 Skills, prompt templates for the video models Claude reaches for
• CC Strategic AI on Skool, where we build this together

If you run an online business and your email campaigns stop working overnight, it usually is not your copy. It is your domain reputation.

Email is about 70% of my revenue. So when sends start landing in spam, that is not a small problem. Over a quarter it can wipe out close to half of what the business should have made, and the worst part is nothing looks broken. Your emails still send. They just land somewhere nobody looks.

This page is the exact fix: check the damage, warm the inbox back up, then keep it clean with two workflows so it never happens again.

• Google Postmaster Tools, free, shows your real domain reputation (shortcut: gmail.com/postmaster)
• Warmbox, my affiliate link, warms your inbox back up automatically
• GoHighLevel, my affiliate link, the CRM I use to build the tagging workflow and the sunset policy

Free to start on the first one. The other two are what I actually pay for and run my business on.

Every time you send, Gmail and the other inbox providers grade you. That grade is your domain reputation, and it decides whether your next email lands in the inbox, in promotions, or in spam.

Google sorts it into four buckets: High, Medium, Low, and Bad.

Most people start at High. Then the slide happens. You keep emailing a list that does not open, does not click, and does not reply. A few people hit the spam button. Some addresses go dead and bounce. Google reads all of that as "people do not want this," and your grade drops from High to Medium to Low, and eventually to Bad.

Nobody sends you a warning. You just watch your numbers fall and assume the offer stopped working.

You cannot fix what you cannot see. Start here, it is free.

• Go to postmaster.google.com and sign in with your Google account.
• Click the plus button and add your sending domain (the part after the @ in your from address).
• Google gives you a TXT record. Paste it into your domain's DNS settings, wherever your domain lives, then hit verify.
• Wait a day or two for data to fill in. Postmaster needs real sending volume before the charts show anything useful.

Then read three dashboards. Domain reputation is your grade. Spam rate is the percent of people hitting the spam button, and you want that under 0.1%. Authentication tells you if SPF, DKIM, and DMARC are passing, and if any of those fail, fix that first because no amount of warming saves a domain that cannot prove it is you.

Once you know your reputation took a hit, you have to rebuild it. You do that by proving to Gmail that real people want your email. That is what warming means.

A good friend put me onto Warmbox and it is what I use. You connect the inbox you want to warm up, and it goes to work on its own.

Here is what it does behind the scenes:

• Sends normal-looking emails from your inbox into a private network of 35,000+ real inboxes.
• Those inboxes open your email, and a share of them reply to it, which is the strongest positive signal there is.
• Anything that lands in spam gets pulled out and marked as important, so the provider learns it guessed wrong.
• It ramps volume up on a schedule instead of blasting day one, because a sudden spike looks like spam by itself.

Setup is short. Create your account, connect your inbox with Google or Microsoft one-click login, or plug in SMTP and IMAP details for anything else (Yahoo, Zoho, Amazon SES, SendGrid, and most others are supported). Pick a warm-up schedule, then leave it alone.

There is also a live email checker inside that runs your DNS and blacklist status, which is worth running once before you start so you know nothing else is broken.

Warming is not a weekend job. Give it a few weeks of running in the background and watch the reputation line in Postmaster climb.

Warming repairs the damage. This step stops you from causing it again.

Inside your CRM, build one workflow that watches for three events and tags the contact when any of them happens:

• Marked as spam. Tag them and stop every campaign immediately.
• Unsubscribed. Tag them and take them out of all marketing sends.
• Bounced. Tag them, because a hard bounce means the address is dead and keeps hurting you every time you hit it.

Then use those tags as an exclusion filter on every campaign you send from now on. That is the whole point. The tag is not for reporting, it is a wall.

I run this in GoHighLevel, which is a full CRM with automations, pipelines, calendars, AI tools, and email plus SMS in one place. It is how I run a chunk of my business. Build the workflow with an email-event trigger, add an if/else for the three event types, then add a tag action and a "remove from workflows" action on each branch. Any CRM that can trigger on email events can do the same thing.

This is the one most people skip, and it is the one that keeps your reputation high long term.

A sunset policy is a rule that removes dead weight from your list on a timer. Mine is simple: track who opens, who clicks, and who replies. If a contact does none of those for 90 days, they come off my campaigns.

How to build it:

• Stamp a "last engaged" date on the contact any time they open, click, or reply.
• Run a daily check for contacts whose last engaged date is more than 90 days old.
• Optional but worth it: send one last "are you still interested?" email before you cut them. Whoever clicks gets to stay.
• Everyone else gets tagged as unengaged and removed from ongoing campaigns.

It feels backwards to shrink your list on purpose. It is not. A list of 2,000 people who actually read your email beats a list of 20,000 where 18,000 ignore you, because those 18,000 are the reason the 2,000 stop seeing you at all.

Nothing changes on day one, so do not panic. Reputation is a trailing score, it moves on weeks of behavior, not hours.

• Week 1. Warming is running and your bad contacts are getting tagged out. Postmaster still looks the same.
• Weeks 2 to 4. Spam rate starts dropping because you stopped sending to people who report you. Reputation begins to move.
• Weeks 4 to 8. Low climbs toward Medium, Medium toward High. Open rates rise before revenue does, because more of your sends are being seen at all.

One rule while you rebuild: do not go back to blasting the whole list to make up for lost time. That is what got you here.

The tools are the easy part. Knowing when a list is worth saving, how hard to ramp your sends, and what to write so people reply instead of report you, that is the part nobody puts in a help doc.

That is what we work through inside CC Strategic AI on Skool. Real campaigns, real numbers, and the workflows I run in my own business.

• Google Postmaster Tools, free domain reputation, spam rate, and authentication dashboards
• Warmbox (my affiliate link), automated inbox warm-up across a 35,000+ inbox network
• GoHighLevel (my affiliate link), the CRM I build the tagging workflow and sunset policy in
• GoHighLevel MCP: Run Your CRM From Claude Code, wire the same CRM into Claude Code
• CC Strategic AI on Skool, where we work through campaigns together

You tell Claude Code to build you a site. It builds one. And it looks like every other AI site on the internet. Same purple gradient. Same rounded cards. Same lifeless buttons.

That's not Claude being bad at its job. It's Claude filling in a blank you left. You gave it a goal, not a design. So it reached for the average of everything it has ever seen, and the average is slop.

The fix is not a better prompt. It's giving Claude three things it cannot invent on its own: a design system to copy, animations to copy, and a judge that tells it when the work is still ugly. Four free tools cover all three.

The hardest part of building a site is knowing where to start with the look. getdesign.md removes that problem completely.

It's a library of real brand design systems, broken down into a file your AI can actually read. Apple. Stripe. Airbnb. Linear. Vercel. Nintendo. You can even grab Claude's own design system if you want.

Each one gives you the fonts, the colors, the spacing, the button styles, all of it. Pick the brand whose vibe you want, hit copy, and paste it into Claude before you ask for a single page.

Now Claude isn't guessing what good looks like. It's copying homework from a company that paid a design team six figures to get it right.

Describing an animation in words is miserable. "Make it fade up but kind of springy and staggered" gets you something you didn't want, three times in a row.

21st.dev fixes that. It's a community library of React components and marketing blocks, and here's the part that matters: every single one ships as a prompt. You browse until you see an animation you like, click copy, and paste it straight to Claude. It rebuilds that exact thing in your codebase.

Animated heroes, buttons, cards, navbars, shader backgrounds, gradients. Thousands of them. Everything is React plus Tailwind following shadcn/ui conventions, so the code lands in your repo and it's yours to edit.

Free accounts get 2 component copies a day, which is plenty when you're pulling one hero and one nav for a build.

These last two do the same job from different angles. They're skills you hand to Claude, and they teach it to spot its own bad taste.

Impeccable runs 58+ checks built to catch the exact defaults AI reaches for, then gives you 23 commands to fix what it finds. /polish, /audit, and /typeset are the ones you'll live in. It respects a design system you already have instead of steamrolling it, and there's a Chrome extension that overlays the problems right on the page.

Taste is open source and calls itself the anti-slop framework for AI agents. Version 2 added brief inference, which means the agent reads the room before it generates anything: your industry, your audience, the mood, how much motion fits, what layout family makes sense.

Pick either one. Or stack both, which is what I do. Impeccable catches the pixel-level tells, Taste catches the "this whole direction is wrong" problems. They don't fight each other.

The two websites need no install. Just open them and copy.

• getdesign.md and 21st.dev: browse, pick, click copy, paste into Claude.
• Impeccable: run npx impeccable install in your terminal. It also installs through Claude Code's /plugin marketplace, which is the cleaner path if you're already using plugins.
• Taste: run npx skills add Leonxlnx/taste-skill.

Both skills work outside Claude Code too, in Cursor, Codex, Gemini CLI, and anything else that reads SKILL.md files.

Stacking matters more than any single tool here. Run it like this:

• 1. getdesign.md gives Claude the design system before it writes any code.
• 2. 21st.dev gives it the exact animations instead of your best guess at describing them.
• 3. Impeccable or Taste (or both) run last, as the quality gate that catches what still looks cheap.

Design in. Motion in. Slop out. That's the whole system.

Tools are the easy part. Knowing which brand system fits the client in front of you, when to overrule the skill's opinion, and how to ship the thing without a week of fiddling, that's the part nobody puts in a README.

That's what we work through inside CC Strategic AI on Skool. Real builds, real critiques on real client work, and the prompts and setups I use daily. If you want to actually master Claude Code instead of collecting tools you never open again, that's the room.

Most people don't need another AI tool. They need to know which thing is actually costing them the most.

The free AI Bottleneck Finder tells you the one constraint capping your revenue right now, plus two builds you could ship this week. Five minutes, free, no call required.

Take the free AI Bottleneck Finder →

• getdesign.md, brand design systems for your AI
• 21st.dev, copy-as-prompt components and animations
• Impeccable, 58+ slop checks and 23 design commands
• Taste, the open-source anti-slop framework
• CC Strategic AI on Skool, master Claude Code with us

Higgsfield opened up unlimited free access to its entire platform for 24 hours. Every top image, video, and audio model, free, run as much as you want. That includes Seedance 2.0, the state-of-the-art video model everyone in AI is talking about.

Every AI platform trains you to hold back. You count credits. You watch the balance. You skip the tenth version of a shot because each one costs. Or worse, you never learn AI at all because it feels too expensive to even try. For one day, that problem is gone. This is the first time Higgsfield has done this, it is one day only, and when it's gone, it's gone.

I wasted no time. I made five cinematic property tours for a real estate agent. All five cost me absolutely nothing to make, because Higgsfield was free. I sold each one for $350. That's a little over $1,700 in a day with zero overhead.

The whole thing ran on two free tools: the free Higgsfield access plus the free RE Walkthrough Pro skill for Claude Code, which turns a listing into a room-by-room cinematic tour. If you want the app version that one-shots the whole pipeline, that's Listing Cinema. Point is: unlimited free access is not a toy. It's a day where the tool cost drops to zero and only your hustle is left.

Read this so nothing surprises you. It's simple and you're in control:

• Day one is a full day of unlimited access, free. All the top models, no credits charged, before any subscription begins.
• After 24 hours it continues into a Higgsfield Plus subscription that includes 7 more days of unlimited access. Same models, still no credit counting. Treat the extra week as the bonus for staying.
• You can cancel in one click during the first day if you don't want to continue. No hoops.

So the move is: start free today, run everything you can, and decide inside the first day whether the extra unlimited week is worth keeping. This offer is for new users.

All of these are unlimited during the offer. The headline is Seedance 2.0, but the whole shelf is open:

• Video: Seedance 2.0 (2K), Seedance 2.0 Fast, Seedance 2.0 Mini, Gemini Omni Flash, Kling 3.0, Kling 3.0 Motion Control, Wan 2.7.
• Image: Seedream 5.0 Pro, Seedream 5.0 Lite, Seedream 4.5, Nano Banana Pro, Nano Banana 2, Nano Banana, Kling O1 Image, GPT Image 2, GPT Image, Soul 2.0, Flux.2 Pro.
• Audio: Seed Audio 1.0, Eleven v3, Minimax Speech 2.8 HD, VibeVoice, Seed Speech.

• If you're new to AI: this is the day you finally learn it without burning credits on every mistake. Make the ugly first version, then the good tenth version, and pay nothing for the practice.
• If you're a pro: run the volume real work actually takes. Countless versions of a shot, a whole campaign in a day, no watching a balance. This is when you clear the backlog you've been rationing credits on.

Higgsfield is an AI-native creative suite: one workspace that turns an idea into a finished product. Image, video, audio, sites, apps, and interactive experiences, all in one place, from the first prompt to the final result, without switching between five different apps. The free window is the cheapest possible way to find out what it can do for your work.

This isn't a standing offer. It's open for one day, and then it's gone. The people who wait miss it entirely. Start your free unlimited access, make the thing you've been putting off because it cost too much to try, and if the extra week is worth it, stay.

Start free on Higgsfield now. Available for new users.

This one is optional, and only worth doing after you've started your free Higgsfield access above. Once you're signed up with the unlimited access, you can plug Higgsfield straight into Claude Code with the Higgsfield MCP. That lets you generate images and videos by talking to Claude instead of clicking around the dashboard.

It's a nice extra if you live in Claude Code like I do, and it is not required to use the free offer. Sign up for the free unlimited access first, then if you want this add-on: add the Higgsfield MCP for Claude Code.

Free access is the tool. Turning it into money is the skill. I run a free live training that walks through my proprietary Claude system for generating cinematic home tours and actually selling them, the same play behind that $1,700 day.

Here's what we cover:

• The video generating system, the exact Claude + Higgsfield setup that makes the tours.
• How to pick and source leads, real estate agents, golf course owners, and Airbnb hosts.
• How to market to them so the videos actually sell.
• How to close $500+ deals.

Register free here: Live Training. And remember, the reason any of this works right now is the free unlimited window, so start your free Higgsfield access here before it closes.

Claude Code normally talks straight to Anthropic, and you pay for every message. OmniRoute is a small program that runs on your own computer and sits between Claude Code and the internet. Instead of sending your messages to Anthropic, it can send them to other AI companies that have free plans. When one free plan runs out of gas for the day, OmniRoute automatically hops to the next one. That is how people are running Claude Code "for free."

The honest truth nobody tells you: the free version is not Claude answering you. When I tested this myself, the model actually doing the work was Xiaomi's MiMo, a free Chinese model, even though Claude Code's screen still said "Claude." Free models are slower, weaker, and sometimes hand back an empty answer.

So here is the rule: this is great for practice, learning, and building throwaway stuff at 2am without watching a meter. Do not run client work or anything private through it. Your messages pass through other companies' free servers, and free servers usually get to keep and train on what you send. Use it on your own projects only. Okay, here is the whole thing, start to finish.

• Node.js installed (version 22 or 24). If you can run node --version and see a number, you are good.
• A free OpenRouter account. We make one in Step 3. No credit card needed.
• Claude Code already installed and working.

Open your terminal and paste this one line:

npm install -g omniroute

Give it a minute. That puts the omniroute command on your computer. Now start it:

omniroute

You will see a little logo and a line that says "OmniRoute is running!" with a web address:

Dashboard:  http://localhost:20128
API Base:   http://localhost:20128/v1

Leave this terminal window open. OmniRoute only works while it is running. Closing the window turns it off. Tip: you can also just tell Claude Code "open the OmniRoute dashboard" and it will pop it open for you.

OpenRouter is like a giant vending machine of AI models. One free key gives you access to hundreds of them, including free ones. It is the easiest single provider to start with.

• Go to openrouter.ai and make a free account.
• Click your profile, go to Keys, and create a new key. It looks like sk-or-v1-xxxxxxxx. Copy it.

Now hand that key to OmniRoute:

1. In your browser, open http://localhost:20128 (the dashboard).
2. Open the side menu and click Providers.
3. Type OpenRouter in the search, scroll to the bottom, and click Add.
4. Paste your OpenRouter key into the box.
5. The important part: flip on the "free only" toggle. That tells OmniRoute to only use models that cost nothing.
6. Click Save.

Done. OmniRoute now has a menu of free models to pull from.

Claude Code needs a password to talk to OmniRoute. That is a separate key you make inside OmniRoute, not the OpenRouter one.

• In the dashboard, go to Endpoints (or "API Keys").
• Click Create key and copy it. It looks like sk-c27997f110d15f31. Keep it private; if it ever leaks, just delete it and make a new one.

Now the trap that gets almost everyone. If you are logged into your normal Claude.ai account, Claude Code ignores OmniRoute completely and quietly uses your paid account instead. You would swear it is free while it is actually billing you. Fix it. Inside Claude Code, type:

/logout

When it asks, choose to use the API key instead of claude.ai. When you are done and want your normal Claude back, just run /login again. Nothing is broken. You are only switching which door it uses.

Close Claude Code. Then open a fresh, throwaway folder and start it with these settings. Swap in your OmniRoute key from Step 5:

cd /tmp && mkdir -p omni-demo && cd omni-demo

ANTHROPIC_BASE_URL=http://localhost:20128/v1 \
ANTHROPIC_API_KEY=YOUR_OMNIROUTE_KEY \
ANTHROPIC_MODEL=auto/coding:free \
ANTHROPIC_SMALL_FAST_MODEL=auto/fast \
claude

What each line means in plain English:

• ANTHROPIC_BASE_URL: "Send my messages to OmniRoute, not Anthropic." This is the actual switch.
• ANTHROPIC_API_KEY: your OmniRoute password from Step 5.
• ANTHROPIC_MODEL=auto/coding:free: "Use the free coding models." Without this, Claude Code asks for paid Opus by default and it breaks.
• ANTHROPIC_SMALL_FAST_MODEL=auto/fast: Claude Code also fires little background helper calls. This keeps those free too.

When it boots, the top of the window will now say auto/coding:free instead of Opus. That means it worked. Type something small to test it, like build a snake game in one html file, and watch the OmniRoute dashboard light up. One more safety note: those settings only live inside that one terminal window. Close it and your normal Claude Code is exactly as it was. Nothing permanent changed.

Want proof it is using OmniRoute and not Anthropic? Run this, with your OmniRoute key dropped in:

curl -s http://localhost:20128/v1/models -H "Authorization: Bearer YOUR_OMNIROUTE_KEY"

If you get a big list of models back, it is live. When I ran this I got 129 models. If the list is empty, no provider is connected yet, so go back to Step 4.

This part is sneaky, so pay attention. There are three places to look, and two of them lie:

• Claude Code's screen shows auto/coding:free. That is just the nickname you asked for, not the real model.
• Asking the AI "what model are you" usually just makes it repeat the nickname. It genuinely does not know.
• The OmniRoute dashboard, Logs tab. This one is the truth. It shows the real model that answered each message. When I checked, it said mimo-auto, which is Xiaomi's MiMo.

So if you ever want to know who is actually reading your code, open the Logs tab. Nowhere else tells you straight.

• "Unlimited" is a stretch. OpenRouter's free plan is about 50 messages a day, then it slows you down. Adding $10 of credit bumps it to around 1,000 a day.
• To get closer to always-on, connect a few more free providers the same way, so OmniRoute has more places to hop when one runs dry. Easy free ones: Groq, Google AI Studio (Gemini free), and Cerebras.
• Quality is the trade. Everything free is MiMo, DeepSeek, or Gemini-Flash level. Good enough to learn and mess around. Not Claude Opus. If a build comes out messy or an answer comes back empty, that is the free model, not your setup.
• Free models get rate-limited a lot. A "429" error just means "too many requests, slow down." Totally normal, and it is exactly why the auto-hop feature exists.

• It still says "Opus" and bills me: you did not log out of claude.ai. Redo Step 6.
• "model not found" error: try ANTHROPIC_MODEL=auto/best-free or auto/coding instead.
• Empty answers: the free model choked. Ask again, or add another provider like Groq.
• The models list is empty: no provider connected. Redo Step 4.
• Dashboard will not open: OmniRoute is not running. Run omniroute again.

OmniRoute is a real, clever tool. It genuinely lets you keep coding after you hit your Claude limit, for free, by relay-racing across other companies' free models. Just go in with your eyes open: it is free models pretending to be Claude, not Claude itself, and it is for your own projects, never client or private work. Use it to practice, to learn, to build throwaway stuff. That is exactly what it is good for.

When you are ready to do the real work well, the smart move is spending less on the paid models, not dodging them. The Save Tokens in Claude Code guide on this page cuts your bill without swapping in weaker models, and the Fable 5 YES Playbook shows how to make the most powerful model pay for itself. Want the prompts, the routing setups, and a community shipping this stuff daily? Join CC Strategic AI on Skool.

Fable 5 is the most capable model Anthropic ships, and it costs a lot more than Opus or Sonnet to run. That is the whole tension. Point it at the wrong work and you will hit your limit by Monday with nothing to show. Point it at the right work and it does things no cheaper model can touch.

There is a video going around where I list the five things you should NOT do with Fable 5. This is the flip side. Same five ideas, but here is exactly what to do instead, in plain steps, with the prompts. Nail these and Fable stops being an expensive habit and starts being your unfair advantage.

One line to remember: the top results in AI don't come from the best model. They come from the best harness around it. Fable is the sharpest tool in the box. This playbook is how you hold it.

Every model has a job it is best at. Fable 5 is your architect and your judge. It is brilliant at the hard thinking: planning a real system, one-shotting a build that is beyond a smaller model, and reviewing work with a sharp eye.

It is not your day laborer. The cheaper models, Opus 4.8 and Sonnet 5, are perfect for the grind: test loops, small edits, retries, brainstorming. So the whole playbook comes down to one habit. Match the model to the job, not to the hype. Use the most expensive model only where a cheaper one would give you a worse answer.

The test is one question: would Sonnet's output actually be worse here? If no, route the task down to Sonnet. If yes, that is a real Fable job.

Don't hand Fable your test loops, tiny CSS tweaks, and retry cycles. That is Sonnet work. Hand Fable the thing only it can do well: the whole build, in one shot.

Here is the clean order that saves the most money:

• Ideate with Opus or Sonnet first. This is the messy part where you don't know what you want yet. Should it be a dashboard or a CLI? What is the data model? Waste all the cheap turns you want here. This is deciding WHAT to build.
• Then turn on Fable to lock the plan and build. Once you know the what, Fable interviews you (see YES #5), writes the plan, and one-shots the build. This is the HOW, and it is where Fable earns its cost.
• Hand the grind back to Sonnet. After the build exists, the maintenance, the small fixes, the test loops all go back to the cheaper model.

Think of it like a job site. You brainstorm with the cheap friend. You brief the expensive contractor. Using Fable 5 to run test loops is a Ferrari doing DoorDash. Let it build the whole thing, then step it back.

Effort is the dial most people leave cranked to the top and never touch. That is why their week's usage dies on Monday. Higher effort means more thinking tokens per turn, and on Fable those tokens are expensive.

The move: start on medium. Fable on medium already beats Opus on xhigh for most work. Only climb the effort dial when the quality genuinely isn't there yet. And save max for one thing: the final judgment pass on a finished build.

• Medium — your default for almost everything. Fast, cheap, still frontier-level.
• High — climb here only when medium's answer isn't good enough.
• Max — reserve it for the final review of an important build, not the daily work.

You change it on the fly with /model and the effort setting mid-session. For the deeper token math, the Save Tokens in Claude Code guide on this page breaks down the exact settings that cut your bill.

Building a snake game with Fable 5 costs the same tokens as building something that runs your business for the next six months. One is a toy you'll never open again. One is an asset. Spend the expensive model on the asset.

The best Fable jobs are the ones that keep paying you back long after the session ends. Point it at compounding work:

• A CLAUDE.md audit. Have Fable review and tighten your CLAUDE.md files into a brief a cheaper model can follow without you in the room. Now every future session with Sonnet inherits Fable's judgment.
• A skills audit. Have it look at your skills, kill the redundant ones, sharpen the keepers, and spot new ones worth building. See the 4 primitives guide if skills, MCPs, and subagents still blur together.
• A PRD or roadmap. Fable excels at planning. Let it write the full implementation plan, then hand that plan to a cheaper model to execute task by task.

See the pattern? Each of these captures Fable's brainpower into something your cheap models reuse for months. That is how you get frontier-level results on a Sonnet budget.

Don't let Fable grade its own homework. Every model, Fable included, is a soft grader on its own work. Ask it if the code is good and it will tell you it's beautiful. You need a reviewer that didn't write the thing.

This is called LLM as a judge, and almost nobody runs it. It is the biggest quality unlock most people are leaving on the table. Two easy ways to do it:

• Run a code review with a different model. Something like Codex can review what Fable built. A neutral second model catches what the builder can't see, because it has no ego in the code.
• Use a blind subagent. Spin up a fresh reviewer that never saw the build get made, hand it only the finished result, and ask it to find what's wrong. No memory of the work means no bias toward it.

Multiple perspectives is always the key. If you want to wire this checking into a loop that runs on its own, the Loop Engineering Playbook shows how the maker-and-checker split becomes a self-running system.

This one is the sequel to YES #1. A lazy prompt in means a confident, wrong build out, and on Fable's burn rate that mistake is expensive. The one-shot build only works because a good brief sits behind it.

So before Fable writes any code, make it interview you. After you've ideated the WHAT with Opus or Sonnet, turn Fable on and run a prompt like this:

Interview me before you write any code. Ask me one question at a time until you fully understand the build and can confidently build me the perfect system. Do not write anything until you're sure.

Now Fable asks the questions instead of guessing the answers. Auth provider? Where is it hosted? What happens on failure? You answer, and like magic it stops guessing and builds the exact thing you pictured, the one you've been trying to get right for months. The interview writes the brief. Fable one-shots the brief.

Tape this to the wall. Five yeses, one habit: match the model to the job.

• Architect, not grunt — Fable plans and one-shots the build. Sonnet runs the grind.
• Medium by default — climb only when quality demands it. Max is for the judge pass.
• Assets, not toys — CLAUDE.md audits, skill audits, PRDs. Things cheaper models inherit for months.
• Second set of eyes — Codex or a blind subagent reviews. Never let it grade itself.
• Interview first — make it ask questions before it writes a line.

The through-line: brainstorm with the cheap friend, brief the expensive contractor, and always get the work reviewed by someone who didn't build it.

Once these five click, Fable stops being a scary bill and starts being the sharpest tool in your kit. The next moves are on this page: cut your spend with the Save Tokens in Claude Code guide, get the four primitives straight in Skills vs MCPs vs Subagents, and wire it all into a self-running system with the Loop Engineering Playbook.

Want the exact prompts, the routing table, the judge prompt, and a community shipping this exact stack? Join CC Strategic AI on Skool. We break down the model and effort routing, the SEED and PAUL workflow, and the review loops already inside.

Claude can now create full cinematic tours, and I can't believe I'm saying this, but from Zillow link to video in minutes. And what's even crazier: the property in the demo video doesn't exist yet. It's a pre-construction listing, and the app generates the interiors anyway.

Using Fable 5 and the Higgsfield MCP server, I was able to one-shot an application build that does this whole process for me. And Higgsfield will host the app for you, so there's no deploy step, no server, no domain wrangling.

The app is called Listing Cinema. Paste a Zillow link, get a cinematic room-by-room tour video back. It's live and hosted by Higgsfield right now:

• listing-cinema.higgsfield.app, the deployed app, try it with any listing

Here's the part you shouldn't sleep on. If you build your own app through Higgsfield over the next 12 days and it absolutely slaps, you can enter their contest and win up to $100,000. You're going to build the app with one prompt anyway. Submitting it is free money if it hits.

1. Download the Higgsfield MCP server. Grab the install command from higgsfield.ai/mcp (my link, it also gets you the free MCP trial plan), copy the command, and just give it to Claude to install.
2. Type /model and make sure you're running Fable 5 before Anthropic decides to take it away. This is the model that one-shots the whole build.
3. Tell Claude to build the app using the Higgsfield MCP. Voice-drop ALL the details about your application into the first prompt: what it does, what the user pastes in, what comes out, the vibe of the UI. One dense prompt beats ten follow-ups.
4. Grab your link. Claude builds it, Higgsfield deploys it, and it drops the link to the fully deployed application for you. Your AI image/video application is completely done with a single prompt.

Don't forget to submit your application to enter the contest.

Want to run this exact play? Get Higgsfield MCP access + 100 free credits here. Then pair it with the Higgsfield MCP setup guide and the Seedance 2.0 skills already in this toolkit, and if real estate is your niche, RE Walkthrough Pro is the manual version of this same pipeline.

Claude Code can easily spend your entire subscription in one session if you let it. But that is only true if you do not know these three simple hacks. Done together, they can save you up to 50% on your tokens, and none of them make Claude worse at the actual work.

Quick plain-English primer first. A token is a chunk of text, roughly three quarters of a word. Every word Claude reads and every word it writes is counted in tokens, and tokens are what you are paying for. So "saving tokens" just means: stop making Claude read and think about stuff it does not need to. Less clutter in, less wasted thinking, lower bill. That is the whole game.

The easiest fix is a command that already ships inside Claude Code. You do not install anything. Just open Claude Code and type:

/doctor

It runs a full health check on your setup and shows you exactly what is eating tokens that you do not need to be paying for. Think of it like a mechanic putting your car on the lift: it finds where the clutter is (old skills, MCP servers you forgot you connected, hooks, bloated config) and tells you what you can safely remove.

• Run it in a fresh session. Type /doctor before you start real work so you see a clean picture.
• Read the warnings top to bottom. Anything flagged is a token cost you are paying every single message, whether you use it or not.
• Trim what you do not use. A connected MCP server or skill you never touch still loads its instructions into context. Removing three dead ones can be a real chunk of your bill.

If you want to actually watch these numbers live while you work, pair /doctor with my Status Line Setup, which puts a running token breakdown at the bottom of every session.

Your claude.md file is a plain text file that Claude reads at the start of every session. It is where you write your rules, your preferences, and how you want Claude to work. One of the highest-leverage things you can put in there is an effort table: a small table that tells Claude which model and which effort level to use depending on the task you give it.

Two dials to understand, at a 9th grade level:

• Model is which brain. Sonnet is the fast, cheaper brain, great for daily and simpler work. Opus is the stronger, pricier brain, better for the big-ticket stuff like architecture and hard debugging.
• Effort is how hard the brain thinks before it answers. More effort means more thinking tokens, which means a bigger bill. I recommend keeping everything on high, because anything above that (like max) burns a lot of tokens for a small gain on most tasks.

Drop this table into your claude.md. It is a starting point. Change the rows to match the work you actually do.

## Model & Effort Routing

| Task | Model | Effort |
| --- | --- | --- |
| Search, quick edits, writing, simple fixes | sonnet | high |
| Building an app, web design, new feature | opus | high |
| Architecture, hard debugging, security review | opus | max |

In plain English, that table says:

• Small or routine job? Use Sonnet on high. Do not pay Opus prices to rename a variable or draft an email.
• Real build? Use Opus on high. You want the stronger brain, but high effort is plenty.
• The genuinely hard stuff? Only then reach for Opus on max, and only for the task that needs it.

The whole point: you stop accidentally running your biggest, most expensive brain on tiny tasks all day. That misallocation is where most people quietly bleed their subscription.

You do not have to guess at the rows. Open Claude Code in your project and paste a prompt like this:

Look at the kinds of tasks I actually run in this project. Then write me a Model & Effort Routing table for my claude.md. Use Sonnet for simple and daily work, Opus for big builds and web design, and only Opus on max effort for architecture or hard debugging. Keep everything else on high effort. Explain each row in one sentence so I understand why.

Claude will read your setup, propose a table tuned to your work, and walk you through it. Tweak it, paste it into claude.md, done. You can customize this however you like, this is just my default.

The effort table is your default. But sometimes you want to change the model or effort right now, mid-session, without touching your file. That is what this command is for:

/model

Run it and you get full control over the model and effort level Claude is using at any given moment. Just in case you ever want to override what your claude.md table says, you totally can, for a single task, then switch back.

• Bump down to save. Cruising through simple edits? Drop to Sonnet for the stretch and pocket the difference.
• Bump up for one hard thing. Hit a nasty bug? Jump to Opus on max just for that, then /model back down so you are not paying max effort for the rest of the session.
• It is live. No restart. The change applies to your next message.

The three hacks above stop waste. If you want to go a level deeper and cut tokens on how Claude searches your project, build it a knowledge graph. Instead of Claude re-reading your whole codebase every session to find something, it queries a map it built once. The creator measured roughly 70x fewer tokens per search.

• Graphify in the toolkit (the skill that builds the knowledge graph, right here on this page)
• The truth about Graphify's 70x token savings (my interview with the creator, pressure-testing the claim: what is real, what is not)
• Claude Code knowledge graph setup (Graphify + Obsidian) (the full step-by-step walkthrough)

• Run /doctor to find and remove the clutter you are paying for every message.
• Add an effort table to claude.md so Sonnet handles daily work and Opus is saved for the heavy lifts, all on high effort.
• Use /model to override that default live, up for one hard task, down for a stretch of easy ones.
• Add Graphify when you want the biggest structural win: 70x cheaper searches through a knowledge graph.

Most people jam everything into one giant claude.md, bolt on ten MCP servers, and hoard hundreds of skills off GitHub they never run. That unintentional bloat is what burns your tokens and makes Claude feel dumb. Claude Code gives you four components with four very different jobs. Master which is which and you stop guessing.

The whole thing collapses into four words: knowledge is claude.md, repeatable action is a skill, another app is an MCP, and too big for one context window is a subagent.

Before you install anything, answer one question about what you're trying to do. The answer picks the primitive for you.

• Is it something Claude should just know, every single chat? That's claude.md
• Is it a task you'll run over and over? That's a skill
• Does it need to reach into another app or live data? That's an MCP
• Is it too big to finish in one clean conversation? That's a subagent

If you can answer that question, you never have to guess which tool to reach for again.

Your claude.md file is memory. It's the stuff Claude should carry into every conversation you have with it. Think rules, facts, and context about you and how you work.

This is not the place for a task, a workflow, or a giant dump of everything you might ever need. It's the always-on baseline. Who you are, your standards, the conventions Claude should follow by default. The moment it turns into a novel, you've turned your memory into bloat that gets read on every single turn.

Use it for: your name and role, your writing voice, hard rules ("never do X"), the handful of facts Claude needs every time.

A skill is a repeatable task you trigger on demand. Package it once, run it forever. Think "do this task."

The value is that you capture a process one time, with your steps and your standards baked in, and then fire it whenever you need it. You stop re-explaining the same job every session. The skill remembers how the task is done so you don't have to.

Use it for: anything you keep re-typing. Formatting a report, drafting a reply in your voice, building a carousel, running a checklist. If you've explained the same task twice, it should be a skill.

An MCP plugs Claude into another app or live data. Your Gmail, your video editor, your CRM. With an MCP connected, Claude can actually do things inside those external tools instead of just talking about them.

This is the wire between Claude and the rest of your stack. No MCP, and Claude is boxed inside the chat. With one, it reads your live inbox, moves a deal in your CRM, or edits a video. The catch: every MCP you connect adds tool definitions Claude has to carry. Ten servers you never use is ten servers of dead weight on every turn.

Use it for: reaching real, live systems. Email, calendar, CRM, analytics, a video editor, the live web. Connect the ones you actually use and skip the rest.

Claude uses subagents naturally, for tasks that are too big for one conversation. It splits the work into parallel workers so your main context window stays clean.

You don't usually summon these by hand the way you trigger a skill. When a job is large or has independent parts, Claude farms pieces out to fresh workers, each with its own clean context, then pulls back only the results. Your main thread never gets clogged with the noise of the sub-work. That's why a big research or refactor task doesn't blow up your session.

Use it for: big multi-part jobs. Auditing a whole codebase, researching across dozens of sources, fanning a task out so several workers run at once while your main chat stays focused.

Tape this to the wall. Four primitives, four jobs, zero overlap.

• Knowledge — claude.md. Stuff Claude should know every chat
• Repeatable action — skill. A task you package once and run forever
• Another app or live data — MCP. The wire into Gmail, your CRM, your editor
• Too big for one context window — subagent. Parallel workers that keep your main thread clean

Here's the part nobody tells you. Everything in your claude.md, every connected MCP, and every loaded skill gets carried in Claude's context on every turn. That context is finite. Stuff it with rules you don't need, servers you never call, and skills you'll never run, and you've spent your budget before Claude even reads your actual question.

That's why an over-loaded setup feels slower and dumber than a lean one. The fix isn't more tools, it's the right tool in the right slot. Put knowledge in memory, actions in skills, connections in MCPs, and let big jobs go to subagents. Lean setup, sharp Claude.

Once these four click, Claude stops feeling like a chatbot and starts acting like a real team. The next move is wiring them into loops that run on their own. Start with the Loop Engineering Playbook, then build your own agentic OS.

Want the full playbook and a community shipping this exact stack? Join CC Strategic AI on Skool.

For three years the skill was wording. You typed a prompt, you got an answer, you typed again. That era is closing. Boris Cherny, the guy who built Claude Code, said it flat out: he doesn't prompt Claude anymore. He builds loops that prompt Claude for him. His words: "My job is to write loops."

This is the playbook for making that jump. The three eras of talking to AI, what a loop actually is, the six parts that turn a chatbot into a self-running machine, and the exact 5 steps to ship your first loop this week.

Every wave moved the skill up a layer. You didn't get worse at the old thing. The leverage point moved.

• Era 1, Prompting (2023). ChatGPT goes mainstream. You type, it answers. One turn. The whole skill was the wording. You are the typist, in the loop every single turn.
• Era 2, Prompt engineering (2024 to 2025). Few-shot, chain-of-thought, system prompts, context stuffing. Real craft. But it's still you steering the wheel on every turn.
• Era 3, Loop engineering (2026). You stop steering. You build the machine that steers. The agent finds the work, does it, checks itself, decides the next move, and repeats. Unattended. You go from driver to factory designer.

Here's the trap. If you're still prompting turn by turn in 2026, you're not behind on a trick. You're behind on the whole way work gets done.

A loop is a recursive goal. You define a purpose, the system iterates until it's done. Prompting optimizes one turn. Loop engineering optimizes the whole system.

The difference that matters: a prompt stops the second you stop typing. A loop runs on a schedule, checks its own work, and keeps a memory so it picks up where it left off. One message equals one output. A loop equals output that scales past your hours.

This is what turns a chat box into a self-running machine. Miss the last two and you don't have a loop, you have a money fire.

• Automations — scheduled triggers that kick the loop off on their own
• Separate workspaces — isolated lanes so multiple agents work at once without colliding on the same files
• Skills — your conventions and context written down, so the agent acts like you instead of guessing
• Connectors (MCPs) — the wires into your real tools: Slack, your CRM, the live web
• Sub-agents — one agent makes, another verifies. Maker split from checker. This is the heart of trust
• State and memory — external notes the loop writes to, because the model forgets between runs

Don't start by leaving it running 24/7. That's how people burn money. Right order: make it work once by hand, then make it check itself, then let it run.

• 1. Pick a boring, repeating task. Not your hardest problem, your most repeated one. Inbox triage. Draft replies to new leads. A daily sales summary
• 2. Write the goal with an exit. Bad: "improve my content" (runs forever). Good: "read the 5 newest comments, draft 1 reply each, stop." A loop needs a finish line
• 3. Do it once by hand in Claude Code. Prompt the whole task manually and watch where it guesses wrong. That tells you what context it's missing
• 4. Teach it a skill and give it a checker. Write a SKILL.md with your rules and examples. Then add a second pass that asks "did this meet the goal?" before anything ships
• 5. Automate it last. Wrap it in a schedule that runs the loop and reports back. Keep a human gate ("draft, don't send") for the first week. Remove it only once you trust the checker

Your literal first loop: "Every morning at 8am, read my new emails, draft a reply to each lead, save the drafts but don't send, and message me a one-line summary. Stop when the drafts are done." Safe, useful, real.

Two rungs of the same ladder. One you trigger and verify. One that triggers itself on a server you never touch.

• A loop you run, PAUL. An orchestration layer for Claude Code. Plan, apply, unify, loop. Nothing is "done" until it reconciles the plan against reality and writes its own state. Pair it with SEED to turn a raw idea into a PAUL-ready plan first
• A loop that runs itself, Hermes. A self-running agent on a server. Cron wakes it, it acts and verifies on its own, then reports back into Slack or Telegram. You wrote the loop once, it works while you sleep. Full setup in the Hermes 24/7 agent playbook

The hype has a dark side called loopmaxxing, the belief that an infinite cycle eventually produces a correct answer. It doesn't. A loop with a vague goal and no checker just converts your budget into an API bill while you sleep.

Two things make a loop instead of a money fire: a clear stop condition (when is it done?) and a checker (did it actually work?). Drill those two and you have the whole skill.

Want the repos, the deeper breakdowns, and a community shipping this exact stack? Join CC Strategic AI on Skool.

Most people use Claude Code as a chat box. It forgets everything the second you close the tab. An agentic OS fixes that. You give Claude a memory it can search, a framework that builds your tools for you, and a home on the cloud so it runs without you.

Three steps: map your data into a queryable brain with Obsidian + Graphify, point the PAUL and SEED frameworks at it to build your dashboard OS, then keep it local or ship it to GitHub and Railway so it runs 24/7.

Your own command center. A full agentic OS that runs on your machine, built on Claude Code. Your data, your dashboard, your memory. No SaaS subscription, no rented tool, nothing that disappears when a company shuts down.

• Built on Claude Code — runs on any model, you do not need the top tier
• 100% yours — your analytics, your skills, your knowledge graph
• Real, not a mockup — this is the exact stack I run every day

Four pieces. Two tools for the brain, two frameworks for the build.

• Obsidian — free notes app. This is where your data lives as plain markdown
• Graphify — turns your notes and files into a knowledge graph Claude can traverse. Full walkthrough and the repo are in the Graphify tutorial video (repo link in the description)
• SEED + PAUL — these are the two frameworks you use to build the OS. SEED turns an idea into a spec, PAUL plans it, builds it, and reconciles it. Both are covered in the full agentic OS build video (resources and repos in the description)
• Railway — where you host the finished OS so it runs 24/7

From the video description:

• SEED repo — grab it below at the #seed resource
• PAUL repo — grab it below at the #paul-plugin resource
• Graphify tutorial — the 9-minute brain setup
• Hermes VPS setup — the agent you link into the OS
• SEED & PAUL deep-dive podcast — the reasoning behind both frameworks
• GitHub CLI and Railway CLI — install both so Claude can push and deploy for you

First you give Claude something to remember. Download Obsidian and drop your notes, docs, and project files into a vault. Then run Graphify on it.

• Install Obsidian and create a vault. Put your data inside as markdown files
• Watch the Graphify tutorial and grab the repo from the video description
• Run Graphify on your vault. It maps every file into a graph of connected nodes

Now Claude does not reread everything every session. It traverses the graph instead. That is your queryable brain. No database, no setup headache.

This is the part that makes it yours. You do not hand-build the dashboard. You point the frameworks at your brain and watch them build it.

SEED and PAUL are the frameworks you build it with. Get both from the full agentic OS build video (resources in the description).

• Run /seed:seed to turn your idea into a clear spec. What does the dashboard show, what does each button do
• Run /paul:plan to turn that spec into a real build plan
• Run /paul:apply to build it, with your analytics wired straight in
• Run /paul:unify to reconcile what was planned against what shipped, so the OS improves itself every loop

You watch, it ships. About an hour for a basic command center.

Now you decide. Keep it private on your machine, or put it online so it runs 24/7. Here are the simple steps.

Option A: keep it local. Want it private? Do nothing extra. Run it on your own computer. Your data never leaves your machine.

Option B: push to GitHub. This puts your code online so Railway can grab it.

• Make a free account at github.com
• Click New to make an empty repository. Give it a name. Click Create repository
• In your project folder, run these commands one line at a time:

git init
git add .
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/yourname/your-repo.git
git push -u origin main

Refresh GitHub. Your code is now online.

Then host it on Railway.

• Go to railway.app and sign in with your GitHub account
• Click New Project, then Deploy from GitHub repo
• Pick the repo you just pushed
• Open the Variables tab. Add your keys (the same ones from your .env file). The key name goes on the left, the value on the right
• Railway builds it and hands you a live link. Click it. Your command center is now live 24/7, even while you sleep

Once it works for you, it works for anyone. The whole thing lives in one repo. Clone it, drop in keys, run it. Then fork it for each client or build custom versions for your team. That is how a personal OS turns into a product you can sell.

The video above walks the full agentic OS build end to end. For the repos, deeper breakdowns, and a community shipping this exact setup, join CC Strategic AI on Skool.

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). Use code CHARLES20 for 20% off, limited to the first 100 signups, so claim it before it runs out.
• 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.

Charles J Dove here. Genspark is an all-in-one AI workspace. It runs the boring back-office side of a business from a single tab, and I did not write one line of code to set any of it up.

Think of it like a desk where every tool already lives in one place. You talk to it in plain words. It does the work. That is the whole thing.

1. Dashboards and CRM. I drop my messy spreadsheets into the chat. It does not just hold them. In about 10 minutes it builds a working CRM with a full pipeline. You do not need a tech background for this. It can stand in for a stack of paid subscriptions, not only a CRM.
2. Super Agent (the research one). I gave it one prompt: research three of my competitors and turn it into a comparison report I can share with my team. It ran the whole chain by itself, research, then analysis, then formatting. The work that eats your whole day was done in minutes. The report comes back clean and ready to export or send to a client.
3. AI Sheets. A raw list becomes a clean, CRM-ready spreadsheet with the formulas already written. Structured data without touching Excel.

Three different jobs, CRM, research agent, spreadsheet, all in one tab, no code.

1. Go to Genspark and make a free account to grab your free credits.
2. Open one tab. That tab is now your whole workspace.
3. Pick one job to start: a CRM, a research report, or a clean spreadsheet. Do not try all three at once.
4. For a CRM, drag your messy spreadsheets into the chat and tell it in plain words what you want. Give it about 10 minutes.
5. For research, hand the Super Agent one prompt, like "research my top three competitors and build a comparison report." Let it run, then export the doc.
6. For a spreadsheet, paste a raw list and ask for a clean, CRM-ready sheet. It writes the formulas for you.
7. Once one job works, replace your paid tools one at a time. That is where the savings show up.

Agency owners, business owners, and anyone who is tired of paying for five tools that barely talk to each other. Let us be honest, most of us are not using half the features inside the tools we already pay for.

Skip it if you love juggling tabs and monthly bills.

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.