Every time I’m about to publish, there’s one step I’ve never fully solved: picking the title.

The rest of my workflow is already dialed in. I write the draft in Substack dashboard, and I ask Claude Code to generate title options based on the post itself, my past titles, and the way I sound. Claude Code knows my voice by now. I take the options it gives me, modify them until something feels right, and that’s usually my working title.

The gap shows up after. Once I have my shortlist, I pick the winner by feel. I’ve been doing this long enough that my instinct is decent. It’s part of how I got here. But instinct can only tell me whether a title sounds like me. It can’t tell me whether that title fits the pattern of posts that pulled 10,000 views, or the pattern of posts that quietly stalled at 4,000.

The difference between those two outcomes is usually invisible from the writer’s chair because the results only show up three days later in the Substack dashboard stats. And then you start feeling guilty because you didn’t optimize it as well as you could.

That was the gap I kept running into, and for a long time I didn’t have a clean way to close it. Gut feel can only carry you so far when you can’t actually pressure-test a title choice against anything other than your own instinct.

Then shared a skill he’d built for himself, and it slotted right into that gap. It doesn’t replace my instinct, it adds a data layer on top of it. Now when I’m picking between title options, I’m not just going with whichever one feels right in the moment. I’m also seeing how that title stacks up against the posts in my own archive that actually worked, and the ones that didn’t.

Today’s guest is Gencay, the creator of Learn AI With Me. His newsletter is for people who want to build with AI and stay on the side that doesn’t get replaced by it, which is close to the same kind of reader I’m writing for here. If that sounds like you, his newsletter is worth subscribing to.

LearnAIWithMe

If you want to build with AI, not just learn how to prompt, this is the right place.

By Gencay

This is actually Gencay’s third contribution to AI Maker. His first two, 3 Hidden NotebookLM Features Most People Don’t Use and How to Built SEO Optimized Content Machine Using Claude Cowork and Apify, are posts I still come back to myself. He keeps coming back because he keeps sharing valuable things I can learn from, and I’m sure you feel the same way.

If you want a sense of what he’s publishing on his own newsletter right now, his three most recent posts are worth the click:

• 10 NotebookLM Prompts For Studying (Beat 99% of Students)

• I Built a Self-Updating Trading Bot (Claude & NotebookLM & Karpathy’s Method)

• How I Automated AI News: NotebookLM & Claude Schedule (Zero Manual Checking)

The contradiction Gencay found in his own data

Gencay has 277 articles in his archives. When he lined up all 277 of his articles side by side, he ran into a contradiction. The posts that earned him the most likes were not the same posts that earned him the most paid subscribers. Sometimes those two numbers moved in opposite directions on the same title.

Here’s one stark example. A tutorial post (step-by-step walkthrough) titled “How to Run Claude Code Locally” pulled 28 likes and converted zero paid subs. A project post (where he documents something he actually built, with the outcome front and center) titled “One Prompt Built an Expense Tracker” only pulled 8 likes but converted 4 paid subs.

Fewer likes, more money. For his audience, what drives likes and what drives payment are apparently two different things, and you cannot see that split by eyeballing titles alone.

That clicked hard when I read his breakdown. I’d felt a version of it in my own archive without being able to name it clearly. Some of my posts get strong engagement and convert almost nobody, while others look quieter but bring in the readers who end up upgrading. I never had a way to pressure-test that pattern the way Gencay did, which is exactly why I wanted to run his skill on my own data and eventually pass it on to you.

The Claude skill he built in response

So Gencay opened Claude, pulled his own Substack stats export, and turned his history into a Claude skill.

He called it MoneyTalks. The premise is simple. Before he publishes, he runs his draft title through the skill, and it scores that title against his own 277 articles, not against generic copywriting advice.

Here’s what happens when you run it:

You paste in a title, and the skill reads it against your archive. It flags anything that looks like patterns that failed for you before, then pulls up the closest past post so you can see the actual numbers it hit. From there, it predicts how your title will perform, rewrites three alternatives if yours looks weak, and tells you whether to ship the original or swap.

Sounds cool, doesn’t it?

So he gave his skill to me so I can share it with you. But I found a problem…

Subscribe now

The gap I ran into

Gencay’s original skill was beautiful, and locked to his data. His top performers, his red flags, his ML (Machine Learning) scoring weights, all hardcoded into the skill file. His winning pattern is “NotebookLM + specific output.” Mine is probably different. Yours almost certainly is.

So I couldn’t just copy his skill and run it. And neither could you.

I went back and forth with myself on whether to build something from scratch or modify his. The right answer was to build on top. His methodology is sharp. His red flag categories are real. What needed to change was the data layer.

So I modified the skill in a few specific ways, with full credit to Gencay for the foundation:

• Split methodology from personal data. The skill file now holds the generic framework. A separate patterns.md holds your personal top performers, red flags, and baseline metrics. Setup populates that file from your CSV.

• Added a setup flow. Point the skill at your stats each time export, confirm the column mapping, and it extracts your top 20% and bottom 20% to derive your patterns.

• Added a refresh flow. New posts shift what works. Every month or so, you re-run setup and the skill updates your patterns.

• Platform-agnostic. It now reads stats exports from Substack, Beehiiv, Ghost, Kit, and ConvertKit. The column names differ, so I added schema-mapping hints.

• Honesty rules. If your dataset is under 15 posts, the skill labels the prediction as “directional only.” Under 10, it refuses to set up and tells you why.

I’m still running it on my own archive as a test case. So far, what’s come back is useful in a specific way: Instead of telling me if titles are good or bad, it tells me which past post the new title resembles, and what that past post actually did. That’s a much smaller claim than most title advice makes, and I find it more trustworthy for exactly that reason.

What changes when you have this Claude Skill running

Here’s what that looks like in practice.

My working title for this post was “The AI Skill That Predicts Whether Your Title Will Convert.” It felt punchy to me, it named what the post was about, and I was close to just shipping it. Then I ran it through MoneyTalks on my own data.

The skill flagged two structural issues in the title, pulled up the closest comparable posts from my own archive, and came back with a predicted range that was lower than I’d want for a paid post this involved. It also generated three rewritten alternatives. The one I liked the most was this:

“How I Built a Claude Skill That Predicts Whether My Titles Will Convert Before I Hit Publish.”

Below is a screen recording of me walking through the full output, including the red flag check, the anchor posts it compared my title against, the prediction range, and the three alternatives. This is the exact workflow you’d get when you run the skill on your own draft title:

From here, the rest of this post gets hands-on. The skill runs on both Claude Code and Claude Cowork, so you can pick whichever you already use. I’ll walk you through installing it, exporting your stats from Substack (or whatever platform you use to publish), running the setup flow, and reading the patterns file it generates once your data is in.

I’ll also embed a full installation and setup video of me running the skill inside Claude Cowork on my own archive, and I’ll close with a real worked example where I ran the predict flow on one of my past titles that quietly underperformed, and saw exactly what MoneyTalks would have flagged before I hit publish.

How to setup MoneyTalks Claude Skill

This section is for paid subscribers. If you’re here, thank you. Let’s build.

Step 1: Download the skill

Read more

I’ve saved hundreds of articles, podcasts, and YouTube videos across Notion, Pocket, and browser bookmarks over the years. And every time I wanted to revisit something I’d read, I had to dig through all of it just to find it. Even when I did, that article sat in complete isolation from everything else I’d saved on the same topic.

When I moved everything into Obsidian (I wrote about this in my project management post), it solved the tool fragmentation. One vault, all markdown, all accessible to Claude Code. But my notes still didn’t talk to each other. An article about automation had no connection to a podcast about AI coding workflows, which had no connection to an essay about why writing forces you to think clearly.

I was the one responsible for drawing those lines. Because it took so much effort, I didn’t actually do it as often as I expected. That’s the honest truth about note‑taking systems like Zettelkasten and “building a second brain.” The theory is beautiful; in practice, the maintenance kills it.

Then I saw what Andrej Karpathy shared. You know how much he inspires me—this is the second workflow I’ve copied from him.

For anyone who doesn’t know him, Karpathy is one of the most respected AI researchers in the world.

He described a pattern he called an “LLM Wiki.” The idea is simple but the shift is significant: instead of you maintaining a knowledge base and occasionally asking AI questions about it, the LLM builds and maintains the entire knowledge base for you.

You collect raw sources. Articles, papers, book notes, podcast takeaways, anything. You drop them into a folder. Then you tell the LLM to “compile” them into a wiki. It reads every source, writes summary pages, creates pages for key people and concepts, and cross-references everything. A single article might touch 10-15 pages across your wiki. The LLM handles all the bookkeeping you’d never do yourself.

Karpathy put it this way:

“Obsidian is the IDE, the LLM is the programmer, the wiki is the codebase.”

You rarely ever write or edit the wiki manually. That’s the domain of the LLM.

And the part that hit me hardest: this compounds. Every new source the LLM ingests makes the whole wiki smarter. It becomes a network that grows denser over time. An article about Tim Dettmers’ automation framework gets connected to Addy Osmani’s AI coding workflow, which gets connected to Dan Koe’s essay on why writing is thinking. Three completely different topics, three different authors, one thread running through all of them that I never would have drawn on my own.

Here’s the build: Obsidian as the interface, Claude Code as the agent, and a set of Obsidian Skills that Steph Ango (the CEO of Obsidian) released to teach Claude how to write in Obsidian’s native language. Wikilinks. Callouts. Canvas. A CLI (Command Line Interface) for running the whole thing from the terminal. If you’re an Obsidian nerd, that last piece is what makes this actually work.

I’ve been running this system for my own interests. AI, human psychology, personal productivity, health and fitness, building a business. All of it flowing into one knowledge base where everything connects to everything else.

What’s Inside This Post

This post is the complete blueprint for building the system I just described. Not the theory. The exact folder structure, the commands, the schema, and a starter kit you can download and set up this afternoon.

Here’s what you’ll walk away with:

1. The Three-Layer Architecture: How the knowledge base is organized: raw sources (your immutable reading material), the wiki (LLM-generated summary pages, cross-references, and concept maps), and the schema (the CLAUDE.md file that turns Claude from a generic chatbot into a disciplined wiki maintainer). I’ll show you how data flows between layers and why this structure makes the whole system work.

2. The Three Operations That Run the System: The exact slash commands I use daily: /ingest-url (feed it a URL, Claude extracts the article and compiles it into the wiki, touching 5-15 pages in a single pass), /process-inbox (fleeting thoughts and quick notes get classified and integrated automatically), and /lint-wiki (a health check that finds broken links, orphan pages, contradictions, and content gaps the wiki suggests you research next).

3. Obsidian Skills (The Missing Piece): A set of agent skills that teach Claude how to work fluently with Obsidian’s native features. Wikilinks, callouts, frontmatter, the Obsidian CLI, database views with Bases, and visual canvases. These are what turn Obsidian from “a folder of markdown files” into a proper knowledge management platform that an LLM can operate natively.

4. Real Examples of the System in Action: I made a video to walk you through this whole process so you can apply it on your own.

5. The Complete Starter Kit + Setup Guide: A downloadable starter kit with the entire system pre-built: folder structure, three slash commands, all five Obsidian Skills, the schema, templates for books and podcasts, and a step-by-step guide to customize it for your own interests. One afternoon to set up. After that, the system runs on three commands.

By the end of this post, you’ll have a personal knowledge base where every article, book, podcast, and fleeting thought feeds into a living wiki that gets smarter the more you use it. Ask it a question six months from now and it gives you an answer synthesized from everything you’ve ever fed it.

To give you a clue, this is what it looks like when Claude ingests the "Paul Graham’s “How to Think for Yourself” and turns it into a wiki page:

The wiki page looks visually appealing, with proper wikilinks, frontmatter, tagging, and callouts, because it leverages Obsidian skills, so Claude knows which features to use in Obsidian. The most interesting part is the Notes section, where Claude creates a connection to Dan Koe’s writing essay. The bigger you build your wiki pages, the more connections you’ll find that you didn’t even notice, that’s how powerful this knowledge base is.

Before we go further: This system runs on Claude Code. If you’re not familiar with it, I’d recommend reading my beginner’s guide first for the basics, or my ultimate guide for the full picture, or my project setup tutorial to get started. You don’t need to be a developer, but you do need to be comfortable with a terminal. Alternatively, you can use the Claude Code extension inside VS Code or Cursor.

Let’s build it.

The Three-Layer Architecture of AI-powered Second Brain

The system has three layers. That’s it. Once you understand how they relate to each other, everything else in this post will make sense.

sources/   ┐
           ├→ Layer 1: Input (everything that feeds the system)
inbox/     ┘
wiki/      → Layer 2: LLM-generated knowledge pages (summaries, cross-references, concepts)
CLAUDE.md  → Layer 3: The schema that governs how the wiki operates

Layer 1: Input (The Raw Material)

The sources/ folder is where your reading goes. Articles, book notes, podcast takeaways, PDFs, anything you want to remember. Organized by whatever categories make sense for your interests.

Mine looks like this:

sources/
  ai/
  health-and-fitness/
  human-psychology/
  personal-productivity/
  books/
  podcasts/

One rule: files in sources/ are immutable. Once you save something here, you don’t edit it. This is your source of truth. The raw material that everything else gets built from.

There are two ways to get content in:

1. Obsidian Web Clipper (browser extension)

See an article you want to save? One click and it becomes a markdown file in your vault. You choose where it goes. This is the manual path, good when you’re browsing and want control over what gets captured.

And it doesn’t stop at articles. You can also send an entire YouTube podcast, along with its transcript, into Obsidian. Simply open the extension on the YouTube link you want to save to your Obsidian vault or click “Reader” view to see the full transcript details.

2. /ingest-url command (Claude Code)

Read more

Every time a new AI tool drops, I ask myself the same question:

“What’s the 10x play here?”

Not the 2x. Not the “saves me 20 minutes.” The thing that fundamentally changes how I work with AI.

For me, that answer has been the same for almost a year: building an agent workspace where AI actually knows your projects, your thinking, your preferences. An AI partner that compounds its understanding of you over time. Claude Code is where I’ve gone all in.

And to be honest, one of the proudest things I’ve done in my entire AI journey, besides growing this newsletter, is converting people to Claude Code. Founding members of AI Maker. Clients. Close friends in the space. Maker Lab subscribers. I’ve walked dozens of them through the setup, watched the moment it clicked, and seen their faces beam with excitement, knowing it changes the way they work.

The Blank Folder Problem

Last week, my livestream with went live where I did something I hadn’t done before: open my entire Claude Code setup on screen and walk through how I actually run this newsletter. Not a polished demo. Just sharing my screen, triggering skills, explaining what each layer does, and answering questions in real time.

🚨 This video can only be played if you are a paid member of Maker Labs.

I showed everything. My CLAUDE.md file. My custom commands. My skills for SEO, thumbnails, LinkedIn carousels, news digests, draft reviews. My MCP connections. My CLI tools. The full system, layer by layer, running live.

And the response from Maker Lab members were almost unanimous:

“That’s incredible. But how do I get there? Is there a clear path I can follow to build something like that?”

That question hit me. Because it confirmed something I’d been hearing in private conversations too. After publishing my Claude Code guide, I got a wave of messages that all sounded the same:

“I installed it. I opened my folder. Now what?”

I started calling it the “blank folder problem.” And the more I dug into it, the more I realized this is the messy middle that nobody talks about. There are hundreds of tutorials showing you what Claude Code can do. Features, demos, possibilities. But almost nothing that addresses the actual gap: how do you go from “I have a project” to “Claude Code understands everything about me and my work”?

That’s where people quit. Not because the tool is too hard. Because the space between knowing the features and setting up YOUR project is a valley that no feature walkthrough can cross.

This post is about crossing that valley. By the end, you’ll know exactly what files to create, what order to create them in, and what to skip entirely. So you can get to the part that actually matters: Claude Code becoming your full agentic AI assistant that knows how you work, end to end.

And to be clear: don’t let the word “Code” fool you. This has nothing to do with coding. I’m not a developer. The people I’ve converted aren’t developers. Claude Code is an AI agent that lives inside your project files, and those files can be anything: newsletter drafts, client proposals, research notes, marketing campaigns, course materials, strategy docs. If your work involves creating, writing, researching, or managing projects, this applies to you.

The Anatomy of a Claude Code Project

Before we get into what to build, you need to see the full picture of what’s possible:

This image shows every file and folder a Claude Code project can have. Study it for a second, then take a breath. Because here’s the thing most people miss:

You don’t need most of this.

At least not on day one. But I’m showing you the full anatomy so you understand the territory, not so you build all of it right now. Think of it like a map of a city. You don’t need to visit every street just because they exist.

Let me walk you through each layer so you know what it does and when it matters.

Here’s something important before we go layer by layer: no matter what kind of project you’re setting up, whether it’s a marketing campaign, a content creation system, a consulting practice, or a personal research workflow, two things need to be in place every time:

• CLAUDE.md

• .claude/ folder

These are your non-negotiables. Everything else is optional and project-specific.

Let’s dive in.

🚨 Quick reminder…

If you enjoyed this preview and want the full blueprints, AI Maker Lab pricing is going up next Thursday (from $10/month to $15). You can lock in $10/month before then, and your rate stays the same forever. You can learn more details here.

Subscribe now

Layer 1: The Foundation

These are the files Claude reads every single time you start a conversation.

CLAUDE.md is your project’s instruction manual. It tells Claude what you’re working on, how you like to communicate, and what mistakes to avoid. This gets committed to git, so if you’re on a team, everyone shares it. This is the only file you absolutely need on day one.

Layer 2: The Control Center

The .claude/ folder is where configuration lives.

settings.json controls what Claude is allowed to do in this project. Can it create files? Edit documents? Access the web? These permissions give you more control over what Claude can and can’t do.

Most people never touch these manually. Claude sets them up through permission prompts as you work. They exist in the background.

Layer 3: The Workflows

This is where things get powerful, and where most people over-build too early:

• commands/ holds your custom slash commands. These are tasks YOU trigger when you need them. Write a markdown file, and it becomes a command you can run with a slash. /project:daily-plan, /project:research, /project:weekly-report, whatever your workflow needs.

• rules/ holds modular instruction files that load automatically based on what you’re working on. You don’t trigger these. Claude reads them on its own when the context matches. A writing-tone.md rule loads when you’re drafting content. A client-communication.md rule loads when you’re writing emails. Set them once, never think about them again.

