01 Claude Code isn’t a chat—it’s an AI with hands

Anthropic (the company behind Claude) sells three products with the same family name. The Claude Chat is a simple chatbot on a website or phone—you ask, it answers, and that’s it. The Claude Cowork is an intermediate layer, a simple interface for automations that are already set up. And the Claude Code is the most powerful of the three: despite its name, you don’t need to know how to program to use it. The key difference is that it has harness: access to real tools, not just the conversation.

Think of your freelance accountant organizing receipts scattered across computer folders, or your HR coordinator matching résumés against a spreadsheet of job openings — in both cases, a regular chat can't see those files. Claude Code can see, open, and read them, and, when you authorize it, edit them.

02 The engine, the car, and the driver

There’s a simple way to understand any AI tool: picture three layers, one inside the other. At the center is the model, the engine that does the reasoning. Around it is Claude Code, the car that uses this engine to run. And at the wheel is you — your judgment, your data, the context of your business.

The engine alone won’t get you anywhere: it needs the car to turn into motion, and it needs someone driving to go somewhere that makes sense. Models and harnesses change over time—today it’s one thing; a year from now, it may be something else, faster or cheaper. The part that doesn’t change, and that matters most of all, is you.

For a small shop owner, the engine can be swapped tomorrow without them having to learn any of this on the spot; for a freelance consultant, what never changes is the context they provide—without it, even the most expensive engine in the world still misses the mark.

03 Stop hunting for the perfect prompt

For a long time, the number one tip about AI was "write a better request" — give the AI a role to play, clear instructions, an example of what you want. That still helps, but it's becoming less decisive because the models themselves are getting better at it. Something else has become decisive: context engineering, what AI knows about you before you even ask.

A new intern won’t produce anything good on their first day if nobody explains what the company does, who’s who, and what’s already in progress—even if they’re hardworking and smart. An AI without context is exactly that: a smart intern guessing. And context is information only you have—if everyone uses the same model with the same generic request, everyone gets the same generic answer.

A teacher who just writes “make a lesson plan about fractions” gets something generic; if they say they teach sixth grade, that students struggle with multiplication, and paste last week’s lesson plan, the response is ready to use from the start—the same difference applies to a self-employed accountant asking for a polite payment reminder for a specific client.

04 No one gets it right on the first try—and that’s okay

Think of teaching a child to ride a bike: you don't let go and walk away. You hold the seat, correct their balance, let go a little, then hold on again. Working with AI is similar — iteration is the rule, not the exception. After "teaching" the fifteenth assistant or automation, the process of making adjustments has become almost a science—but everyone starts out stumbling.

This explains a common pattern: on paper, learning something new looks like a straight line of progress. In practice, it’s a curve that dips before it takes off—you slow down for a while before getting much faster later. Most people quit right in that valley, just before the payoff is worth it.

An HR coordinator testing a new AI resume-screening process won’t get the ideal filter on the first try—they adjust it, look at the mistakes, and adjust again. The same goes for a small business owner testing an automatic response to customers: the second version is already much better than the first, and the fifth is better still.

05 Vending machine or slot machine?

The difference between a regular chatbot and a AI agent is this: the chatbot only acts when you tell it to; the agent starts on its own when something happens—that’s what this course calls building your own "Jarvis." But before you start automating everything, it’s worth asking a simple question: is this task a vending machine or a slot machine? A vending machine is deterministic—the same coin, the same product, every time. A slot machine isn’t: every time you pull the lever, the result varies. Whenever you talk to generative AI, in a way you’re betting on a slot machine—the result varies.

The practical rule: use AI when the task really requires reasoning and varies from case to case; use a fixed step-by-step process when the process is always the same — it’s cheaper, faster, and almost never breaks. Before automating, ask two questions: do I need to trigger this myself, or can the system trigger it on its own? And does this step really need AI, or would a simple, fixed approach solve it for less?

A freelance consultant who always sends the same proposal template, changing only the name and amount, doesn’t need generative AI every time—a fixed template gets the job done faster. But when a teacher needs to adapt a difficult explanation to the way a specific student learns, that’s when real AI comes in, because each case calls for different judgment.

06 What you publish carries your signature

The better AI gets, the easier it is to blindly trust the first answer—that’s the trap. There’s a joke that sums it up well: one side uses AI to turn a bullet point into a formal email; the other uses AI to turn that same email back into a bullet point. Nobody reads what’s in between. A common red flag is text full of unnecessary em dashes—if you’ve never written that way yourself, you can tell right away when nobody has reviewed the text.

You can train your judgment: study the best examples in your field, save what works, ask the AI itself “why did this turn out well?”, and whenever you correct something, feed that correction back into your instructions. Here’s the phrase that sums it up: judgment means deciding what deserves to have your name on it—what you publish with AI’s help carries your signature, for better or worse.

This same range of skills can protect your career when you package your expertise in more than one way — not across different subjects, which can scatter your focus and fall apart, but within the same specialty, using different formats: a course, an email newsletter, one-off consulting. The same expertise of a self-employed accountant can become a short course on tax organization, a monthly newsletter, and a one-off consulting service, without changing subjects; a small business owner who already knows inventory control can do the same, packaging what they already know in different ways.

One caution: if you have an employment contract or an exclusivity clause, check first and be transparent with your employer. And sharing what you’re learning, even gradually, is what makes you discoverable—including when someone searches for the topic using AI.

01 Three doors, the same engine

There are three ways to open Claude Code, and none of them changes what’s inside. The first is to type commands in a command screen (what technicians call the terminal); it’s the fastest path for people who are already comfortable with computers, but it’s not required. The second option, and the one most recommended for beginners, is Claude’s own desktop app — a window with buttons and a chat, like any program you already use. The third is an extension inside VS Code, an editor used by people who already code; it only makes sense if you already use that program for another reason.

Installation itself requires a paid subscription — Claude’s free plan doesn’t include Claude Code; only the Pro and Max plans do. The Max plans (US$100 or US$200 per month) have much higher usage limits than Pro; think of it like hiring an employee: a good software engineer would cost well over US$100,000 a year, so US$200 a month for a complete "AI employee" is a different calculation. No matter which of the three doors you choose, the files, conversations, and projects stay the same if you switch doors later.

A freelance consultant with no experience using a black screen can start right in the app; a teacher who already uses VS Code to organize tests may prefer the extension—they both get to the same place.

02 It doesn't just respond — it actually changes your files

