Over the past few months, you’ve been hearing me talk about how much of a difference using Claude Code agents has made in my work.
But if you haven’t used Anthropic’s Claude Code or OpenAI’s Codex, then agents still feel abstract. And, it’s hard to commit time to something where the benefits aren’t concrete.
Then, I saw the incredible demo, which I share in today’s post.
For context:
Earlier this year, we hosted Wyndo of The AI Maker on Cozora.
Wyndo runs the fastest-growing AI newsletter on Substack, and he has been using Claude Code since it came out.
Cozora is an organization I co-founded with Claudia Faith and Joel Salinas. Every week, we share a top AI skill of a top AI knowledge worker, entrepreneur, and creator, so you can supercharge your AI productivity.
Wyndo walked us through his setup and how he works with Claude, step by step. Everyone in the Zoom said it was one of their favorite Cozora sessions.
I was so impressed by the presentation that, soon after, I pitched Wyndo on creating a program together to help non-technical knowledge workers make the shift to agentic.
He loved the idea.
It’s now a few months later, and we’re launching the Agentic Academy For Knowledge Work this Monday, June 22. It feels surreal that the idea is now a reality.
So, I asked Wyndo if I could share his demo video and an explainer article about it with my subscribers. He agreed.
Over to Wyndo…
The Claude Code Setup Behind My Newsletter
By Wyndo
Most people are still trying to get better AI output from better chats.
I get why. That is where most of us started.
You open ChatGPT, Claude, Gemini, or whatever tool you like. You ask a better question, add more background, paste in a few examples, and try to explain what good output looks like.
Sometimes it works really well.
But then the next chat starts from zero again.
You re-explain the project, re-upload the files, paste the same rules, correct the same mistakes, move the output into Google Docs, Notion, email, Substack, Slack, or wherever the real work happens.
At some point, the problem is no longer the prompt.
The problem is that the AI has no real connection with your work.
That was the main idea I tried to show in a past session with the Cozora Community. I walked through how I run AI Maker from inside Claude Code, including my newsletter folder, my project structure, my CLAUDE.md, my skills, my slash commands, my memory rules, and the way I use agents to help with research, writing, planning, and operations.
This was a live tour of the system I actually use, and now I’m sharing it with you.
When people hear “Claude Code,” they often assume this is for programmers. Margaret, one of the people in the session, asked the obvious question right away:
“So is Claude Code like about coding?”
That is the question most normal people have.
And the answer is: it started there, but that is not where it ends.
Claude Code is useful because it lets an AI agent work inside a real project folder. It can read files, follow rules, create outputs, run repeatable workflows, store a large amount of information, use tools, remember corrections through files and instructions, and help you move from “answer this question” to “help me run this part of my work.”
That is a different relationship with AI.
The Shift I Was Trying To Show
For the last few years, most AI work has looked like chat.
You ask a question, get an answer, copy the answer, paste it somewhere else, open another app, bring back more context, ask again. Then you rinse and repeat.
That is still useful. I still use normal chat sometimes, especially on mobile.
But for my day-to-day work, the center of gravity has moved.
My newsletter now lives in a folder Claude Code can read, including the drafts, archive, writing rules, audience notes, paid-versus-free rules, and performance data.
So when I ask for new post ideas, Claude does not have to guess from the prompt alone. It can inspect the actual project, read the files that matter, see what I have already published, and follow the rules I wrote for the newsletter.
That’s the transformation you can expect when you go full AI‑agent mode.
💡 Quick note: This is also the shift Michael Simmons and I are teaching in Agentic Academy for Knowledge Work.
AI chat has a ceiling. You re-explain the project, re-upload the files, repeat the same corrections. Agentic Academy is 10 live weeks where you build one AI system that runs your real work. No coding. Starts June 22. Enroll now.
Watch The Video
This replay is a walkthrough of the system behind my newsletter and project management setup.
I would not watch it like a normal webinar where you try to remember every tool name. I would watch it with one question in mind:
What would my first agent folder need to understand about my work?
That is the useful lens.
Because the specific tools will change. But the underlying pattern is going to matter for a while:
Give the agent a folder.
Put the right source material inside.
Write the rules it should follow.
Create repeatable workflows.
Add guardrails.
Improve the setup every time the agent gets something wrong.
That is the pattern I kept coming back to during the session.
What We Covered
The session started with a question from Julia about managing multiple systems together.
She was already deep in the work, cleaning up a bunch of Claude projects, trying to build a better master project, and thinking through how memory and project status could work across different kinds of work.
That was useful because it surfaced one of the real problems with AI agents:
They can do a lot, but they can also do too much.
Julia mentioned that Claude Code can sometimes “go nuts” and do far more than she asked for. I have felt that too. Sometimes the agent understands the intent and runs with it in a useful way. Sometimes it does a long chain of work and gives you something that is technically impressive but not what you wanted.
That is why the folder matters.
You need a place where the agent can learn:
What this project is
What counts as good work
Which files matter for which tasks
What actions are allowed
What mistakes it should not repeat
When it should ask before moving
That is the job of the system around the agent.
In my setup, the most important file is CLAUDE.md.
I described it in the session as the brain of the project. It is the file Claude reads first. It tells Claude what the project is, what folders exist, what rules matter, what reference files to use, and what standards to follow.
For AI Maker, that means Claude knows things like:
Newsletter drafts live in one place.
LinkedIn posts have a different style than newsletter posts.
Paid posts need implementation detail.
Free posts should be complete on their own.
My writing should avoid polished corporate language.
If a task involves audience data, it should read the audience files first.
The more I use it, the more I think most people should start with the file that teaches the agent how to understand the project. The complicated automation can come later.
The Six Pieces I Walked Through
During the replay, I broke Claude Code into six pieces.
You do not need all of them on day one. I definitely did not build all of this at once.
But once you see the pieces, the whole thing feels less mysterious.
1. CLAUDE.md
This is the main instruction file for the project.
It tells the agent:
What the project is.
What rules matter.
What files to read for different tasks.
How the folder is organized.
What quality standards to follow.
For my newsletter, this is what stops Claude from treating every request the same way. A newsletter draft should load different context than a LinkedIn post. A strategy question should load different files than a quick copy edit.
Without this file, Claude has to infer too much from the chat.
With it, the agent starts from the project itself.
2. Skills
Skills are reusable workflows.
The example I showed was my AI News Intel skill. It connects to my Gmail, fetches AI newsletters from a specific label, reads the recent emails, summarizes the themes, and turns them into content opportunities for AI Maker.
The news summary is useful, but the repeatability matters more. I no longer have to write the whole prompt every time.
I can trigger the skill, give it a time range, and let it run the workflow. If the output is not useful, I can update the skill so the next run gets better.
That is different from saving a prompt in a note somewhere.
A prompt is something you remember to reuse.
A skill is a small workflow the agent can run.
3. Slash Commands
Commands are simpler shortcuts.
I use them for repeated actions where I do not want to explain the same thing again. A command might analyze a draft, generate notes, start a review, or run a recurring process.
But some people still find it hard to tell the difference when to use commands vs skills.
My current version is simple:
If it is a small shortcut, it can be a command.
If it is a full workflow with multiple steps, references, and quality checks, it should probably be a skill.
This rule works really well for me.
4. Memory
Memory is where corrections start to compound.
When Claude gives me an output that feels wrong, I do not only fix that one output. I ask it why it made the choice, what preference it missed, and how that preference should be saved so it does not repeat the mistake.
That is how the system slowly becomes more like me. I keep turning repeated corrections into written rules instead of hoping the model magically knows my taste.
This is one of the biggest mindset shifts. If you correct the same thing three times, that correction probably belongs somewhere outside the chat.
5. Subagents
Subagents are separate workers Claude can run for different parts of a task.
In the session, Julia asked a good question about this. Why use five agents instead of one? How much direction do you have to give each one?
My answer was that I usually do not want to manually manage five separate agents every time. Instead, I prefer to build that pattern into a larger skill.
For example, a research skill might send one agent to inspect Reddit, another to look at Twitter or X, another to check newsletters, another to summarize, and another to critique the argument. Then the main agent pulls the pieces together.
That is not necessary for every task.
But for work where different sources or viewpoints matter, subagents help keep the work cleaner. Each one can focus on a specific job instead of one overloaded chat trying to hold everything at once.
6. Tools
Tools are the connections that let the agent do real work.
In my setup, that can include Google Workspace, Gmail, Google Docs, Obsidian, GitHub, Tavily, and other command-line or MCP connections.
This is where things start to feel different from chat.
Instead of asking AI to write something and then manually moving it into the real tool, the agent can often create the file, read the folder, generate the document, or pull the information directly.
I still review the work.
But when the tools are connected carefully, the agent can handle more of the boring middle steps.
The Part Beginners Should Pay Attention To
If you are newer to this, the technical words can make the whole thing feel bigger than it is.
Claude Code. Cursor. Terminal. Markdown. GitHub. MCP. CLI. API. Skills. Subagents. Plugins.
That list can make the setup feel like a software engineering project.
But the beginner version is much smaller.
Create one folder for one area of work.
Put the real material inside:
Your drafts.
Your examples.
Your notes.
Your rules.
Your decisions.
Your recurring tasks.
Then create the first version of CLAUDE.md.
That file should answer:
What is this project?
What does good work look like?
What should the agent avoid?
Which files should it read for common tasks?
What should it ask before doing?
That is enough to start.
In the session, someone asked how to begin if you do not know the right folder structure yet. My answer was pretty simple: dump the relevant files into one folder, run /init, and let Claude suggest the first structure.
Then you brainstorm with it.
You do not need to design the perfect structure before you begin. You need enough structure for the agent to start learning how your work works.
The Privacy Question Matters
Joshua raised the privacy and access question during the session, and I am glad he did.
Because this is the part that can get hand-waved when people get excited about agents.
If an agent can read and act on local files, you need to think about what it should not read and what it should not do.
My current rule is boring, but useful:
Do not put truly sensitive information in the folder unless you are comfortable with the risk.
For API keys, I use separate files like .env.local and make sure the agent should not access them. For tool permissions, I keep some actions restricted. For example, I might let an agent read emails or draft something while blocking send access.
I also try to open Claude Code inside the specific project folder I am working on, not from the top level of my computer.
If I am working on AI Maker, the agent should be inside AI Maker folder. If I am working on another project, that should be a different folder. My journaling and workout files do not live in this newsletter folder because they are different kinds of work.
The goal is to give the agent enough access to help with one real area of work, while keeping the boundaries clear. It does not need your entire life to be useful.
Why I Still Recommend Starting With Claude Code
We also talked about OpenClaw, Perplexity Computer, Claude Dispatch, Telegram, Discord, scheduled agents, and cloud-based agent tools.
Those are all interesting.
Some of them may become better starting points over time. OpenClaw is especially interesting for scheduled work because it can run while you are not sitting in front of the computer. Perplexity Computer is interesting because it can connect multiple models and run in the cloud.
But for most people, I still think Claude Code is one of the best starting places because it keeps you close to the work.
You can see what the agent is reading, approve or reject changes, inspect the folder, and watch it make mistakes—and turn those mistakes into better rules.
You are still in the control.
But this becomes a whole different story if you jump straight to a fully automated agent that runs at 2 a.m., because you need stronger guardrails to ensure the agent doesn’t do things you don’t want it to do, such as sharing private data or sending or deleting emails.
Claude Code is a good training ground for that.
Once you understand the structure, the pattern transfers into other tools, including Codex.
What I Would Do After Watching
If you want to use this session as a starting point, I would not try to copy my full newsletter setup.
That would be too much.
I would start with one area of work where you already repeat yourself.
Good candidates:
Weekly planning.
Newsletter drafting.
Client prep.
Research synthesis.
Meeting follow-ups.
Content repurposing.
Project status updates.
Then build the smallest agent folder for that work.
The first version only needs a few files:
CLAUDE.md: how the agent should understand the project.examples.md: examples of good output.rules.md: what to do and avoid.source-material/: the files the agent should use.outputs/: where finished work goes.
That is it.
Do not start with five subagents, ten skills, and every tool connection you can find.
Start with the folder.
Then add the next layer only when the friction shows up.
If you keep repeating the same prompt, turn it into a command or skill.
If you keep correcting the same mistake, turn it into a rule or memory.
If one task keeps requiring different kinds of research, consider subagents.
This is how the system grows without becoming too heavy.
Key moments from the session
Opening questions: participants share what they are trying to figure out with Claude, Claude Code, and project systems.
Margaret asks whether Claude Code is about coding, which becomes the beginner doorway into the whole session.
Michael frames the move from chat to agents and shares his own Make.com example.
I explain how I run The AI Maker from a local folder Claude Code can read.
We talk through Obsidian versus Notion and why local Markdown files are easier for agents to inspect.
I walk through the six core pieces:
CLAUDE.md, skills, commands, memory, subagents, and tools.I show the AI Maker folder in Cursor and explain why I prefer the visual interface over the terminal for most people starting out.
Julia asks how to control scope when Claude Code over-executes.
Joshua asks about privacy, file access, and permissions.
I demo the AI News Intel skill and show how it turns labeled Gmail newsletters into an AI Maker content report.
We discuss plugins as a larger layer above individual skills.
Julia asks whether OpenClaw makes this obsolete.
We compare Claude Code, OpenClaw, Perplexity Computer, scheduled agents, and multi-model orchestration.
The closing recommendation is to start by creating a
CLAUDE.mdand using/initto help structure your first folder.
Resources Mentioned
Claude Code: the main agent tool demonstrated in the session.
Claude: used as the broader Claude chat and model family people already know.
Claude Code Desktop: the recommended starting path for Agentic Academy.
Cursor: the visual interface I recommended for people who want to see files and approvals more clearly.
VS Code: another editor that can run Claude Code through an extension.
Terminal: the more technical interface for running Claude Code.
CLAUDE.md: the project instruction file that tells Claude what the folder is, what rules matter, and where to find context.Markdown: the file format I use because agents can read and edit it cleanly.
Obsidian: my local Markdown layer for managing notes and project files.
Notion: discussed as a cloud tool I moved away from for this kind of agent setup.
Google Docs: discussed in Julia’s example of extracting comments into structured Markdown.
Google Workspace: one of the tool connections I use with Claude Code.
Gmail: used by my AI News Intel skill to read labeled newsletters.
GitHub: described as a backup and collaboration layer for project folders.
Git: the version-control layer behind GitHub.
Make.com: Michael’s example of a task that took him 20 hours there and 20 minutes in Claude Code.
Tavily CLI: mentioned as one way I can run research from inside Claude Code.
NotebookLM: mentioned as a tool people might otherwise open separately.
Nano Banana: mentioned as an image-generation tool people might otherwise open separately.
Asana: mentioned as an example of a project tool that could connect through agent tooling.
MCP: one way tools can connect to agents.
CLI: command-line interface, another way agents can access tools.
API: another way tools and data can be accessed.
Skills: reusable workflow instructions for agents.
Slash commands: shorter triggers for repeated actions.
Memory: saved preferences and corrections that help future sessions improve.
Subagents: separate workers used for parallel or role-specific tasks.
Plugins: larger bundles that can include skills, agents, tools, commands, and MCP connections.
AI News Intel: the skill I demoed for summarizing AI newsletters from Gmail.
OpenClaw: discussed as a more automated agent environment with scheduled tasks and memory patterns.
Perplexity Computer: discussed as a cloud-based agent tool with built-in app connections and multi-model orchestration.
Claude Dispatch: mentioned as part of the move toward triggering Claude Code from outside the computer.
Telegram: discussed as a place to trigger or interact with agents.
Discord: discussed as another place Claude can connect.
Manus: mentioned as part of the broader agent-tool category.
Google Ads and Meta Ads: mentioned as examples of tools a marketing plugin might connect to.
.env.local: mentioned as a safer place to store API keys outside normal agent access.settings.local.json: mentioned as a way to restrict what Claude Code can do.Substack: the publishing home for The AI Maker and several participants’ work.
Cozora: the community where this session happened.
Take Action
Join Cozora to get more demos like Wyndo’s from other amazing creators. Paid subscribers of this newsletter get a 50% discount.
Join the inaugural cohort of the Agentic Academy of Knowledge Work.