• skills/ are auto-invoked workflows. The difference from commands: you don’t trigger skills manually. Claude recognizes when a skill is relevant and runs it. Each skill lives in its own folder with a SKILL.md file that defines when and how it activates.

• agents/ are isolated specialists. They run in the background, handle longer tasks, and don’t interfere with your main conversation. A research agent. A content-repurposing agent. A weekly synthesis agent. Each one stays in its own lane.

What This Means For You

The anatomy image shows a mature, fully-built project. Yours won’t look like that in the beginning, but it will evolve over time as you add more capabilities to your Claude Code system, and eventually it will reach that state.

The rest of this post will help you figure out which layers you actually need and how to set them up for your project, so you can navigate it on your own.

What You’re Getting Below

Now you know the anatomy. You understand the layers. You know you don’t need all of them.

But knowing the map isn’t the same as knowing how to start walking.

Below, I’m sharing the exact three-phase process I’ve walked my founding members, clients, and friends through, one by one, to get their Claude Code projects running. The same process that turned “I opened my folder and froze” into “Claude already knows how I work.”

This is the first part of my agent harness guide, which I’ll expand in upcoming posts.

Here’s what’s inside:

1. The Three-Phase Setup - The complete Dump > Refine > Audit process. What files to throw in your folder (by project type), how to run /init the right way, the interview prompt that fills in what your files can’t capture, and the plugin that scores your CLAUDE.md so you know it’s actually good.

2. My Actual CLAUDE.md, Broken Down Line by Line - I’m sharing the exact file that runs my entire newsletter operation. It started at 500+ lines and made Claude worse. I trimmed it to ~130 lines and Claude got dramatically better. I’ll show you what stayed, what got cut, why each section exists, and the principle that took me 9 months to learn about how to structure this file.

3. When to Add Each Layer - The exact signals that tell you it’s time to build your first rule, your first command, your first skill, your first agent. With the specific question to ask yourself before adding anything.

4. 8 Stress Tests - Specific scenarios you can run to pressure-test whether your setup actually works. The ambiguity test, the rule canary test, the cold start test, and more. Each one targets a failure mode you won’t catch if you use it normally.

5. Video Walkthrough - I’ve recorded myself walking you through the Claude Code setup process from scratch all the way to a fully working system.

This is the guide I wish existed when I started. And it’s the one I keep sending people when they message me saying “I’m stuck.”

Before we continue, I want to be clear: if this is your first time reading about Claude Code, you might want to go through my previous Claude Code ultimate guide to understand its full capabilities, then jump into this post.

The Three-Phase Setup (From Blank Folder to Working System)

This is the part most people get wrong. They either create a CLAUDE.md but never improve it over time, or they keep adding to a 500-line instruction file that ruins the agent’s effectiveness.

Both fail for the same underlying reason: they focus on the file, not the process behind it.

I’ve landed on a three-phase approach that works every time. It takes about 30 minutes, and you end up with a CLAUDE.md that actually makes Claude useful from day one.

Here’s the process: Dump > Refine > Audit.

I’ve prepared two things to help you follow along:

I recorded myself running through this entire process from scratch: the three phases, setting up rules, building commands, creating skills, and deploying agents. If you prefer learning by watching, start here. If you prefer reading, skip the video and use the written guide below. The video covers the same ground.

Read more

This is not a polished demo or even a curated walkthrough. Instead, I was just sharing my screen, triggering skills, explaining what each layer does, and answering questions from the audience in real time.

Blockbuster Blueprint

Receive a step-by-step, proven system to create 10x quality & quantity content with AI. Weekly emails contain a deep-dive or video lesson from a famous thinker and an easy way to apply it. Think Masterclass for idea creators.

By Michael Simmons

And what came out of that conversation surprised even me. Because when Michael started asking about the “most impactful” thing I’ve built inside Claude Code, I realized I couldn’t point to one skill or one automation. The answer was the whole system. Every part of my newsletter operation, from researching topics to writing drafts to creating thumbnails to generating LinkedIn carousels, runs through Claude Code.

I want to share what that system actually looks like.

Why This Matters Right Now

If you’ve been using ChatGPT or Claude chat, you already know the workflow: type a prompt, get an answer, copy the output, paste it into wherever you actually work. Google Docs, email, Canva, whatever.

I lived in that world for over a year. And the thing I kept bumping into was that I was always the middleman. AI could think, but I had to do all the moving. Copy this here, paste that there, re-explain my context in every new chat window, re-upload files every time I wanted to reference something.

It works. But there’s a ceiling to it that you don’t notice until you’ve experienced something different.

When I adopted Claude Code around August 2025, three months after hearing about it (I was hesitant because the name has “code” in it and I’m not a technical person), everything shifted. I went from being the middleman between AI and my work to having an AI agent that lives inside my work. It reads my files, understands my context, triggers workflows, and executes tasks.

Now, roughly 80% of my newsletter operation runs through Claude Code. And I rarely write prompts anymore. I just speak through WisprFlow, and the system triggers the relevant skill based on what I said.

Here’s how the full system is built, layer by layer.

1. Context Management - how CLAUDE.md and local files replace the copy-paste loop

2. Skills - the reusable workflows that handle SEO, thumbnails, carousels, news digests, draft reviews, and social content

3. Custom Commands - how I trigger all of it without writing prompts (and why voice replaced typing)

4. MCP Connections - the bridges to external tools like NotebookLM and Nano Banana

5. CLI Tools - the faster, token-efficient alternative to MCP for services like Tavily and Google Workspace

Plus how all five layers fire together in a single workflow, what it looks like on a typical day, and where to start if you’re coming from chat.

🚨 This post is for paid subscribers

The five agentic layers aboe are what power The AI Maker behind the scenes. I’m sharing the full breakdown, including specific tools, how each layer connects, and lessons from building this as a non-technical creator. This post is a great introduction to agent harness, which I’ll cover in an upcoming post.

Let’s dive in.

Layer 1: Context Management (The Brain)

Read more

A few months ago, I published the full blueprint for my content repurposing system. One newsletter URL into a Google Sheet, and Make.com delivers 5 LinkedIn posts, 10 Substack Notes, and 3 Twitter threads.

That system changed my weekly workflow. What used to take 5 hours of manual reformatting now takes 30 minutes of polish.

But it has limits I never solved.

It only covers 3 platforms. No YouTube scripts, no email variations, no quote graphics. And the output quality varies. Some pieces come out sharp, some come out sounding like generic AI rewrites, and I have to catch those manually.

The biggest gap: my system takes the article and adapts it for each platform’s format. That works for most pieces. But a great LinkedIn post is built from different raw material, a different hook, a different angle, a different entry point into the same idea. Reformatting gets you 80% there. The last 20% needs something else.

Today’s guest post is from , who writes GenAI Unplugged, a newsletter about building AI automation systems for Solopreneurs. He built a content repurposing workflow in n8n that solves exactly the gaps I’m describing.

GenAI Unplugged

Simple AI automation systems for solopreneurs who are done doing everything by hand.

By Dheeraj Sharma

🚨 In case you haven’t noticed, the exclusive AI Maker Labs post is coming early today because I have a big announcement this Thursday. We’ll also be doing more posts like this in the future, where AI experts share their AI blueprints with Maker Labs members. I hope you enjoy this post!

His system extracts the building blocks from your article first, then recomposes them natively for 7 platforms. And it has a quality gate that scores every piece and auto-revises anything that reads like AI slop.

Before we have the deep dive, you might want to explore what Dheeraj has shared in his latest newsletter posts:

1. FREE n8n Full Course: Zero to Hero in AI Automation

2. Claude Code Channels Setup Guide: Telegram, Discord, and Custom Webhooks

3. I Built 5 Research Subagents using Claude Code (Here’s the Foundation)

Now, here’s what you’ll get from this post:

1. The downloadable n8n workflow file (JSON, ready to import)

2. Step-by-step setup walkthrough with screenshots (about 45-60 minutes)

3. The AI prompts powering content extraction, platform generation, and quality scoring

4. A customization guide so you can adapt it to your brand voice

5. Troubleshooting for the most common setup issues

If you built my Make.com system, think of this as the next level. If you didn’t, this is a standalone blueprint you can run on its own. And if you’ve been wanting to try n8n as an alternative to Make.com, this is a solid first project.

Here’s Dheeraj.

Hello 👋🏻

Content distribution is eating your creative hours alive.

You publish an article. It’s good. Your audience is on LinkedIn, Twitter, email, YouTube, and your blog. Each platform has different formatting rules, character limits, and audience expectations. A LinkedIn post that works bombs as a tweet. An email subject line that gets opened sounds wrong as a YouTube title. So, you:

• Manually rewrite each piece

• Open six tabs

• Copy paragraphs, trim character counts, adjust tone, add hashtags, reformat bullet points

That’s 5 hours per article. Multiply by 2 articles per week. That’s 40+ hours a month of distribution work. At $75/hour, you’re spending $3,000 monthly on distribution. Not creating, not serving clients, not building products.

And here’s the hidden cost: you skip platforms.

You don’t have time to create a Twitter thread AND an email AND quote graphics. So you pick two platforms and leave the rest on the table.

This n8n workflow changes that. You fire a webhook, wait 90 seconds, and get back 7 platform-native content pieces, each one written specifically for its platform’s algorithm and audience expectations.

Not reformatted copies. Platform-native pieces with an AI quality gate that catches weak hooks and generic AI slop before anything reaches your audience. Total cost per execution: $0.15-0.25.

Content Multiplication, Not Content Reformatting

Content multiplication is not content reformatting. Reformatting takes your article and crams it into different character limits. Multiplication extracts the atomic building blocks like hooks, insights, data points, frameworks, stories and recomposes them into pieces that sound like they were written natively for each platform.

That’s the difference between a LinkedIn post that reads like a truncated blog and one that reads like it was born on LinkedIn.

Tuna Principle for Content Repurposing

Think about how a chef handles a whole tuna at a high-end restaurant. They don’t just slice it into identical portions. They break it down into distinct cuts, sashimi-grade belly for the raw bar, loin steaks for the grill, collar meat for the special.

Each cut gets prepared differently because each dish has different requirements. The belly needs precision slicing. The collar needs slow roasting. The staff meal needs bold seasoning.

Your article is the whole tuna. Right now, you’re slicing it into identical portions and hoping each platform likes the same thing. This workflow breaks your content into its atomic building blocks.

The hooks, the data points, the stories, the frameworks and recomposes each piece specifically for its destination. LinkedIn gets the professional insight cut. Twitter gets the punchy hook cut. Email gets the personal narrative cut. Each piece is prepared for its platform, not just resized for it.

Subscribe now

How the AI Content Repurposing Works (7 Steps)

Here’s what happens when you fire the webhook:

1. You send your article as a URL, a Notion page ID, or raw markdown

2. The workflow fetches and normalizes your content from any source using Jina.ai for URL-to-markdown conversion

3. An AI analyzer extracts “content atoms” from your article: hooks, insights, data points, frameworks, stories, tips, and CTAs

4. Each platform gets its own AI-generated content using prompts built with platform-specific algorithm intelligence

5. A quality gate AI reviews every piece for AI slop, weak hooks, and brand voice compliance, scoring 6 criteria

6. Anything scoring below 7/10 gets auto-revised with specific feedback targeting the weak areas

7. You get back a single JSON response with all 7 pieces, quality scores, and the original content atoms

What You Get Back: 7 Platform-Native Pieces

• LinkedIn post (professional insight with engagement hooks)

• Twitter thread (punchy, scannable, optimized for retweets)

• Substack Notes (punchy, scannable, based on proven frameworks)

• Email newsletter (personal tone with clear CTA)

• YouTube hook script (visual-first, pattern-interrupt opening)

• Quote graphic specs (designed for sharing with key insights)

• Multi-format summary (comprehensive reference piece)

Cost and Speed Breakdown

• 5 hours saved per article in manual distribution work

• 40+ hours per month at 2 articles per week

• $3,000 monthly in recovered capacity at $75/hour

• That’s capacity for 4 more client calls, 2 more product features, or 8 more articles

NOTE: The workflow just generates the output, you can always add distribution or publication n8n nodes like LinkedIn, Wordpress, Twitter/X, Substack (Community), Facebook, Instagram, etc.. to publish these output. If you need help adding them, just send a DM.

AI Tools You Need Before Starting

• n8n - Workflow automation engine

  • Free : Yes (self-hosted)

  • Paid : $20/month (cloud)

• OpenAI API - GPT-4.1-mini for 4 AI nodes

  • Pay-per-use

  • ~$0.10-0.25 per execution

• Jina.ai Reader - URL-to-markdown conversion

  • Yes (free mostly)

• Notion API - Optional: Notion page input

  • Free (integration available)

Total monthly cost: $0 (self-hosted n8n) to $20 (cloud n8n) + ~$5-10/month in OpenAI API costs at 2 articles per week with all 7 platforms.

The workflow uses 19 nodes total with 4 AI calls per execution. The temperature gradient varies across the AI nodes. Lower for analysis, higher for creative generation, moderate for quality evaluation.

If you’re already using n8n for other automations, you can connect AI assistants to n8n workflows for even more powerful setups.

Full Setup Walkthrough

Total setup time: 45-60 minutes

Step 1: Install n8n (15 minutes)

Self-hosted (free):

• n8n local installation video

• n8n Docker installation video

Cloud ($20/month):

1. Sign up at n8n.io

2. Skip to Step 2

Step 2: Import the Workflow (5 minutes)

Read more

I have over 20 skills running my newsletter right now. Each one is basically a compressed AI brain trained to do one specific job really well. Social notes, LinkedIn posts, SEO optimization, carousels, performance analysis. A skill takes something that used to cost you 30 minutes of context-setting and turns it into a single command.

Here’s the problem nobody talks about.

When I run my skills, maybe 70 or 80% of the outputs are genuinely good. The rest miss the mark. And my “testing process” is basically: run it a few times, tweak what obviously breaks, call it done. If it looks “pretty good” on three test runs, I ship it and move on.

But I’m testing for confirmation, not for failure. I use similar inputs every time. I evaluate on gut feeling. I stop improving when it feels “good enough.” Which means a skill could sit at 70% of its potential for months and I’d never know. You don’t know what you don’t know.

If you’ve ever built an app feature or shipped a workflow and thought “this works, but could it work better?”... same thing. Nobody has a systematic way to answer that question.

Then I saw what Andrej Karpathy released, and it clicked.

What Karpathy Actually Built

Karpathy, for those who don’t know him, is one of the people who shaped how we think about AI today. He was a founding member of OpenAI, led Tesla’s Autopilot AI, and taught Stanford’s most popular deep learning course. When he builds something, people pay attention.

In early March, he open-sourced a project called autoresearch. And the idea behind it is one of those things that sounds obvious once you hear it but nobody was doing it.

Here’s the setup. Karpathy had a piece of code that trains a small AI model. The training takes about 5 minutes to run and produces a score at the end that tells you how well the model learned. Lower score = better.

Instead of manually tweaking the code himself (change a setting, run the training, check the score, repeat), he gave the code to an AI agent and said:

“Your job is to make this score go down. You can change anything in the code. Run the training after each change. If the score improves, keep your change. If it doesn’t, throw it away and try something else. Don’t stop. Don’t ask me. Just keep going.”

Then he went to sleep.

He left it running for about two days. The agent worked through roughly 700 changes autonomously and found about 20 that actually improved things. Stacking them all together gave an 11% efficiency gain on a project Karpathy thought was already well-tuned after years of manual work.

In his own words:

“I am mildly surprised that my very first naive attempt already worked this well on top of what I thought was already a fairly manually well-tuned project.”

And every single improvement transferred to larger models too. The agent found things that generalized.

This is a person who has been doing this exact kind of optimization manually for two decades. And the agent found improvements he’d missed on a project he’d already spent significant time tuning by hand.

He ended his thread with something that stuck with me:

“Any metric you care about that is reasonably efficient to evaluate can be autoresearched by an agent swarm. It’s worth thinking about whether your problem falls into this bucket too.”

I find Karpathy is a truly fascinating person. In his recent podcast with , he explained the idea behind auto-research: he wants to maximize what an AI agent can do by letting it handle all of his work. He wants to remove himself from the loop between human and AI, because his presence as the human becomes the bottleneck. Check out this clip:

This is what I've been so obsessed with lately. The idea that your presence as the human becomes the bottleneck. The highest-leverage move is not doing the work yourself, but setting up the right conditions and then stepping back.

Karpathy's tweet about it got over 8.6 million views in two days. Fortune magazine wrote about it and coined the term "The Karpathy Loop." His GitHub repo got starred by 50k+ users and forked by 7.9k people, including me.

Then Shopify’s CEO Tobi Lutke tried the same pattern the night Karpathy released it. He pointed an agent at a query-expansion model, told it to optimize for quality score and speed, and went to bed.

He woke up to a 19% score improvement after 37 experiments. The 0.8B parameter model was now outperforming his previous 1.6B model. A smaller model, beating the bigger one, because the agent found better settings overnight.

Why The Karpathy Loop Works on Almost Anything

Here’s the part that most people miss when they see Karpathy’s results. They think:

“Cool, an AI that optimizes neural networks. That’s neat but not relevant to me.”

But the Karpathy Loop has nothing to do with neural networks specifically. In fact, it works anywhere, as long as you have three things:

1. Something you can edit: code, config, instructions, a template, a prompt

2. A way to measure if it got better: a score, a benchmark, a pass/fail test, any number that goes up or down

3. A time-boxed way to test: run the thing, get a result, decide keep or discard

That’s it. That’s the whole loop.

What Karpathy Loop cares about is the loop, not your domain: change something, measure the result, keep or discard, repeat.

Subscribe now

From Karpathy Loop to Skill Loop

When I saw all of this, I couldn’t unsee it. It’s like my third eye finally opened wide and started making connections to the things I do every day, in this case, skills.

My skills have all three primitives:

1. Something editable: The SKILL.md file. That’s the instruction set that tells the AI what to do, how to do it, and what the output should look like.

2. A way to measure quality: I can build an eval rubric. Score the output on 6-10 dimensions, 1-5 each. Did the tone match? Did it follow the structure? Was the hook compelling? Did it miss any requirements?

3. A time-boxed test: Run the skill once. Get the output. Score it. Done.

Here’s how it works:

The one thing I had to figure out: neural network metrics are clean numbers. You train the model, you get a score, done. Skill quality is fuzzy because you need to answer questions like, “Was this LinkedIn post good?” and most of the time, that isn’t a yes/no question.