The difference becomes clear with the first unusual request. A user asked Claude Code to find a logo file called "AIS Live Black" somewhere in the Downloads folder — without knowing its exact path. A regular chat couldn’t do that: it can only see what you paste on screen. Claude Code opened the folder, looked at the file names and even the images to visually confirm which one was right, found the logo, returned the full path — and even asked whether it should organize or copy the file somewhere else.

This applies to the day-to-day work of anyone dealing with scattered files. A self-employed accountant with invoices in different folders for each client, or an HR coordinator comparing resumes received by email with a spreadsheet of open positions—in both cases, Claude Code sees the actual files on the computer, not a description of them.

03 The four levers that make a request worthwhile

There are four things that turn a generic request into one that gives you exactly what you need—and none of them is “write a better question.”

A teacher who just writes “make a lesson plan about fractions” gets something generic. If they say they teach sixth grade, that students regularly struggle with multiplication, and paste last week’s lesson plan, the response is ready to use from the start—the same four levers apply to a freelance consultant asking for a business proposal for a specific client.

04 From a request to a finished spreadsheet

In a real demonstration, the four levers turned into a full YouTube analytics report. The request went like this: "I want an evaluation of the channel’s second quarter, pulling real data from YouTube and doing an in-depth analysis as if you were my content strategist—not just showing me numbers." Notice that this request doesn’t list the steps to follow: it describes the finished result and lets AI decide how to get there. That’s what’s called request with a goal: instead of asking for a one-off task, you describe the "done" condition and let AI work until it gets there.

The result: Claude Code went to YouTube, took screenshots to check that the numbers matched, and generated a complete Excel spreadsheet — executive dashboard, score for each video, month-by-month trend, content themes, format and length, audience, and traffic sources — in about ten minutes. Work that would take hours by hand came from a single request in plain language, without the person asking having to type a single formula.

The same kind of request works for a small-business owner who wants to understand the store’s quarter, or an HR coordinator who wants a snapshot of the semester’s hiring—the request structure is the same; only what’s being evaluated changes.

05 Ask the AI to prove its own work

The better AI gets, the easier it is to blindly trust the first answer—and that’s where the risk lies. There’s a simple question that helps: “If a human handed me this work, what would I do to approve it? Would I open it and test it? Review it three times? Try to break it on purpose?” Whatever you’d do manually to approve a human’s work, you can also ask AI to do on its own before handing it to you.

A real example: asking the AI to test a hundred submissions to a website form and find email-validation bugs on its own, instead of discovering the problem weeks later when a customer complains. That changes the starting point for the result.

This applies to any profession: a small-business owner can ask the AI to independently check whether all the prices on a list match the original price sheet before publishing it; a freelance consultant can ask the AI to reread its own proposal and look for inconsistent numbers before sending it to the client.

06 What each answer costs

Every request and every response are measured in tokens — one token is equivalent to about three-quarters of a word. Three models are available, each with a different balance of speed, cost, and capability: Haiku is the fastest and cheapest; Sonnet 5 is the everyday balance; Opus 4.8 is the most capable, reserved for tasks that really need depth—and costs more than the other two. Generating a response always costs more than reading a request, because writing is the model’s active work.

A real number helps put things in perspective: the Q2 analytics spreadsheet from the previous step used about 25,000 output tokens running on Opus—around US$0.63 in actual cost, within a session that used 428,000 tokens out of a 1 million limit. People who subscribe to a plan (instead of paying per use) don’t pay for each token individually: they get a usage window that renews every five hours, plus an overall weekly limit and a separate weekly limit for the more expensive models. Using up that entire allowance on a US$200-per-month plan would amount to about US$8,000 worth of usage if paid per token—a substantial discount from the pay-as-you-go price.

In practice: an HR coordinator who screens batches of résumés every day saves money by using Haiku for repetitive tasks and reserving Opus for decisions that really matter; a teacher grading a complex essay benefits more from Opus than from saving money with the cheapest model on a task that requires fine judgment.

01 The note AI reads before helping you

Every AI agent reads a specific file before processing any message from you—every time, in every new conversation. Think of a receptionist who, before helping you, always takes a quick look at a note posted by the entrance with the day’s reminders: who’s who, what’s in progress, what to avoid. The CLAUDE.md plays that role. You just type "hi," and behind the scenes, the AI has already read that entire note before replying — that’s why the response can be contextual, like "ready when you are — just a reminder: event X is this Friday, project Y opens on such-and-such a day".

A real CLAUDE.md usually follows a similar format, regardless of the writer’s profession: first, the agent’s role (“you’re my assistant; your job is...”); then, a map showing where to look for each topic—“if it’s about X, the path is Y”—for every important area of your work. The “.md” in the name is just the file extension, a short code that tells you the type: formatted plain text (called markdown), just as “.py” indicates a computer program or “.txt” plain text with no formatting.

There’s a way to make this note improve on its own over time: when an answer turns out badly, use your judgment to point out what was missing, then ask the AI to update CLAUDE.md with that instruction. A teacher who notices that responses always cite too few sources can ask for this; a self-employed accountant bothered by unnecessary em dashes can do the same. Next time, the AI will do better without you having to explain anything again.

02 Global vs. Project—two layers of memory

There are two levels where this note can live, and the difference matters. The global lives in your computer's personal folder and applies to any project you open — it's the right place for preferences that never change, like a writing style you never want to see in a response (a list of phrases that sound robotic), or things the AI has learned about how you work over time. The project lives inside a specific project's folder and only applies there.

In practice: when you open a new folder for the first time, the AI asks if it can trust that location—it will be able to read, write, and even run things there, so only authorize folders you recognize. And if the folder is new, you don’t have to set anything up yourself: just ask the AI "initialize this project with a CLAUDE.md" and it will create the basic structure.

A freelance consultant who serves three different clients can have a global CLAUDE.md with their own email-writing style, and a separate project CLAUDE.md for each client with context that applies only to that contract; a small-business owner with just one store may not miss the project-level file at all and use almost exclusively the global one.

03 Permission modes: from constant questions to autopilot

There’s a setting that controls how often the AI stops to ask you “Can I do this?” before acting. In automatic mode (the default, and a good fit for most cases), it asks before more sensitive actions. You can move the setting toward greater caution, requiring permission for every step, or turn it all the way up—a mode where it never stops to ask anything. You have to deliberately enable that mode in settings because it’s risky by default.

There’s a real story that shows where the actual risk lies: an agent on a team sent a discount coupon by email to 150,000 people without anyone asking it to. The problem wasn’t the permission mode they chose—it was that the agent HAD ACCESS to the email-sending tool when it should only have had access to the drafting tool. Real permission isn’t just about what you tell the AI not to do; it’s also about which tools it can literally use.

