Today you'll learn to hand your work off — so Claude picks it up itself.
In the Q&A, someone asked about building a whole group of agents — dynamic agents. So today we zoom in on one thing: what an agent really is.
A program trained on an enormous amount of text. It learns patterns — then predicts what comes next, so well it feels like it understands you. Claude is an LLM.
“It doesn't look things up — it predicts what's most likely to come next.”
Give it “the sky is …” and it fills in “blue”. Next word, next word — that's the whole trick.
It groups things that mean the same — so “invoice”, “quote” and “receipt” sit close together.
Tools like ChatGPT and Gemini are LLMs too. You type a message — it types back.
That's the part everyone knows: a conversation. Today we go one step further.
It tells you. You copy-paste.
It does it — right in your files.
Same conversation — but now it happens in your terminal. That's the switch we're making today.
An LLM can chat.
An agent can BUILD.
That's the leap: from words on a screen to work that's actually done — in your files.
The moment you ask, the same loop runs — watch it live on the right. — click through it →
While it works, you can keep adding context — just type. Want it to stop? Press Esc.
Models reason, tools act. The harness binds them together and runs the loop. That's how it fits.
Each tool step feeds the next — the agentic loop in action. The details come over the next weeks, module by module.
A frame around the model that gives it tools, memory and a workspace. That's what turns a language model into a capable agent.
AI doesn't come with a manual — and it's an ongoing product, still growing every week.
To really grasp what it can do, it helps to look under the hood. The engineers behind Claude Code work in one place: the .claude directory.
You don't have to know it all. We'll touch the parts that matter: tools · hooks · skills · agents · subagents · workflows.
You ask: “Build a landing page.” Here's what happens under the hood:
That folder looks overwhelming. But most of it is engine room you skip past — and this is exactly what we open up over the coming weeks.
Like setting an alarm or picking a wallpaper on your phone: this is where you save your rules and preferences. Claude reads it every time you start a session.
So it knows straight away how to work with you.
Write it once. Every conversation, it remembers.
“There is no one correct way to use Claude Code.”
Boris Cherny — co-creator of Claude Code at Anthropic — says his own CLAUDE.md is “surprisingly vanilla”. It works fine out of the box. You can tweak and hack it however you like. But you don't have to.
So: no stress about doing it “wrong”. There is no wrong.
Predict the next word · cluster meaning. But there's one thing it's bad at →
Procedural knowledge is knowing the steps to get something done — the recipe, in the right order.
An LLM starts a long list fine — then drifts. It predicts the next word; it was never built to hold a whole procedure in its head.
Great at language, weak at following a long list of steps. That's exactly the gap a skill fills.
Without a skill you spell out every step, every time. A skill lets you write those steps once — then just call it.
A skill is just a recipe — your steps, saved once — so a short call gives the full result.
We help you grow your business.
Get startedWarm, editorial, unmistakably yours — cream & bordeaux, elegant serif, every single time.
Join the clubSame request — but the skill already knows your style, so the right one comes out on-brand.
Pick one recurring task from your business. You ask once — Claude writes the skill file you'll reuse forever.
Goal: you go home today with one Skill you'll actually use this week.
An agent is a helper with a role that decides for itself which steps to take. A skill is a recipe it can reach for — so the agent doesn't guess the procedure, it picks the right skill and runs it.
Your recipe — the steps and preferences, written down once.
A helper that decides on its own when to reach for that recipe.
Skills are the building blocks. Agents are what pick them up and run — which is exactly why the skill has to be good first.
An agent makes decisions for itself. That's powerful — but first you want to be able to trust it.
With a skill, you choose when to run it.
You use it, tweak it, until the output is reliable.
So when the agent later picks it on its own, you already know the result is right.
Build the recipe first. Hand it to the agent second.
Each one gives you time back. No tech — just handing work off.
Same worker either way — it runs the same loop of observe → think → act. What changes is the role. Think of a kitchen.
One person does every step themselves — one pair of hands, tasks wait in line.
A lead agent splits the work across subagents who cook in parallel.
Same worker — different role. Alone at the top → the agent; hired by another → a subagent.
The agent hands a sub-task to a subagent — and both reach for the same skills below. One recipe, shared by whoever needs it.
The essentials in one line: one clear role, a precise trigger, the right tools — and you iterate until you trust it.
What an agent is, how it wakes up (you · a schedule · an event), and why skills come first.
Step by step: write the role, set the trigger, pick the tools, and ship a working agent of your own.
We keep it simple here. The full build-along lives in the module on the website.
You make an agent once: you give it a role, a task and your rules. After that you call it and it works on its own — you don't have to spell out every step.
Reviews every page against your colours, font and tone — and says what's off.
Writes in your voice: product copy, newsletters, posts.
Grabs your details, fills in the quote and checks the total.
Important: an agent remembers its role and sticks to your rules. You can have several — each with its own job.
Your skills are the recipes. Your agent is the cook with a fixed role. Give the agent access to your skills, and it reaches for the right recipe itself.
You give the agent a goal — it decides which skill to use, and when. That's why the output holds up, even when you're not watching.
Today you made one helper. Next week we go further: agents that decide for themselves which steps are needed, and sub-agents — several helpers at once, each on its own piece of the work.
One for the copy, one for the design, one for the structure — in parallel.
Then we'll also explain how sub-agents work. For now: good to know it exists.
Two steps: make one Skill you trust, then give it to an agent and tell it when to reach for that skill on its own.
See you Friday