That’s why the eval rubric became the critical piece. It turns “does this feel right?” into “does this score 4/5 on hook quality, 3/5 on tone consistency, 5/5 on structure compliance?” Suddenly you can compare experiment A to experiment B. You can see which dimensions improved and which regressed. You have data instead of vibes.

But here’s where I had to go further than Karpathy’s setup. A 1-5 rubric is great for humans to understand where quality stands. It’s terrible for an unsupervised loop running at 2 AM. “Was the hook quality a 3 or a 4?” is a judgment call. An agent can’t reliably make that call without you there.

So I added a conversion step: take the weakest dimensions from the rubric and turn them into binary yes/no checks. “Does the hook include a specific number or data point?” Yes or no. “Does every content slide have a concrete action?” Yes or no. No gray area. Two different agents scoring the same output should agree.

That’s what makes the autonomous loop actually work. The 1-5 rubric tells you where the problems are. The binary evals let the agent fix them without you.

So I built a meta-skill with three phases:

1. Setup (you’re involved): Analyze the skill, generate test cases, build the rubric, run a baseline, convert weaknesses to binary evals. You approve everything before the loop starts.

2. Autonomous loop (no human): Mutate one thing, run all test cases, score with binary evals, keep or discard, repeat. The agent doesn’t stop. It doesn’t ask permission. It just runs experiments until it hits the stopping criteria you set.

3. Debrief (you review): Re-score with the original 1-5 rubric so you can compare before and after in the same language. Full report on what changed, what worked, what didn’t.

The human approves the plan. The machine runs the experiments.

And honestly? The results surprised me.

What the Karpathy Loop Unlocks for Your Skills

By the end of this post, you’ll have:

1. The complete autoresearch skill: The three-phase system I built that you can run on any skill today. Setup, autonomous loop, debrief. Point it at a skill, let it run, get a before/after scorecard.

2. Real results from my own skills: Before/after scorecards from running autoresearch on [2-3 specific skills], including the specific blind spots the loop found that I’d missed after months of manual testing.

3. How to design eval rubrics that actually work: The hardest part of this whole system isn’t the loop. It’s defining what “better” means. I’ll show you how to build scoring criteria that catch real quality problems instead of just validating what you already believe.

4. The Karpathy Loop for app features and workflows: How to adapt this same loop for code performance, loading times, content templates, or any workflow with a measurable output.

🚨 One thing to know before we dive in: This entire system runs on Claude Code. I’d suggest using Opus 4.6 to run this because it requires long‑running tasks and sub‑agents. If you’re not using Claude Code yet, start with my beginner’s guide, then level up with the ultimate Claude Code guide. If you already are, you can run autoresearch on your own skills today.

Let’s build it.

How the Autoresearch Skill Works

Before you run this on anything, ask one question: is this skill ready for optimization, or does it need a rewrite?

The Karpathy Loop has a sweet spot. If your skill works 60-80% of the time and fails in specific, repeatable ways, autoresearch will find those failure patterns. If your skill works but the output is generic or bland, the loop can target specificity. But if your skill fails completely or produces the wrong type of output, optimization won’t help. Rewrite it first, then optimize. And if your skill already works 90%+ of the time, you’re probably hitting diminishing returns. The remaining 10% is usually taste or edge cases that binary evals can’t capture.

The biggest prerequisite: you need to know what “good” looks like. You can’t build evals without a clear picture of quality. If you can’t describe what a good output looks like for your skill, that’s the work to do first. Not configuring the loop.

Once you’ve cleared that bar, the skill runs in three phases. The human is involved in the first and last. The middle runs completely on its own.

I’ll share how I improved my LinkedIn Carousel Generator skill as well as my Infographic Generator skill using Nano Banana, which comes as a bonus in today’s post 🎁.

Phase 1: Setup (Two Touchpoints)

This is where you and the agent align on what “better” means. The whole phase is designed around just two human decisions. Everything else runs automatically.

What you need to do is simply trigger the autoresearch skill and mention the other skill you want to improve. An example will be provided later in the case study.

The agent works first. It reads your entire skill directory. SKILL.md, reference files, examples, configs, everything. It documents what the skill does, what goes in, what comes out, and which files can be edited vs. which ones stay fixed. Then it scans your project for real test inputs, then proposes what it found.

Read more

A few months ago, I built an AI agent that sends me AI news summaries every week. Perplexity searches the internet. Make.com orchestrates the pipeline. OpenAI writes the summary. Gmail delivers it. Set it and forget it.

It works. It still runs. It saves me 3-5 hours a week.

And I’ve been slowly realizing it’s not enough.

Week after week, the same format lands in my inbox. Solid summaries. Useful links. Zero awareness of what it told me last week. The agent doesn’t know that three companies announced agent frameworks in the past month because it doesn’t remember the first two. It doesn’t know I already wrote about Claude Code because it has no logs of my newsletter archive. It can’t tell me “this contradicts what Source X reported last Tuesday” because last Tuesday doesn’t exist to it.

Every run starts from zero. Fresh amnesia. Great at the task, zero accumulated knowledge.

The email arrives. That’s it. If something catches my eye and I want to go deeper? I’m back to manual research. I can’t ask follow-up questions to a Make.com scenario.

What I actually wanted was a research partner, something that remembers every finding, understands what matters to me, and gets better at the job over time. Not a pipeline. An agent.

Same goal. Completely different architecture.

If you built V1 from my previous post, this is the upgrade. If you didn’t, this system stands on its own.

Inside the AI Research Agent: Architecture, Modes, and How It Works

An AI automation follows the same steps every time regardless of what happened before. An agent remembers what it learned and adapts.

We’re going to leverage two of Claude Cowork’s most recent features to make this work: Dispatch and Scheduled Tasks.

If this is your first time hearing about Claude Cowork, you may want to read my full guide on how to use Cowork.

Under the hood, the system combines five capabilities:

1. Dispatch

This is Cowork’s mobile entry point is worth pausing on. Dispatch gives you the full power of Cowork from your phone. Everything Cowork can do on your desktop—spin up subagents, read and write to local folders, connect to MCP servers like Gmail, Google Drive, Slack, etc., execute files—Dispatch can trigger from a text message on your phone.

Imagine you’re on the train, waiting for coffee, sitting in a boring meeting—pull out your phone, tell Claude “research autonomous coding agents,” and walk away. Claude picks it up on your desktop, deploys parallel subagents, scans the internet through Tavily MCP, writes the finished report to your local folder, and it’s all waiting when you get back. Your phone is the remote control. Your desktop is the engine.

And you know what? The more I use Dispatch, the more I realize this is Anthropic’s answer to OpenClaw, letting you access a full-blown AI agent anywhere. Even though Anthropic launched remote control in Claude Code a while back, having it in Cowork unlocks more possibilities and gives many more people access to it.

You know what makes this exciting is that less than 24 hours ago, Anthropic made this 10x better by letting Dispatch launch a Claude Code session directly inside your computer.

Now you can ask Dispatch to open Claude Code in your terminal and start building for you. You can also connect to Google Workspace CLI through Dispatch via Claude Code. In a future post, I’ll do a deeper dive on this, so stay tuned.

2. Scheduled Tasks

This is the recurring layer. Schedule your daily briefing to run at a set time while your computer is on. You step away to grab lunch, come back, and the intelligence report is sitting in your folder. You don’t need to prompt or trigger anything. The agent just runs on schedule and the results accumulate.

3. Subagents

Claude can deploy multiple parallel agents that each handle a different research topic simultaneously. Instead of searching one thing at a time, the system fans out across all your tracked topics at once and then synthesizes the results.

4. Tavily MCP

This is the agent’s connection to the live internet. Tavily offers five capabilities: search to scan for new developments, extract to read full articles without noise, research to run comprehensive multi-source investigations, crawl to capture entire sites, and map to understand site structure before crawling. The free tier covers daily briefings. Pay-as-you-go if you run heavy deep research sessions.

5. Three-layer knowledge system

This system separates what the agent already knows about you, what it is actively tracking, and the day‑to‑day details that eventually compound into something useful.

This system has three modes:

• Daily Briefing (5-10 minutes) — You say “morning briefing.” Claude reads its memory (your preferences), checks the trend index (everything it’s been tracking), reads yesterday’s log (what’s pending), reviews your research profile (what you care about) — then deploys parallel subagents to scan all your topic areas simultaneously. It synthesizes findings, connects them to previous days, and delivers a focused report. The briefing on Day 30 looks nothing like Day 1 — because the agent has 29 days of accumulated intelligence informing what matters and what’s noise.

• Deep Research (10-15 minutes) — You say “research [topic].” Claude goes deep. But unlike a fresh search, it starts from everything it already knows. It checks the trend index for existing data points, then runs a comprehensive multi-source sweep before deploying parallel subagents to fill specific gaps. If you’ve been tracking a trend for two weeks through daily briefings, the deep research builds on that foundation instead of starting cold. This one takes longer because it’s thorough: multiple research phases, gap-filling, confidence scoring.

• Trend Review (5-10 minutes) — You say “trend review.” Claude pulse-checks every active trend it’s tracking, makes explicit decisions (keep, promote, archive, flag for deep dive), identifies meta-patterns across trends, and produces a landscape summary. This is the system’s strategic assessment mode — it keeps the accumulated intelligence healthy and surfaces the big-picture view that daily briefings miss. Run it weekly.

Here’s what that looks like in practice:

• Day 1: “Here are today’s top AI developments.” (Clean scan. No context yet.)

• Day 5: “This connects to Tuesday’s finding — OpenAI is the third company this week to announce agent frameworks.” (Pattern recognition kicks in.)

• Day 15: “Based on two weeks of tracking, here’s what’s actually signal vs. noise.” (Accumulated intelligence.)

• Day 30: “You asked me to research AI coding tools. Based on everything we’ve tracked, here’s what’s shifting vs. what’s just marketing.” (Deep research powered by a month of context.)

The whole thing lives in one folder:

Open this folder in Cowork and type “morning briefing.” That’s it. (If you prefer Claude Code, run claude in the directory — same files, same system.)

Subscribe now

How the Agent Gets Smarter: Day 1 vs. Day 7

Let me walk you through what actually happens when you use this system for a week. These are real outputs from my own research agent, not mockups.

Day 1: A Good Summary

I open Cowork, point it to my research-agent folder, and type “morning briefing.”

The agent kicks off. It reads memory, trend index, yesterday’s log (all empty — first day), and my research profile. Then it deploys parallel subagents — one per topic area in my profile — each scanning the internet using Tavily MCP simultaneously.

A few minutes later, the first briefing lands.

Here’s the structure of what Day 1 delivered:

• Top Signal: MCP’s 2026 production roadmap — security deliberately deprioritized despite a major vulnerability that compromised 437K+ dev environments. The agent flagged the tension: the protocol everyone’s building on doesn’t yet enforce security at the protocol level. Strong newsletter angle.

• 5 Key Developments: Claude Code Review (multi-agent architecture), GPT-5.4 with computer use, Anthropic’s labor market report, Claude inline visualizations, shadow AI hitting 57% employee adoption

• Emerging Patterns: Empty — first briefing. “No patterns identified yet. This section populates as context accumulates — typically by Day 3-5.”

• Worth Watching: 4 items on the radar for future tracking

• Memory Updates: “No changes — first briefing, no user preferences to record yet.”

Behind the scenes, the agent also:

• Seeded the trend index with 6 emerging trends from today’s findings

• Created a detailed daily log with every source consulted and follow-up questions

• Saved the briefing to output/daily-briefings/2026-03-17.md

The overall result was solid and clean. This is a good summary of today’s landscape.

Day 7: When the Agent Started Connecting Dots

Same command. “Morning briefing.” But now the agent has a week of logs and a trend index carrying six active trends with dated evidence trails.

The briefing is different in ways I didn’t design for. Two things happened that week that made me realize this wasn’t just a faster news reader:

• It connected dots I missed. Three separate announcements across the week, each one looking like independent news, turned out to follow the same pattern: they were all about workspace AI integration. The agent saw it because it remembered all three. I would have read them in three separate newsletters and never connected them.

• It caught a contradiction. The agent flagged that something a company announced directly conflicted with what a different source reported earlier in the week. The trend index carried both data points with dates. It surfaced the tension unprompted: “This conflicts with [Source]’s earlier report.” That contradiction became the angle for a newsletter post I wouldn’t have written otherwise.

The system is measurably smarter than it was on Day 1. And next week, it starts from here, not from zero.

Everything Inside the Research Agent Folder

That’s what the system does. Now here’s what you’ll walk away with if you keep reading.

The complete research agent folder: every file, configured and ready to use. Drop it into a directory, open Claude, and type “morning briefing.” That’s it.

Here’s what’s inside:

• CLAUDE.md — The brain. 250 lines of operating instructions that turn Claude from a chatbot into a research intelligence agent. Includes the three-layer knowledge system, a full Tavily MCP usage guide (when to use search vs. extract vs. research vs. crawl vs. map), parallel subagent architecture for concurrent topic scanning, proactive suggestion logic, and the exact session startup sequence the agent follows every time.

• research-profile.md — Where you tell the agent who you are and what you care about. Your topics, your trusted sources, your filters for what matters and what’s noise. I’m including 3 complete example profiles (creator, knowledge worker, entrepreneur) so you can start from a template instead of a blank page.

3 skill files — The step-by-step processes for each mode:

• Daily Briefing (10 steps, parallel subagent deployment, proactive suggestions)

• Deep Research (11 steps, two-phase research with gap-filling)

• Trend Review (10 steps, keep/promote/cold/archive decisions)

3 output templates — Consistent formatting for briefings, research reports, and trend reviews so every output is scannable and structured.

The three-layer knowledge system — Starter files for memory.md (user preferences), logs/trend-index.md (accumulated intelligence), and the daily log format. Each with commented examples showing exactly what goes where — and why the separation matters.

Plus the full setup and tuning guide:

• Step-by-step setup walkthrough (Cowork primary, Claude Code alternative)

• Tavily MCP connection setup (2 minutes by giving the agent live internet access)

• How to build your research profile inside Cowork — let Claude interview you and write the file for you

• Dispatch setup: trigger research from your phone, results waiting on your desktop

• Scheduled Tasks: automatic daily briefings that run without you prompting

• What every file does and why it exists (so you can tune the system with confidence)

• Compound intelligence timeline (what to expect at Week 1, 2, and 4)

• Week 1 tuning checklist — what to adjust after your first 5-7 briefings

• How your source list grows naturally over time

• Honest results: what improved, what didn’t, and what’s still imperfect

What you need: Claude Pro ($20/month) or Claude Max — Cowork is the easiest way to run this (Claude Code works too). Tavily MCP for internet research (free tier of 1,000 credits/month is available, with pay‑as‑you‑go pricing at $0.008 per credit for heavier usage). That’s it. You don’t need a Make.com subscription, an OpenAI API key, or even a multi-tool pipeline to maintain.

The whole thing takes about 15 minutes to set up. The research profile is the only part that requires real thought — everything else is copy, paste, and go.

Day 1 will feel like a good news summary. Day 5 will feel like having a research partner. Day 30 will feel like having an intelligence operation.

How to Set Up Your AI Research Agent (Step by Step)

Step 1: Download the Agent Folder and Connect Tavily MCP

Download the complete research-agent folder (link below). Drop it anywhere on your machine. Every file is ready to use, you only need to customize one.

Read more

I’ve spent the last few months building what I call my agentic workspace — and if you’ve been following along, you’ve watched it grow in layers.

First, I moved from scattered ChatGPT conversations to a single Claude Code environment where my entire newsletter lives. Writing guidelines, performance data, content archive, social media creation — all accessible to one AI agent in one place.

Then I connected NotebookLM through MCP, giving Claude the ability to research across 50 sources without me switching tabs. Then Nano Banana, so Claude could generate images directly inside the same conversation where I write. For a quick research session, I injected Claude with Perplexity and Firecrawl MCP to execute the research for me.

Then — if you read my last post — I moved my entire project management system into Obsidian and connected it to Claude Code. Goals, roadmaps, sprints, weekly plans, daily logs — all as plain markdown files that Claude reads and writes directly. Five slash commands that plan my week, prep my mornings, process my inbox, wrap my evenings, and review my progress. A copilot that doesn’t just store my plan — it has opinions about my plan.

Each layer removed a gap. Each integration meant one less place I had to be the middleman.

But there was still a gap. A big one.

My projects, my goals, my writing, my research, my image generation — all inside Claude Code. But my email, my calendar, my Google Docs, my Google Slides & Sheets — the place where I actually communicate with the outside world — still trapped in browser tabs, forcing me to manually hop between them.

I was the human bridge between Claude and Google Workspace.

Then Google quietly released something that closed that gap.

Google Workspace (GWS) CLI — a command-line tool that gives your terminal direct access to Gmail, Calendar, Docs, Drive, Sheets, etc. And here’s the part that caught my attention: Google built it specifically with AI agents in mind.

This is not a chatbot plugin. Or MCP (Model Context Protocol). Or even a browser extension. It’s a terminal tool. The exact surface where Claude Code already operates. Before you get discouraged by the term CLI (Command Line Interface), stick with me, this is how AI agents will interact with the millions of software tools we use every day (soon).

And the timing couldn’t have been better. Because right around the same time, Anthropic shipped the /loop command for Claude Code — a way to set any workflow to run on a recurring interval inside your active session. Every 10 minutes. Every 30 minutes. Every hour. As long as your session is running, Claude keeps executing.

Two things clicked into place at the same moment: Google gave Claude access to my work data. Anthropic gave Claude the ability to act on it repeatedly without me triggering each step.

I spent the last few days connecting it all, building workflows, breaking things, and rebuilding them. Here’s what a normal day looks like now.

Last Tuesday, I opened my laptop around 9 AM and launched Claude Code. By 9:15, my morning briefing had already run — a scheduled task that fires the moment my session starts. 34 emails categorized into five segments. Two newsletters summarized with key takeaways I’d actually want to read. Three emails flagged for reply. My calendar pulled up to show every call for the day.

I had a client call at 10. One command — Claude pulled the attendee’s email history, found two unresolved threads, searched my Drive for a doc they’d shared last month, and compiled a one-page meeting prep with context on what they’re working on and how I can help. Ready before I finished my coffee.

After the call, I shared the transcript. Claude generated a summary, extracted four action items, and routed them straight into my Obsidian vault — linked to the right sprint, tagged with deadlines. Then it drafted a follow-up email to all attendees. I adjusted one line and sent it.