An HR coordinator who builds an agent to screen resumes should give it access only to read and organize, never to respond to candidates on its own without review; a teacher who uses AI to grade tests should keep grade entry out of its automatic reach and review grades before publishing them.

04 Inside the support folder: permissions, agents, ready-made recipes

Besides the main note, every project can have a support folder (called .claude) that holds three important things. The first is the settings file — where permissions live: what the agent CAN and CANNOT do, written in plain language ("you can use the command prompt, you can search the internet, but never delete this specific folder"). You don’t need to know how to write in this technical format: describe in Portuguese what you want to allow or prohibit, and the AI itself edits the file for you.

The second is a folder of helper agents—secondary assistants, each with a specific task, covered in depth in a later module. The third is a folder of ready-to-use recipes (skills)—packaged instructions that the AI loads automatically when a request matches that recipe, also covered in depth later.

Think of this folder as the back office behind reception: the note (CLAUDE.md) stays at the entrance and is always read; the back office is opened only when the subject calls for it. A freelance consultant who serves different clients might keep a separate recipe for each client there; a small business owner might have a helper agent just for organizing orders received over WhatsApp.

05 An API key is a password to YOUR data

Two tools communicate with each other over a channel called API — think of it as a direct line between two programs. Without any credentials, this line can only access public information: Claude Code can see public data from any YouTube channel, for example, but not your private metrics. A API key is what unlocks this private access—it works like a password and should be treated with the same care as one.

Where this key is stored matters: there's a specific type of file for that, called .env — think of it as a safe inside the project itself, kept separate from everything else, that should never be shared or published anywhere. When you ask AI to create this file, it also creates a safeguard (called .gitignore) to make sure that safe never ends up somewhere public by accident.

A freelance consultant who uses a paid search tool for market research, or a teacher who connects a slide-generation service—both need the same thing: get their own key from the service’s website and let the AI store it in the right vault.

06 Testing for real: the lesson that only surfaced with the wrong key

In a real demonstration, someone connected an API key for a search tool (Tavily, which gives you the first thousand uses for free) by following a simple sequence.

The same test was deliberately repeated with an invalid key—and without any extra instructions, the AI simply went back to using its own built-in search instead of telling you the key had failed. The lesson: be explicit ("don’t use built-in search; use Tavily only"), because without that instruction, an agent may silently choose a worse alternative without telling you. After fixing the key, it’s worth asking AI to save the service address and authentication method in CLAUDE.md itself—so next time, it won’t waste time "rediscovering" the same process.

A self-employed accountant connecting a tool to look up public company data, or an HR coordinator connecting a job platform—the steps are always the same: get the key, store it in the vault, test it, and have the AI note the path so it doesn’t have to rediscover it later.

07 Treat every key like an unlimited credit card

When creating a new key for any service, you can usually restrict it in two ways: a spending limit (it stops working after a set amount) and a capability limit (it can do only one specific thing, not everything the service offers). A key for generating sound effects doesn’t also need access to dubbing or other features from the same service.

Would you give a new employee an unlimited credit card? Treat every API key the same way. The practical rule for guiding this choice: if your agent CAN touch a piece of data, assume it WILL — even if you don’t ask. So give it only the minimum access the task requires, never the maximum available.

This ties directly to privacy: with personal subscription plans, training the AI on your data has become a choice you actively make, and you can turn it on or off in settings. But even when it’s off, the company behind the AI still has access to your data; it just doesn’t use it for training. Before pasting in a contract, client data, or any sensitive information, check your company’s policy. An HR coordinator should never paste a candidate’s personal information into a chat without knowing that policy; for a self-employed accountant, the same caution applies to a client’s banking information.

01 Context, connections, capabilities, cadence

When a central AI project is connected to all your business tools, with full context about what you do, it starts to function as a kind of AI operating system — perfect memory, instant search, and context no human can hold entirely in their head at once. There’s even a curious real-world example: on one team, when someone can’t reach the leader, they message the leader’s AI system directly—it responds better and faster than the leader would.

This system is organized into four parts, called the four Cs here: context (what AI knows about you and your business) and connections (which tools it can reach) make up what the next modules call the "second brain"; capabilities e cadence (the ready-made recipes and automatic routines) come later, once your second brain is up and running.

02 How to choose what to connect first

You can’t—and it’s not worth it—connect everything at once. Start with what businesses generally rely on most: revenue, customers, calendar, communication, tasks, meetings, and accumulated knowledge. There’s a simple way to find out which of these tools are yours: look at the tabs open in your browser right now, your saved bookmarks, and your recent history—those are the things you visit most, and the ones most worth connecting first.

The process for connecting any of them follows the same steps every time: search for "[tool name] API documentation," ask AI to read that documentation and configure the connection, get the access key from the tool’s website, and paste it into the project’s vault (.env)—the same process as the previous module, repeated for each tool.

A teacher who moves between email, their class schedule, and a folder of materials has the first three obvious candidates right there; a small-business owner who lives in a sales spreadsheet and WhatsApp Business has theirs. A simple measure of progress is worth more than any abstract goal: how much of your day can you handle entirely within this AI conversation window, without switching programs?

03 One channel for Drive, Gmail, Calendar, and more

There’s a free, open-source tool from Google itself that gives you access to Drive, Gmail, Calendar, Docs, Sheets, and Slides through a single channel—with more than a hundred ready-made tasks, like generating a document from a template, reading spreadsheet data and putting together a report, or finding a free time slot and scheduling a meeting automatically. The advantage over connecting each tool separately: one interface, responses in a format the AI understands well, and automatic updates whenever Google adds something new. Once it’s set up, it takes very little maintenance.

Once it's set up, requests become simple: find a Google document you only vaguely remember; read unread emails and assign a priority rating based on what matters to your business, automatically marking low-priority messages as read; or create a complete presentation, with the AI taking a screenshot of the result, comparing it with the expected visual identity, and adjusting the spacing on its own until it matches. A freelance consultant who loses documents between projects benefits from document search; a self-employed accountant who handles dozens of client emails a day benefits from priority sorting.

04 ".env" or "connect" — the decision that prevents rework

Many AI apps already have a ready-made "connect" button with a simple login for common services—much easier than setting up a key and vault by hand. The problem is where that connection is tied: it only works with that specific app. If you switch apps, interfaces, or even AI companies—which has happened more than once in recent years—you lose all the connections you made and have to set them up again one by one.

