🧰 Setup: your environment

A chatbot returns text. You ask, it answers—and that’s it. It doesn’t open any files or run any commands.

Without understanding this limit, you expect a chatbot to do something only an agent can do—and end up frustrated without knowing why.

Text input → text output. No real action on your computer.

A coding agent reads files, writes files, runs commands in the terminal, and returns a result that has already happened—not just a description of what “could” happen.

It's this ability to act that turns “conversation” into “real automation”—the foundation of everything else in the course.

Tools, real execution, verifiable result.

Think of Claude Code as a new employee: you give it the task, it decides how to do it, carries it out, and comes back to show you the result.

This analogy guides how to ask, how to supervise, and when to trust more or less — a central topic in Track 0.6.

Delegation, supervision, growing trust.

A program that runs in your terminal, connected to an Anthropic AI model, with permission (which you grant) to read and write files and run commands.

Knowing “what it is” removes the mystery and makes you comfortable installing and using it without fear — the topic of module 0.2.

Terminal program, AI model, permission granted by you.

Each message exchanged consumes "tokens" — the AI billing unit — and a typical simple automation session costs a few cents to a few reais.

Without this understanding, cost becomes an abstract fear that gets in the way of learning—it’s better to face the real number.

Token, cost per session, estimate (not a fixed bill).

Install → understand the project folder → write the CLAUDE.md → learn plan mode → set the security rules.

Seeing the complete path helps you stay on track — each module builds on the previous one.

Progression: install, organize, guide, review, protect.

A simple text window where you type commands and the computer runs them right away — without clicking any icons.

This is where Claude Code runs. Getting over your fear of the terminal is the first step in the whole course.

Prompt (the “blinking cursor” waiting for a command), type + Enter.

The recommended path on Windows is to enable WSL (Linux inside Windows) and install it there.

Avoids 90% of the compatibility problems that come up when trying to install directly on plain Windows.

WSL, Windows Terminal, restart after enabling.

Open the Terminal app (it’s already installed) and paste a single installation command.

This is the most direct path—without an extra layer like WSL.

Native terminal, official installation script.

cd changes folders; ls (Mac/Linux) or dir (Windows) lists what's inside it.

These are the only two commands you use all the time before calling the agent.

Current folder, navigation, listing.

Run a version command and see a number appear — a sign that the installation succeeded.

Avoids moving forward with a broken installation.

Verification command, version number.

Type the command that opens Claude Code inside a folder and send the first message.

This is the course’s “hello world”—from here on, it’s all practice.

Session, input prompt, agent response.

A regular folder on your computer, dedicated to a project — nothing magical, just organization.

The agent only sees what’s inside the open folder—mixing projects confuses the context.

One project = one folder = one context.

A project folder with a saved version history (via git) — every change is recorded and can be undone.

This is what will let you “publish” the automation in Learning Path 4.

Repository (repo), version history, git.

Common folders: source code, configuration files, the CLAUDE.md, and a `.claude/` folder with skills and preferences.

Recognizing these names prevents confusion when the agent mentions one of them.

Source code, configuration, `.claude/`.

The files stay on your computer; only the conversation text and necessary excerpts travel to the AI model to generate the response.

Addresses the question “are my files exposed?” — revisited in module 0.6.

Local vs. cloud, what flows in each message.

Create a new folder, navigate into it in the terminal, and open Claude Code inside it.

This is the ritual you’ll repeat for every new automation in the course.

mkdir, cd, open the agent in the right folder.

Mixing several projects in a single folder, or opening the agent in the wrong folder (e.g., the user’s home directory).

Prevents the agent from accidentally “seeing” and changing files from other projects.

One project per folder; always open it in the right place.

A plain text file at the project root that the agent reads automatically whenever it opens the folder.

This is how you “teach” fixed rules to the agent without repeating them in every conversation.

Automatic loading, persistent rules.

Each new conversation session "forgets" the previous conversation. CLAUDE.md is how you give the agent a minimal sense of continuity.

Explains why you should put key information there, instead of just saying it out loud.

New session, cleared memory, persistent context via file.

A well-written 20-line CLAUDE.md gives better guidance than a generic 500-line one—the agent reads everything, and too much information dilutes what matters.

This is the most common mistake beginners make: “documenting everything” in the wrong file.

Signal vs. noise, essential rules first.

A ready-to-use template for a concise CLAUDE.md that you can adapt to your project (complete in module 0.4).

Copying a good example is faster than learning the structure from scratch.

Sections: goal, rules, commands, what never to do.

If the project grows, put extra details in separate files referenced by CLAUDE.md—not inside it.

Sets the stage for the concept of skills, explored in depth in Track 3.

Point instead of bloating.

Ask to "summarize this project" right after writing the file — if the response matches what you wrote, it worked.

This is the final exercise in the learning path, completed in module 0.6.

Practical check, immediate feedback.

A mode where the agent writes out the steps it plans to take and waits for your approval before doing anything.

It's the simplest safety net in the course—you see it before it happens.

Plan, approval, conditional execution.

You ask for something → the agent writes the plan → you read, edit, or approve it → only then does it actually run.

Completes the visual understanding of this cycle (full diagram in module 0.5).

Request → plan → review → execution.

Large tasks that modify many files, or involve deleting/publishing things: always use plan mode. Small, reversible tasks: optional.

Always using it slows things down; never using it is risky — balance matters.

Task risk, reversibility.

You can ask for changes to the plan ("do it without step 3," "use a different folder name") before approving it.

Fixing the plan is much cheaper than undoing an execution.

Feedback before the action, cost of correction.

Vague steps ("adjust the necessary files"), or steps that mention deleting/overwriting something you didn’t ask for.

Knowing how to recognize this is what makes plan mode worthwhile.

Specificity, plan scope.

Ask for something small in plan mode and review the generated plan before approving it.

Practice is worth more than theory — seeing a real plan makes the concept stick.

Repetition, familiarity with the workflow.

Commands that delete several folders/files at once always call for plan mode and careful review.

It's the most costly and hardest-to-undo category of error.

Irreversibility, mandatory review.

"Production" is the live environment, used by real people — unlike the isolated test environment.

Covered in depth in Track 4, but the golden rule starts here: never publish without reviewing.

Production, test environment.

Make it clear in CLAUDE.md that nothing goes live (site, post, email) without your explicit approval.

A rule written in the file is read every time — it prevents accidental publishing.

Explicit rule, human approval in the loop.

A table showing what to authorize right away and what to always review first (full version in module 0.6).

Serve as a quick reference when a question comes up in the middle of a task.

Gradual trust, checklist.

Create the project, write the CLAUDE.md, and ask the agent to summarize the project itself — closing the Trilha 0 cycle.

It's proof that the environment is ready for Track 1.

Final check, “environment ready.”

With the terminal, project, CLAUDE.md, plan mode, and security rules ready, Track 1 introduces the WAT framework.

Wraps up the track with a clear next step.

Track transition, environment ready.