That afternoon, a client needed a presentation for their team. I pointed Claude at my strategy doc and triggered the Google Slides skill. Structure, content, formatting — done and saved to Drive in under 15 minutes. No Slides editor. No dragging text boxes around.

At 5 PM, I ran inbox zero. 47 emails categorized, 6 draft replies ready for review, action items routed to Obsidian, the rest archived. Ten minutes instead of forty-five.

That was one day. Every day since has looked similar.

Obsidian handles what I’m working toward. Google Workspace handles how I communicate about it. Claude Code sits in the middle: reading both, connecting both, running both.

What Is a CLI and Why It Matters for AI

If you’ve been following this newsletter, you’ve been using Claude Code, which is itself a CLI. But let me explain this clearly for everyone, because it’s the key to understanding why this Google integration is different from everything else out there.

CLI stands for Command Line Interface. Instead of clicking buttons in a browser, you type a command and get a result.

Think of it like this: Gmail’s web interface is designed for you. You click into an email, read it, scroll down, click reply, type your response, click send. Every action requires your eyes and your mouse.

A CLI is designed for software. It lets you say “show me all unread emails from this week” and get the answer instantly — no clicking, no loading, no scrolling. One command, structured data back.

AI agents can’t click buttons. They can’t navigate a browser. But they can run commands. A CLI gives your agent direct access to your data without trying to simulate human behavior in a browser window.

Andrej Karpathy tweeted about this recently. He’d built his own dashboard using the Polymarket CLI and made the point that every company needs to ask: does our product make it easy for agents to access it? Because agents are increasingly doing the work for us.

Google answered that question. They built a Workspace CLI — a terminal tool that talks directly to their APIs — and said it out loud: “built with agents in mind.” Claude runs a command, Google returns the data, Claude acts on it. No browser in the loop.

The companies building the best AI integrations right now are all doing the same thing: building surfaces that agents can operate on natively. Terminals, IDEs, scheduled task runners. Better prompts help. But better surfaces — where your AI can actually read and write your data — that’s where the real shift is happening.

Subscribe now

CLI vs MCP — What’s the Difference?

If you’ve read my MCP posts where we connected NotebookLM and Nano Banana to Claude, you might be thinking: “Isn’t this the same thing? Connecting a tool to Claude?”

Close, but different in a way that actually matters.

MCP is a protocol. It’s a standardized bridge between Claude and an external tool. Someone builds an MCP server that translates Claude’s requests into something the tool understands, and translates the tool’s responses back. It works well, but it depends on a third party maintaining that server. If the API changes, someone has to update the bridge.

A CLI is the tool itself. No bridge needed. Google built the GWS CLI, Google maintains it, and Google updates it when their APIs change. Claude runs the `gws` command in the terminal the same way you’d run any other command — directly.

In practice, the difference is reliability and maintenance. My NotebookLM MCP and Nano Banana MCP work great — but they depend on community-maintained servers. The GWS CLI comes from Google software directly. When Gmail’s API changes, Google updates the CLI. I don’t have to wait for someone to fix a broken MCP server.

The bottom line: MCP is how Claude connects to tools that need a translator. A CLI is when the tool already speaks Claude’s language — the terminal.

For this setup, you don’t need to configure any MCP server. Claude Code uses the GWS CLI as a regular terminal tool, out of the box.

What Google Workspace CLI + Claude Code Unlock

I showed you what one day looks like in the opening. Here’s the full picture of what becomes possible once Google Workspace is connected to your terminal.

• Email intelligence. Claude can read your entire inbox — not one email at a time, but in bulk. It categorizes by urgency, sender type, and required action. It fetches full content only for the emails that matter and summarizes the rest. It drafts replies that match the context of the conversation, not generic templates.

• Calendar awareness. Claude sees your full schedule — who you’re meeting, when, and what’s on either side of each call. It cross-references attendees against your email history, shared documents, and past meetings. For new contacts, it can run web research automatically through Perplexity.

• Docs as output. Any workflow can save its output to Google Docs — morning briefings, meeting summaries, weekly reports. Proper headings, clean formatting. Useful if you want a running log or need to share results with someone who doesn’t use Claude Code.

• Sheets as data. Claude can read from and write to Google Sheets — pull numbers for analysis, append rows to a tracking spreadsheet, or generate a formatted report from raw data. If you’re tracking metrics, managing a content calendar, or running any kind of structured workflow, Sheets becomes a live surface Claude can operate on.

• Slides from content. Claude can create Google Slides presentations — from a meeting summary, a strategy doc, a newsletter outline. It builds the structure, writes the content, and saves the deck to your Drive. Turns any written output into something shareable without opening the Slides editor.

• Drive Access. Claude can search, create, edit, and delete files across your entire Drive. Pull context from a shared doc before a meeting, find a proposal someone sent three months ago, organize files into folders, or clean up outdated drafts — full read-write access to your Drive without opening a browser.

And all of this can run on a loop inside your session. Your morning briefing fires when you open Claude Code. Meeting prep runs every 30 minutes, checking for upcoming calls. Inbox processing at end of day. You set the cadence once per session, and the workflows keep running as long as your session is live.

What’s Inside This Post

This guide covers everything from installation to automation. Here’s what you’ll walk away with:

1. The complete setup — Installing the GWS CLI, authenticating your Google account, and installing the GWS skill that teaches Claude how to use every Google Workspace command correctly. Ten minutes from start to finish.

2. Permission settings that make it usable — By default, Claude asks for your approval on every single CLI command it runs. That’s fine for learning, but it kills the flow when you’re processing 100+ emails. I’ll show you exactly which permissions to whitelist so Claude can read your inbox, check your calendar, and search your Drive without stopping to ask while still requiring approval before it sends anything on your behalf.

3. 4 daily workflows as custom commands — Morning briefing, meeting prep, meeting follow-up, and inbox zero. Each one packaged as a Claude Code slash command you copy into your project. Type one command, Claude handles the rest.

4. Session-based scheduling with /loop — How to use Claude Code’s /loop command to run these workflows on a recurring interval inside your active session. Imagine it as a live copilot that keeps working as long as your session is open.

5. 🎁 A Google Slides skill — This is a gift for you. A downloadable Claude skill that turns any written content — meeting notes, strategy docs, newsletter outlines — into a properly structured Google Slides presentation. Claude analyzes the content, builds the slide structure, writes the copy, and saves the deck to your Drive.

Before we go further: This system runs on Claude Code. If you’re not set up yet, read my beginner’s guide to Claude Code first for the basics. If you want the full picture, jump straight to my Claude Code complete guide. In it, you’ll see that Terminal isn’t the only way to use Claude Code. You can also run it from VS Code or the Cursor extension, which are both more user-friendly than Terminal.

That’s the full surface. Now let me show you how to set it up.

How to Install Google Workspace CLI

Read more

Every newsletter I publish needs a thumbnail. And for months, my process for creating one looked like this:

• Open my newsletter draft inside Claude Projects.

• Ask Claude to analyze the post — the hook, the key themes, the emotional angle.

• Tell Claude to generate a detailed text-to-image prompt based on what it understood.

• Copy that prompt.

• Open ChatGPT in a new tab.

• Paste the prompt into ChatGPT’s image generator.

• Wait for the result.

• Hate it.

• Tweak the prompt. Regenerate. Still not right.

• Adjust again. Maybe three, four, five rounds until I get something that actually captures what the post is about.

• Download the image. Drag it into my project folder. Move on.

That was the process for one thumbnail. Multiply that by weekly posts, and you start to feel the weight of it.

Then Google released Nano Banana 2 last month.

If you haven’t seen what this model can do — it’s built on Gemini 3.1 Flash and it’s a genuine leap. 4K resolution. Text rendering that actually works across multiple languages. Subject consistency that can maintain up to 5 characters and 14 objects across images. And it’s fast — Pro-level quality at Flash speed.

You might want to check out some use cases along with prompts created by Justine Moore 👇

The image quality was so good that I started doing something new: creating infographics for specific sections within my newsletters. If you’ve read my recent posts (including this one), you’ve probably noticed those visual breakdowns that explain key concepts, frameworks, or workflows. They help readers understand complex ideas faster than text alone.

But even with better image quality, the workflow was still the same.

I was still analyzing my newsletter in Claude, generating prompts in Claude, then copying those prompts into Nano Banana 2 to actually create the images. For thumbnails. For every infographic. The same copy-paste loop, just with a different tool on the receiving end.

The thinking happened in one place. The creation happened in another. And the gap between them kept killing my momentum.

Then I connected Nano Banana directly to Claude using MCP:

1. Now when I finish writing a newsletter post, I share the draft with Claude and say: “Generate a thumbnail for this post.” Claude already understands the content — the themes, the hook, the emotional tone — because it just helped me write it. It crafts the perfect prompt and generates the image right there. No tab-switching. No copy-pasting. No five rounds of “not quite right.”

2. Same thing for section infographics. I highlight a paragraph and tell Claude: “Turn this into a visual breakdown.” It reads the context, understands what needs to be communicated visually, and generates the infographic using Nano Banana Pro — all without me leaving the conversation.

What used to take 20-30 minutes of back-and-forth across multiple tools now happens in the same space where I’m already writing.

This works in Claude Desktop, Claude Code, and Claude Cowork. Anywhere you can connect an MCP server, you can give Claude the ability to generate and edit images on command.

If you followed my NotebookLM + Claude MCP guide — where we connected Claude to Google’s research tool and turned it into a research partner — this is the same idea, different superpower. That guide gave Claude the ability to think with your sources. This one gives Claude the ability to see what you’re writing and create visuals that match.

In this guide, I’ll show you exactly how to set this up, the custom instructions that make Claude generate better images, and three use cases that changed how I create visual content for my newsletter.

Let’s build it.

Subscribe now

What the Nano Banana + Claude Integration Unlocks

Before we get into the setup, let me show you what’s actually possible once these two are connected.

Everything you can do with Nano Banana’s image generation — you can now trigger directly from Claude.

Inside a single Claude conversation, you can tell it to:

• Generate images from scratch — thumbnails, social headers, blog visuals, concept art. Describe what you want in plain language and Claude handles the prompt engineering for you.

• Edit existing images — hand Claude a photo and say “change the background to a coffee shop” or “make this darker and more moody.” It understands context and makes targeted edits.

• Add text overlays that actually work — this is where most image models fall apart. Nano Banana handles text rendering cleanly, including multiple languages and proper positioning.

• Generate at any size and aspect ratio — 1:1 for social posts, 16:9 for newsletter headers, 9:16 for stories, 4K resolution when you need production-ready output.

• Batch-generate multiple images — up to 4 images per request, with consistent style across the set.

• Maintain subject consistency — Nano Banana 2 can keep up to 5 characters and 14 objects consistent across multiple generations. Huge for branded content series.

But here’s what makes this actually powerful:

You’re combining Nano Banana’s image capabilities with Claude’s understanding of your content.

Claude doesn’t just generate a generic image from a prompt. It reads your newsletter draft, understands the themes, and creates visuals that match what you’re actually trying to communicate. It can look at a framework you’ve written and turn it into an infographic. It can read your carousel outline and generate slide visuals that follow the narrative.

The image intelligence of Nano Banana meets the content intelligence of Claude.

That’s the unlock.

What It Costs

I want to be upfront: image generation through the Gemini API requires a paid tier. The free Gemini API key gives you access to text models, but image generation is pay-as-you-go only.

The good news — it’s cheap. NB2 (the default) runs about $0.04–$0.05 per image at standard resolution, scaling up to ~$0.15 per image at 4K. Pro costs roughly $0.13 per image at 2K and $0.24 at 4K.

In practice, generating all the visuals for one newsletter — a thumbnail plus 2-3 infographics — costs me less than a dollar. You’ll need to add billing to your Google AI Studio account, but there’s no monthly minimum or subscription required. You only pay for what you generate. We’ll get to this setup process later.

What You’ll Learn in This Guide

By the end of this post, you’ll have:

1. Complete technical setup (10 minutes): Nano Banana MCP server installed and connected to Claude Code, Claude Desktop, or Claude Cowork.

2. Use Case #1 — Newsletter Thumbnail Generation: How I use my existing Claude project knowledge to craft the perfect text-to-image prompt, then generate the thumbnail without ever leaving the conversation.

3. Use Case #2 — Spreadsheet-Driven Bulk Image Generation: How to use a simple CSV file inside Claude Cowork to batch-generate 10+ images at once — each with its own platform, aspect ratio, style, and color palette. Includes a downloadable template you can customize.

4. Use Case #3 — A Visual Intelligence Skill: A downloadable Claude Skill that analyzes your content, selects the right visual archetype (timeline, comparison, pyramid, iceberg, and 8 more), maps visual metaphors, and engineers the prompt — all before generating. Includes 20+ styles, structured prompt templates, and iterative refinement logic.

These cases will help you master the end-to-end image generation workflow using Claude, so you can create any images you want.

Now, it’s time to dive in.

How to Set Up Nano Banana MCP with Claude

Same as my previous NotebookLM + Claude integration guide, this requires using the terminal. And if this is your first time, the whole thing takes about 10 minutes.

Read more

I used to start every Monday morning the same way.

Open Notion to check my quarterly roadmap. Switch to Todoist to review my weekly tasks. Open a Google Sheet to see how my revenue numbers tracked against my annual goals. Pull up my content calendar to check what’s publishing this week. Then try to hold all of that in my head while deciding what actually deserves my best hours today.

By the time I finished checking everything, 45 minutes were gone. And here’s the part that frustrated me the most — I still didn’t have clarity. I had information. Tabs full of it. But clarity about what actually matters this week? That required me to mentally cross-reference everything I just looked at and make a judgment call while my coffee was getting cold.

I was spending more time following my plan than executing my plan. And over time, something subtle happened — I started confusing checking my system with making progress:

• Dragging a task card across a Notion board felt productive.

• Color-coding priority labels felt productive.

• Watching a satisfying animation when I checked something off felt productive.

These tools are designed to make organizing feel like doing. The appealing UX — the buttons, the colors, the smooth transitions — rewards you for managing work, not finishing it.

But at the end of the week, when I looked at what actually moved forward... the answer was uncomfortable.

Organized, but not effective. Informed, but not clear.

So I started questioning the whole setup. Not which app to switch to — whether the multi-app approach itself was the problem. Whether the clicking, the tab-switching, the manual cross-referencing was a tax I’d been paying so long I stopped noticing it.

When I started moving everything into Obsidian and connecting it to Claude Code, I wrote about this frustration in my notes. The response made it clear this wasn’t just my problem:

The engagement was wild 🔥 — people wanted to know exactly how it works. What the setup looks like. What Claude actually does inside the vault.

About a month ago, this tweet also proved my frustration — saying his choice to stick with Obsidian “has gotten vindicated” in the Claude Code era.

He was watching friends scramble to install MCPs for Notion, pay for Notion AI subscriptions, and build middleware just to get AI access to their notes. Meanwhile, Obsidian users just... pointed Claude at their folder.

A recent YouTube video by Greg Isenberg and InternetVin has gotten popular for this, in case you want to see how they use it.

The people who’ve made this switch keep saying the same thing: it’s the best decision they’ve made for their AI workflow. And the people who haven’t are asking how to start.

Look no further, this post is the answer.

I knew in my heart that a better task management app wasn’t going to cut it. That’s what I had been doing all this time. I realized that I needed to remove myself from the progress-tracking loop entirely.

I moved everything into one Obsidian vault — goals, roadmaps, sprints, weekly plans, daily logs — all as plain markdown files. Then I connected Claude Code to it. Not as a chatbot I talk to about productivity. As a copilot that lives inside my files and already understands the full picture.

Now when I start my week, I don’t click through four apps. I ask one question:

“What should I focus on this week?”

And Claude already knows. It reads my quarterly goals, checks my sprint progress, looks at what I actually did last week versus what I planned, and surfaces the priorities that connect to real outcomes — in seconds.

That’s not a second brain. A second brain stores what you know. This is closer to a copilot that tells you what you’re avoiding.

The rest of this post is exactly how I built it — the folder structure, the memory system, the five commands that run my week, and how you can set up your own version.

Before we dive in, let me explain why I turned to Obsidian and left Notion.

Why Obsidian (And Not Notion)

Notion stores your data in a proprietary cloud database. Nothing exists as files on your computer. If you want an AI tool to read your Notion workspace, you need API keys, database queries, and middleware to translate between Notion’s format and something the AI can parse. Every time you want Claude to check your quarterly goals against your weekly plan, that request travels through an API, hits Notion’s servers, and comes back translated.

Obsidian is the opposite. Everything is a plain markdown file in a folder on your computer. Claude Code reads and writes files directly — no API, no middleware. I point it at my vault folder and it sees everything I see.

More importantly, it’s not just about access, it’s also about format. Markdown is the native language of LLMs. It’s the format they were trained on. When Claude reads a markdown file, there’s no translation layer. Headings, bullet points, wiki-links, plain text — it understands the structure the way you wrote it. When it reads from Notion’s API, it’s parsing JSON objects and database schemas. That’s overhead between the AI and your thinking.

That’s why the AI community has been gravitating toward Obsidian: your notes are already in the language AI speaks.

But the difference that actually matters for this system is the knowledge graph.

Obsidian has a Graph View that visualizes every connection between your files as a live network. When you link one note to another with [[double brackets]], that link goes both ways automatically. The sprint file knows which weekly plans reference it. The quarterly goals file knows which roadmaps point to it.

Notion doesn’t have this. No graph, no automatic backlinks. Notion is hierarchical — pages inside pages inside databases. Obsidian is a network — everything connected to everything through explicit links.

When Claude reads my vault, instead of navigating a hierarchy, it’s traversing a network. It can start at my weekly plan, follow a link to a sprint, follow another to the quarterly goal, and trace all the way to my annual targets — in one read. The graph structure lets Claude see relationships that would take me five clicks to piece together in Notion. And the speed is second to none.

Subscribe now

What’s Inside This Post

This guide is the complete blueprint for building the Obsidian system I just described. Not the theory — the exact folder structure, the memory files, the commands, and the step-by-step setup process.

Here’s what you’ll walk away with:

1. The Folder Structure — My modified PARA system with six folders that connect daily tasks to annual goals through explicit wiki-links. I’ll show you every folder, what goes inside, and how the “strategic cascade” works — the chain from your 3-year vision all the way down to today’s task list.

2. The Memory Layer — Three files that give Claude persistent awareness across sessions: CLAUDE.md (the operating manual that teaches Claude your system), VAULT-INDEX.md (the live dashboard Claude reads first every session), and the SessionStart hook that loads your full vault structure automatically.