The API key stored in the vault (.env), on the other hand, doesn’t belong to any application: it’s just a folder and a text file. Any AI from any company, running in any interface, can read the same vault. Being independent of any one tool is the most important part of all this — because models and interfaces change every week, but your data and connections shouldn’t have to change with them.

A small-business owner who tries two or three different AI interfaces over the course of a year saves a lot of time if the connections are already in the vault, ready for any of them to use; a freelance consultant who changes subscriptions from time to time gets exactly the same benefit.

05 The recipe AI learns by heart

A skill (a recipe, in plain English) is a written instruction that teaches AI to repeat a process your way. Think of a cake recipe: the first time, you follow it to the letter; after making it a handful of times, you know it by heart and adjust by eye. A skill works the same way — except the AI is the one that "memorizes" the recipe, not you.

The trick that prevents waste: the AI doesn't read every saved recipe in full each time — it takes a quick look at each one's title and description, decides which one fits your request, and only then reads that recipe in full before acting. That's what keeps the system fast even with dozens of saved recipes.

There are two ways to create one: ask it to build one from scratch by explaining step by step what you want, or do the process manually once and then ask, “Turn what we just did into a recipe.” An HR coordinator who has manually sorted her inbox for weeks can later ask to turn that process into a fixed recipe—and better yet, if an email was misclassified, she can explain why, and the AI will adjust the recipe on its own, without having to rewrite anything by hand.

06 The context window fills up — and judgment gets worse

Truck drivers can only drive a limited number of hours before they have to rest—not because they’ve lost the skill, but because fatigue worsens their judgment, even if they don’t notice it. Something similar happens with AI: the fuller the context window of that conversation, the worse the response quality gets — even if the model technically still "knows" everything.

The recommended practice is to end the conversation well before you hit the limit — when you’ve used about a quarter of the total space, it’s already time to start over. But starting over from scratch means losing all the context you’ve built up, and that’s where a simple step comes in: before closing, ask AI to generate a structured summary of the session — where it started, what was decided, what was delivered, and what’s still open. Copy that summary, start a new conversation, paste it back in, and the conversation continues exactly where it left off, but with much more space available.

A freelance consultant in a long project-planning session, or a teacher organizing materials for an entire semester in one conversation—both benefit from the same habit: summarize and start over before quality drops, instead of waiting for the AI to "forget" on its own.

01 Claude Code learns on its own—to a point

After using it for a while, Claude Code starts writing down facts it has learned about you and your work on its own — without you asking. This automatic memory stores each learned fact in its own short file, inside a folder of its own: for the person who recorded this course, there are already 72 individual files, each with a name that explains what it's about — something like "how Noel likes me to organize reminders" or "how the company structure works." At the top of each file is a short label saying whether it's a preference, a correction, or a reference, and an index file brings them all together.

To check whether it's on — it's on by default — there's a specific command that shows the status, but it only appears in the version of Claude Code that works through text commands typed into a screen, not the simpler app with windows and buttons. A freelance accountant who corrects Claude Code three times about how they prefer receipts to be sorted by client doesn't need to correct it a fourth time — after a few sessions, it becomes a remembered fact. The same goes for a teacher who always repeats the same grading criteria: automatic memory learns that pattern on its own.

02 Rule, learned fact, or map—three different layers

It’s easy to confuse three things that look like the same "memory" but serve different roles. The CLAUDE.md files are the rules you write — what the AI should always do, your way, without exception. The automatic memory file is the learned facts — preferences corrected, decisions made, references saved, written by AI itself over time. And there’s a third, larger layer: a second brain — a map of the entire business, not just your personal preferences (this course explores the idea further in module 8). CLAUDE.md works like a router: when AI doesn’t know something right away, it points to where else to look—in memory, the larger map, or the projects.

The idea of a second brain comes from a post that went viral: instead of complicated tech databases, you can simply organize documents as plain text — the model itself can maintain indexes and summaries, and navigate among them without getting lost, even across a hundred articles or half a million words. One real example mentioned: someone organized 383 loose files and more than a hundred meeting transcripts into a compact wiki, and the AI’s "reading ammo" spend for each query (which cost and speed depend on) dropped by 95%.

An HR coordinator who keeps internal policies scattered across fifteen separate files gets much more value from organizing them in one navigable place than from correcting the AI session after session; a freelance consultant serving twelve different clients can avoid mixing up one client’s context with another’s only if they have this bigger map, not just the automatic memory of general preferences.

03 Before you automate, find the bottleneck

Think of your business as a water pipe: orders and customers enter at one end, pass through the process, and the result comes out the other end — the work delivered, the profit. At some point in that pipe, there's always a bottleneck, a bottleneck, which limits how much gets through, no matter how well the rest works. Automating a part of the pipeline that already flows well changes nothing about what comes out the other end — only fixing the bottleneck changes the final result.

The question that reveals where it is: "if I had five times as many customers tomorrow, what would break first?" This question forces you to map the actual process instead of guessing. And after you clear a bottleneck, more water flows through the pipe — and the next pinch point appears somewhere else. It’s an endless cycle, but each round gives you a clear roadmap for what to tackle next.

A small shop owner discovers, by asking this question, that the bottleneck isn’t selling more—it’s keeping up with requests already coming in through WhatsApp in time to avoid losing the sale. An independent accountant discovers that the bottleneck isn’t closing the books faster—it’s the time spent waiting for clients to gather the right documents.

04 One metric, defined before you start

Every project or automation needs a north star metric — agreed on before building anything, not afterward. Going back to the pipe example: if the identified bottleneck is "too few orders coming in" (say, five a week), the north-star metric becomes "fifteen a week." Without agreeing on this number ahead of time, no one will know months later whether the automation was worth the effort—measuring an automation’s return isn’t as straightforward as "I spent X on ads and brought in Y in revenue."

A teacher who decides to automate part of test grading will only know whether it was worthwhile if they decide on a number before they start: for example, reducing the time from three hours to one hour per class. A freelance consultant automating follow-ups on sent proposals needs the same clarity up front: the metric might be the client response rate, not "it seems to be going better."

05 You don’t automate what you can’t sketch on paper

If your work isn’t yet at a scale where it makes sense to think about formal bottlenecks, there’s a simpler exercise: literally write down on paper which processes and tools you use every week, what gets repeated, and what your triggers — what happens that makes you take action. This usually reveals five to ten candidate processes; choose the one that happens most often, unless it’s too risky to change right now.

