26:37Jake Van Clief · Tutorial
You're Automating The Wrong Layer
How 30,000 people build AI systems with folders and markdown files — no frameworks, no orchestration code.
May 20thThe argument in one line.
AI competence builds in three layers, chat, skills, and folders with one agent, and each layer is just the corrections you keep repeating getting written down once until a single sentence can run the whole thing.
Read if. Skip if.
READ IF YOU ARE…
- You've only ever used AI as a smarter search bar and want a real path past copy-pasting one-off answers.
- You already use ChatGPT projects or saved prompts and want to turn them into reusable skills instead of retyping corrections.
- You work inside Claude Code or Codex already and want a repeatable way to organize folders, maps, and routing for your own work.
- You run a small team or solo business and want to build an AI workflow around your actual job instead of a generic template.
SKIP IF…
- You want a quick prompt-engineering cheat sheet, not an 11-lesson structural course.
- You're looking for coverage of a specific tool's newest feature rather than a durable, tool-agnostic system.
The full version, fast.
Jake Van Clief's free Foundations course argues AI skill builds in three layers: chat, where you retype corrections every session; skills, where those corrections get written once into a file the AI reads on its own; and folders with one agent, where the AI works directly on your files through a short routing map. He frames design around a 60-30-10 split, mostly knowing the data and the question, a little existing tooling, only 10% AI, then shows how to stage work so judgment lands early and cheap, turn repeatable steps into code, and keep a folder from going stale. The throughline: start simple in a chat, build the complicated part into a skill and a folder, then collapse it back to one sentence that runs all of it.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:09
01 · Why This Course
Social proof and the course promise: what 11 free lessons get you, from a first AI chat to an agent working inside your own folders.
01:09 – 04:23
02 · Start Here: The Map
Introduces the three layers (chat, skills, folders with one agent), the three modules, and a quick guide to where different experience levels should jump in.
04:23 – 11:16
03 · 1.1 Chat
Layer one: using Claude or ChatGPT as a plain chat, the 'desk' model of context, and turning real corrections on a sample email into a decisions framework (voice, facts, identity).
11:16 – 17:28
04 · 1.2 Skills (and Projects)
Layer two: what a skill file actually is, building one from the prior lesson's corrections, testing it in a fresh chat, and separating skills (method) from projects (client-specific facts).
17:28 – 24:38
05 · 1.3 Folders and One Agent
Layer three: defining 'agent' via Simon Willison, setting up Claude Code against a real folder, the map file as routing table, and a live demo answering client emails from files on disk.
24:38 – 27:57
06 · 1.4 Pick Your Setup
The four pieces of any AI setup (model, harness, interface, where it runs), a menu of real options, the true cost of a tool, and a one-job test to validate a pick.
27:57 – 32:37
07 · 2.1 Start With the Outcome
The 60-30-10 rule for designing AI work, four questions to ask before opening a chat, and a worked bookings-export example.
32:37 – 37:26
08 · 2.2 Design Your Folder
Three real folder shapes (stages, records, wiki), the instructions/runner/state model of a program, writing a short routing map, and the free ICM Architect skill that proposes a structure automatically.
37:26 – 40:55
09 · 2.3 One Model, Different Jobs
Why 'agents' are mostly a naming convention for one model reading different map rows, the model-vs-tools split, and the narrow set of cases where running multiple agents actually pays off.
40:55 – 45:22
10 · 3.1 Stages You Can Step Into
Splitting work into stages that each leave a reviewable file, a real example of catching a scripting error early versus late, and manual mode, plan mode, and hooks as enforcement layers.
45:22 – 49:55
11 · 3.2 Turn the Steady Parts Into Code
How to spot a deterministic step worth scripting, asking the AI to write and test the code against a manual precedent, and wiring the resulting script back into the map.
49:55 – 54:04
12 · 3.3 Keep It Useful and Hand It On
Signs a workspace has gone stale, the fresh-session test, keeping one home for every fact, archiving retired work, and handing the whole folder to someone else.
Lines worth screenshotting.
- AI skill splits into three layers: chat, where you retype corrections every session; skills, where corrections get written down once; and folders with one agent, where AI works directly on your files.
- Every word in a prompt is a question, and something has to answer it: a file, a connection to your real data, or you retyping it every morning.
- A chat's context is just a desk: whatever you typed and attached, plus a little memory. If a fact isn't on the desk, the AI guesses.
- Starting a new chat for every new job matters because an old chat's desk stays covered in the last job's stuff and drags it into the next answer.
- A skill is nothing exotic: one markdown file with a name, a description of when to use it, and plain-English steps, the same format Claude, ChatGPT, and Codex all read.
- One team in Dubai mapped 38 of their own workflows into skills in four days and cut a three-day presales estimate down to six hours.
- An LLM agent is just a model running tools in a loop to reach a goal; the word 'agent' adds no instructions and no access by itself.
- The map file (CLAUDE.md or AGENTS.md) is a routing table in plain English: for this job, read these files, skip those, use this skill.
- The 60-30-10 rule: 60% of good AI work is the data and the thinking, 30% is tools that already exist, and only 10% is the AI itself.
- Most people start with the 10%, the AI writing the output, and then wonder why it keeps confidently getting the facts wrong.
- A folder has three parts, same as any program: instructions (your skills), a runner (the model), and state (the facts it reads and changes).
- The most common mapping mistake is cramming everything into one giant map file, which just puts the whole drawer back on the desk.
- One model can play every role a workflow needs; different 'agents' are usually just the same model reading a different row in the map.
- Multiple agents earn their cost only for independent parallel work, jobs too big for one desk, or something live that needs constant watching.
- Breaking work into stages that each leave one reviewable file means a mistake gets caught cheap and early instead of expensive at the very end.
- A step is a candidate for turning into code the moment you've done it the same way three or four times and taste isn't involved.
- A script is only trustworthy once you've checked it properly against something you already did by hand and it matched.
- If your prices or facts live in three different files, those files will drift; keep each fact in exactly one place and point everything else at it.
- The real test of a workspace: if you turned the AI off tomorrow, could you still find your way around the files and do the work yourself?
- Files and folders have outlasted every computing shift since the 1960s, which is why building structure around them survives the next model upgrade.
Three Layers Turn Corrections Into Structure
THE THREE LAYERS
AI competence isn't a better prompt, it's writing your own corrections down once as a skill and then letting an agent run them inside your actual files.
02Start Here: The Map
- AI work organizes into three layers: chat (talking back and forth), skills (writing recurring corrections down once), and folders with one agent (the AI working directly inside your files).
- Each layer is about organizing and reusing your own work, not about a smarter model, so there's no ceiling on how far a single layer can go.
- Where to start depends on where you already are: total beginners start at chat, people with saved prompts jump to skills, people already in folders skip to module two.
- The baseline gear is just a Claude or ChatGPT account; the free plan covers the first two lessons, and only the folder lesson needs the desktop app and a paid plan.
031.1 Chat
- A chat's context is a desk: whatever you typed, attached, and a little memory. Anything not on the desk gets guessed at, which is why a fact like 'the room isn't booked' needs to be stated explicitly.
- Start a new chat for every new job; an old chat's desk is still covered in the last job's stuff and will drag it into your next answer.
- Every correction you make to an AI's draft is a decision about voice, facts, or identity, and until it's written down, you're making that same decision again next week.
- The model is the brain and the app is everything around it, so the same model can feel smarter in one app purely because it can touch more of your files.
041.2 Skills (and Projects)
- A skill is just a markdown file with a name, a description of when to use it, and plain-English steps, written the way you'd train a new hire on day one.
- Build a skill by pasting past corrections into a new chat and asking for a skill file; read what it writes back since it sometimes invents a rule you never actually said.
- Projects hold what's specific to one area, a client, a newsletter, while a skill holds how you do a kind of job across all of them; mixing the two makes the skill unreliable elsewhere.
- A team in Dubai mapped 38 of their own workflows into skills in four days and cut a three-day presales estimate down to six hours.
051.3 Folders and One Agent
- An agent is nothing more than a model running tools in a loop: read a file, do something, check the result, decide what's next, repeat until done.
- A map file (CLAUDE.md or AGENTS.md) at the top of a folder is a routing table in plain English: what the folder is for, where things go, which skill to use for which job.
- Manual mode makes the agent ask before it changes anything, which is the safety net worth using until you trust the routing you've written.
- The same desk-and-drawers logic that applies to chat applies to folders: the map puts only what a job needs on the desk and leaves unrelated files in the drawers.
061.4 Pick Your Setup
- Any AI setup has four pieces: the model (the brain), the harness (what it can open or run), the interface (the window you work in), and where it runs.
- The real cost of a tool is the subscription plus setup time, upkeep, time spent checking its work, and time spent waiting on it, not just the monthly price.
- Working on your files locally and running the model locally are separate decisions; most people only need the first, and the second trades quality for privacy and a strong machine.
- Test any new setup with one tiny job: point it at one file, ask for a one-page summary, and confirm you can open, read, and change what comes back.
072.1 Start With the Outcome
- The 60-30-10 rule: 60% of good AI work is knowing the data and asking the right question, 30% is tools that already exist, and only 10% is the AI itself.
- Before opening a chat, answer four questions: who is this for, what do they need to do next, where does the information come from, and what breaks when it's wrong.
- Most people start with the 10%, which is exactly why the output keeps confidently stating things that aren't true, like promising a room that was never booked.
- Frame the job by the problem, not the tool: 'write my emails' builds an email writer, but 'my clients need clear answers about dates' might mean fixing the calendar first.
082.2 Design Your Folder
- Three different folder shapes all work for different jobs: stages, records, and a wiki, and the right shape depends on the work, not a template.
- Every file in a folder is one of three things: instructions (method), state (facts and work in progress), or sometimes both, and a file that's neither is worth questioning.
- Keep the map short: what's in the folder, where things go, naming rules, and a routing table. The most common mistake is cramming everything in.
- A cafe owner built a five-folder newsletter system with this method and sold it to an engineering firm in Australia, proof the structure matters more than the industry.
092.3 One Model, Different Jobs
- What looks like separate 'agents' is usually one model reading a different row of the same map; the name on the door adds no instructions or access.
- The model is good at reading a situation and choosing; the tools do the actual doing, like a scheduling connection that handles posting instead of the AI clicking around a website.
- Multiple agents earn their cost in three cases: independent parallel work, one job big enough to bury everything else, or something live that needs constant watching.
- Every extra agent costs more tokens, more waiting, and more places for coordination to break, so the default is one agent, splitting off a helper only when you can name the job it's taking off the desk.
103.1 Stages You Can Step Into
- Splitting work into stages that each leave one file behind means a mistake gets caught while it's still cheap to fix, instead of at the very end.
- Each stage needs a small contract: what it reads, what it makes, and who checks it before it moves on, written as plain English in the map.
- Three enforcement levels exist for judgment: a note in the map (read, not guaranteed), manual mode (asks before acting), and a hook (a hard rule that blocks an action no matter what).
- Stepping in is more than approving or rejecting: the highest-value move is often deleting a scene, paragraph, or step that doesn't earn its place.
113.2 Turn the Steady Parts Into Code
- A step is a candidate for code once you've done it the same way three or four times and the right answer doesn't depend on taste.
- Ask for the script directly: describe the transformation, have it write and run the code, then test it against something you already did by hand.
- A script is trustworthy only after you've checked it properly once, because a wrong script is wrong the same way on every single run.
- Once a script exists, add one line to the map telling the agent when to use it, so the same plain request now triggers the same reliable code every time.
123.3 Keep It Useful and Hand It On
- Run the fresh-session test periodically: open a new session and ask what's in the folder and what's next; if the AI gets it wrong, the map is out of date.
- Keep one home for every fact; if a detail lives in three files, those files will drift apart, so point everything else at the single source instead of duplicating it.
- An archive folder for retired work keeps the agent from wasting time on old versions, described in the map in a few words so it's never read by mistake.
- The real test of a workspace: if the AI disappeared tomorrow, could a person still navigate the files and do the work? A good structure passes that test for both an AI and a new hire.
Terms worth knowing.
- Agent
- A model that runs tools in a loop to reach a goal, reading a file, taking an action, checking the result, and deciding what's next, until the job is done.
- Harness
- The app or environment around the model that lets it open files, run commands, and save work, such as the Claude desktop app, Claude Code, or Codex.
- Skill
- A saved markdown file with a name, a description of when to use it, and plain-English steps, so an AI can run a process without being retaught every time.
- Map (CLAUDE.md / AGENTS.md)
- A short routing file at the top of a folder that tells an AI agent what the folder is for, where things go, and which file or skill to use for each kind of job.
- Interpretable Context Methodology (ICM)
- A way of organizing a folder so its structure, instructions, facts, and outputs, mirrors how the actual work gets done, making it readable by both a person and an AI.
- 60-30-10 rule
- A planning heuristic for AI projects: roughly 60% of the value comes from knowing the data and the right question, 30% from existing tools, and 10% from the AI itself.
- Desk-and-drawers metaphor
- A way of describing an AI's context window: the desk is whatever is in front of it right now, the chat plus attachments, and the drawers are everything else it can't see unless handed over.
- Artifact / Canvas
- A side panel Claude (artifact) or ChatGPT (canvas) opens for bigger outputs like documents, charts, or small apps, refined by talking rather than regenerated from scratch.
- Determinism
- The property of a process that gives the same output for the same input every time, the signal that a step belongs in a script rather than left to an AI's judgment.
Things they pointed at.
30:00bookThe Psychology of Computer Programming (Gerald Weinberg, 1971)
44:10bookAugmenting Human Intellect (Doug Engelbart, 1962 report)
Lines you could clip.
09:00
“Every word in a prompt is a question, and something has to answer it.”
18:50
“An LLM agent runs tools in a loop to achieve a goal.”
29:10
“Solve the problem first, then turn it into software after, if you can.”
47:30
“A script that's wrong is wrong the same way every single time, so check it properly once.”
52:10
“If I turned off the AI tomorrow, could you still find your way around these files and do the work?”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
Over 50 ,000 people have joined my free AI community, it's sitting at 5 stars from over 100 reviews, and this is the course they all start with. All 11 lessons start to finish in one video, and it's free. People come in having watched dozens of AI gurus and finally get from learning mode to actually building.
One member built a tool for tracking how his team follows their procedures and it worked straight away. And one review literally says, if you're wondering whether the five stars are just people being nice, they aren't. So here's what you're getting.
You'll go from your first AI chat to skills to an AI working right inside your own folders and then building it all around your actual work. Now, every lesson has a page that goes with it. So the steps written out, the setup links, the homework, and the practice folders I use in these videos.
And all of that lives in the free school community. Links right below. You can track your progress in there, post what you're building, and get feedback from people working on the same stuff.
Which, honestly, is where most of the learning happens. And when I mention history and concepts or live lessons, those are sections in there too. Alright, let's start.
All right, this is Foundations, and this is the Start Here video. So in the next few minutes, I'm going to tell you what this course actually gets you, what you need before you start, which is honestly not much, and where you should jump in. Because depending on where you're at, you might not need to start at the beginning at all.
So most people use AI like a really smart search bar, right? They ask it something, copy the answer, paste it somewhere, and then tomorrow they start over with a blank chat. And that's fine.
It works. And it's also about the smallest thing you can do with it. By the end of this course, you'll have AI working inside your own files, on your own work, where one short sentence kicks off real work and you can open up every piece of it.
Case in point, this video. The script, the animation, the little pixel me pointing at stuff, all of it came out of one folder on my computer. And later in the course, I'll open that folder up and show you how it's built.
So you can build one around whatever you do, videos or not. Now, everything in here hangs off one idea of mine, the three layers. And it's the same thing I teach the companies that hire me to train their people.
Layer one is chat. So you and a chat bot going back and forth, copying and pasting. Layer two is skills and saved prompts, where the stuff you keep retyping gets written down once.
And layer three is folders and one agent, where the AI works right inside the files on your computer and one sentence can reach all of it. And they're really about how you organize and reuse your work, so there's no ceiling on it. Layer three goes as advanced as you want.
Module one is one lesson per layer, plus a quick one on picking your setup. And they're hands -on, so you'll see exactly where I click and what I type on the real apps every step. Then in module two, we take your actual work and design a folder around it, starting with the outcome you want.
And module three is where we automate the parts that should run on their own, and you still step in wherever your judgment matters. Now, where you start depends on where you're at. If you've never really used AI past asking it questions, start at 1 .1.
And honestly, even if you think you know chat, there's a couple of things in there most people miss. If you already use projects or saved prompts, jump to 1 .2, skills. And if you're already working in folders with clod code or codex, go straight to 1 .3.
Or skip ahead to module 2. I won't be offended. For gear, you need a Claude account or a ChatGPT account.
And on Claude, the free plan covers the first two lessons. For the folder lesson, you'll need the desktop app and a paid plan. And I'll keep the current details on the page under each video, because these apps change every couple of weeks and I'm not rerecording every time a button moves.
And you don't need to know how to code for any of this. I promise you, almost everything you're going to see is just English sitting in text files, and I'll show you that too. There's also two extra sections in the classroom.
Live Lessons are longer recordings of me working through real stuff with people, and History and Concepts is where I nerd out about Engelbart and Unix and why any of this works in the first place. You can dip into either one whenever you want to go deeper. Alright, that's the map.
Let's start with Layer 1. This is Lesson 1 .1, the first of the three layers, which is Chat. All you need is Claude or ChatGPT open, and the free plan's totally fine for this one.
By the end, you'll have gotten a real piece of work out of a chat, corrected it until it's actually right, and you'll know which of your corrections are worth keeping, which is literally what the next lesson is built on. So let's start with what a chat can actually do right now, because people are building real stuff in there.
Little working apps. So a pricing calculator, a dashboard off a spreadsheet, a game for their kid. They're dropping in a messy spreadsheet and getting the chart and the summary back.
making slide decks, research write -ups with the sources linked, all from one box. And quick bit of background, because it explains why this course is built the way it is. I've been working with these models since the original BERT models, before ChatGPT was even a thing.
And I've been chatting with them since that showed up almost four years ago. And yeah, back then, I was pasting prompts in by hand, in a specific order, wait for the answer, check it. paste the next one, like some kind of ritual.
But my research needed way more than that. For my psychometric work, I wrote Python scripts that fired prompts at a bunch of different models at once, over 10 ,000 responses. And that turned into a paper and a tool researchers at the University of Edinburgh now use to study authoritarianism.
I take the whole thing apart in my psychometrics video, over in History and Concepts, if you're curious. And the reason I bring it up is that the stuff I built the hard way back then, I can kick off now with one short sentence because all the complicated parts got written down into skills and folders underneath it. That's the shape of this whole course, right?
You start simple in a chat. You build up the complicated stuff, and then it folds back into one simple sentence with all that work behind it. And that's what I want you walking away able to do.
So let me show you how I'd use it today. Go to clod .ai or chatgpt .com or open the app and sign in. The moves are pretty much the same in both.
And you've got one box in the middle. That's where everything goes. This little plus is how you hand it stuff.
So a PDF, a spreadsheet, a screenshot, a photo of your whiteboard. And this microphone, honestly, I use that half the time. I just talk at it like I'm talking to you right now.
And when you ask for something bigger, a one pager, a chart, a little app, Claude opens it in a panel right next to the chat. Those are called artifacts, and ChatGPT calls its version Canvas. You keep shaping it just by talking.
So make the header blue, add a column for the date, cut the second paragraph. And if you hand it a spreadsheet, it can actually run the numbers on the real file. Quick thing that confuses a lot of people.
The model is the brain and the app is everything around it. What it can open, what it can run, where it can save stuff. So the same brain can feel way smarter in one app than another just because one of them lets it touch your files.
Keep that in your back pocket. It matters a lot in 1 .3. Now, the AI only sees what's on its desk for this conversation.
So whatever you typed and whatever you attached, plus a little bit of memory, which I'll get to. So it has no idea who your clients are, how you like your emails, or what you meant by the usual. If it's not on the desk, it guesses.
And if you dump everything on the desk, it guesses which one you meant. Which is also why I start a new chat for every new job. It's right up here at the top.
An old chat's desk is still covered in the last job's stuff, and it'll drag that into everything. So if you've ever had it randomly bring up something from an hour ago, that's why. New job, new chat.
And if you want the deep version of why the desk works like this, there's a video on a 1953 word game over in History and Concepts. So let's do a real one. I've got an email from a client asking to move their workshop.
And these are made up emails, by the way. Trust me, nobody needs to see my actual inbox. I paste the email in and type, write a reply.
I can't do the 14th, but the 21st works. Keep it short. So it's got the email, what I want back, and the dates, which only I know.
And even a tiny prompt like that is full of questions. Reply how? Formal or casual?
Long or short? Reply as who? And what do I usually promise people?
Every word in a prompt is a question, and something has to answer it. Either a file you wrote, a connection to your stuff, or you retyping it every single morning. Right now, in Layer 1, the answer is you.
Every time. So it writes something, and it's fine, but it's weirdly formal. It opens with, I hope this email finds you well, which nobody in history has ever meant.
And it promises them the room, which we haven't booked. So I just tell it, too formal. I'd never say that.
And don't promise the room yet. And it fixes it. One more.
Just sign it Jake. And now it's something I'd send. And there's a little copy button right under it, so it goes straight into my email.
Now look at what just happened. Every correction I made was a decision, right? Too formal is about my voice.
The room is about what we actually know. And that one's a big deal, because a wrong promise in an email costs you way more than a stiff sentence. And the sign -off is about who I am to this person.
The AI made its own calls, too. The tone, the length, what to assume. So even a chat this small is a whole chain of decisions.
And this is where layer one starts to hurt. Next week, another email comes in, and I'm typing too formal again, don't promise things we haven't booked again, sign it Jake again. Both apps can remember a little about you now, which is nice, honestly, but the app decides what it keeps, and your way of doing this job still isn't written down step by step anywhere you could hand to somebody else.
People fix that with saved prompts, a big one they paste in every time, or a doc full of favorites, and honestly, that's the start of layer two. I did it for years. But you're still the one carrying everything from chat to chat.
So the move is to take those corrections, the ones you keep typing, and write them down once, somewhere the AI can pick them up on its own. That's a skill, and that's where Layer 2 gets good. And you're going to hear the word agent a lot.
For now, just know that when the AI starts using tools on its own, so opening files, running things, checking its own work and going again, that's what people mean. And it's way less mysterious than it sounds. We'll get there in 1 .3.
So here's your homework. And it's optional. I'm not checking.
Pick one thing you do every week, do it in a chat, and every time you correct it, write the correction down. bring that list to the next lesson, because that list is basically your first skill already. Either way, happy learning everyone!
This is lesson 1 .2, layer 2, which is skills. You need the chat from last lesson, or honestly any chat where you had to correct the AI a couple of times. And on Claude, the free plan works for this one too.
By the end, you'll have your first skill, made from your own corrections, saved and working in a brand new chat without you retyping a thing. And you'll have a project set up for your files. So back in 1 .1, I told you about pasting prompts in by hand, in order, and then writing scripts to fire them off at scale.
At some point, you realize all of that is a process, right? And a process can be written down. Somebody goes through all that back and forth, figures out the right instructions in the right order, the stuff that makes the output actually good, and packages it up so the AI can run it.
That's a skill. Let me show you some. In Claude, click Customize in the left sidebar, then Skills, and these are all skills, some from Anthropic, some from other companies, so PowerPoint, PDFs, designs, spreadsheets, and you can make your own.
If you don't see them, check that code execution's turned on in Settings, under Capabilities, Skills Needed. And ChatGPT and Codex have skills too, in pretty much the same format, so what you build travels with you. And if you look inside one, and plenty of them are sitting on GitHub where you can just read them, it's a folder, and inside there's a file called skill .md.
At the top, there's a name and a description, which says what it's for and when to use it. And under that, it's steps, written in plain English, the way you'd write instructions for a new hire on their first day. Sometimes there's templates or little scripts in the folder too, but the heart of it is that one file.
And that .md is markdown, which is just a text file with a tiny bit of formatting. Dashes for bullets, hashtags for headers, or pound symbols if anyone else remembers when they were called that. A guy named John Gruber came up with it in 2004, and your AI already writes in it.
All those bold words and bullet points in its answers? That's Markdown. And the AI only sees the names and descriptions of your skills, and when your request matches one, it opens that one up and follows it.
That's the desk from last lesson, kept clean, so you can have a hundred skills sitting there and it only pulls the one this job needs. So let's make one from that email chat. Start a new chat and say, I want a skill for replying to client emails and paste in the corrections from last time.
Too formal. Don't promise anything we haven't booked. Sign it, Jake.
And Claude actually interviews you. So what should this do? When should it kick in?
Show me a reply you liked. And then it writes the skill file and hands it to you to save. Then read it.
Seriously, read it. Sometimes it writes down a rule you never actually said. Or it takes one example and turns it into a law for everything.
And this is your process now, so it should sound like you. You just tell it what to fix, and it rewrites the file. It's all just English.
So here's mine. It's called How I Reply, and the description says, Use this when replying to client emails. Then the steps.
Match their length, keep it short and casual, no hope this finds you well, never promise a date or a room that isn't confirmed, and sign it Jake. That's literally the list of corrections from 1 .1, written down once, plus a couple of things it picked up when it interviewed me. Now the test.
New chat, empty desk, I paste in the next email and type, reply to this. That's it. No speech about my tone.
Nothing. And you can see it says it's using how I reply. And the draft comes back short and casual.
Nothing promised that we haven't booked. Signed, Jake. I didn't retype a single correction.
And it's the same move for anything you do over and over. how you write a proposal, how you check a spreadsheet before it goes to your boss, how you turn a call into meeting notes, how you review code. And you can grab skills other people made.
There's one called Humanizer I recommend to basically everybody. It strips the AI -sounding stuff out of writing, and you just download it and upload it in Customize, Skills, with the plus button. And I've watched this work for real.
I trained a team at a company in Dubai, people who barely touched AI. And in the first four days, they mapped 38 of their own workflows, which is this exact move, writing down how they actually do the job. And in three weeks, they turned a three day presales estimate into six hours.
Now, a skill is how you do a kind of job. But some stuff only belongs to one area of your work, like everything about one client or your newsletter or the course you're building. That's what projects are for.
In Claude, you hit projects, make a new one, and you get two things. Project knowledge, where you drop your files, and instructions, which apply to every chat inside that project. And when a project gets big, not every file makes it onto the desk every time.
So if one really matters for this job, mention it by name. So the way I think about it, my skill is how I reply to anybody. And everything about this one client, their workshop, what we agreed last month, goes in the project.
So the skill still works for the next client. Mix them together and your skill starts promising every client the 21st. And look, if you've got a doc full of saved prompts, that's still layer two.
A skill's just the cleaner version the AI can pick up on its own. And somebody's going to ask about the instructions box in your settings, so use that for stuff that's true in every chat, like your name, and skills for a kind of job. But you'll notice I'm still dragging files in by hand.
A client sends a new brief, I upload it again. The AI writes me a draft, and I copy it out of the chat. And all my actual work, my spreadsheets, my notes, my code, lives on my computer.
That's layer three. folders and one agent. And it's where skills get really powerful, because they stop floating around and get wired into the actual work.
For now, take your list of corrections from last lesson and turn it into your first skill, then test it in a fresh chat. Either way, happy learning everyone! This is lesson 1 .3, the last of the three layers, folders and one agent.
For this one, you'll need the Claude desktop app on a paid plan or Codex if you're on the ChatGPT side. I'll keep the current setup steps on the page below and a folder with some real work in it. And honestly, use a copy of it the first time.
By the end, the AI will be working right inside that folder, reading your files, saving its work back where you can open it, and one short sentence will reach all of it. And you'll finally know what an agent actually is. For most people, the agent problem is already solved.
One good model, a good harness, and a good set of folders. And a harness is just what I called the app back in 1 .1. Everything around the brain that lets it open files and run stuff.
So let's talk about the word agent for a second, because it scares a lot of people off for no reason. Simon Willison, a developer who writes a ton about this stuff, put it in one line. An LLM agent runs tools in a loop to achieve a goal.
And LLM just means the language model, the brain. That's it. The model reads a file, does something, looks at what happened, decides what's next, and keeps going until the job's done.
And the tools are just things like open this file, search this, save that, run this command. And all the ones you hear about, research agent, writing agent, email agent, that's the same model reading different instructions with different tools. Which is why I keep saying agents are just a naming convention.
The value comes from everything else. The instructions you write, what it can reach, and the outcome you actually want. And look, if you've built a cool multi -agent setup, I'd honestly love to see it.
There are real cases for them. So here's how you actually do it. Open the Clod desktop app, go to code, pick local, and select your folder.
And you'll see it right up here. That's where it's working. I'm using code for this because it reads the map file every single time, which I'll show you in a sec.
And how much it asks before it changes stuff is a setting right under the box, so put it on manual and it'll ask first, at least until you trust it. So let me bring this down to earth. Here's a little folder I set up for client emails, same made -up clients as before.
Up top there's a file called claw .md, and this is the map. Claude Code reads it every single time it opens this folder. So it's like the floor plan on the wall when you walk into a building, right?
You put the stuff it always needs in here, what this folder's for, where things go, and what to read for each job. And in Codex, the same file's called Agents .md. Then there's About Me, which is who I am and how I work.
There's my reply skill from last lesson. I copied it in here under .Claude Skills, so it travels with the folder. There's a folder for each client with their notes, an inbox with the emails, and drafts, which is where finished stuff goes.
And if you open any of these, they're just text, no secret code, I promise, I checked. And this is the most important part, the routing. It's just a little table in the map that says, for this job, read these files, skip those, use this skill.
So for replying to email, read about me, the client's notes and the inbox, use how I reply, and save to drafts with the date and the client in the name. That's the whole trick. And it's all English.
And you don't have to write it from scratch. Just ask it to look through the folder and write you a clod .md, then read it and fix it. Same as the skill.
Just remember, the map's something it reads, so for anything that must never happen, like sending an email, use the settings too. More on that in 3 .1. So now I type three words, check my email, which is honestly almost terrible prompting, and watch it go.
It reads the map. opens the inbox, reads about me, pulls the reply skill, checks each client's notes so it doesn't promise anything we haven't agreed, and writes the replies into drafts, named with the date and the client, and since we're on manual, it asks me before it saves. And boom!
There they are. Back in 1 .1, I said every word in a prompt is a question, and something has to answer it. Check is how, and that's answered by the skill.
My is who, and that's about me. Email is which mailbox, and right now that's this inbox folder. But you can connect your actual Gmail in Customize under Connectors, and then it's reading the real thing.
And the drafts are just files. I can open one in Notepad, change a word, delete the one I don't like, and when one's right, I paste it into Gmail and hit send myself. Nothing breaks when you edit it, it's just English.
And that matters more the more you automate, because you always want a way to get in there and add your judgment, or take something out. And this is why folders work so well. It's the desk again.
The map and the routing put exactly what this job needs on the desk and leave everything else in the drawers. So even if my video scripts were sitting in here, they'd stay in the drawer while it answers email. And one sneaky thing I do?
I put naming rules in the map. So I can say, pull last week's draft for Maple Street, and it just knows where to look. And nine times out of ten, that's all you need.
No database, nothing. And this works for way more than email. This is the folder I promised you back in the Start Here video.
The one that made this video. And it's the same pattern. A map up top, a room for each stage, and each video in its own folder.
A sales team's folder might hold their data, how they check it, and this week's report. And a developer's holds their code and the decisions behind it. And this whole pattern is what my paper on Interpretable Context Methodology is about.
I call it ICM, and the skill that builds these, which you'll meet in 2 .2, has almost 1800 stars on GitHub. And these are just files and folders, the same idea computers have run on since the 70s. So when a better model comes out next month, and it will, I bet all of this keeps working, maybe with a renamed file or two.
And we'll dig into why in 3 .3. And this is the bigger idea I keep coming back to. When Doug Engelbart showed the world the mouse in 1968, one little movement of your hand could drive this whole complicated system.
A sentence is starting to work like that now. Check my email is the click and everything underneath it is still sitting right there in folders you can open. So that's the three layers.
And look at the shape of it. You started simple in a chat. built the complicated stuff into a skill and a folder, and it came right back to one simple sentence, check my email, with all of layer three behind it.
Next up, 1 .4 is a quick one on picking your setup. And then module two, where we take your actual work and design the folder around it, starting with the outcome. And that's where my 60 -30 -10 rule of thumb comes in.
For now, take one folder of real work and write a short map for it. What's in here, where things go, what to read for which job. Then give it one short request and watch what it reads.
And if it reads the wrong stuff, that's your map telling you what to fix. Either way, happy learning everyone! This is Lesson 1 .4, Picking Your Setup, and it closes out Module 1.
For this one, you just need what you've already got, because it's all about choosing. By the end, you'll know the four pieces of any AI setup, what each option really costs you, and you'll test whatever you pick with one tiny job. So there's about a hundred ways to run AI right now, and every week somebody online tells you the one you're using is wrong.
Honestly, most of them are fine, and your folders come with you to most of them, and the useful bit is knowing which piece does what so you can tell when switching actually buys you something. Back in 1 .1, I called the model the brain, and the app everything around it. And in 1 .3, we called that app the harness.
So let's add two more pieces. The interface, which is just the window you work in, a chat box, a terminal, an editor, and where it runs. So somebody's cloud, your own computer, or a bit of both.
So here's the menu. The Clod app is the easiest start. chat for talking, and code when you want it working in your folders, which is what we've been using.
Cloud Code also runs in a terminal or right inside an editor like VS Code. Same brain, same harness, a different window with more control. On the ChatGPT side, Codex does the same job.
Cursor is an editor with AI built right in, and you can even run an open model on your own computer with something like Ollama. And people mix these two up all the time. Working on your files locally and running the model locally are two separate choices.
Everything in 1 .3 used files on your computer with the model running in the cloud. A local model keeps everything on your machine, which is great for privacy or working offline, and you'll usually trade away some quality and need a pretty beefy computer. Now the cost.
And I mean the whole cost. The subscription's the part everybody looks at. Then there's the setup time, keeping it running, the time you spend checking its work, and the time you spend waiting on it.
A cheaper tool that eats your whole Saturday costs you a Saturday. And look, I'm pretty loud online about not needing fancy setups, and for most people that's true. I also built my own pipeline for that psychometrics research from 1 .1, so I know when a custom setup earns it.
And it's usually when you need something none of the apps do at a scale they can't handle. So if you're new, the Clod app, done. If you live in code, clod code or codex inside your editor.
If your company's already on Microsoft or Google, check what's already in there before you buy anything. And if privacy is the whole point, look at a local model. Then test it with one tiny job.
Point it at a folder with one file in it. Or on the free plan, just attach the file. Then ask it to read the file, write a one -page summary, and save it right next to the original.
Or hand it back as a file you download. Then open that summary yourself, outside the AI. If you can open it, read it, and change it, Your setup works!
The exact install steps change constantly, so they live on the page under this video with a date on them. So your homework? Pick one setup, run the tiny test, and open the result yourself.
Next up is Module 2, where we build around your own work, starting with the outcome you want. Either way, happy learning everyone! This is Lesson 2 .1, the start of Module 2, and this is where we build around your own work, with mine right alongside.
You'll want one real job you'd like help with, and that's it. No setup needed for this one. By the end, you'll know who the job's really for, what they need to do next, and how to split the work 60 -30 -10 before you touch any AI.
Back in 1 .1, the most important correction I made was don't promise the room. And no amount of better writing fixes that one, because the answer lives in a calendar. The AI wrote a perfectly confident reply about a room we didn't have.
So here's my rule of thumb for designing anything with AI. 60, 30, 10. 60 % is the data.
The questions and the thinking. So knowing what's actually booked and what the client really needs. 30 is the tools that already exist.
Your calendar, your email, a spreadsheet. And honestly, I know people who can solve problems with Excel better than a machine learning model. And 10 % is the AI.
Writing the reply. Most people start with the 10, and then wonder why it keeps promising rooms. And it's a rule of thumb for how to think about the work, so the numbers are rough on purpose.
And if you've watched some of my older videos, you'll notice I used to split it differently, more technically, so code, routing, and AI calls. Same instinct, and honestly I think the deeper fundamental is how I'm describing it now. The data, the questions, and the thinking.
Because that 60 is where people actually get stuck. So before you open a chat, start with the question I always start with. What are you doing right now for people?
And what would you do manually? Then four quick ones about your job. Who is this actually for?
What do they need to do next? Decide something? Send something?
Fix something? Where does the information come from right now? And what breaks?
And who feels it when it does? That first one matters more than it looks. Whatever you make, the report, the deck, the reply, you're building something that helps inform someone, right?
If your boss needs to decide whether to hire someone, what they need is the three numbers that matter on one page before Friday. And it usually pays off in speed to the decision, cost of the decision, or the big one now, how people interact with the decision. So let's run one.
Say every Monday you pull a bookings export and turn it into a table for the owner. Who's it for? The owner.
What do they need to do next? Chase the bookings that are still pending before the week fills up. Where does the info live?
One export from the booking system. And what breaks? Pending bookings slip through and nobody notices until it's too late.
So the 60 is knowing that pending is what matters, the 30 is the export and a spreadsheet, and the 10 is the AI writing the owner a two line heads up. And we'll turn that table part into a script in 3 .2. There's a book from 1971 I love, The Psychology of Computer Programming by Gerald Weinberg.
And the big idea is that programming is a human activity. And the way I read it, how people understand the problem shapes what the software turns into. AI's exactly the same.
Frame the job as write my emails, and you build an email writer. Frame it as my clients need clear answers about dates, and you might end up fixing your calendar first. And I always push this.
Solve the problem first, then turn it into software after, if you can. So build the smallest thing that gets you close and check what the app already does before you build anything. The chat can already read a spreadsheet and make a chart.
A project already holds your files. A skill already remembers your corrections. And only add the next piece when you hit a real need, like the files keep changing.
It's the same steps every week or somebody else needs to use it. Here's a real one of mine. When I post videos, the outcome is people finding stuff that actually teaches them something, and maybe joining the community.
The 60 is knowing what to post, which hooks actually worked, and who it's for, and that comes from my numbers and a lot of questions. The 30 is Metricool, which schedules everything across YouTube, TikTok, Instagram, and LinkedIn. And the 10 is AI helping with scripts and captions, and I still pick every title myself.
And if you want the bigger picture of where to build and what the platforms are about to hand you for free, the latter video's over in History and Concepts. So your homework, pick one job, answer the four questions, and split it 60 -30 -10. Write it down, because next lesson, 2 .2, that's exactly what we build the folder around.
Either way, happy learning, everyone! This is lesson 2 .2, designing a folder around your own work. You'll want the job you wrote down in 2 .1, the who, the next step, and the 60 -30 -10, plus the desktop setup from module 1.
By the end, you'll have a workspace shaped around your own job, a short map that sends each job to what it needs, and you'll have tested it with one real request. So here's three folders that all work, and they look nothing alike. My animation folder runs in stages, one after another.
The client email folder from module one is records, a folder per client. And Andrej Karpathy, who helped start OpenAI, shared an idea for a wiki that the AI keeps up itself. Raw sources in one place, and the pages it writes and links in another.
Three totally different shapes, because they're three totally different jobs. And they all come from the same way of thinking. That's ICM, Interpretable Context Methodology, from the paper I mentioned back in 1 .3.
People started calling the folders themselves ICMs, and when I say it, I mean the method, the way of thinking that builds the folder, so your folder comes out shaped like your work, and it won't look like mine. Start from what you wrote in 2 .1 and list the jobs that get you to that outcome. The email folder has two jobs, replying to clients and sending them updates.
For my videos, it's plan, voice, words, storyboard, scene, and render. For each job, write down what it needs to read and what it makes, and that list is basically your folder already. The folder becomes your app, honestly, and there's no simpler interface than a folder.
Then separate stuff by what it is. Your method, so how you do the job, that's your skills and instructions. your facts , the work in progress, and the finished outputs.
This is the same split we made back in 1 .2 between the skill and the project, because the method carries over to the next client, and the facts stay with this one. Here's a lens I use in my lectures. A program has three parts.
The instructions, something that runs them, and the state, which is the stuff it reads and changes. And nothing in that needs a computer. A loom had all three.
So did a room full of clerks with a ledger. And yes, that's a different three from the three layers, just to keep you on your toes. In your folder, the model is the thing that runs, and the other two are yours to write.
So go through your files and label each one. because every file you've built is instructions, state, or sometimes both, like notes it reads and then updates, and a file that's neither is the first thing to question. Then the map.
Keep it short. It's a routing file, so what's in here, where things go, your naming rules, and the routing table we built in 1 .3, which is traditional software routing that's been around for decades, except now it's plain English. The most common mistake I see in the community is a giant map with everything crammed in.
And that just puts the whole drawer back on the desk. The email folders map fits on one screen with two rules. Never send anything.
And if the client's notes don't confirm something, say so. And remember, it's the setting that actually stops a send. And you don't have to design all of this by hand.
I made a skill called ICM Architect. It's free on GitHub. And you point it at your messy folder and say, make this an ICM.
It looks at what's there, asks you about the work, and proposes a structure and a map, and it knows six different shapes a workspace can take, including the three I just showed you. Then read what it proposed, same as the skill back in 1 .2. It might give you rooms you don't need yet.
Start with the smallest version that does today's job, that's the rule from 2 .1, and add a folder when the work actually asks for one. Then test it. New session, ask for one real job, and watch what it reads.
If it opens the right few files and skips the rest, your routing works. If it wanders around reading everything, your map's too vague, so tighten that one row and try again. And look, nothing's built right the first time, and most things built the seventh time aren't great either.
And this stuff is worth real money, by the way. Somebody in my community runs a cafe, and they built a five -folder system for a newsletter and sold it to an engineering firm in Australia. Five folders.
And if you want to watch me build one from scratch, start to finish, the full walkthrough is over in Live Lessons. So your homework, list your jobs, split method, facts, work and outputs, write a short map with a routing table, and test it with one real request. Next lesson, 2 .3, we give that one folder a bunch of different jobs and talk about when you actually need more than one agent.
Either way, happy learning everyone! This is lesson 2 .3, one model doing a bunch of different jobs. You'll want the folder you designed in 2 .2.
By the end, you'll know how one model plays every role your work needs, where code and connections fit in, and the handful of times a team of separate agents actually earns its keep. Back in 1 .3, I said agents are just a naming convention, so let me show you what that looks like for real. This is the map for my animation folder, and look at this table.
Make a new video, write a short, schedule a finished one, fix a broken piece of the animation kit, make a video in the hand -drawn style. Every one of those is a completely different job, and it's the same model every time, reading a different row. So when people say they need a writing agent and a scheduling agent and a research agent, most of the time what they need is the instructions for each job written down, and a map that sends each request to the right ones.
A lot of frameworks push you to build a separate agent for every job, and I'd rather just have Claude Code become the agent you need, right there in the workspace. The role comes from what it reads, and a name on the door adds zero instructions and zero access. Try it in your own folder.
Give it two different jobs back to back, like reply to this email, and then make me a table of every booking this month, and watch what it opens for each one, and you'll see different rows and different files with the same model both times. And a lot of the jobs aren't even the models to do. In my folder, the model lines up what I've picked to post, and a connection to Metricool does the actual scheduling, and when it's time to render, it runs a command that does the exact same thing every time.
The model's great at reading the situation and choosing, the tools do the doing. And we'll turn more of your own steps into tools in 3 .2. Now, there are real times you want more than one agent running, when there's a lot of independent work that can happen at the same time.
like researching 10 companies at once, when one job is big enough that it would bury everything else on the desk, or when something's happening live and needs watching the whole time. That's when a team of agents earns it. Funny enough, while I was writing this course, I had one helper pulling quotes out of my old talks and another one checking the product facts, both at the same time, because neither job needed the other.
And the simplest version of that is just opening a second session. So one's writing a script while another one does something in production. Same folder, no framework.
And in Cloud Code, it's built in too. It can hand a chunk of work to a subagent and get back just the answer, so its own desk stays clean. But every extra agent costs you something.
More tokens, more waiting, and more places for things to go sideways, because now they're handing work to each other. So start with one, and split off a helper when you can point at the exact job it's taking off the desk. Anthropic's own guide to building agents says the same thing.
Start with the simplest setup that works, and sometimes that means no agent at all. And if you want to get into the difference between a model, a wrapper, an agent, and all the orchestration around them, there's a whole video on that over in History and Concepts, the OpenClaw one. So your homework?
Give your folder two different jobs and watch what it reads for each. Then find one job that could run on its own. at the same time as everything else.
Next up is Module 3, where we automate the stages and keep your judgment right where it counts. Either way, happy learning everyone! This is Lesson 3 .1, the start of Module 3, which is where we automate more of the work without losing our grip on it.
You'll want a job you already do in Steps, or the folder you built in Module 2. By the end, you'll know how to split work into stages that each leave a file you can open, where your judgment actually changes the result, and how to make the AI wait for you when it matters. So here's my animation folder again, the one from 1 .3.
I made a whole video walking through every stage of it. It's up on my channel, the one about making AI videos that don't feel like AI slop, so I'm not going to redo the full tour. Today, we're looking at one thing in it, the spots where I step in.
Each stage is one step that leaves one file behind. The voice stage leaves an audio file. The word stage leaves a transcript with every word timed.
The storyboard is a plain text file. Then comes the scene, then the render. And nothing moves to the next stage until somebody's looked at the last file.
And that rule's sitting right there in the map. Here's a real one from lesson 1 .1. The script said I'd been doing this for two years, and it's closer to four.
I caught it reading the script. One line in a text file, a ten second fix. If I'd caught it after the animation was done, that's a new voice take, new timings, new frames, the whole thing.
And that's the reason for stages. When the work sits in files between steps, your judgment has somewhere to land, early. while it's still cheap to change.
When it's one giant run from prompt to finished thing, the only place left to fix anything is the very end, and the end is the most expensive place there is. Stages stop what I call the narrow funnel, the AI doing too much all at once, and you can still automate the whole process when you want to. So to set this up for your own work, first write your job as stages, each one with the single file it makes.
A weekly client report might be gather, draft, check, send. Then give each stage a little contract, what it reads, what it makes, and who checks it before it moves on. Here's one of mine, and it's short.
It's just English sitting in the stages folder. Then you tell it where to stop. You can write it right in the map, stop after each stage and wait for me.
And it reads that and pretty much always follows it. But that's still something it reads. So for anything that really can't happen without you, like sending an email or deleting stuff, use the settings.
Manual mode asks before it edits files or runs anything. Plan mode only lays out a plan without touching anything. And if you want a hard rule, there's a thing called a hook that blocks an action no matter what.
Now, you don't need to watch every step. I don't sit there watching it transcribe. That's a script.
It does the same thing every single time. I listen to the whole voice take, I read the storyboard, and I watch the stills. Because that's where my taste actually changes the result.
So put your eyes where your judgment matters, and let the rest run. And stepping in is way more than a yes or a no. I add a line, I stretch a beat that's rushing, and honestly, the one I use most?
I delete stuff. A scene that doesn't teach anything, a paragraph where I'm clearly just showing off, gone. And this is the part I care about most.
Doug Engelbart wrote a report back in 1962 called Augmenting Human Intellect. And the whole idea was computers making people more capable with the person right there steering. That's what these stages are for.
The AI does more and more of the work and you keep a way in. And this is where the mouse idea from 1 .3 really comes together. People used to edit with pencils and scissors and glue.
Then came the keyboard and the word processor. Then the mouse, where you just point at things. Every one of those made the work simpler to drive, while the stuff underneath got way more complicated.
A sentence is the next one, and since the model still interprets it, the same sentence won't always run the exact same way. So the good setups keep the complicated part right underneath, where you can open it up and check. So your homework.
Take one job and split it into stages, name the one file each stage makes, and mark the one or two where your judgment changes the result. That's where it stops and waits for you. Next lesson, 3 .2, we take the stages that come out the same every single time and turn them into code.
Either way, happy learning, everyone. This is lesson 3 .2, turning the steady parts into code. You'll want a workspace with at least one step you've done the same way three or four times.
And no, you don't need to know how to code. I'll show you why. By the end, you'll have one of those steps running as a script, written into your map so the AI uses it, and you'll know which steps should stay with the AI.
So something that surprises people about my animation folder is that most of the work making these videos is plain old code. One command turns the voice into words with exact timings, one lines the storyboard up to those words, one renders every single frame, and Claude doesn't have to think for any of it. That's the help screen right there.
And look at the line under the list. Each command does one stage and stops. And the reason is consistency, or determinism if you want the fancy word.
When the same input should give you the same output every single time, like timing words, rendering frames, or totaling a spreadsheet, that's a job for code. A script does it the same way on the hundredth run as on the first. The AI is great at the parts that need judgment, like writing the script for this lesson or deciding what goes on screen.
And that's where I keep it. Back in 1 .1, I mentioned my psychometrics research. The AI part of that was the models answering the questions, but scoring the answers is arithmetic.
Researchers worked out those scoring keys decades ago, so a script does it the same way across 10 ,000 responses. And that's the 30 and 60. 30, 10.
the tools and code that already exist doing what they're good at. Spotting one is pretty easy. Write the process down and ask yourself, can I do this the same way consistently?
If you've done a step the same way three or four times and the right answer doesn't depend on taste, it's a candidate. And the bookings table from 2 .1 is a perfect one. Renaming a pile of files, turning an export into the same summary table every week, pulling the numbers out of a report, resizing images, things like that.
Then you just ask. Something like, write me a script that turns this export into the weekly table, put it in a scripts folder, and add a line to the map saying when to use it. And it writes the code, runs it, and shows you what came out.
You don't have to write the Python yourself, though honestly you'll start reading it after a while, and that's a good thing. Then test it on something you already did by hand, like last week's export, and compare the two. And this part matters, because a script that's wrong is wrong the same way every single time, so check it properly once and ask it to walk you through anything you don't follow, line by line if you have to.
Now the map. One line, for the weekly table, run the make table script. So next week you just say, make this week's table, and it runs your script, the same way every time.
And because the script has one clear input and one clear output, you can swap it out later, make it faster, change the format, and nothing else in the folder has to change. That's pretty much the old Unix rule from the 70s. Make each program do one thing well.
And if it should happen on its own, like every Monday morning, the desktop app has scheduled tasks right in the sidebar. You set when, write what it should do, and it runs.
And since this one works on files on your computer, the app has to be open and the computer awake. Monday comes around and the table's already sitting there waiting for you. Now, not every step should become code.
If a step needs reading between the lines, like replying to a client or deciding what a video should show, keep that with the AI and with you. And you don't have to plan any of this up front. Keep doing the work by hand while you automate one piece at a time, and that's going to tell you where the best automations to build next are.
And a pro tip? Anytime you can get at the back end of something, an export or an API, use that and skip having the AI click around a website. And if you want the deep version of why this works, there's a video over in History and Concepts on what happens under one line of Python.
and how every layer of computing got reliable by putting good engineering around the unreliable parts. AI is just the newest layer. So your homework?
Find one step you've done the same way three times, ask for a script, test it against last time, and add the line to your map. Next lesson, 3 .3, the last one. We keep the whole thing from going stale and hand it to someone else.
Either way, happy learning, everyone. This is Lesson 3 .3, the last core lesson in Foundations. You'll want a workspace you've been using for a while, or the one you built in Module 2.
By the end, you'll know how to check if it's gone stale, what to clear out, how to keep one home for every fact, and how to hand the whole thing to someone else so they can actually pick it up. So AI makes it really easy to make a lot of stuff. drafts, versions, notes, summaries of the summaries.
And the folder that felt amazing in week one can be a swamp by week six, where the AI finds three different prices for the same thing and has to pick one, and of course it picks the old one. My own workspace has a folder called underscore archive, and the map describes it in five words. Retired work, never read it.
Old versions, old experiments, stuff that worked once and doesn't anymore, it all goes in there, out of the way, and the AI never wastes a second on it. First, the fresh session test, a cousin of the routing test from 2 .2. Open a brand new session and ask it, what is this folder, what's in progress, and what's next?
If it gets that wrong, your map's out of date, and it's way better to find that out from a test than from a confused client. Second, one home for every fact. If your prices live in three files, those three files are going to drift, I promise you.
Keep each fact in one place and have everything else point to it. Same with your skills. When the way you do something changes, fix the skill file and every job that uses it picks up the change.
Third, clear stuff out. Retired work goes in an archive like mine, and delete the generated stuff nobody's ever going to use. And try not to be afraid to delete and restart.
We get attached to files because of how long they used to take to make, and they just don't take that long anymore. Just keep your hands off the originals, your sources, and anything that belongs to someone else. And if you keep it on manual like we did in 1 .3, it asks before it changes anything.
Then, handing it on. And honestly, this is one of my favorite parts. Because the map that tells the AI where everything is tells a new person the exact same thing.
Somebody joins your team, you hand them the folder, they read clod .md, and they know what's where and what to do first. Same as the AI did. And here's the test I give people.
If I turned off the AI tomorrow, could you still find your way around these files and do the work? If so, that's a pretty good structure. You can hand over a copy, zip it up, or drop it in a shared drive, and that's great for templates.
Or everyone works in one shared place, a synced drive, or Git if you want every change tracked. That's more powerful, and it means you need to agree on who changes what. And who can open it at all is a permissions thing.
The folder doesn't decide that for you. And this is why I'm comfortable betting on folders. Files and folders have been around since the 60s.
Unix made them the backbone of computing in the 70s, and they've made it through every big shift since the PC, the Internet, phones, the cloud. Next week, some other company is going to have the better model. And what stays yours is your files and folders, your context, your data.
So when that happens, you point the new one at the same folder, maybe rename the map file, maybe tweak a skill and keep going. It's a bet. And it's one I'm happy to make because I want to teach you the stuff that lasts.
So that's foundations. You started in a chat. You saved what worked as a skill.
You gave it a folder and one agent. You designed a workspace around your own outcome. You put your judgment where it counts.
You turn the steady parts into code. And now you can keep it alive and hand it on. Simple.
then complex, then simple again, with all your work sitting right underneath. From here, the where to go next page has routes for whatever you need. More examples, working with a team, bigger setups and live lessons and history and concepts are there whenever you want to go deeper and go build something.
And honestly, show me. Post it in the community. I love seeing what people make.
Either way, happy learning, everyone.
The Hook
The bait, then the rug-pull.
Jake Van Clief opens by stacking proof before promise: a free community over 50,000 strong, a 5-star rating, and one member whose tool worked straight away. Then he hands over the entire free course in one sitting, eleven lessons that walk from a plain chat box to an AI agent working directly inside your own folders.
Named ideas worth stealing.
01:30model
The Three Layers
- Chat
- Skills (and Projects)
- Folders and One Agent
His organizing model for the whole course: chat is talking back and forth, skills is writing recurring corrections down once, and folders with one agent is the AI working directly inside your files.
Steal forstructuring any AI-adoption training or onboarding sequence
07:40concept
The Desk-and-Drawers Model of Context
Context is a desk: what you typed plus what you attached plus a little memory. Anything not on the desk gets guessed at, which is why a new chat for a new job matters.
Steal forexplaining why prompts fail without blaming the model
18:50concept
Simon Willison's Agent Definition
"An LLM agent runs tools in a loop to achieve a goal." Used to strip the mystique out of the word 'agent' before showing Claude Code working a real folder.
Steal forde-jargoning agent explanations for non-technical audiences
28:00model
The 60-30-10 Rule
- 60% data, questions, thinking
- 30% tools that already exist
- 10% the AI
A design heuristic for where AI effort should actually go, replacing an earlier more technical version (code, routing, AI calls) with a plainer one.
Steal forscoping any AI feature or workflow before building it
29:00list
Four Questions Before You Open a Chat
- Who is this actually for?
- What do they need to do next?
- Where does the information come from right now?
- What breaks, and who feels it?
A pre-flight checklist he runs before touching any AI tool, used to reframe a weekly bookings export job around what actually matters (pending bookings, not formatting).
Steal forany client-facing workflow design brief
33:20list
Three Folder Shapes (ICM)
- Stages (sequential pipeline)
- Records (one folder per entity)
- Wiki (raw sources to written pages)
Three different folder architectures that all count as Interpretable Context Methodology, picked based on the shape of the underlying work, not a fixed template.
Steal fordeciding how to structure a Claude Project or working directory for a new client
How they asked for the click.
VERBAL ASK
00:15link
“All of that lives in the free Skool community. Links right below.”
States it once near the top before any teaching starts, then lets the free lesson pages carry the pitch; repeats once at the very end as an invitation to post what you built. No hard sell anywhere in between.
MENTIONED ON CAMERA
Visual structure at a glance.