3. The Five Commands That Run My Week — The exact slash commands I use: /plan-week, /daily-prep, /process-inbox, /end-day, and `/review-week. Each one with the full step-by-step logic Claude follows — what it reads, what it checks, and what it outputs.

4. 7 Moments Where the Copilot Was Smarter Than Me — Real examples from the last two weeks where Claude caught patterns I missed, flagged blockers I forgot about, and pushed back on my priorities when I was avoiding the hard work.

5. The Complete Starter Kit + Setup Guide — A downloadable starter kit with the entire system pre-built: folder structure, slash commands, templates, memory layer, hooks — plus a three-phase guide to customize it for your projects, your goals, and your schedule. One Sunday afternoon to set up. After that, the system runs itself.

By the end of this post, you’ll have the exact system I use to run my week — from Sunday planning to Friday review — without opening a single project management app.

🚨Before we go further: This system runs on Claude Code — Anthropic’s AI tool that works directly with files on your computer. If you’re not familiar with it yet, I’d recommend reading my beginner’s guide to Claude Code first for the basics, or my ultimate guide to Claude Code if you want the full picture of what it can do. You don’t need to be a developer to use it — but you do need to be comfortable with a terminal.

The daily workflow looks like this: Obsidian open on one side of your screen for viewing and editing your notes, Claude Code running in the terminal on the other side. You type commands, Claude reads and writes your files, and you see the results update in Obsidian in real time.

If working in a terminal isn’t your thing, there’s an alternative — you can use the Claude Code extension inside VS Code or Cursor instead. Same functionality, but inside an IDE with a more familiar interface. Either way works.

Let’s dive in 🔥

The Folder Structure

I use a modified version of Tiago Forte’s PARA method. If you’re not familiar, PARA stands for Projects, Areas, Resources, Archives — a way to organize information by actionability rather than topic. I adapted it to match how I actually work.

Here’s my full structure:

Read more

I’ve been using Claude for almost two years.

I started because it was the best AI for writing. Clean, coherent, didn’t sound like a robot trying to convince you it understood feelings.

Then something shifted.

Claude got really good at coding. Not just “here’s a code snippet” good—but “I can build your entire system” good. That’s when Claude Code emerged, and I went all in.

I built my entire newsletter infrastructure inside Claude Code. Every workflow, every automation, every piece of content architecture you’re reading right now—Claude Code understands it, executes it, improves it. It’s no longer my assistant; it’s becoming a coworker that lives in my terminal.

But I keep running into this problem:

When I tell people about Claude Code, I see the same reaction. Interest, then hesitation, then: “I’m not touching a terminal.”

Look, I get it. Claude Code is powerful, but it requires us to be more comfortable using command-line interfaces (CLI), file paths, git operations. For developers and people who already live in terminals, it’s perfect. For everyone else who just want AI to do the work—it’s a barrier they’ll never cross.

Here’s what I’m realizing with Claude Cowork:

✅ Anthropic just removed that barrier.

Claude Cowork is what I’d call “Claude Code without the terminal”—it keeps the same agentic execution model (the thing that makes Claude Code so powerful), but wraps it in a GUI (Graphical User Interface) that anyone can use.

Before you assume this is a dumbed-down version, it’s not. It’s actually the same autonomous, multi-step task execution—just accessible.

If you find it hard to differentiate between the regular Claude website, Cowork, and Code, this post is for you.

After spending the last few weeks using Cowork, I can now see clearly how these three major Anthropic products fit together:

• The Claude website is for conversation and iteration

• Claude Code is for developers and terminal-comfortable builders

• Claude Co-work is for everyone else who wants autonomous AI execution without the technical barrier

Let me show you exactly how these three tools differ, then we’ll go deep on the Cowork workflows that are actually working for you.

Claude Website vs Cowork vs Code: When to Use What

As a long-time Claude and TUI‑pilled user, I’ve been using all three tools—and here’s what I’ve learned about when each one actually fits:

Claude Website: The Conversation Partner

What it’s built for: Iterating on ideas, drafting content, refining thinking

How it works: You upload files (max 30MB), have a conversation, copy-paste outputs back into your work

When I use it:

• Drafting newsletter content and getting feedback on structure

• Brainstorming content angles with rapid back-and-forth

• Quick edits and rewrites when I need conversational iteration

• Prompt engineering and testing new ideas

What it can’t do:

• Touch files on your computer directly

• Execute multi-step workflows autonomously

• Generate finished files (.xlsx, .pptx, .docx) in your local folders

• Run tasks in parallel with sub-agents while you walk away

The limitation: You’re always in the loop. Every action requires your next prompt. It’s collaborative, not autonomous.

Claude Code: The OG of Agentic AI

What it’s built for: Autonomous execution—building software, automating workflows, managing complex systems

How it works: Lives in your terminal, has deep access to your files and system, executes multi-step plans autonomously

This is where agentic AI started. Code has had all the agentic features from the beginning:

• Direct file system access

• Multi-step autonomous execution with visible todo lists

• Custom instructions via claude.md files

• Parallel sub-agent coordination

• Context management and memory systems

When I use it:

• Building my entire newsletter infrastructure (workflows, automations, content systems)

• Creating custom Skills that I deploy elsewhere

• Debugging when something breaks in my technical setup

• Any task that requires actual software engineering like building apps

The limitation: The terminal barrier. If you’re not comfortable with command-line interfaces, file paths, and git operations, you won’t cross that threshold. The power is complete, but the interface filters out 90% of potential users.

Claude Cowork: The Same Engine, Accessible Interface

Here’s what Cowork actually is: It’s Claude Code’s agentic architecture wrapped in a GUI (Graphical User Interface).

Built on top of the same foundation, but different access point.

To put it simply, Cowork is the manifestation of Claude Code but for everyone else, which aligns with their slogan. Cowork has the same features as Code but without the complexity of having to go through the terminal:

• Autonomous multi-step execution

• Direct file access (you need to upload files, whereas Code lives inside them)

• Visible todo lists (this is how agentic AI shows its multi-step planning)

• Custom claude.md instructions

• Sub-agents

When I use it:

• Organizing hundreds of messy files by actual content (not just filename)

• Research synthesis from 50+ sources simultaneously

• Building finished deliverables (Excel with formulas, branded PowerPoints, formatted docs)

• Any agentic task I need but don’t want to do in terminal

The limitation: High usage quota consumption (unless you only use it for chat). And it’s slower than Claude Code.

Subscribe now

What Cowork Actually Adds: Accessibility Features

Before we get into workflows, let me be clear about what Cowork brings to the table. These aren’t new capabilities—they’re the same agentic features Code has always had, just accessible without the terminal.

It’s hard for me to say this. As much as I love Cowork, I still find myself coming back to Code. If you’re already using Claude Code, Cowork doesn’t fundamentally change your workflow; it just gives you a GUI option when you don’t want to work in the terminal. And Code is way faster than Cowork—that’s something I couldn’t easily ignore.

But if you’re coming from Claude Website, these features represent a complete transformation in how you work with AI:

1. Claude.md Files in Working Folders (Custom Project Instructions)

Code had this first. Cowork just makes it easier to set up.

claude.md is the brain of your folder. I covered claude.md in more depth in my Claude Code Guide.

Here’s how it works in Cowork: when you upload a folder into your Cowork task, you can create or adjust a claude.md file inside that folder. Claude reads it and follows those instructions for every task it runs inside that project.

Drop in your custom rules—brand voice, formatting standards, synthesis methodology, output structure—and Claude operates by them every time.

This was initially folder-level only in Cowork, meaning you’d need a separate claude.md for each project. But Felix Rieseberg (Cowork’s product owner at Anthropic) just shipped a significant update: you can now set a global claude.md that applies across your entire Cowork workspace. One set of instructions that travels with you into every task you run.

That’s a meaningful quality-of-life upgrade. Your writing voice, your formatting preferences, your workflow rules—set once, applied everywhere.

Code users: You already know this. Same pattern, different interface.

Website users: This is persistent context you’ve been missing. No more re-explaining yourself at the start of every conversation. To set up claude.md in a working folder, you can edit yourself or simply ask Claude to read all the files in the folder and write its own instructions.

2. Visible Todo List (Multi-Step Execution Tracking)

Code’s signature feature. Cowork inherited it.

Give Claude a complex task and it doesn’t just start executing—it shows you the plan first. A visible todo list with every step it intends to take. You can review before it starts. Each step gets checked off as it completes.

This is what transparent autonomous execution looks like. Instead of watching a loading spinner and hoping for the best, you see the reasoning, the sequence, the progress.

Code users: Same transparent execution you’re used to. Different visual treatment.

Website users: This is what autonomous AI looks like—visible, trackable, correctable. The difference between delegating to someone you trust and hoping someone doesn’t misunderstand you.

3. Claude in Chrome (Direct Browser Integration)

New integration point, same automation capability.

Cowork has direct integration with Claude in Chrome—Anthropic’s browser automation tool. When you ask Claude to navigate the web, it automatically triggers Claude in Chrome to control your browser.

Practical examples:

• “Go through my Gmail, find newsletters I haven’t opened in 3 months, unsubscribe from all of them”

• “Pull the pricing page from these 5 competitor sites and compile into a comparison doc”

• “Fill out this form using the data in my spreadsheet”

Code users: You can do this directly from your terminal. This is the GUI equivalent.

Website users: This is browser control that you can trigger without opening Claude in Chrome via the extension. Simply ask Cowork to do it for you.

Fair warning: It’s slow. Every action runs on a screenshot → decision → next action loop. For quick tasks, manual is faster. But for tedious, repetitive web work you’ve been putting off? It works.

4. Parallel Sub-agents

This is where Cowork stops feeling like a single AI and starts feeling like a team.

When you give Cowork a complex research or execution task, it doesn’t work through it sequentially—it spins up multiple sub-agents to run independent workstreams simultaneously.

For example: say you ask Cowork to build a competitive landscape report on 8 companies. Instead of researching one company at a time, it launches 8 parallel agents, each analyzing a different company, then synthesizes the findings into one report. What would take hours of sequential research collapses into minutes.

The same pattern applies to content production, data analysis, document processing—anything where the subtasks don’t depend on each other can run in parallel.

Code users: You know this capability. Cowork surfaces it without needing to architect the parallelism yourself.

Website users: This is the biggest hidden upgrade. You’ve been working in single-file mode. Cowork runs multi-threaded.

Fair warning: Sub-agents currently work best in Opus 4.6, and they can consume a lot of tokens.

5. File Outputs (Powerpoint, Excel, Word, HTML, etc)

This closes the loop that Claude Website never could.

When you work in Claude Website, outputs are text in a chat window. You copy, paste, format, export manually. The AI does the thinking, you do the finishing work.

Cowork outputs directly to your local file system—finished, formatted, ready to use.

Specifically:

• Excel with working formulas and summary charts

• PowerPoint with proper layouts and slide structure

• Word documents with formatted sections

• HTML dashboards for data visualization

• CSVs with cleaned, structured data

The workflow looks like this: drop a folder of receipts, invoices, or raw exports into your Cowork folder, describe the output you need, and Claude writes the files directly to your local directory. You open your folder and the finished deliverable is there.

No copy-pasting. No reformatting. No manual export.

Code users: You’ve been generating outputs through scripts and commands. Cowork does this through natural language and GUI.

Website users: This is the biggest practical difference you’ll feel on day one. You stop producing drafts and start receiving deliverables.

The honest summary

If you’re a Claude Code user, Cowork is a convenience layer. Same capabilities, GUI interface. Use it when you don’t want terminal overhead.

If you’re a Claude Website user, Cowork is a fundamental upgrade. You’re moving from conversational AI to agentic AI. That’s the transformation.

The features themselves aren’t revolutionary—they’ve existed in Code since launch.

What’s revolutionary is accessibility. Anthropic just removed the terminal barrier and gave agentic AI to everyone.

Now let’s talk about how to actually use this.

Subscribe now

7 Advanced Workflows to Unlock Cowork’s Full Potential

I’ll walk you through each of these workflows so you can see what Cowork is actually capable of at full power.

I won’t talk about how you can clean your desktop screenshot files or export your financial statements to Excel — I’m sure you can figure that out yourself. Instead, I want to focus on end-to-end autonomous work that helps you in your job and that you can apply to your own case, because the possibilities now are endless.

🚨 But fair warning before we go any further: what you’re about to read is one of those mega-workflow territories that will cost you significant tokens. My Newsletter DNA Extraction workflow alone can push you to the limit of a current session on the Pro plan.

So if you want to run these without hitting walls—Max plan and Opus 4.6 are the only real recommendation here. I’ve tested with Sonnet 4.5 in thinking mode. It handles parts of it, but hits consistent failures when generating the HTML dashboard or building out the PowerPoint deck. Opus just executes. Cleanly, completely, first try.

But I want to add something too: Sonnet 4.6, which was recently launched, has made a huge improvement here, so this post comes at the perfect time!

Here’s what we’re building.

1. Landing Page Competitive Audit (Model: Opus 4.6)

Point Cowork at your service page and 5-10 competitors at once. Claude reads each site the way a potential customer would—analyzing brand positioning, offer structure, hero copy, social proof, and conversion strategy. Then it compiles a full Word document report comparing where you’re strong, where you’re getting outpositioned, and what specific changes would move the needle.

2. Interactive Performance Storyboard (Model: Opus 4.6)

This workflow transforms your raw data into something you can actually use. Feed Cowork your post analytics, subscriber growth data, reader survey responses, and audience feedback. Claude analyzes it all together—not separately—and builds a story-driven interactive dashboard that shows you not just what happened, but why, and what it means for what you should build next.

3. Your Personal Daily Operating System (Model: Sonnet 4.6)

This one changes how you start every day. Using a custom claude.md file, you configure Cowork with everything it needs to know about your life and work—your active projects, your goals, your priorities, your context. Then each morning, you type one phrase and Claude does the rest: reviews what’s in progress, surfaces what needs attention, drafts your task list, and starts executing the work it can handle autonomously.

4. AI-Powered Content Flywheel (Model: Sonnet 4.6)

Most content creators operate with no memory. Every new piece of content gets created in isolation—same angles, same blind spots, repeated. This workflow fixes that. You feed Cowork your entire content archive: newsletter posts, Substack notes, LinkedIn posts, brain dumps. Claude indexes everything, identifies what you’ve covered, spots the genuine gaps, generates new content directions grounded in what your audience has actually responded to, and stores it all in a persistent memory system so it gets smarter over time.

5. SEO Content Strategy Engine (Model: Opus 4.6)

Run a comprehensive SEO audit across 10+ of your published posts simultaneously. Not only Claude scores your existing content, it also runs live competitor research using Brave Search and Firecrawl MCP, identifies keyword gaps, and suggests specific improvements for each post. The output is an interactive dashboard that visualizes your current SEO health and maps out exactly what to fix first.

6. Newsletter DNA Extraction (Model: Opus 4.6)

This workflow turns your entire Substack archive into a living brand document. Claude in Chrome reads through your published posts, Firecrawl MCP scrapes and structures the content, and Opus synthesizes your voice patterns, recurring themes, what topics perform, what falls flat, and where your growth opportunities are—presented as a complete brand DNA report.

7. Product Idea Validation Framework (Model: Opus 4.6)

Before you write a line of code, run this. Describe your product concept, point Cowork at 3-5 competitors, and it researches the entire landscape in parallel—positioning, pricing, features, customer gaps. Then it does something most founders skip: gives you an honest go/no-go verdict before writing anything. If the idea needs pivoting, it says so. If it passes, you get three files saved to your folder: market research report, full PRD, and a Claude Code starter prompt ready to paste and build from.

That’s the map.

The rest of this post walks through each workflow step-by-step—the exact setup, the prompts that work, the folder structures, the MCP configurations, the result, and what to do when something breaks.

Whenever you are ready, off we go 🚀

1. Landing Page Competitive Audit

Most people do competitor research the wrong way. They visit a few sites, take mental notes, and come away with a vague sense of “they look more professional” or “their copy is cleaner.” Nothing actionable. Nothing specific enough to actually change anything.

This workflow changes that. You give Cowork your landing page up to 5-10 competitors. It navigates each one, takes screenshots, and runs a structured analysis across seven dimensions—hero section, messaging, social proof, branding, copywriting patterns, and more. Then it compiles everything into a professional Word document with a side-by-side comparison table, gap analysis, and prioritized recommendations.

Instead of getting vague summary at the end, you are getting a strategic brief that tells you exactly where you’re losing people and what to fix first.

What’s actually happening under the hood:

Cowork uses Claude in Chrome to navigate to each URL like a real user would—scrolling the page, reading the copy, capturing screenshots. It’s not scraping raw HTML. It’s reading the page the way a potential customer reads it, which means it catches things like emotional tone, visual hierarchy, and trust signals that a traditional scraper would miss.

After analyzing each page individually, it runs the comparative layer—stacking all competitors side by side and identifying the gaps between what they’re doing and what you’re doing.

Get the final 22-page document result here for my landing page analysis:

Download Landing Page Audit

The prompt:

Copy this exactly and replace the URLs with your own. Three competitors is enough. More is better, but it adds time and tokens.

Alternatively, you can store URLs in an Excel file within the project folder if you want to keep all related files organized in one place.

Read more

If there’s one AI tool I keep coming back to because it has such unique value for my research workflow, it’s NotebookLM. In fact, I’ve written about it twice, and both pieces are among my all-time favorite posts:

• NotebookLM Got Crazy Powerful: Here’s How I Used It to Learn Something Really Hard

• How I Learned Complex Topics 10x Faster with NotebookLM

Anyway, I spent 6 hours researching Claude Cowork last month to find use cases that would actually resonate with my audience.

20+ blog posts. 10+ YouTube tutorials. 10+ Reddit threads. And the rest comes from X. All loaded into NotebookLM because that’s where I do deep research—20+ million token context window, 50 sources, custom outputs ranging from briefing docs to presentation deck.

Then I hit the same wall I always hit:

All this research lived in NotebookLM. My actual work happened in Claude. And the gap between them killed my momentum.

Here's what the back-and-forth actually looked like:

• Run deep research in NotebookLM

• Type multiple queries to extract insights

• Switch to Claude to start writing

• Realize I need to verify something from source #23

• Switch back to NotebookLM

• Search through sources

• Copy the relevant section

• Paste into Claude

• Lose my train of thought

• Start over

The back-and-forth wasn’t just annoying, it was also ruining my focus.

I kept telling myself: “There has to be a better way to connect these two tools.”

Turns out there is.

I connected NotebookLM directly to Claude Desktop (this also applies to Cowork) using MCP.

Now when I need to create a presentation deck about Cowork use cases, I don’t:

• Manually query NotebookLM 76 times trying to understand the research

• Finally tell NotebookLM “create a presentation” and get a generic deck

• Realize the slides don’t reflect the insights I actually need

• Start over with better prompts

Instead, I tell Claude:

“I need a presentation deck about Cowork use cases for creators. Research all 50 sources in my NotebookLM and create a deck that matches my audience needs.”

Claude autonomously queries my entire NotebookLM research library—running multiple sequential searches to deeply understand the material. Then it crafts a context-aware prompt based on everything it learned, and triggers NotebookLM to generate a presentation deck grounded in actual insights, not generic summaries.

I don’t manually prompt to learn from sources. I don’t write slide prompts hoping they’ll capture the right insights. Yet, I get a deck that reflects what actually matters from the research.

Now I can automate my research process, understand it deeply, and turn it into something valuable in a single deck — all in one space.

This has been my favorite duo combo over the past month 🔥

It’s such a liberating feeling, since I can now do more inside Claude as my primary agentic workspace.

Subscribe now

What the NotebookLM + Claude Integration Unlocks

Everything you can do in NotebookLM—you can now trigger directly from Claude.

You’re no longer have to switch tabs. You don’t need to copy context anymore. You keep the momentum going.

Inside a single Claude conversation, you can tell it to:

• Generate Audio Overviews (podcasts) from your research notebooks

• Create Video Overviews synthesizing your sources

• Build Mind Maps visualizing connections across your knowledge base

• Generate Reports pulling insights from multiple notebooks

• Create Flashcards for studying frameworks you’ve researched

• Design Quizzes testing your understanding of the material

• Build Infographics visualizing data from your sources

• Generate Slide Decks presenting your research findings

• Create Data Tables organizing information systematically

All nine NotebookLM studio features—now accessible without leaving your Claude workspace.

But here’s what makes this actually transformative:

You can actually combine NotebookLM’s research intelligence with Claude’s unlimited creation capabilities.

That same research sitting in your NotebookLM notebooks? You can now:

• Build custom slides branded to your style from NotebookLM research

• Generate interactive dashboards from your data sources

• Create working apps based on user research insights

• Design visualizations tailored to your exact specifications

• Develop Claude Skills from frameworks you’ve studied

Everything Claude can build—now grounded in your NotebookLM knowledge base.

The research depth of NotebookLM meets the creation flexibility of Claude.

That’s the unlock.

What You’ll Learn in This Guide

By the end of this post, you’ll have:

• Complete technical setup (10-15 minutes): NotebookLM MCP server installed, authenticated, and connected to Claude Code and Desktop

• Custom instruction integration: NotebookLM’s query types (briefing docs, study guides, podcasts, etc.) accessible directly from Claude Project Knowledge

• Use Case #1 - Autonomous Research Synthesis: How to tell Claude your research goal and let it query NotebookLM sources while you work on something else (the Co-work research workflow that changed how I prepare newsletter content)

• Use Case #2 – Building Claude Skills from Research Queries to Presentation Deck: Transform frameworks you’ve studied in NotebookLM into custom Claude Skills that run research queries and turn that content into a context-aware presentation deck

• Advanced patterns: Cross-notebook synthesis, parallel research mode, integration with Claude Projects for ongoing work

Let’s build it!

How to Set Up NotebookLM MCP Integration with Claude Desktop

Look, I’m not going to lie—this requires using the terminal. But I’m also not technical, and I got this working in about 15 minutes. Trust me, it’s easier than you might think right now.

There are four different ways to install this thing. I’m going to show you the one that actually works and skip the alternatives that’ll just confuse you.

This process is also 10x easier if you ask Claude Code to do it. If you’ve tried it on my previous post, then this is the right time to test drive installing something technical.

Let’s get started by following this process so you can understand the details for troubleshooting later.

Step 1: Install the NotebookLM MCP Tool

Read more

I know how overwhelming it is to keep up with AI news. New tools drop almost every week. Each one demands time and focused effort just to understand what it does. Yet, most of them aren’t worth your limited attention.

You’ve got maybe 16 waking hours in a day.

Spending half of those testing every shiny new AI tool is a losing game.

After playing around with 100+ AI tools, one thing I realized: you don’t need more AI tools. Instead, what you need is a better tool that can cover a lot of things in your workflow.

So, if I had to point to one AI tool that’s given me the highest ROI on both productive hours AND understanding what AI can actually do—it’s Claude Code.

I’ve been using it for six months now. I spoked about it on my previous post. It keeps getting better and better every day.

It took me awhile to realize that I barely use Claude’s web version anymore.

Like most people, I used to spend 100% of my Claude usage was on Claude.ai.

Today? I’m fully Claude Code–pilled 80–90% of the time. The web version is now my backup, only when I need something quick and don’t want to open my project workspace.

That shift didn’t happen in an instant or because I’m technical—trust me, I’m not. It happened because Claude Code is such a powerful agentic tool that it can do something the web version fundamentally can’t:

It’s agentic. FAST. And it doesn’t forget.

All of my newsletter work lives inside Claude Code. It knows my audience. It knows which posts performed well and why. It knows my other projects, my priorities, my voice, how I write. It remembers what worked last week when I’m planning this week.

Here’s how my current folder looks like:

And here’s what it actually does for me:

• Writes and edits my newsletter drafts

• Analyzes performance data from 30+ published posts

• Researches topics using integrated tools like Perplexity

• Generates social content from newsletter posts (LinkedIn, Twitter threads, Substack Notes)

• Manages my projects on Notion with instant context switching

• Processes files (PDFs, spreadsheets, presentations) without needing separate tools

• Runs autonomous agents that synthesize my week every Friday

• Handles coding tasks when I need custom tools or automations

One workspace. Multiple capabilities. Persistent memory.

Most AI tools are one-night stands.

You get something useful, then never touch them again because you’re just curious and it doesn’t suit how you work—or it’s just tackling a small part of your workflow.

Claude Code is different.

It’s like working with someone who’s been on my team the whole time—someone who can write, research, analyze, code, and remember every project we’ve worked on together.

But I know some of you might have some concerns:

I hear you. Using the terminal can feel intimidating if you’re not a technical person.

But I wasn’t technical either when I started.

Believe me, Claude Code is easier to learn than you think. The more you use it, the easier it gets. And the benefits far outweigh the initial learning curve.

Plus, this guide gives you two ways to use Claude Code:

1. VSCode or Cursor extension - Visual interface, easier to digest for beginners (recommended starting point)

2. Terminal/CLI - More powerful once you’re comfortable, but not required to start

I know Claude Cowork just launched a few weeks ago. It’s more user-friendly since it can be accessed on Claude desktop app.

But, Cowork’s capabilities are still limited. It’s great for getting started, but it can’t do what Claude Code can do:

• No deep MCP integrations

• No file system access at the same level

• No persistent project context in the same way

And it still feels clunky and slow. If you want the full power, you need Claude Code. Period.

And this guide will make it as painless as possible. We’ll start with the VSCode/Cursor extension so you can ease into it without touching the terminal until you’re ready.

What You’re Actually Getting

Most Claude Code guides give you theory. This one gives you the working system.

I spent six months building my Claude Code workflow from scratch. Made every mistake. Hit every dead end. Rebuilt it three times before it stuck.

You’re getting the final version—the one that actually works.

The Starter Template

A cloneable repository with everything pre-configured. Clone it, run one command, and you have a working AI operating system. No guessing what to build first. No figuring out file structure. No wondering if you’re doing it right.

The Three Core Components

• CLAUDE.md that teaches Claude how you work (so you stop re-explaining context)

• Three daily-use commands I can’t live without (daily planning, research synthesis, project switching)

• One autonomous agent that runs in the background while you work

The Customization Playbook

How to adapt this template for your workflow. When to add features. When to keep it simple. How to write your own commands. How to build agents that do the work for you while you’re busy with something else. How to install your Skills through plugins and marketplaces.

The Complete Reference

Every shortcut you need to master Claude Code, think and plan mode, Skills & Plugins, and MCP integration in one place. Bookmark it because you’ll use it constantly.

You can clone this and have a working system in 5 minutes. Then customize it as you discover what your workflow actually needs.

That’s what this template does. It starts simple, covers your actual needs, and grows with you.

What Claude Code Can Do

Before we dive in, here’s what Claude Code handles that you might not know.

Built-in Capabilities:

• Reads PDFs, Docs, CSVs/XLSX, and PowerPoint files natively

• Manages (create, delete, update, move, copy, etc) computer files

• Executes code in multiple programming languages

• Integrates with multiple tools via MCP: Perplexity, Firecrawl, Notion, Obsidian, Apple Notes, etc

• Remembers conversations across sessions (memory system)

• Runs autonomous agents in the background

• Creates to-do list before taking actions

• Supports custom commands for your specific workflows

• Integrates Skills through plugins and run them for automated workflows

• Uses plan mode for more reliable and accurate outputs

Ready? Let’s dive in.

🚨 A quick note about something I built.

I just launched Newsletter Compass with because we got tired of juggling five different AI tools to write one newsletter. It’s the complete AI system for Substack creators - post titles generator & analyzer, content ideas, Notes, and welcome sequences all in one place. In your voice, not ChatGPT’s.

7-day free trial + 50% off for life with code WELCOME.

Try Newsletter Compass for FREE

Getting Started with Claude Code

Let’s get you set up. But if this is the first time you’re hearing about Claude Code, you might want to read my previous post first.

I’m going to walk you through two installation options: VSCode/Cursor extension (easier, visual interface) and the terminal/CLI (more powerful, but optional for now).

If you’re not technical, start with VSCode or Cursor—we’ll use the extension for this walkthrough. You can always move to the terminal later when you’re comfortable.

Option 1: VSCode/Cursor Extension (Recommended for Beginners)

What you’ll need:

• VSCode or Cursor installed on your computer. I suggest to use Cursor since it offers more AI-native experience than VSCode. Here’s where you can download VSCode and Cursor.

• An Anthropic Pro/Max account connected on your web browser.

Step 1: Install the Claude Code Extension

Firs thing, Open Cursor/VSCode.

Then, toggle on the left Primary Side bar (or press `Cmd+Shift+X` on Mac, `Ctrl+Shift+X` on Windows).

Click the “Extension” menu. Search for “Claude Code for VS Code” and Click Install.

Step 2: Connect your Anthropic account

After installation, you’ll see a prompt to configure Claude Code.

Choose “Claude.ai Subscription” as the login method unless you use an API.

Connect it and you are ready to use it.

Step 3: Verify It’s Working

Open the Claude Code chat interface:

1. Go to Settings on top right of the Cursor screen

2. Click the “three dots”

3. And Click “Claude Code: Open”

Type a simple test message: “Are you Claude?”

If Claude responds with a “yes,” then you’re good to go.

Option 2: Terminal/CLI (For Later)

The terminal version is more powerful and gives you access to the full feature set. But you don’t need it to start. The Cursor or VS Code extension is enough to run Claude Code.

Yet nothing’s wrong if you want to install it on Terminal by typing this code:

npm install -g @anthropics/claude-code

Then activate Claude Code in your Terminal by typing:

claude

Then you need to login by typing this shortcut in your Claude Code chat:

/login

Then simply follow the instructions to connect your Anthropic subscription to Claude Code.

And it’s done!

In case you run into any issues, YouTube has plenty of resources on how to install it, this is one of them.

Open or Clone the Starter Repository

Now that Claude Code is installed, let’s get the starter template. To make things simple, in this scenario, we are going to use the Cursor extension instead of the terminal.

Open Cursor and select “Clone repo” to start cloning the folder we want to work on from Github. Additionally, you can also download the ZIP file here and open it with “Open project” menu on Cursor.

🚨 To get the template, skip to the Template section at the bottom of this post.

Then, we need to open Claude Code chat interface. Once done, now Claude Code has access to your project folder.

Here’s how it looks when you successfully open Claude Code:

The left side is where you can access your folders and files, the middle section is where you can chat with Claude Code and access your past conversations, and the top section shows your recent activity. Additionally, you can close the Cursor chat interface because we won’t be using Cursor; we use Claude Code instead.

To test if Claude can read your project folder, type a simple test message:

“Can you read this directory and tell me what files you see?”

Claude will read all files and send you a summary.

Since Claude can now read files, whenever you are working on something, simply refer to your files by using “@” to trigger file reference and use them as additional context for your work.

Understanding What You Just Cloned

Let’s take a quick tour of what’s in the repository. Don’t worry about memorizing this—just get familiar with the structure.

Main files you’ll interact with:

1. CLAUDE.md - This is the instruction manual for how Claude should work with you. It contains:

   1. Your project context

   2. Your preferences for how Claude communicates

   3. Your work patterns and decision-making style

   4. Anti-patterns (what NOT to do automatically)

2. .claude/commands/ - This folder contains three ready-to-use commands:

   1. daily-planning.md - Analyzes your calendar and generates focused daily priorities

   2. research-deep-dive.md - Comprehensive research synthesis

   3. project-status.md - Instant context switching between projects

3. .claude/agents/ - Contains one autonomous agent:

   1. weekly-synthesis - Runs every Friday (or on demand) to generate weekly accomplishments and blockers

4. templates/ - Template files you can copy and customize:

   1. daily-plan-template.md` - Format for daily planning output

   2. project-template.md` - Structure for project files

   3. command-template.md` - Starting point for creating your own commands