No matter how good the AI model behind it is, without a deep understanding of the process and the expertise you alone have about your own work, AI can’t do anything meaningful with your business data. It’s the same idea behind the quote attributed to Abraham Lincoln: "if I had six hours to chop down a tree, I’d spend the first four sharpening the axe." The time spent mapping and planning before automating is far more valuable than jumping straight into execution.

A teacher who maps out the grading steps on paper—read, compare with the answer key, assign a grade, write a comment—can clearly see which step is worth handing off to AI. An HR coordinator who maps out the resume-screening steps before automating any part avoids automating exactly the wrong step.

01 The main session is the boss—and it can delegate

Up to this point, you’ve always talked to the same session—the same "person" listening to everything from beginning to end. There’s a different way to work: the main session becomes a kind of boss, still the only one who talks to you, but able to delegate tasks to a sub-agent — which works with its own separate memory and reports back only to whoever called it, never directly to you.

A real example: asking for five sub-agents, each with a different persona—a complete beginner, a software engineer, a business owner, an editor—to review book chapters in parallel, each seeing the text through a different lens. The five work at the same time, each in its own isolated session, and return five different reviews for the same boss to bring together.

A self-employed accountant can ask the main session to delegate the review of forty invoices to sub-agents in parallel while they keep discussing another topic in the main conversation; a small-business owner can delegate comparing prices from three different suppliers at the same time instead of making one inquiry at a time.

02 Built-in or custom—how a sub-agent is made

There are two types: general-purpose ones that are ready to use and require no setup—you just ask, and the main session automatically calls one when it makes sense; and custom ones that you create and save as a separate file in a special project folder. That file has a fixed structure: at the top, a configuration block—like an ID card, with its name, what it does, which model it uses, and which tools it can or can’t use—and below that, plain text instructions on how it should behave.

The most important part of this sheet is the description: it acts as the trigger automatic. The more precise this description is, the fewer “false calls” happen—whether that means triggering when it shouldn’t or failing to trigger when it should.

A freelance consultant can create a permanent sub-agent just to review proposals before sending them, triggered whenever she says something like "review this proposal"; a small business owner can have a sub-agent check prices before any ad is published.

03 Why delegation is worth it — three reasons

There are three practical reasons to use subagents. The first is to keep the main conversation clean: extensive research or reading dozens of files can “mess up” the context window main one; a delegated task runs in a fresh window on its own, and only the final summary comes back to you. The second is cost: the main conversation can run on a more expensive, capable model, while simple, repetitive tasks go to sub-agents on a cheaper model — a smart boss with a team of low-cost workers. The third is parallelism: several sub-agents working at the same time, each in its own window.

An HR coordinator who needs to go through fifty résumés avoids cluttering the main conversation about the open position by delegating that review to a sub-agent; a teacher with a stack of essays to grade keeps planning the next lesson in the main conversation by delegating the grading to another window.

04 Building yours—the Plan Roaster and a common mistake

A real example of building one: “Plan Roaster,” a devil’s advocate sub-agent created to deliver tough criticism of a plan or idea before you move forward with it. Its profile: a clear description (“adversarial plan critique, triggered by phrases like ‘review my plan’”), tools limited to reading—it doesn’t edit anything—a simple, inexpensive model since the task doesn’t require costly reasoning, and its own color to visually identify when it’s active.

A teacher can build, in the same way, a "lesson plan reviewer" sub-agent that only reads and comments, never edits the original plan; an independent accountant can set up a "calculation checker" to review numbers before finalizing a client report.

05 A subagent is not the same as a skill

Skills and subagents are structurally almost identical under the hood—both are text files with the same configuration block at the top. The real difference is how they run: a subagent runs in a fresh, isolated memory window, allows true parallelism, and can use a different model from the main conversation; a skill usually runs within the main conversation itself, without that separation. They can also work together—a skill can call a subagent, and a subagent can use a skill.

The same logic as CLAUDE.md applies here: a sub-agent kept inside a project folder exists only in that project; kept in your personal folder, it works in any project on your machine. There are ready-made collections of sub-agents to download from the internet — but, like any file from an unknown source, it’s worth reviewing before installing: a malicious file can hide a instruction injection disguised as an ordinary form.

An HR coordinator keeps the screening sub-agent only within the recruiting team’s project so it doesn’t spill over to other teams; a freelance consultant keeps the proposal-review sub-agent in their personal folder because they use it with every new client.

06 When to delegate—and when not to

Signs it’s worth creating a subagent: you’re going to read lots of files or generate a long answer you’ll never really reread; the task repeats every week; the work is independent and can be done in parallel; or you want an unbiased opinion from someone who “wakes up” with no prior context.

Signs it’s not worth it: a quick, one-off edit; steps that depend on each other in sequence—that’s orchestration across multiple agents, not a standalone subagent, because subagents don’t talk to one another; they only report back to whoever called them; or a task that needs the full conversation history or needs to ask you a question along the way, since subagents don’t interact with you directly.

There’s also a more advanced feature for truly large tasks: automatically launching multiple subagents in phases, scaling from a few to dozens or even hundreds for a single task. This uses up your usage limit very quickly—a real test reached 210 subagents in a single run—so use it carefully and keep an eye on your limit before letting it run on its own.

A freelance consultant uses these signals to decide whether to review a one-off contract themselves right away or delegate a stack of similar contracts to a sub-agent; an HR coordinator uses the same reasoning to decide when it’s worth reviewing a résumé in the main conversation and when to delegate screening a whole batch.

01 An empty folder is the start of a project

To build something that leaves the conversation and becomes a real webpage, the simplest way is to download a free code editor — a program like a word processor, but made for organizing project files, not for typing code by hand. Then, an extension connects Claude Code right inside it, you sign in with your subscription, and open an empty folder on your computer. From then on, that folder is your project: everything Claude Code creates will live there.

A small-business owner who has never opened anything like this in their life can build a digital menu for their own store from an empty folder; a teacher can build a simple website showcasing the class’s work in the same way.

02 The number-zero hack—and the difference one rule makes

Before asking for any page, it’s worth writing one rule in the project’s CLAUDE.md: "always use visual design reinforcement before writing any page code, without exception." Without this rule, the result tends to look "done by talent alone" — visually plain, even when it works properly.

The difference is significant: there are installable design enhancements you can add with a simple command that dramatically improve visual quality and animations, even with a minimal request — a real example: a one-sentence request, "make a music player app," came out with animations and dynamic elements far above the usual standard, just because of this rule combined with this enhancement.

A freelance consultant builds her own presentation page with this rule written in from the start; a small business owner does the same for the shop’s digital menu, without needing to know anything about design to make it look good.