5. examples/ - Real outputs from actual usage:

   1. sample-daily-plan.md - What daily planning generates

   2. sample-research-output.md - What research synthesis looks like

   3. sample-project-status.md - Example project overview

   4. sample-weekly-synthesis.md - Weekly agent output

6. claude-code-cheat-sheet.md - Complete reference for all shortcuts, think modes, file capabilities, and MCP integrations

Look, you don’t need to read all of these files now. I’ll walk through the important ones later.

Your First Command: Daily Planning

Let’s run something immediately so you see this working get benefits out of it.

Simply type this in the chat:

/daily-planning

Claude will:

1. Ask you a few clarifying questions (How many priorities do you want? What’s most important today?)

2. Read your calendar if you’ve given it access

3. Generate a focused daily plan with 3 priorities

4. Save it to a file (if configured to do so)

Your first output might look like this:

# Daily Plan - January 26, 2026

ary 26, 2026

## Top 3 Priorities

1. **Finish Part 2 of Claude Code guide** (2 hours)

- Status: In progress, 60% complete

- Next: Write installation section

2. **Review newsletter analytics** (1 hour)

- Check open rates for last 3 posts

- Identify patterns for upcoming content

3. **Research MCP integrations** (1.5 hours)

- Test Perplexity setup

- Document installation process

## Calendar Overview

- 10am: Team standup (30min)

- 2pm: Deep work block (2hrs)

- 4pm: Weekly rev

What Just Happened?

You ran your first Claude Code command. Here’s what made it work:

1. The command file (.claude/commands/daily-planning.md) contains instructions for Claude

2. Your CLAUDE.md file provides context about how you work

3. Claude reads both, asks clarifying questions, and generates output based on your preferences

This is the pattern for all commands: instruction + context + execution.

And this is why Claude Code is so much more powerful than typical AI tools: it reads context before making decisions, follows instructions and other references, and then executes. It’s not guessing anymore; it’s creating deliberate, calculated reasoning.

What’s Next

You have:

✅ Claude Code installed (VSCode or Cursor)

✅ The starter repository cloned

✅ Your first command tested and working

✅ Basic understanding of the file structure

Now let’s understand what each component actually does.

Subscribe now

The Starter Template Breakdown

Now that you’ve got Claude Code running and you’ve tested your first command, let’s break down what you actually cloned.

I’m going to walk through the three core components of the starter template:

1. CLAUDE.md - The instruction manual that teaches Claude how you work

2. Commands - On-demand workflows you trigger when needed

3. Agents - Automated workflows that run in the background

For each component, you’ll see what it does, how it works, and how to customize it for your workflow.

Don’t just copy-paste this. Understand why each piece exists. Then make it yours.

CLAUDE.md Foundation

1. What CLAUDE.md Actually Does

Think of CLAUDE.md as Claude’s instruction manual for working with you.

Most AI tools start from zero every time you open them. You explain your context, your preferences, your project. Then you close it, come back tomorrow, and... you’re explaining it all over again.

CLAUDE.md solves this.

It’s a persistent memory file that sits in your project directory. Every time Claude Code starts working, it reads this file first. It learns:

• What you’re working on (project context)

• How you want Claude to communicate (voice and tone)

• Your work patterns and decision-making style (key preferences)

• What NOT to do automatically (anti-patterns)

This is transformative. Instead of generic AI assistance, you get collaboration that matches your thinking style.

2. Two Ways to Create Your CLAUDE.md

Option 1: Use the `/init` shortcut (fastest)

If you want Claude to build your CLAUDE.md automatically, just run:

/init

Claude will:

1. Read your project folder structure

2. Analyze the types of files you’re working with

3. Generate a custom CLAUDE.md tailored to your project

This is the fastest way to get started. Claude figures out what you’re doing and builds instructions accordingly.

But since it reads your project folder first, you need to ensure you’ve put all of your files, documentation, and any references you can think of inside that folder. Without this, using /init won’t make any difference.

For my newsletter operating system, I’ve put all of my post archives, audience research, post performance reports, LinkedIn and Substack notes, about page, why-upgrade page, etc., so when I run it, it can refer to these files to create a highly reliable and accurate CLAUDE.md file.

Option 2: Use the template (more control)

If you want to write your own CLAUDE.md from scratch (or customize what `/init` generated), use the template below.

I’m showing you the full structure with inline commentary so you understand what each section accomplishes.

Your CLAUDE.md Template:

Read more

In the previous post, I showed you how to build a personal AI agent that connects your email, calendar, and Notion tasks—an on-demand assistant that responds when you ask.

But that agent had a problem.

It was reactive. You still had to check your inbox and tell the agent what to do.

You were still the bottleneck.

Here’s what I actually needed: an agent that watches my inbox and processes emails automatically as they arrive.

Not one that sorts everything into folders (that’s how important emails get buried).

Not one that auto-replies without approval (that’s how you send something stupid).

But an agent that:

• Runs automatically when unread emails hit my inbox

• Analyzes each email (sender, subject, content)

• Applies my triage rules to categorize and label them

• Sends me a summary email with everything processed

This morning, I woke up to an email titled “Email Triage Summary” with:

• 3 emails labeled URGENT (meeting invites that need responses)

• 2 emails labeled NEWSLETTER IDEAS (reader questions worth exploring)

• 1 email labeled FOLLOW-UP REQUIRED (partnership inquiry)

• 4 emails archived (newsletters, notifications, low-priority updates)

I didn’t open Gmail once. The agent handled everything while I slept.

That’s the difference between an on-demand agent and a proactive agent.

The workflow is simple:

1. Gmail triggers the scenario when unread emails arrive

2. Make.com’s AI Agent processes each email against your triage rules

3. The agent categorizes, labels, and takes action (archive, flag, etc.)

4. You receive a summary email showing what happened

Same foundation as the last post. Same Make.com AI Agent module. Same Gmail integration.

The key difference? Instead of waiting for a Slack command, this runs on autopilot using Gmail’s “Watch New Emails” trigger.

I’m going to show you exactly how to build it.

By the end of this guide, you’ll have an email triage agent that processes your inbox automatically—one that applies your rules, takes action, and sends you clean summaries without you touching Gmail.

This is the system I wish I’d built years ago.

Let’s get into it.

Subscribe now

Before we begin, here’s what you’ll need:

• Make.com (AI automation platform)

• OpenAI API

• Gmail account

Here’s the additional cost details you need to consider:

• OpenAI API key ($5-10 in credits, can last 1-3 months)

• Make.com paid account (starts from $9/month)

Cost: ~$12-15/month on average (Compare to AI agent services charging $20-50/month)

References: Read my previous AI agent post to understand the basics so you can follow this process more easily.

Sign up Make.com

Building Email Triage AI Agent

To start this process, the first thing you need to do is configure your AI agent—beginning with the system prompt and tool access.

1. System prompt

Build your AI agent and use this system prompt as its brain:

Read more

If 2025 was the year AI agents arrived, 2026 is when agentic workflows finally become accessible to the rest of us—the non-technical AI users who don't spend their weekends debugging code.

Here’s why that shift matters.

I’ve been wrestling with a contradiction for months now: I know I should be writing about new AI tools. That’s part of my job. But every time I sit down to evaluate the latest product launch, three realities stop me cold:

1. The options are overwhelming. There are hundreds of AI tools promising to revolutionize your workflow, and most of them do essentially the same thing Claude or ChatGPT or Gemini already handle.

2. Most of these tools won’t exist in 1-2 years. I’m not interested in sharing you a platform that’s going to be dead soon.

3. Lastly—and this is the real killer—even when I find a tool that looks promising, the question that matters most is the hardest to answer: How does this actually fit into my workflow? Without a clear evaluation framework, answering that question becomes a full research project. Every. Single. Time.

These questions have been living rent‑free in my head.

This is why I’ve been selective. I don’t want to add noise to your tool stack. I want to be a curator, not a hype machine. So I’ve focused on tools that deliver 10x returns rather than marginal improvements—tools like NotebookLM, Claude Code, Make, n8n, Dia Browser and Glif. The reason is simply that they make you feel like you have a superpower: they automate entire workflows, not just individual tasks.

That selectivity is also why I’ve been sitting on Google Opal for over five months.

I’ve been using it since the early beta. I saw the potential. But it felt like an experiment. It’s interesting for sure, but not essential. I couldn’t articulate why it mattered beyond “Google made another AI thing.”

Then Gemini 3 launched. And Opal changed. I mean, a lot.

It’s no longer a side project buried in Google Labs. It’s now natively integrated into Gemini. The capabilities have expanded. It’s multimodal—spanning video, audio, and image generation. More importantly, I finally saw the use case clearly. I understood what Google was building toward.

Google Opal isn’t trying to be another chatbot or another automation tool competing with Zapier or Make. It’s something fundamentally different: an AI-native workflow builder designed for building custom apps to automate tasks, where plain english becomes the programming interface, and you build functional workflow without writing code or understanding JSON and other technical formatting.

And it’s completely FREE.

In fact, it offers a better user experience compared to Make or n8n. This is the agentic workflow future we’ve been talking about. And it’s here now, wrapped in a simple Google interface and integrated across Google products.

So I changed my mind. This one’s worth the deep dive.

When I built a tool to evaluate tools

Let me show you what changed for me.

Every week, someone launches a “revolutionary” new AI tool. And I’m left asking:

“Is this actually useful? How does this fit my workflow? Is this worth writing about?”

I had this intense FOMO to try everything.

Answering those questions used to take 2+ hours of scattered research per tool. So I took a long breath and dissected what’s in my head when researching and deciding whether new AI tools are worth testing. Then I automated this process into Opal.

By using Opal, I just had to input the tool’s website URL.

Five minutes later, I had a clean HTML report with:

• A clear overview of the tool’s capabilities, the problem it solves, and the target audience it serves

• Scores against my criteria (10x vs. marginal, technical barrier, newsletter fit)

• Specific recommendations for my workflow as a newsletter builder

Now, whenever I find new AI tools in the market, I no longer feel FOMO because I have my evaluation tool that measures use cases against how I actually work.

Because Opal is integrated across Google products, I save my HTML report to Google Drive and share it with friends who are drowning in the same tool chaos. If they want to remix my evaluation framework for their own workflow, they can grab my Opal template and customize it.

In that moment, I realized I’d built a capability I could reuse and share. And that’s when I finally understood what Google was building.

Subscribe now

How Opal actually works - The two modes you need to understand

Most automation tools force you to think in steps from day one:

“If this happens, then do that. Parse this JSON field. Map this variable to that output.”

Opal works differently.

It gives you two modes, and here’s the key insight: you can start in the simple mode and graduate to the complex mode only when you need it. You’re never locked out of the logic.

Mode 1: Describe What You Want (The “Vibe” Interface)

This is where most people start, and honestly, where most people can stay.

You open Opal. You see a text box. You describe the outcome you want in plain English.

Not “Use the Google Search module, then use the Browse Web module for each result, then extract the text, then pass it to the Generate module with this specific prompt structure...”

Just: “Build an app to evaluate new AI tools.”

Or: “Turn YouTube video into a Twitter thread.”

Or: “An app to analyze all my financial statements on PDFs and calculate my spending.”

The AI figures out the workflow.

You didn’t have to architect each process. You described the destination. Opal built the route.

This is what people mean by “vibe coding.” You’re coding with intent instead of detailed instructions.

What Makes This Different from Just Chatting with ChatGPT?

Fair question. Here’s the difference:

When you ask ChatGPT/Gemini/Claude to research something, it gives you an answer based on its training data (which is frozen in time) or maybe uses a search tool to grab a few snippets. You get a response. Then it’s over.

When you ask Opal to research something, it builds a workflow—a repeatable, editable process that you can see, modify, and reuse. It creates a web app with input fields and output displays—it can be Google Docs, Sheets, Slides, and HTML. You can run it again tomorrow with different inputs. You can share it with someone else.

ChatGPT or other typical chatbots give you answers. Opal gives you tools.

Mode 2: Build How It Works (The Workflow Editor)

Here’s where it gets interesting.

After Opal creates your workflow from your description, you can click into the “Build” view and see exactly what it made.

You’ll see a visual graph—a series of connected nodes. Each node is a step:

1. An Input node (where data comes in), here are available inputs:

   1. Text

   2. Youtube URL

   3. Computer files, including images

   4. Google Drive files

   5. Drawing

   6. Webcam video

2. A Generate node (where the AI does thinking work), two things you can access:

   1. Tool (where it can access tools to search, fetch website pages, search maps, get weather, and run code)

   2. AI Generation (Gemini 2.5, 3, Nano Banana Pro, Veo 3.1, Deep Research, AudioLM, Lyria for music, etc)

3. An Output node (where results get displayed):

   1. Custom HTML web layout

   2. Google Docs

   3. Google Slides

   4. Google Sheets

You can click on any node and edit it. Change the prompt. Add a new step. Reroute the logic. Delete something that’s not working.

Additionally, you can use “Add Asset” as a reference or knowledge base when the AI makes decisions—it can include your writing style, template, voice, or images you want the AI to reference.

I’m sure some of you are quite familiar with this if you have implemented all AI automation blueprint I have shared using Make.com. But Opal is way simpler and requires less technical knowledge to really understand how it works as well as its interface.

That said, understanding how Opal builds workflows will help you move faster. Once you see the patterns—how it executes tool calling, chains Generate nodes and formats outputs—you’ll start thinking in systems instead of one-off tasks.

Building your first Opal workflow app

In this section, I’m walking through exactly how I built that AI Tool Evaluation workflow. Not just what it does, but why I structured it the way I did.

You’ll see:

• The complete node breakdown (Input → Research → Framework Application → Scoring → HTML Output)

• The evaluation framework I use and how to customize it for your workflow

• The HTML template setup that makes reports clean and shareable

Plus 4 ready-to-use Opal workflows you can import and remix:

1. Newsletter Repurposing Engine - Turn one post into 10 Substack Notes, 5 LinkedIn, and 2 Twitter threads

2. Competitor Intelligence - Analyze your business competitors, identify opportunities, and improve your business strategy

3. Infographic Generator - Convert text and visualize them into infographic

4. Infographic Explainer - Find topic you want learn , run research, summarize them in text and turn them into visual assets

I’m convinced the fastest way to learn is to take examples and play around with your workflow until it fits your own style. Use my Opal as a reference to remix now, and reuse later. You can also learn from the workflow templates the Opal team has created inside your account.

I’m also sharing my honest take on Google Opal: when to use it vs. Make or n8n, where it excels, where it falls short, and how to fit it into your existing automation stack.

By the end, you’ll know whether Opal belongs in your workflow, and if it does, you’ll have working examples to build from.

Workflow #1: AI Tool Evaluator (Step-by-Step)

Let me walk you through how this workflow actually works.

But I won’t share the prompts here because you can find them directly on my Opal account instead. To see inside the workflow and the detailed prompts, you can go directly to the tool here:

Read more

I’ve spent years optimizing my productivity system.

GTD (Getting Things Done) for tasks. Time blocking for my calendar. Inbox zero for email.

But the problem was that each system worked in isolation. Here’s what broke down every single day:

• An email arrives about a project deadline → Should this go on my calendar?

• A meeting gets scheduled → Does this conflict with my deep work blocks

• Someone asks for a status update → Which tasks are actually in progress?

Three separate systems. Dozens of micro-decisions. Constant context switching.

That’s when I realized I didn’t need better productivity apps. I needed something that could think across all three systems and handle the coordination I was doing manually.

Last week, I told you why AI agents mostly don’t work—how they’re unreliable, how they hallucinate, how “agentic workflows” are the better choice for automation you can trust.

I stand by that.

But here’s what I didn’t tell you: narrow, specialized AI agents actually work perfectly.

Not Jarvis. Not an AI that handles “everything.”

But an AI agent that connects your email, calendar, and tasks.

I’ve been using mine for months now.

My AI agent has access to my Gmail, Google Calendar, and Notion. It responds accurately by taking action through tool calls and proceeds when I give it a specific command via Slack:

• “Triage yesterday’s emails and send me a summary”

• “What’s on my calendar today?”

• “Add task: review Q4 analytics”

Same agent. Different tools. Complete control.

This is no longer science fiction—it’s a system you can build this afternoon.

Let me show you exactly how it works.

How the system actually works

I built this as my productivity AI assistant that sits between me and my productivity stack. Here’s what it can do across each system:

1. Email Tools:

   • Triage and label emails by category (URGENT, FOLLOW-UP REQUIRED, NEWSLETTER IDEAS, etc.)

   • Search emails by time range, sender, keywords

   • Summarize recent emails in digestible format

   • Draft replies (never sends without your approval)

   • Send emails (only after explicit confirmation)

2. Calendar Tools:

   • Show daily/weekly schedule on demand

   • Create events with specified details

   • Flag scheduling conflicts

   • Delete events (with confirmation)

3. Task Tools:

   • Create Notion tasks with properties (project, priority, due date)

   • Update existing tasks (status, deadline changes)

   • Search and retrieve filtered task lists

The AI understands your command (”triage yesterday’s emails” vs “what’s on my calendar”) and routes to the right tool automatically.

When you say “block Friday afternoon for deep work,” it knows to:

• Check your calendar for conflicts

• Create a 3-hour block

• Confirm the event was created

This guide shows you how to build this AI agent using Make.com, OpenAI, Gmail, Google Calendar, Notion, and Slack.

By the end of this post, you’ll be able to build your personal productivity AI agent and use it as the foundation for what we’ll build next as we advance in developing AI agents.

Subscribe now

Before we begin, here’s what you’ll need:

• Make.com (automation platform)

• OpenAI API (the AI brain)

• Gmail + Google Calendar (email and scheduling)

• Notion (task management)

• Slack account and Slack Bot integration (command interface)

Here’s the additional cost details you need to consider:

• Gmail, Google Calendar, Notion, Slack (free tiers work)

• OpenAI API key ($5-10 in credits, can last 1-3 months)

• Make.com paid account (starts from $9/month)

Cost: ~$12-15/month on average (Compare to AI agent services charging $20-50/month)

Architecture:

One Make.com scenario triggered by Slack messages. AI agent receives your command, understands intent, routes to the right tool (Gmail, Google Calendar, or Notion), executes the action, and reports back to Slack.

Sign up Make.com

Understanding AI Agents in Make.com

Before we build, you need to understand what’s actually happening under the hood.

Make.com’s AI Agent feature works like a coordination layer that connects AI reasoning to your actual apps and workflows.

Think of it this way: the AI is the brain, and Make scenarios are the hands.

Make scenarios are everything I’ve been sharing on Maker Labs—from newsletter digests and social repurposing automation to turning voice into a second brain.

Generally, whether you use n8n, Zapier, or other AI agent tools, these are the essentials you need to understand.

The five components you’ll configure

1. System Prompt (The Brain)

This defines everything about how your agent behaves:

• What it does and doesn’t do

• How it responds to different requests

• Which tools it can access

• When to ask for confirmation vs. act immediately

For our productivity agent, the system prompt tells it:

“You manage email, calendar, and tasks. You only act when explicitly instructed. You always confirm before sending emails or deleting events.”

2. Context (The Knowledge Base)

This is the reference material your agent can consult.

For example, if you were building an AI Maker growth agent, the context would include past posts, content strategy, audience data, and performance metrics—just like what I shared in Claude Project Knowledge. When you ask for newsletter ideas, it references this context to give personalized recommendations—not generic advice.

For our productivity agent, context isn’t critical (we’re working with live data), but you could add things like project definitions, priority frameworks, or a list of emails you want the agent to prioritize.

3. Tools (The Hands)

Tools are Make scenarios that the agent can call to take actions.

There are two types:

• Individual modules: Single operations like “Search Gmail” or “Create Google Calendar Event”

• Complete scenarios: Multi-step workflows like “Triage yesterday’s emails and send digest” or “Find tasks due this week and change due dates”

When you tell the agent “Find tasks due this week and change due dates to next week,” it:

1. Recognizes this is a Notion task

2. Calls the Notion search tool

3. Get all task details

4. Calls the update tool for each Notion task

5. Sends you a summary via Slack

This process can be done based on how precise and accurate your system prompt is.

4. MCP Integration (Optional Advanced Feature)

MCP (Model Context Protocol) lets your agent connect directly to apps like Notion, Monday.com, and Asana to read and write data natively.

For this guide, we’ll use Make’s standard tool approach (which works perfectly), but MCP is available if you want deeper integrations later.

We’ll get to that on the later post.

5. Testing & Training

A chat interface inside Make where you test if your agent behaves as expected before connecting it to Slack.

This is where you’ll verify that “what’s on my calendar today” actually searches your calendar instead of hallucinating a schedule.

How it all connects

Once your agent is configured, you connect it to a trigger—usually a messaging platform like Slack, Telegram, or WhatsApp.

Here’s the full flow:

1. You send a message in Slack: “Triage yesterday’s emails”

2. Make’s Slack trigger catches this message

3. The AI Agent module receives it and interprets intent

4. The agent calls the appropriate tool scenarios (Gmail search → label emails → summarize)

5. Results come back to the agent

6. The agent sends a summary back to Slack

That’s what makes it feel like an assistant instead of a basic automation.

Let’s get into the setup. The process will be divided into two parts: first, you’ll configure your AI agent; second, you’ll connect the AI agent to a workflow through Slack.

Now, let’s build it.

Building personal productivity AI agent

Before setting up the five components of our AI agent, we first need to choose which AI models to use.

In the Make dashboard, go to the AI Agent menu and click “Create agent.”

I recommend using OpenAI by connecting your API key and choosing gpt-5-mini—it’s faster, and this agent doesn’t need a more advanced model. Feel free to experiment, though. You’ll also need to complete the organization registration to fully access the model, which you can do on the OpenAI website in minutes by uploading your ID.

🚨 Important: DO NOT USE Make’s AI Provider Connection because it will drain your credits so much you’re going to scream.

Now, we can proceed through five components to set up our AI agent:

1. System prompt

Here’s the system prompt you can copy and paste:

Read more

A few months ago, I showed you how MCP (Model Context Protocol) turned Claude into my personal operating system. That post became one of my favorites because it explored how we can use AI to connect with our favorite apps—whether Notion, Google products, Slack, and more.

The concept clicked. AI escaping the chatbox, connecting directly to your tools, working WITH your actual project files instead of just talking about them.

But then you tried to implement it and hit a wall.

JSON config files. API keys that expire. Error messages that say “MCP server failed to start” without explaining why. GitHub documentation written for developers. Terminal commands that feel like black magic.

Most of the problems you face happen because understanding MCP and actually implementing it are two completely different challenges.

Most people give up after the first cryptic error message, or they don’t even try at all given the complexity of the implementation process.

That’s why I made a 30‑minute video walkthrough showing exactly how to set up the five MCPs that matter for non‑technical work, like doing research, connecting to your business context or project‑planning system, scraping content across the internet, designing social media banners, and more.

Subscribe now

What you’ll learn in the video

Phase 1: Why MCP matters for non-technical work (0:00 - 11:20)

• The real problem: Your AI lacks context about YOUR business

• Why most MCP servers only work for developers (and how we fix this)

• The 5 MCPs that actually matter for most knowledge work

Phase 2: Notion MCP - The easiest starting point (11:20 - 14:30)

• Why Notion is the perfect first integration (official support, no JSON hell)