03 Clone responsibly and let the AI correct itself

A practical way to start with something beautiful instead of a blank page: find an inspiring website, take a screenshot of the full page, copy its visual style, and give both to Claude Code with the request “clone this website.” Then just ask it to swap in your own brand’s color, logo, and text—and the result starts with a visually tested foundation.

There’s also a self-correction trick: Claude Code takes screenshots of the page as it builds, compares them with how it’s supposed to look, and adjusts on its own. This can take the work from about 60% done to over 90% without as much repetitive manual correction. One important caveat: for animated elements, a still screenshot can confuse the process. In that case, explicitly tell it that the element is an animation so it doesn’t try to compare a still image with movement.

A teacher can clone the layout of a ready-made course website to use as a base for class materials; an HR coordinator can clone an attractive event registration form they found online and adapt it for their team’s hiring process.

04 From your computer to the world

While you work, Claude Code runs everything locally — only on your computer, accessible only to you. Publishing for real takes two more steps: sync the project with a repository (a special folder that keeps a history of everything that's changed) and connect that repository to a service that monitors it — every time a new change arrives there, the service fetches it automatically and updates the live site, without you having to do anything else.

One good practice applies to every profession: always test the change on your computer before asking to sync it—this can even become a standing rule written right in CLAUDE.md ("always test here until I confirm; only then sync"). A small business owner publishing a digital menu for the first time follows these exact steps; so does a teacher publishing the class portfolio.

05 The autonomy scale

There’s a useful scale for understanding any AI system, from the ground up: at the bottom, a chatbot—you trigger it manually every time. Above that, a fixed process with no AI, always following the same steps, triggered by an event or a schedule. Above that, the same fixed process, but with AI handling just one step—the order stays predictable, while only the content of that step varies. At the top, an agent: with no fixed order at all, deciding on its own what to do. The higher you go on the scale, the more autonomy, unpredictability, cost, and risk.

The golden rule: Build the simplest solution possible for the problem. If you don’t need AI, don’t use AI—it’s the same logic as the vending machine versus the slot machine, from module 1: the same input and the same output every time calls for a fixed process; input that varies from case to case calls for real AI.

A real example comparing both ends for the same problem—email triage: an agent design, with a huge rulebook and several tools, making all the decisions on its own, proved less reliable, more expensive, and harder to review when it made mistakes; a fixed-process design, with objective routing rules and AI used only to summarize information, had almost no failures, cost less, ran faster, and made it possible to trace exactly where something went wrong. A freelance consultant deciding between an agent to triage emails or a fixed process, and an HR coordinator deciding between AI making all the decisions on its own or fixed résumé-screening rules, face the same choice.

06 The prompt doesn’t lock the door—the tool does

Writing "never send an email, just prepare the draft" in the request is only a suggestion — it could fail on the 101st time, even if it worked the previous hundred times. Real protection works differently: if the "send email" tool isn't among the things that system can use, it physically can't send one, no matter what it "decides" to do. The same logic applies to deleting records or changing a database — don't grant access to an action that should never happen.

The same lesson applies as with the bicycle in module 1: don’t let an automation run on its own without any supervision the first time—gradually reduce supervision as you test your confidence, never all at once. A freelance consultant carefully sets what an automation can and can’t access before turning it on; a small business owner limits an automated-response tool to the right channel instead of granting access to everything for convenience.

07 Test before publishing

Before letting any automation run on its own in production, it’s a good idea to set up a test suite: dozens or hundreds of input examples with the correct answer beside each one, running the system against them, measuring the accuracy rate, and only then putting it into production or switching models. This doesn’t have to be complicated: in natural language, you can ask Claude Code itself, "help me think of all the edge cases that could go wrong here before I publish" — it helps you design the tests and safeguards.

A teacher testing an exercise-generation automation with known past examples before using it with the whole class avoids a faulty exercise reaching students; an HR coordinator testing a resume screener against previously confirmed decisions before trusting it to make real decisions avoids accidentally rejecting a good candidate.

01 Stop relying only on your memory

There’s a simple way to give the AI access to what you already know, without needing any expensive or complicated tools. The idea became famous after Andrej Karpathy, one of the most respected people in the field, described the method he uses himself: keeping everything in plain text file organized into two folders. A folder called raw stores the original sources — the articles, transcripts, notes, just as they came in. Another folder called wiki stores what the AI itself organized from these sources: summaries, links between topics, what's important. A file index.md works as a summary of everything, and a log.md stores a history of what was done — so you or the AI can later understand what has already been processed.

A tool called Obsidian can display these same folders as a visual map, with connected dots—but that’s just optional decoration on top of the same text-file system. What matters isn’t the pretty map; it’s whether the AI can find and use what’s stored.

An independent accountant who gets a change in the law every month can paste the official text into the raw folder and ask for a practical summary in the wiki; a teacher who collects materials from multiple courses they’ve taken can use the same system to stop searching in three different places for the same note. In practice, processing a dense article takes 10 to 15 minutes the first time—and organizing 36 transcripts at once, in a batch, takes about 14 minutes.

02 The 5 levels — start with the simplest one that solves the problem

There are five ways to build a second brain, each answering a different question—and there isn’t a “best” level, just the right level for the problem you have right now. The practical rule: always start with the simplest option that solves your problem, and move up only when you feel real pain at your current level.

O Level 1 is exact-word search: a root file that works like a guide, plus simple folders—one for general context, one for active projects, and one for decisions already made. The question it answers: "Can I find this file by searching for its name or an exact word?" The risk is that it grows too large without structure and becomes a mess that the AI itself starts to ignore.

O Level 2 is a wiki with relationships—the raw/wiki system from the previous step, with links between saved texts (one document points to another related one), plus an automatic memory file with what’s already been agreed on. The question it answers: "Can I bring together everything I know about a topic, even when it’s spread across different texts?" For most small businesses, this is the level to stay at for quite a while.

A small-business owner who just needs to find the supplier contract by name can get by with Level 1; a freelance consultant serving several clients who wants the AI to pull together everything they’ve discussed with one specific client across different meetings needs Level 2.

03 When “search by meaning” fails

O Level 3 comes in when you search using different words from the ones you wrote, and still want to find what you need — it’s called semantic search. To make this work, each document is cut into smaller pieces, and each piece becomes a point on a kind of map of meanings, where nearby points represent similar ideas.

The problem is that this map isn’t magic. If you ask, "summarize the March 5 meeting" and that meeting was split into 20 scattered chunks, the search might return only the 5 chunks most similar to the word "summary"—and ignore the chunk with the most important data. One such search returned "week 6" when the period’s biggest sale had happened in "week 19," simply because the week 19 chunk didn’t use the same words as the question.

For data that needs to be read in full to make sense — like an entire meeting or a contract — an organized text file (Level 1 or 2) is still more reliable than semantic search. An HR coordinator who saves full interviews is better off relying on an organized wiki than splitting each interview into loose pieces; a teacher with a library of hundreds of short texts, where each one already makes sense on its own, may benefit from searching by meaning.

04 When the connections between things matter

O Level 4 comes in when you don’t just need to find information, but need to follow a chain of connections between them — a knowledge graph. For example: "John works at company X; company X is recommended by company Y; company Y is a competitor of company Z". This is only worth the effort of setting up when you have lots of interconnected customer or business data — that’s not the case for most independent professionals.

O Level 5 is the "always-on brain"—a system that updates itself without you having to manually send anything into it. One caveat: keeping control over what goes into your second brain tends to be more worthwhile than automating the whole process—without curation, the system becomes noise over time instead of becoming more useful.

An HR coordinator with hundreds of candidates, partner companies, and cross-referrals might one day have a good reason to use a knowledge graph; a small business owner who just wants to remember what they’ve agreed with each supplier doesn’t need anything that advanced—and is better off being wary of any system that promises to update itself without even letting them know what went in.

05 What’s worth saving forever—and what isn’t

There’s a practical distinction for deciding what deserves to become a permanent memory. Context is what doesn’t change from one week to the next: decisions already made, how your business works, information that will still be useful a year from now—that’s worth saving in your second brain. Connections these are details that change all the time: a conversation from yesterday, an email from today, a customer number that changes every week — they’re not worth storing permanently because they become outdated clutter too quickly.

If you have access to a work tool that's already in use — a spreadsheet, a management system — the right approach is usually to give the AI access to that live tool, rather than copy the data into the second brain. A teacher who updates student grades every week is better off letting the AI consult the current grade spreadsheet than pasting in an outdated copy; a freelance consultant with a fixed agreement with each client that rarely changes can keep that agreement as permanent context.

06 The bottleneck isn’t AI—it’s getting things out of your head

Before asking the AI to build any new system, there’s a step almost everyone skips: getting the knowledge out of your own head. A quick 5-minute summary is almost never enough—you know much more about your own work than you can remember to write down all at once. There’s a short, ready-to-use instruction for solving this, nicknamed "interview me": you ask AI to interview you continuously about every part of a plan or process, working through one decision at a time, always giving a recommendation and asking only one question at a time — until you reach a complete, shared understanding.

Instead of trying to explain all at once how they handle a difficult customer, a small-business owner lets the AI interview them step by step until the process is clear even to someone who has never seen the store; an HR coordinator can use “interview me” to record how they decide between two similar candidates—a criterion that existed only in their head and had never been written down. After each answer, it’s worth saving the progress to its own file—a summary, decisions already made, the question-and-answer history—so nothing gets lost even in a long conversation. The payoff is real: a new process created without this interview usually starts out getting about 70% of what you wanted right and improves gradually with each correction; created after a good interview, it starts out about 90% right in the first version. As the saying attributed to Lincoln goes: if he had six hours to chop down a tree, he’d spend the first four sharpening the axe.

01 Delegating isn't the same as building a team

One sub-agent works like "one to many": the main session delegates a task, the sub-agent handles it on its own in a new window, and reports back only to the main session — sub-agents don't talk to each other. A agent team is something else: the main session creates the team, there’s a shared task list, and members can communicate with one another and claim tasks from that list—it’s real collaboration, not isolated delegation.

The trade-off is real: an agent team uses far more tokens and session limits than regular sub-agents, because each member maintains its own context and exchanges messages with the others. Use it sparingly, only when the value of multiple perspectives debating each other is worth the cost.

A freelance consultant who needs to format three similar proposals at the same time can handle the job well with simple sub-agents, each taking care of one proposal; an HR coordinator deciding between two hiring process formats—a decision that really matters—gets more out of an agent team debating the pros and cons among themselves.

02 The council that debates on your behalf

The most common use of an agent team is to put together a kind of "board" or "war room": a team with different personas — for example, a small business owner, a large business owner, and a junior employee — discussing the same report or decision, with several rounds of debate before reaching a collective verdict. The scientific basis for this comes from research at Stanford University: research conducted with multiple personas tackling the same topic from different angles produces a more complete and rigorous result than a single perspective.

A small-business owner deciding whether to raise the price of a product can set up this council and see the same information debated from different perspectives before deciding; a teacher can set up a debate between personas representing different teaching approaches to choose which one best explains a difficult topic to their class.

03 Be explicit, or the AI will take the simple path again

After a long discussion or research session, you can ask "package this into a shareable page" — the AI creates a well-formatted page hosted at a real link (not just on your computer). It updates automatically if you ask for changes later, so you don't have to send a new file to anyone with the link.

An independent accountant who asks "put together a team to review my fee proposal" needs to check whether the result really came from a debate or just from parallel responses dressed up as a team; a freelance consultant can ask for the same shareable page to send a research result to a client through a direct link, without having to resend anything after making changes.

04 Automations that run without the computer turned on

A routine is different from a scheduled reminder on your computer: it runs on the internet, in an infrastructure maintained by the people who make the AI—you don’t need to leave anything running. To set one up, you define: a name; a single prompt (the instruction has to be complete, because no one will be there to answer questions while it runs); which AI model to use; the repository the routine will pull information from; the access keys it will use (pasted in manually, since these keys normally aren’t transferred along with the rest of the project for security reasons); the frequency (at least once an hour); and its level of internet access—trusted and verified sites only, any site, or a specific list you choose.

Each run takes place on a temporary machine that gets erased afterward, except for two things that are saved: any code changes become a review proposal for you to approve later, and the run history is kept. Practical rule: if something exists only on your computer (a saved browser session, for example) or isn’t accessible externally, the routine simply can’t use it.

A small-business owner can set up a routine that sends a reminder of the day’s appointments every morning; an HR coordinator can set up one that reviews new candidates every week without having to remember to do it manually.

05 A real example: an automatic morning briefing every day

A well-designed automation follows the rule of always using the simplest tool that gets the job done: a daily briefing sent at 6 a.m. can be designed as a process with fixed steps—research a topic, write a summary with AI, and send the finished message—instead of letting an AI freely decide everything on its own each time it runs. The most important security precaution is to hard-code the message destination as one specific private location, never a public channel—and actually test this before activating the automation for real, so a message never ends up in the wrong place again.

A teacher can get a daily summary of news in their own field without having to search for it; a freelance consultant can get a daily briefing about potential new clients, ready when they start their workday.

06 Ring the doorbell or check the door again?

There’s a second type of automation, triggered by an event instead of a schedule. The difference is like the difference between a doorbell and checking the door every 10 minutes: an automatic alert between systems fires only when something actually happens — for example, when someone submits a form — instead of checking in a loop. A real example: a simple contact form fires a notification already formatted for you as soon as it’s submitted. One important point: this specific automation deliberately uses no AI at all — it’s just a template filling in blanks, because adding AI would only add cost and risk (such as "correcting" someone’s typo) without any real benefit.

As a bonus, there’s a command that exposes an active session to the mobile app on the same account—useful for keeping track or even sending new instructions remotely when you need to leave home but want the work to keep moving.

A small-business owner with a contact form on their website benefits from an automatic alert (no AI, cheaper and more reliable); a self-employed accountant who goes out to visit clients can use mobile access to monitor an automation without having to return to the computer.

01 Why the conversation gets expensive without you noticing

Every time you send a message, the AI rereads the entire conversation from the beginning—the cost doesn’t add up, it multiplies. A first message may cost a small number of tokens (the unit that measures how much an AI “reads” and “writes”); the thirtieth message in the same conversation may cost thirty times more because it rereads everything that came before, all over again. A developer measured a session of more than 100 messages and found that 98.5% of the total cost was just rereading old history—not processing anything new.

There’s also an invisible cost: with every message, instruction files, connected tools, and system rules are reloaded behind the scenes, even for a simple “hi.” And beyond the money, very long sessions make responses worse—the AI tends to pay more attention to the beginning and end of the conversation and “forget” some of what was in the middle.

A freelance consultant who notices more generic responses after an hour of conversation isn’t imagining things—it’s the effect of a bloated session; a teacher who was startled by a higher bill one month later discovered they had left a single conversation open for weeks without ever clearing it.

02 The basic habits — for everyone

A handful of simple habits already solves much of the waste. Clear the conversation whenever the topic changes instead of carrying a new topic on top of the old one. Turn off connected tools you aren’t using—each one brings its own instructions with every message, and some of them cost thousands of tokens per message on their own. Combine requests into one message instead of sending three separately (and if something went wrong, editing the original message is cheaper than sending a new correction on top). Use planning mode before any real task, letting the AI map out an approach and ask questions before spending tokens going down the wrong path. And there are two commands that show exactly where things usually stay hidden: one shows where the tokens are going (history, connected tools, loaded files), and the other shows the session’s estimated spending.

A small-business owner who sends three separate requests on a busy morning pays for three complete rereads—combining them into one message already saves a lot; an HR coordinator who disconnects a tool they no longer use that week sees the difference directly in that session’s cost.

03 Habits of people who already use it every week

There’s a special file called CLAUDE.md, which holds the fixed rules for your project — and it’s reread with every message, even a simple "hi". That’s why it’s worth keeping it lean, treating it as an index that points to where more information lives, rather than an encyclopedia that tries to hold everything. Another helpful habit: point precisely to a specific document instead of asking AI to "search everything." And it’s worth clearing or summarizing the conversation when you’re around 60% of the context window, without waiting for the maximum limit — and be careful with long pauses, because the reuse discount (explained in the next step) expires after some idle time.

A teacher who keeps a concise “instruction notebook” for the AI instead of pasting the entire course material every time sees the difference in response speed and cost; a self-employed accountant who makes sure never to leave a session paused for too long avoids reprocessing everything from scratch in the next message.

04 Choosing the right tool for each task

Not every task needs the most expensive, most powerful AI model. A faster, cheaper model handles simple, repetitive tasks well; the default model takes care of everyday work; and the most expensive, slower, deeper model is worth saving for important planning—ideally, less than one-fifth of your total usage. Sub-agents use far more tokens than a regular session because each one starts from scratch with a full context—but they’re still worthwhile for specific tasks that can run in parallel, especially with a cheaper model.

It’s also good to understand that usage drains faster during peak hours—scheduling big refactors or tasks with multiple agents outside those hours gets more done. And CLAUDE.md works well as a "constitution" for the way you work: keep stable decisions there so you never have to explain the same thing twice.

A freelance consultant who only needs to format a simple document saves time by using the fastest model, saving the more expensive one for decisions that require deep reasoning; a small business owner who avoids sending a big task at the busiest time of day gets more out of the session.

05 The discount you’re already paying without knowing it

There’s a mechanism called prompt cache behind much of the savings: tokens reused this way cost only 10% of the regular price. With a standard subscription, this reuse window lasts 1 hour — if you go more than an hour without sending a message, the next one reprocesses the entire conversation from scratch at full price. What breaks this discount along the way: switching models during the same session resets reuse, even if it’s only to save on another task — that’s a conscious trade-off. Editing CLAUDE.md doesn’t break the discount right away; it only does when the session actually restarts.

Three habits cover most cases: don’t leave a session paused for more than an hour unless necessary; clear or summarize whenever you change topics; and, for large documents you use every week, keep them in one reference location instead of pasting them again into each separate conversation.

An HR coordinator who steps away for lunch for more than an hour and returns to the same conversation notices the next response takes longer and costs more—that’s the discount expiring; a teacher who always uses the same lesson plan as a reference benefits from keeping that plan in one place for reference, instead of pasting it into every new conversation.

06 Hitting the limit can be a good sign

There’s a fairer way to think about hitting your usage limit: if you’re already practicing the habits in this module and still hit the limit, that’s not necessarily bad—it’s a sign you’re really using the tool and getting its real value, not wasting it. The problem is rarely “I need a bigger plan.” It’s usually context hygiene: stop resending the same entire conversation dozens of times when you could send much less, in a more concise form.

This course covered fundamentals, project structure, a second brain, agent teams, automations, and now token management — ten modules that form the foundation for becoming someone who thinks with AI by default. The final invitation is simple: keep practicing, treat this journey as something that never "ends," and build your own way of working around four pieces — what you save (context), what you connect to live (connections), what AI can do for you (capabilities), and how often you repeat this cycle (cadence).

A teacher who applies just one habit from this module each week will feel the difference in a month; a small business owner who treats this learning as ongoing, instead of something "completed" with a certificate, is the one who really gets value from everything this course has to offer.