• Connecting Claude directly to your databases in under 3 minutes

• Testing if it’s actually working vs. just pretending to work

Phase 3: Firecrawl MCP - Reliable web scraping tool (14:30 - 19:00)

• Why Claude’s built-in web fetch breaks on certain pages

• Your first JSON config: Step-by-step to implement it

• The debugging trick: Using Claude to fix broken config files

• How to verify your MCP server is actually running (not just installed)

• Where most people get stuck and how to fix it

Phase 4: Perplexity MCP - Deep research without subscriptions (19:00 - 21:00)

• The cost hack: $5-10 in API tokens vs. $20/month subscription

• When to use Perplexity vs. Brave vs. Claude’s native search

• Setting up API access and JSON configuration

Phase 5: Brave Search MCP - Free alternative (21:15 - 23:00)

• Getting 2,000 free queries per month

• The exact NPX configuration you can use to install Brave Search MCP

• Common API key mistakes and how to avoid them

Phase 6: Zapier MCP - Connect your AI to 8,000+ apps (23:00 - 27:30)

• Connecting 8,000+ apps through one integration: works with ChatGPT too

• Setting up Gmail, Google Analytics, Asana, Jira, Slack

• How to segment permissions (read-only vs. full access)

• The explicit command pattern: Making Claude use the right MCP

What you need before watching

✓ Claude Pro account ($20/month)

✓ Claude Desktop installed (this ONLY works on desktop, not web)

✓ 30 minutes of uninterrupted time

✓ The apps you want to connect (Notion, Gmail, etc.)

We’re connecting real APIs with real permissions. No sandbox. This is production-level setup that will actually run your workflows.

After watching, you’ll be able to:

✅ Set up all 5 MCPs I use daily without getting stuck

✅ Connect any new MCP server you discover online (the pattern repeats)

✅ Debug JSON config files when error messages are cryptic

✅ Stop paying for multiple AI subscriptions you don’t need—use an API token instead

For Maker Labs subscribers: Watch the full implementation walkthrough here.

Not a Maker Labs subscriber? This is exactly the kind of complete implementation blueprint you get with the paid tier. No theory, no concepts, just the exact configurations and troubleshooting steps that actually work.

The difference between knowing MCP is powerful and actually using it every day is implementation. This video bridges that gap.

Further resources you can explore

Here are additional resources for you to explore list of MCPs available in the market right now:

Read more

Keeping up with AI news is overwhelming work and so tiring.

You don’t know who’s going to lead this week and no idea what new tools will rise to the surface.

Every AI model tells they are better. Until another AI model takes over. The King throne only lasts for a week or two. That’s how brutal AI news is.

To keep up with AI, I run an RSS reader with AI automation 24/7. It delivers every newsletter and blog post from 30+ sources I curated: the system works exactly as designed.

But it only covers what I already know.

The real gap is the sources I don’t know to follow yet. If I miss a few weeks, that blind spot turns into 3–5 hours of catch‑up just to get back to speed.

RSS only monitors sources I’ve manually added. If a breakthrough gets published on a blog I’ve never heard of, or discussed in a paper from a researcher I don’t follow, or mentioned in a newsletter I’m not subscribed to—I miss it completely.

I started noticing this pattern. I’d see people talking about new AI tools on X, and when I looked them up, the original source wasn’t in any of my RSS feeds. By the time I learned these insights, everyone else was already ahead of me.

That’s when I realized I needed something beyond RSS. Not a replacement for monitoring known sources, but a layer above it that actively searches the entire internet for information I don’t know exists yet.

So I built an AI agent for that. It uses Perplexity to search intelligently across the web, logs findings in Google Sheets, and sends me weekly summaries of discoveries from sources I would have never found manually.

I’ve been running this for 3 months. It’s saved me 3-5 hours every week by eliminating the manual browsing and anxiety about missing something important. And it’s found insights from sources that weren’t anywhere in my RSS feeds.

By the end of this guide, you’ll have your own AI news agent running automatically, searching the entire internet based on your interest, and delivering weekly summaries to your inbox, covering:

• Finance: markets, macro updates, earnings, and risk signals

• Marketing & growth: campaigns, funnels, benchmarks, and channel changes

• Funding & startups: raises, valuations, investor notes, and M&A

• Crypto & web3: token movements, on-chain metrics, protocols, and regulation

• AI & product: model releases, tooling, roadmaps, and competitor launches

And anything you can think of.

Let’s build it.

What you’ll build in this guide

By the time you finish implementing this system, you’ll have a fully automated AI news agent that:

1. Searches intelligently across the entire internet - Not limited to RSS feeds or pre-selected sources. Perplexity AI actively searches based on your custom topics and queries to find relevant information anywhere it exists online.

2. Stores everything in organized Google Sheets - Every research finding gets logged with metadata (source, date, topic, relevance score) so you can spot patterns and track trends over time without manual organization.

3. Sends weekly intelligence summaries to your email - OpenAI analyzes your accumulated findings and generates one clean summary email highlighting only what deserves your attention, with key insights and source links.

4. Runs completely on autopilot - Webhook trigger in Make.com kicks off the entire workflow. You set your research topics once, then the system runs every week without any manual intervention.

5. Costs almost nothing to operate - Runs free within Make.com’s limits for most users. Perplexity and OpenAI API costs typically under $3-5 monthly even with aggressive research schedules.

What makes this different from RSS automation

RSS monitors sources you already know about. This system discovers sources you don’t.

RSS requires manual feed curation. This agent searches dynamically based on topics.

RSS gives you everything from selected feeds. This agent filters for what actually matters to YOU.

Think of it this way: RSS is your known network. This AI agent is your discovery engine.

You need both.

Prerequisites you’ll need:

• Make.com account (free tier works)

• Perplexity API access (minimum $5 in token credits)

• OpenAI API key (minimum $5 in token credits)

• Google Sheets (free)

• Gmail account

Time to implement: 30-45 minutes for initial setup. After that, zero maintenance unless you want to adjust research topics. If you copy my JSON template, you can run this instantly.

Expected results after 1 month:

• 3-5 hours saved weekly on research and news consumption

• Discovery of sources outside your RSS feeds

• One clean summary email instead of dozens of browser tabs

• No more anxiety about missing important news

Here’s the result of the report:

This whole process will be divided into two scenarios: the first is to collect the information, while the second is to summarize it.

Let’s dive in.

🚨 Before we move on, we’ll keep using Make.com to build this AI automation because it’s reliable and cost-effective (FREE or cheaper than alternatives). If this is your first time with Make.com, check my previous posts—linked “here” and “here”—for basic setup and configuration. I won’t repeat the module steps covered there, so we can focus on what matters next.

Subscribe now

Scenario 1: Collecting information using Perplexity

The goal of this scenario is to begin requesting information from Perplexity to collect the data. We start this workflow with a Mailhook module.

1. Use Mailhook to start your research

This automation begins by triggering a Mailhook and sending the request to Perplexity as the next module.

Check this post to learn how to set it up.

You need to write your request in the email body. In the example below, I ask it to research “New AI tools this week.”

This input is highly customized. You can adjust the timeframe and the specific topic you want to research. For example, recent AI startup funding or new AI model launches.

Once your Mailhook is configured, we send the request to Perplexity.

2. Perplexity to start researching

I chose Perplexity because it’s great at deep research, scouring the internet to find relevant information based on your queries.

As the first step, you need to buy a Perplexity API token with a minimum value of $5 on their API billing page. See the screenshot below.

Once done, return to Make.com and set up the module named Perplexity AI: Create a chat completion. Create an API connection and enter your API key inside.

Once connected, update the following key fields in the Perplexity AI module:

• Model: Choose “Sonar Pro” first. If you need more complex research, go one level up to Sonar Reasoning, Sonar Reasoning Pro, or Sonar Deep Research.

• System and user prompt.

• Max tokens: Set to 10,000.

• Web Search Options: Depending on how much you want to rely on web search, tweak between Medium and High.

Here’s the system prompt you can copy and paste:

Read more

I’m trying something new with this week’s post.

It’s a video walkthrough instead of my usual written guide.

Why? Because there’s too much nuance in building Claude Skills that I can’t capture in text alone. The edge cases, the files that break randomly, the weird formatting issues that only show up when you actually try to upload because I think you need to SEE this stuff to understand it.

In previous post, I showed you WHAT Claude Skills are and WHY they matter.

This week? HOW to actually build them without losing your mind.

Because here’s what nobody tells you: Claude generates messy files. Sometimes the skill.md is named wrong. Sometimes it references files that don’t exist. Sometimes it works perfectly in chat but breaks when you try to upload it.

I spent weeks figuring out these gotchas so you don’t have to. So I made you an hour-long video on how to do this.

Here’s what’s inside of the video

Part 1: Understanding the file structure

• What’s actually inside a Claude Skill ZIP file

• Why skill.md is the main instruction file

• How Claude reads additional reference files for context

• Real examples from my Strategic Decision Framework and Business Idea Generator Skill

Part 2: Building your first Skill

• Live build: Editorial Assistant Skill from scratch

• The exact moment when Claude generates broken files (and what to do)

• How to identify when skill.md is incomplete or wrongly formatted

Part 3: Debugging with Claude Code

• Setting up Claude Code in Cursor to analyze Skill files

• Fixing missing reference files and broken instructions

• Making Claude Code improve your Skill structure automatically

• Why some Skills work perfectly and others need manual fixes

Subscribe now

Throughout the video, I’m working with real examples:

• Strategic Decision Framework (analyzes business decisions through 10 frameworks)

• Business Idea Generator (transforms voice memos into validated concepts)

• Editorial Assistant (the one we build live that breaks and we fix together)

But, this video got longer than I planned because we hit a real problem during the build.

Claude generated files with the wrong naming convention. The skill.md wasn’t in the right folder. Reference files were missing.

I kept it all in the video because that’s EXACTLY what you’ll experience when building your own Skills. I won’t hide the confusing cases in building Claude Skills. You can actually watch me debug when things inevitably break.

Before you watch the video, make sure you come prepared:

✓ Claude Pro account - $20/month

✓ Cursor or VS Code installed (for editing Skill files) - FREE

✓ Claude Code extension installed in your IDE - FREE

The video shows you every step: activating Skill Creator, building through chat, downloading files, fixing them in Claude Code, zipping correctly, and uploading to your account.

Download the Skills I reference:

All 7 Skills shown in the video are available on the Maker Access page:

• Strategic Decision Framework

• Business Idea Generator

• Newsletter Repurpose to Social

• SEO Content Optimizer

• AI News Digest

• Substack Notes Generator

• Newsletter Brief Generator

Make sure you leveraged what I have provided.

P.S. Yes, the video shows me struggling with broken files for ~15 minutes around the 35-minute mark. I kept it in because that’s the real experience of building Skills. You’ll hit the same issues, and now you’ll know exactly how to fix them.

Until next week,

Wyndo

---

P.P.S. If you get stuck building your first Skill, post the error inside Substack chat. I’ll help you debug. That’s what Maker Labs is for.

Read more

I spent 5 hours every week manually reformatting my newsletter into social posts.

And I felt like a robot doing mindless copy-paste work.

The cruel irony? I’m a writer who writes about AI automation.

Every week, the same exhausting routine:

• Monday morning: Start drafting the Thursday newsletter. Get the core ideas down while the thinking’s fresh.

• Monday afternoon: Try to pre-repurpose. Turn the strongest sections into LinkedIn drafts, reformat, add line breaks, check character count, adjust tone. Save to schedule, not post.

• Tuesday: Do the same for Substack Notes—ten short insights, each tightened to 200-ish characters. Sketch one or two Twitter thread outlines with curiosity gaps. Queue them.

• Wednesday: Finalize the newsletter—edit, add examples, tighten the open and close. Schedule it for Thursday morning and double-check the queued posts.

But, some weeks I just... skipped it entirely. Too burned out from writing 2,000-3,000 words of long-form content to spend another 5 hours manually adapting it for different platforms.

And here’s what made it worse:

Content repurposing isn’t just “copy and paste the same thing everywhere.”

The game is not that simple because:

• LinkedIn wants thought leadership with strategic line breaks and declarative hooks.

• Substack Notes wants 200-character insights that create mic-drop moments.

• Twitter threads need conversational flow with curiosity gaps between tweets.

Each platform has its own language, rhythm, and audience expectation.

So even when I forced myself to repurpose, I’d either:

1. Post generic versions that felt flat and got zero engagement, or

2. Spend way too much time rewriting everything from scratch, defeating the entire purpose of “repurposing”

I knew I should be everywhere. LinkedIn, Substack Notes, Twitter—these platforms could 3x my newsletter reach.

But the manual work required to do it properly was impossible to sustain.

Then I asked myself the question that changed everything:

“If I can automate voice memo processing, why can’t I automate content repurposing?”

Not just using AI to rewrite stuff. That creates generic, soulless content that sounds like everyone else.

I needed a system that:

✅ Understood the specific adaptation rules for each platform
✅ Preserved my conversational voice and framework thinking
✅ Ran automatically without me having to ask ChatGPT to do it every week
✅ Delivered 80% ready content that only needed 10-20% final polish

So I built exactly that.

My AI automation that repurposes newsletter content into social-ready posts.

Here’s what the system does now:

I add my newsletter URL to a Google Sheet and change the content status from “Live” to “Repurpose.”

That’s it.

The automation runs and delivers to my Google Docs:

• 5 LinkedIn posts (each adapted to different content styles: steps, lessons, examples, stats, mistakes)

• 10 Substack Notes (200-character insights with bold formatting and mic-drop endings)

• 3 Twitter threads (conversational hooks with curiosity-driven flow)

Every piece maintains my voice.

Every piece is platform-optimized.

Every piece is ready to publish with minimal editing.

What used to take 5 hours now takes 30 minutes of final polish.

In the previous guest post on content repurposing, it showed you why repurposing matters and what the strategy looks like.

This guide gives you the exact automation blueprint to make it happen without touching any AIs, writing prompts from scratch, or spending hours reformatting content.

You’ll get:

→ The complete Make.com workflow (JSON import ready)
→ All three platform-specific prompts (LinkedIn, Substack Notes, Twitter)
→ Google Sheets template for simple URL management
→ My voice preservation framework that keeps your tone intact
→ Platform adaptation rules that make content feel native, not forced

By the end of this guide, you’ll have a content repurposing system that runs itself.

No more manual reformatting. No more skipped weeks. No more guilt about leaving your best insights trapped in long-form.

Just one newsletter URL → 18 pieces of platform-optimized content.

🚨 Before we move on, we’ll keep using Make.com to build this AI automation because it’s reliable and cost-effective (FREE or cheaper than alternatives). If this is your first time with Make.com, check my previous posts—linked “here” and “here”—for basic setup and configuration. I won’t repeat the module steps covered there, so we can focus on what matters next.

What you’ll need before you can run this automation:

• Google Sheet for webhook integration and URL management

• OpenAI API key with credits worth of $5

• Firecrawl API key (free for up to 500 URLs)

• Make.com account (free tier works fine for this)

Subscribe now

Now let’s build it.

1. Create Google Sheet webhook integration

This AI automation for social content repurposing starts from Google Sheets. We’ll set a rule so the scenario runs when the condition is met, specifically, when the “Repurpose” status filter is turned on. We’ll get into it later.

In Make.com, open your scenario and add the module: “Google Sheets — Watch Changes.” This module monitors any edits in the sheet. Before it can listen, integrate the webhook so Make.com can receive the update events.

Create your first webhook in the module and name it based on its function. For example, “Content Repurposing.” Then save.

What you need to do next is integrate the webhook URL you just saved into Google Sheets. The sheet will store everything about the newsletter URL that you want to repurpose later.

Now follow these steps:

1. Create the Google Sheet you will use for this automation

2. Open the Extensions menu, click Add-ons, then click Get add-ons

3. Search for “Make” in the marketplace

4. Open the Make page

5. Click Install

When you finish installing, open the Extensions menu again. Click Make, go to Settings, and paste your webhook URL into the field. Then save.

The webhook has been integrated!

2. Add Google Sheets module for URL management

The next thing you need to do is add “Google Sheets — Search Rows” module. We need this because we want data access inside the Google Sheet that was integrated with the webhook earlier so the AI automation can run it from there.

Here’s the example how the Google Sheet look:

1. URL: Paste your published newsletter URL here.

2. Status: Automation triggers when the status changes to “Repurpose.”

3. Channel: Select the social channels where you want the newsletter repurposed.

4. Outputs: Substack Notes, LinkedIn posts, and Twitter threads are generated drafts you can review and edit before publishing.

And here are the fields you need to fill in inside the module:

1. Spreadsheet ID: Get the ID from the previous “Google Sheet — Watch Changes” module.

2. Sheet Name: Get the Sheet Name from the previous “Google Sheet — Watch Changes” module.

Everything else remains default. Nothing complex here.

3. Set up the “Repurpose” filter on the first two Google Sheets modules

I mentioned earlier that we’re using the “Repurpose” filter to trigger the entire automation, so we need to ensure that’s implemented correctly.

In the Google Sheets — Watch Changes and Search Rows modules, configure a filter to watch only for Status values that change to “Repurpose,” and send those rows to the next module.

Once that’s done, proceed to the next step.

4. Scrape the newsletter post using Firecrawl

I covered this flow in the previous post; you might want to check it there for more details. You’ll also need a Firecrawl API key to run this. You can find it in this post.

Enter the URL you want Firecrawl to scrape: the one referenced in the right column of the previous Google Sheets module.

It should look like this:

Now we can continue to the next module.

5. Add router to create social channel segment

In this automation, we use three routers to repurpose the newsletter into three social channels. Each channel has its own system prompt and ends in a Google Docs module to deliver the output.

Each router has its own filtering system to decide which posts go to Substack, LinkedIn, Twitter, or All.

The filters come from the previous Google Sheets module. Here’s the routing logic:

• If Column C (Channel) contains “Substack,” send the post to the Substack router.

• If Column C (Channel) contains “LinkedIn,” send it to the LinkedIn router.

• If Column C (Channel) contains “Twitter,” send it to the Twitter router.

• If Column C (Channel) contains “All,” send it to every router (Substack, LinkedIn, and Twitter).

See the screenshot below for the flow.

This should be easy to set up, and then we can proceed to the Substack OpenAI module.

6. OpenAI module for Substack Notes Generator

If this is your first time setting up the OpenAI module, check out this post first. I’ll skip the walkthrough here and give you the system prompt you can copy and paste.

Read more