1The model works with what it receives

When this course talks about AI, it means language models, the LLMs. A model is a mechanism trained to produce text based on what you give it.

It doesn’t see your school, your team, or last week’s meeting. Whatever is missing from the request, it fills in with the most common way to respond.

Denise, the educational coordinator, asked for a plan for a parents meeting. Without the agenda, the AI imagined priorities. With the agenda and the previous minutes pasted in, it returned a proposal she was able to review.

2There is no best model

There are several models, with different names, sizes, and costs. The question "which one is best?" doesn’t have a useful answer.

The helpful question is different: which model solves this task, within this timeframe, at this cost, and with how much you’ll need to check? That’s why the module compares models with a real task, not an opinion.

Lúcia, a science teacher, stopped looking for "the best AI". Now she asks which tool corrects the 8th grade exercise list within the time she has.

3Seven pieces make the system

A model produces responses. A system organizes how those responses become work. OSWork combines seven pieces: model, interface, files, instructions, tools, memory, and automations.

The name OSWork is a metaphor for organization. You won’t replace your computer’s system.

Denise drew the seven boxes for the task "parents meeting minutes." There was a template and an interface. The missing files were the issue: the agenda was in someone else’s email.

4Correct the right piece

Separating the pieces prevents the reflex to write a request that keeps getting bigger. First you ask where the failure was born. Then you fix only there.

And a piece never leaves the system: you. The model reasons, the tools execute, and you are the one who checks.

Lúcia’s AI said it saved the notes, but the file didn’t appear. A tool with permission to save was missing. Writing the request again wouldn’t solve it.

1 Four functions, four types of model

Language models, the LLMs, write, summarize, explain, and program. Image and video models generate or edit visual material.

There are also classification models. They don’t chat: they receive options and return a choice, yes or no, or a score.

Lúcia listed what she does with AI in a month. Summarizing the class council minutes needs text. The science fair brochure cover needs image. Separating two hundred class comments needs classification.

2Names change, the function stays

ChatGPT, Gemini, and Copilot are chatbots: behind each one there are language models. Within each type, there are families with their own names. In text, the GPT family has Sol, Terra, and Luna, plus GPT-6 Astra. The Claude family has Opus and Fable.

You don’t need to memorize this list: these names come from a query on 09/20/2026. Names, versions, and availability change. That’s why the choice happens when the task appears, and it can be different the next week.

Denise heard from a colleague that "this model is the best" and wanted to use it for everything. When she requested the artwork for the June festival invitation, she found out it only writes text.

3The classifier doesn’t chat; it chooses

A classifier, like the Jev, receives a text and a closed list of alternatives. It returns a choice—not a paragraph.

To triage many items across a few categories, this can be simpler to check than a conversation. It’s a hypothesis to test, not a guarantee. You can try the idea today in the same chat: paste the items and ask "respond with only one of these categories".

Lúcia pasted a student comment into the chat and the three categories, asking for only the category. It returned a single word. She checked ten responses by hand before trusting the others.

4Gateways open many doors with one point

There are also gateways, which give access to multiple providers at a single point. The OpenRouter brings together language models. The Kie brings together image and video models.

Availability varies by account, plan, and release. A model that shows up for a colleague may not show up for you.

For the ten-second graduation vignette, Denise didn’t need to sign a video service by model. In a text and video hub, she compared two models in the same place, with one account.

1Two different axes

The model is the chosen mechanism. Reasoning effort is a setting of that mechanism: how much it analyzes before responding.

Higher levels can spend more time and more tokens. The selector names change between Chat, the Work, and the Codex. There is no single list of levels that applies to all products.

Denise thought changing the level meant changing the AI. She found out that, within the same model, you can ask for a quick response or a longer analysis.

2More effort doesn’t bring the missing file

Increasing effort doesn’t provide a document that was left out. If the answer depends on some data, the data needs to be included in the request.

First complete the inputs. Then evaluate whether the problem calls for more analysis.

Lúcia wanted to know why the secretary’s grades spreadsheet didn’t match hers. At maximum effort, without the spreadsheets, she received general hypotheses. With the default, with both spreadsheets pasted in, she got the exact line of the difference.

3Start with the standard

For most everyday tasks, the default effort works. Save more analysis for what involves multiple steps or lots of data.

Denise needed to rewrite a five-line invitation for the parent meeting. In the default, the response came in seconds and it worked.

4Compare under equal conditions

To see whether effort helped, repeat the same request, with the same material, using the same model. Change only the effort.

Then record: was there an improvement you can show? One more fact, one fewer mistake, a correct calculation. “Got better” without evidence doesn’t count.

Lúcia asked for the same correction, commented on, twice. At the highest level, a unit error appeared that the standard had let slip. She noted which one it was.

1Define before you request

A quality ruler says, before the request, which facts need to appear, which errors are unacceptable, and how the output will be used.

Written beforehand, it doesn’t get carried away by the response. Written afterward, it usually approves what came.

Denise was going to ask for a summary of the planning meeting for the science fair. Before opening the chat, she wrote three lines on paper.

2Three small criteria are enough

To start, use three criteria. Faithfulness to the data: no data from the material changes or disappears. Combined format: the size and sections you asked for. Verifiable conclusions: nothing is added that you can’t find in the material.

The three criteria are the template. In each task, they turn into concrete items. In Denise’s minutes, fidelity became “the three responsible people, no invented deadline”; format became “a pending items section”; verifiable became “each sentence can be found in the minutes.”

Lúcia used the same template for a chapter summary from a science book. The items changed: chapter concepts, a page, each statement with the page number.

3The prettiest answer can be the worst

The test needs to reflect the work you will deliver, not a demo made to impress. An elegant sentence doesn’t make up for losing a responsible person.

Denise got two versions of the summary. The first was smooth and pleasant to read. The second was dry. She applied the rule to both.

4Write down what was expected, what you observed, and keep the bad one

Turn the rule into a four-column table: criterion, expected, observed, and passed? That way the decision is written down and you can repeat the test later.

Also keep a bad answer. It reminds you what you’re trying to avoid.

Lúcia pasted the table at the end of the corrections document. The following week, she used the same rule to compare a new model, without starting from scratch.

1Signing in with the account uses your plan

Doing a login with the ChatGPT account uses that account’s rights and limits. They come from its plan and its workspace. What you can use—and how much—comes from the plan.

These limits and rules change. The source of truth is the current configuration of your account, not what someone told you.

Lúcia uses the school’s account to access the chat. When she hit the day’s usage limit, she found out the limit was from the school’s plan—not hers.

2The access key charges per usage

Programs use the AI through an API. For that, they use a API key, charged per usage on the platform.

Subscribing to the chat doesn’t mean you get free balance for any program that calls the API. It’s two accounts, with two charges.

Denise ran a reports program with an API key from the school. The tokens used showed up on the platform, not in the chat subscription.

3Centres have their own credit

Centres like the OpenRouter and the Kie have their own credit, billed by usage. It’s separate from any subscription.

So there are at least three places where the money can come from: the chat plan, the API platform, and the centre credit.

Lúcia generated the reading week posters on a centre, with a small credit that she bought herself to test. The credit ran out in the middle of the batch. The chat subscription was still active, but it didn’t cover that.

4Check the method before a long run

Before leaving something running for a long time, check which method is active: in the tool settings, look at the account plan, or the key in use. Later, in Codex, a command in the terminal shows that.

In the project sheet, note the method: account, key, or centre. The credential itself never goes on the sheet, for a request, or in a screenshot.

Before asking for the summary of the forty meeting minutes from the year, Denise checked the settings and wrote in the sheet: "school chat · school account · plan limit". Without any password.

$ codex login status
Logged in using ChatGPT

1An agent performs multiple steps in sequence

In a chat, you send a message and get a response. An agent receives an objective and goes alone: it reads files, creates, compares, corrects.

This saves you work. It also multiplies the places it can make mistakes without you seeing.

Lúcia asked an agent to organize the notes from the grading period. It read three spreadsheets, created a new one, and renamed the old ones. The last step she hadn’t asked for.

2Five parts of an authorization

Combine five things before you start: the objective, the permitted files, the authorized actions, the time limit, and the stop condition.

In a chat, time turns into “respond in a single message”; in an agent, it’s an execution ceiling. Technical permission and written instruction complement each other: the tool limits what’s possible, and the authorization says what’s desired.

Denise wrote the authorization for the agent that prepares the monthly attendance report. It took two minutes and fits on a sticky note.

3The existence of a button is not permission

Sending a message, posting, or deleting are external actions. Each one requires explicit instruction. The fact that a send button exists does not authorize using it.

Lúcia authorized the agent to create the draft of the scavenger hunt announcement and compare it with last year’s. Sending it to families was left out on purpose.

4The result accounts for what it did and how it checked

Always ask for a three-part closing: what was done, how it was verified, and what’s still pending. This way, the result becomes something you review, not something you have to trust.

Denise’s agent finished the draft of the attendance report and listed what she checked. She opened the spreadsheet, checked one of the numbers, and approved the rest.

1Chat is a conversation: question, answer, adjust

The chat is a interface for conversation. Think about the question you ask a coworker in the hallway, between two lessons. It’s short, the answer comes right away, and you decide what to do with it.

If the answer didn’t work, you don’t start over. Send an adjustment in the same conversation.

Lúcia will cover a math lesson for a colleague. She asked for three ways to explain fractions using the ingredients from a recipe. She chose one, adjusted another, and took them to the class.

2Who and what for change the answer

A free-form question gets an encyclopedia-style answer. Say who will read it and what you’re going to do with the text. The answer already comes in the right length and tone.

Denise needed to explain the class council to the parents of 6th grade. The first question brought a technical paragraph. With the audience and purpose, two ready-made sentences came for the message.

3Ask for the AI’s assumptions

Every short question leaves gaps. The AI fills those gaps without telling you: it assumes the students’ age, the tone, the size. Ask it to list what it assumed.

That way you can see the guess before you use the answer. Correcting a guess costs a message.

Lúcia asked for an opening question for the lesson about mixtures. The list of guesses showed that the AI thought of high school students. She corrected it with one line.

4When the chat is enough, and when it asks for more

The choice is based on the task’s intent, not on a technical restriction. Some chats also read attached files. If the delivery is a response you read and check right away, the chat is enough.

If the delivery is a document with multiple entries, the conversation gets too short. Some chats have a mode for bigger tasks; in ChatGPT, it’s called Work. It’s the topic of the next lesson, which also shows how to do it without that.

Denise almost opened a long task to write a three-line message. She went back to the chat and got it done in two minutes.

1Work receives the task and returns the result

In Work, you don’t chat sentence by sentence. You submit a task, like an analysis or a document, and get the result to review. It can use files and approved tools.

Think of the request for a cake at the bakery. You say flavor, size, and day. You don’t keep watching the oven. Work doesn’t show up in every plan. Can’t find it there? Use the request in regular chat: it works the same.

Denise needs to hire a bus for the museum field trip. She has three quotes and wants a comparison to take to management.

2Five parts of a request

A request says five things. The goal. The inputs, which are the material the AI can use. The output, which is the format of the result. The limits. And the stop, which is when the work ends.

It looks like lesson authorization 6, in module 1, and it’s related. The authorization says what the AI can do; the request says what must exist at the end.

Denise wrote the request for the bus quotes in five lines. It took three minutes.

3"Search" turns into a table you review

A vague request opens the door to endless research. The request closes that door: three options, the documents you provided, a format.

Notice the field with no information. The request asked for "not informed", and the AI didn’t fill it in with a guess.

4 The stop point tells you when the work is finished

Without a stop point, the AI decides on its own when it arrives. Sometimes it stops too early. Many times it goes too far. Tell it the size of the result and the point where it should deliver.

Lúcia ordered a comparison of microscope kits for the lab. She limited it to three kits, from the catalogs she pasted, and a table. In one page, she got what used to take five.

1The Desktop is on your computer, near the folders

The Desktop is the app that sits on your computer. If your app offers that, it can open folders and other apps, always with your permission.

In the browser chat, you attach or paste each file. In both cases, the AI only reads what reached it.

Lúcia uses the chat in the school’s browser and the Desktop on her home notebook. In both, she checks what the AI received before asking for the request.

2Authorize a folder, not your entire computer

Giving access is like handing over the key to a drawer, not the key to the whole school. Put only what the task needs into a subfolder. When the app asks for access, choose only that subfolder. Screen names change between versions; what doesn’t change is choosing the smallest folder possible.

The science fair folder has three versions of the budget. Denise wants to test the AI without risking the original. She authorized only the examples subfolder, with two copies.

3Ask for the list of what was read before the work

Before the comparison, ask for the names of the files the AI can read. Along with that, the first and last line of each one. A name alone doesn’t prove it was read. The first and last line show the beginning and the end arrived, and you verify it in the file.

If the list comes back wrong, the problem is access, not the request. Fix access and repeat the list.

4No access? Send it another way

If Desktop doesn’t exist on your account, or it can’t reach the folder, send the files using a path that works. Attach it in the chat using the attach button next to the message box. Or paste the text with a header that includes the file name.

Lúcia pasted two texts into the browser chat, each with the name on top. She asked for the list before the summary.

1Local depends on your computer

In local execution, the work runs on your machine. It’s like a cake in your home oven: if the power goes out, the oven stops.

Power, network, and your computer’s permissions matter. If the notebook sleeps, the task can stop halfway through.

Lúcia asked the app Desktop, from lesson 9, for a review of lesson plans that only exist on her notebook. She closed the lid at 6:00 PM and left. The next day, the review had stopped halfway through.

2The cloud keeps going, but you only see what it received

In the cloud, the work runs on remote computers. It’s like a bakery: the oven doesn’t depend on your home. But the baker only has the ingredients you brought.

The chat you already use is an example: the model works on the company’s computers. That’s why it only knows what you pasted or attached.

Denise wants the draft of her attendance report to be ready even if she turns off the notebook. For that, the spreadsheet needs to be somewhere the cloud can reach.

3The screen name doesn’t say where it runs

Some environments run in the cloud and keep going without your machine turned on. That depends on the feature, not just the name Work or whether the screen is modern.

When in doubt, replace the assumption with three questions. Look for the answer in the tool’s help page. Or test: start a short task, close your notebook for ten minutes, and see if it made progress. Couldn’t tell? Turn it into an open item. In your everyday chat, wait for the full answer to appear before closing the tab. That way you don’t have to guess what happens to a response halfway through.

4Three lines on the project sheet

For each task, write where it runs, where it reads the inputs from, and where it saves the outputs. Don’t know one of them? Write it as an open item. A written open item is better than a forgotten assumption.

The right place is the project sheet, created in lesson 5. Didn’t do lesson 5? Use any notepad.

Denise wrote the three lines from the attendance report and an open item. With the open item, she went to ask the school’s support.

1Six fields, one sentence each

Think about the service work order of a technical support shop. It has fixed fields: the device, the problem, what not to touch, how to test on delivery. Nobody writes "fix it properly".

The delivery contract is the work order of lesson 8 with a sixth part: verification. The lesson 6 authorization, in module 1, fits inside it: objective and stopping continue, files become inputs, actions and time become limits.

Denise wants the draft minutes from the educational meeting based on the agenda. She filled in all six fields in four minutes.

2Name what must be there at the end

"Make minutes" leaves the format, size, and what to do with what’s missing open. The contract answers all three: fixed format, defined length, and absent data marked. The AI stops guessing.

3Replace "good" with a criterion you can verify

"Good", "clear", and "complete" are wishes. Nobody can verify a wish. Verification uses criteria that anyone can check by looking at the result, like the quality ruler of lesson 4.

Lúcia asked for experiment scripts that were "well explained." She replaced that with two criteria. Now she checks each script in one minute.

4The easier it is to check, the earlier the deviation shows up

An easy-to-inspect outcome shows the error on the first read. That’s why the contract asks for a fixed format and a written check at the end.

In Denise’s minutes, the check said "2 responsible parties". She counted in the agenda and in the minutes: 2 and 2. It took 30 seconds, because the minutes was a list.

1Open the delivery and compare it to the source

It’s like checking a grocery bag against the receipt before you leave. It’s not enough for the bag to be full. Each item on the receipt has to be there, and nothing extra.

Lúcia received the minutes from the sciences area meeting. She compared each decision with the agenda. She found a responsible person the AI invented.

2 Three reviews: fact, format, action

You don’t need to reread everything. Choose three points. A fact that matches the source. A format, which is what was requested. And an action, that works or was done the way it was agreed.

In the attendance report, Denise checked the total number of absences for a class and whether the file opened with the requested columns. Then, she tested the spreadsheet link mentioned in the report.

3Tested is not the same as suggested

Ask the AI for the evidence of what it checked. And ask it to separate what it truly verified from what it only suggests you check.

"I reviewed everything" doesn’t say what was reviewed. A list does: and it shows what’s left for you. Even the AI’s "I verified" is a claim—check one item from the list as a sample.

4Write down and correct the request—not just the text

Write down what you observed in each verification, with the exact result. Did you find an error? Correct the request too before reusing it, or the source if the mistake came from it. If not, the same error will come up again next time.

Lúcia corrected the name in the minutes. Then she added a line to the delivery contract: "responsible that the agenda doesn’t define becomes [not informed]".

1Each system has its own terminal

The terminal is already included on your computer. You just need to know where it is. The commands in this course are written in Bash, the terminal language on Linux and macOS. Mac uses a variation of it, and the commands work the same.

On Windows, they work inside the WSL. The terminal that comes with Windows uses a different language. Don't paste the course commands into it without adapting them.

Lúcia uses a notebook with macOS. She pressed Cmd+Space, typed "Terminal", and hit Enter. It took ten seconds.

> wsl --install

2You type one line, it returns another

When you open it, the terminal shows a short line that ends with $, with a blinking cursor. On the Mac, it ends with %: it’s the same thing. It’s the computer waiting for your command.

You type the command and press Enter. The response appears right below. Then the $ comes back, ready for the next one.

Denise opened the terminal for the first time and waited for something to happen. Nothing happened, because it was waiting for her.

denise@notebook:~$ pwd
/home/denise
denise@notebook:~$ 

3pwd is the "you are here"

Do you know the school map with the "you are here" sticker? The pwd command does that. It tells you the full path of the folder you’re in right now.

Read the path like an address. Each slash separates a folder, and the last one is where you are. On macOS, your personal folder starts with /Users; on Linux, with /home.

Lúcia typed pwd and read /Users/lucia. So she was in the personal folder, the same one that opens when you click the little house in Finder.

$ pwd
/Users/lucia

4ls shows what’s in the folder

Once you know where you are, see what’s there. The ls command lists the folders and files in the current location, side by side. On the Mac, the personal folder’s folders appear with English names, like Documents and Downloads.

To change folders, use cd. It’s in lesson 16. For now, just know that the starting folder matters.

Denise opened the Codex in the Downloads folder, during a test by a colleague. He couldn’t see her project, which was in another folder. The pwd would have shown that earlier.

$ pwd
/home/denise
$ ls
Documentos  Downloads  Imagens  Músicas

1Three steps, one at a time

Installing puts the program on your computer. It does not connect your account or choose your work folder. Each thing has its own step and its own check.

This lesson only covers the first one. The other two come in lessons 15 and 16.

Right after installing, Lúcia typed codex and the program asked her to sign in with her account. She thought it was broken. It wasn’t: the first step had worked, and the second one was missing.

2Check the seal before opening the box

When a box arrives in the office, you check the seal and the sender before you open it. With a command, it’s the same: the sender is the address it comes from.

The official command downloads a script from the address chatgpt.com and runs it. That’s why the address matters so much. Don’t paste commands from an unknown page.

Denise received a "faster way" to put Codex on the computer in a group. The address in the middle of the command wasn’t the official page’s address. She didn’t paste it and used the official page instead.

3Paste the command and wait for the last line

On macOS and Linux, the command from the official page is the one below. On Windows with WSL, paste the same command inside the Ubuntu. Without WSL, follow the official Codex page, which has its own instructions.

Use the copy button: you don’t need to type the vertical bar. The installer writes a few lines while it’s working, and you don’t need to understand each one. Wait for $ (on Mac, %) to come back. The one that confirms it worked is step 4.

Lúcia pasted the command into the Mac Terminal and waited. She didn’t try to decipher the lines that scrolled by. When the % returned, she moved on to the check.

$ curl -fsSL https://chatgpt.com/codex/install.sh | sh

4codex --version confirms

To see if it worked, ask for the version. If the computer recognizes the program, it responds with a number.

If you see "command not found", the terminal hasn’t found the program yet. Close the terminal, open it again, and repeat.

On Denise’s laptop, the first attempt returned "command not found". She closed the terminal, opened another one, and typed it again. The version number came back.

$ codex --version
codex: command not found
$ # fechou e abriu o terminal de novo
$ codex --version
codex-cli 0.156.1

1 The badge passes through the turnstile; the password stays with you

At school, you pass your badge through the turnstile and no one hears your password. The Codex login works like this: the terminal takes you to the browser, and that’s where you sign in.

The password never goes through the terminal. When you’re done in the browser, Codex receives the confirmation and stores what you entered.

ChatGPT plans that include Codex change over time. Before you start, check on the official authentication page whether your plan is listed there. The name of your plan shows up in the settings of your ChatGPT account.

Lúcia typed codex login. The browser opened on the ChatGPT sign-in screen. She signed in with the school account and went back to the terminal.

$ codex login
# o navegador abre; entre com a conta do ChatGPT e volte ao terminal

2codex login status tells you the method

Being signed in isn’t enough: it matters which path you use. Signing in with your account uses that plan. A API key is charged per usage, on another account.

That difference is from lesson 5, in module 1. If you skipped it, here’s the summary: it’s two accounts, with two charges.

Denise expected to see "ChatGPT" and saw that Codex was signing in using an old school API key. She left with codex logout and signed in again with codex login, using the account.

$ codex login status
Logged in using ChatGPT

3Through the API, the key doesn’t appear on the screen

Are you going to sign in via your ChatGPT account? You can skip this step. If you use the API, the key is stored under a name, OPENAI_API_KEY, which the terminal knows. The official command passes the value directly to Codex, without showing it on the screen.

Typing the key into the command is the common mistake: it stays in the terminal history and shows up in any print. A standalone .env file also doesn’t connect anything. Some mechanism has to load the value.

A coworker asked for the school key to test at home. Lúcia didn’t send it in the group. She explained that the key tells who pays, and each person signs in with their own account.

4On the form: the method; the key, never

In the project sheet, which method is active and where you checked it. It’s the same access sheet from lesson 5. No sheet yet? A note on your phone is enough.

The credential doesn’t go in the sheet, into a request, or into a screenshot. If it leaks, whoever manages the account needs to rotate the key.

Denise’s line ended up like this: "Codex · ChatGPT · checked with codex login status". No password, no piece of key.

1Enter the room before you start the lesson

If you enter the wrong room, you give the lesson to the wrong group. With Codex it’s the same: it works where it was opened. So you enter the folder before you open the program.

mkdir -p creates the folder, and the previous ones if they’re missing. cd enters it. The ~ sign means "my personal folder": on the Mac Finder, it’s the folder with your name and the house icon.

Denise created the training folder and entered it. The pwd confirmed the address before she opened any program.

$ mkdir -p ~/projetos/meu-primeiro-projeto
$ cd ~/projetos/meu-primeiro-projeto
$ pwd
/home/denise/projetos/meu-primeiro-projeto

2Inside the folder, only the task material

You don’t need to open your entire personal folder to experiment. A small area, with training files, reduces confusion. When something goes wrong, it’s clear which files could have changed.

Lúcia thought about opening Codex in the Documents folder, where the exams and class notes are. She preferred the training folder, with a fake agenda. Nothing real was within reach.

3One file for people, another for the agent

The README describes the project’s purpose for anyone who arrives. The AGENTS.md gives working instructions to the agent.

Both end in .md because they are text in Markdown: the # marks the title, and the hyphen marks a list item.

Denise wrote the purpose in the README: prepare the meeting agenda. In AGENTS.md, she added two rules: work only in that folder and don’t send anything.

4Check the folder and open the Codex

Before typing codex, run pwd and ls. If the address and the files match, open the program there.

On the first time in a folder, the Codex asks if you trust it. It’s your training folder: choose "Trust and continue" using the arrow keys and press Enter. In this training, don’t use "Open restricted". To exit the Codex, type /quit and press Enter.

Lúcia checked the address, saw the three items in ls, and only then typed codex. She answered the folder question and exited with /quit, without asking for anything yet.

$ pwd
/Users/lucia/projetos/meu-primeiro-projeto
$ ls
AGENTS.md  README.md  entradas
$ codex
Trust this folder? Codex can read, edit, and run files here,
subject to your permission settings. …
› Trust and continue
  Open restricted

1Inspection before the renovation

No serious person starts a renovation by breaking down a wall. First comes the inspection: look, write notes, understand. With an agent, it’s the same order, in four steps.

Denise would ask Codex to "improve the meeting folder." She replaced it with two requests: first, read and say what’s missing; then, create a single file.

2The first request only reads

In the lesson 16 training folder, ask Codex to read the AGENTS.md and the README. Say it in plain words: without editing. And ask it to cite the files it used.

Lúcia made this request in the training folder. The response below is real, from Codex, in that same folder, just shortened.

3Check what it used

The list of files used shows what the answer is based on. Compare it with what ls shows in the folder.

In the real response, Codex read two files and said it didn’t open the agenda. So the list of what’s missing comes only from the README. That’s a good read, but it still doesn’t know the five meeting items.

Denise read "I did not read its contents" and understood the response limit. In the second request, she made it clear that the plan should rely on the agenda.

4Then, an alteration with a name

Now authorize a small change: create only plan.md, with three actions and one verification for each. The Codex can ask "Would you like to make the following edits?". Check that the change is only in plan.md and choose "Yes, proceed". If it’s another file, choose the option that starts with "No". Did it create without asking? That also happens: your current permissions let you write in the folder. Check with ls.

After that, exit with /quit and read the file with cat plano.md, which shows the content in the terminal. Check whether the actions rely on what exists in the folder.

The plan Lúcia received covers the five items on the agenda and warns that times and dates still need to be defined. She checked in reuniao.txt: everything was there.

$ cat plano.md
# Plano de ações

Base: entradas/reuniao.txt (reunião pedagógica fictícia).
Horários e datas ainda precisam ser definidos.

1. Ação: Organizar o novo horário da biblioteca e as regras
   de uso dos notebooks da sala de informática.
   Verificação: Conferir se a proposta registra o horário
   da biblioteca e as condições de uso dos notebooks.
…

1The key to a room, not the master key

Whoever will use the lab gets the lab’s key, not the whole bunch. With an agent, it’s the permissions that control what it can reach in files, on the internet, and in commands.

Go up one step at a time. Reading files is low risk; writing is medium risk; executing commands is high risk. Each step increases the possible damage.

Denise gave the intern only the reading room key. With Codex, it started from the same principle: access only to the training folder.

2Written rule guides; permission limits

What you write in AGENTS.md guides the agent’s behavior. But it’s text: it doesn’t technically prevent anything. What prevents things is the program’s permissions.

In Codex, the /permissions command shows and changes what it can do. Start with the most restricted option that covers the task. Don’t remove all protections to work around an error.

Codex asked Lúcia for internet access to consult documentation. She evaluated that request on her own, without also allowing it to delete files or send messages.

3Save the "before" with a copy

The cp -r command copies an entire folder, with everything inside. Make the copy before the change, with a name that tells you what it is.

Later, in module 5, the Git will do this in a more complete way. For now, the copy already gives you a rollback point.

Before authorizing the change in AGENTS.md, Denise copied the training folder with the ending "-before". The ls confirmed both.

$ cp -r ~/projetos/meu-primeiro-projeto ~/projetos/meu-primeiro-projeto-antes
$ ls ~/projetos
meu-primeiro-projeto  meu-primeiro-projeto-antes

4Compare: did only what you were supposed to change?

After the change, the diff compares the copy with the current folder. It shows only the differences, file by file. The lines that start with > are the new ones.

If another file shows up in the comparison, the agent changed something it shouldn’t have. The "-before" copy has the old version for you to recover.

In Lúcia’s diff, only one file appeared: AGENTS.md, with two new lines. It was exactly what she authorized.

$ diff -r ~/projetos/meu-primeiro-projeto-antes ~/projetos/meu-primeiro-projeto
diff -r …/meu-primeiro-projeto-antes/AGENTS.md …/meu-primeiro-projeto/AGENTS.md
3a4,5
> - Todo resultado vem com a verificação que você observou.
> - Esta tarefa não autoriza publicar nada.

$ cp ~/projetos/meu-primeiro-projeto-antes/AGENTS.md ~/projetos/meu-primeiro-projeto/AGENTS.md

1The folder tells the AI where the topic starts and ends

In the secretary's steel file, each drawer holds a class. Nobody searches for 8th A in the 7th B drawer. A work folder does the same: it gathers the material for just one topic. That material is the context of the task.

When you open the Codex in a folder, it works from that folder. If the folder mixes topics, anything that doesn't relate to the request becomes noise.

Lúcia stored the science fair project in the same folder as the report cards. She asked the AI for a summary of the fair and got a paragraph with a student's grade mixed in.

2The tilde ~ is the nickname for your personal folder

In the terminal, the ~ (tilde) symbol represents your personal folder. Inside it, you will create a projects folder, which gathers independent work.

You read the path ~/projetos/config in this order: personal folder, then projects, then config. On the Brazilian keyboard, the tilde is produced with the tilde key followed by the space bar.

Denise typed pwd in the terminal, as in module 3, and saw the full address of her personal folder. The ~ is just the short way to write that address.

$ cd ~
$ pwd
/Users/denise

3What applies to everyone goes in config, outside the projects

The config folder, for configuration, stores the knowledge that applies to any project, like your preferences. It sits inside projects, but outside each individual project.

Each project keeps its own entries, the material the AI reads, like minutes or spreadsheets. And it keeps its own results, what it produces. Separated, you can check one against the other. Don’t mix in a project documents from different classes or different schools.

Denise prefers short reports, with the pending items at the end. This applies to the council report and to the agenda for the parents meeting. So you go to config, just once.

4Draw the tree before creating the folders

Before creating anything, draw the tree on paper: one config folder and a single training project. That way you decide the names calmly.

Use short names, with no space and no accent, like meu-primeiro-projeto and saidas. In the terminal, space and accent add work to every command.

Lúcia drew it on a napkin: projects, with config and feira-de-ciencias; inside the fair, entries and saidas. It took a minute and avoided three folders with similar names.

$ mkdir -p ~/projetos/config ~/projetos/meu-primeiro-projeto/entradas ~/projetos/meu-primeiro-projeto/saidas
$ ls ~/projetos
config  meu-primeiro-projeto

1Markdown is text with three simple marks

Every lab experiment script for Lúcia has a title, materials, and procedure. She underlines the titles and puts a dash before each material. Markdown does the same with the signs you type.

The # at the beginning of the line creates a title, the ## creates a subtitle, and the hyphen creates a list item. The file is still text: you can read it even without a special program.

Lúcia took the script "Germinação do feijão" and turned it into Markdown in five minutes. She learned nothing beyond these three marks.

2The name ends in .md and opens in any editor

A Markdown file is a text file whose name ends in .md, like README.md. It opens in the computer's text editor and also in the terminal.

In the terminal, the nano opens the file so you can edit it right there. Then the cat command shows the content on the screen so you can check it.

Denise opened the board project's README with nano. She changed one line, saved with Ctrl+O, confirmed the name with Enter, and exited with Ctrl+X. Then she checked with cat.

  GNU nano                    README.md
# Meu primeiro projeto OSWork

## Propósito
Produzir relatórios de treino a partir de dados fictícios.

^G Help    ^O Write Out    ^W Where Is    ^X Exit

3The README explains the project for people who arrive later

The course kit template has five sections: Purpose, Read first, Organization, How to check, and Current status. You replace each template text with what matters in your project.

Still unsure about a field? Write "to be defined". An honest open field is better than a template text that nobody checked.

On the science fair README, Lúcia wrote under Purpose: "organize the fair sign-ups". Under How to check: "every registered group shows up on the final list".

4Clarity beats formatting

Small files with a clear name last longer than a lost conversation. People can review them, and agents can look them up.

The value comes from clarity. The three marks are enough. Bold, table, and link are optional.

Denise took a week off. The colleague who covered in her place opened the council project README and continued the work without needing to call her.

1Each secretariat book answers a question

The school secretariat doesn’t write everything in just one notebook. There’s the minutes book, the incidents book, and the procedures notebook. Each one answers a different question.

In the config folder, four files do that job. Separated, you look up only what you need—and the AI does too.

Denise was looking for why the parents meeting had been moved to Saturday. The reason was in a 40-page notebook, among messages and phone numbers. It took half an hour to find it.

2Preference and decision live in different files

Preference is your steady way of working, like "I prefer short reports". It goes in memoria.md.

A decision is a choice with a reason, and the reason can change. "We chose a spreadsheet because the whole team uses the same one" is a decision. It goes in decisoes.md, with a date.

Lúcia prefers exercises with an answer key at the end: that's memory. But "the 8th grade tests have 10 questions because the coordinator standardized them" is a decision.

3Failures get consulted when they come back, and you don't copy them into every request

The falhas.md records a problem, the cause, and the smallest correction—that is, the small protection that prevents repetition. It's for checking when the problem comes back. The dicas.md stores procedures that already worked.

Copy the entire falhas.md into every request, "just in case." It fills the chat with warnings that have nothing to do with the task. You open it when the problem shows up again.

The meeting minutes summary came out empty on a Monday. The entradas folder was empty. Denise noted it in falhas.md and started checking the folder before asking.

4Did the decision change? Write the new one with a date and a reason

When a decision changes, don't replace the old line in silence. Write the new one with a date and a reason, and mark the old one as replaced.

That way, you never have two contradictory rules valid at the same time. And whoever reads it understands the path the decision took.

In October, Lúcia's tests went from 10 to 12 questions, with two graph-reading questions. She added the new line and marked the August one as replaced.

1Who has the credential acts on behalf of the account

At the school’s front desk, the key board shows which rooms exist. Nobody worries about that list being visible. With keys, it’s different: whoever takes the key opens the room.

A credential works like a key. A password, a API key or the bot token let whoever has them act on behalf of your account.

Denise was going to send to the team group a screenshot of the notes system configuration. Before sending, she noticed the entire coordination password in the corner of the image.

2The .env stores variables, but it's not a vault

The file .env stores variables: a name, an equal sign, and a value. For example, TELEGRAM_BOT_TOKEN or DATABASE_URL, the address of a database, with the password inside.

It's not encrypted. Anyone with access to the file can read what's inside. That's why it stays only on your machine. In lesson 7, the command chmod restricts reading to you only.

In lesson 7, Lúcia will create a lookup bot for the class. Its token will live in the .env in the project folder, and nowhere else.

3O .env.example shows the structure without giving access

The .env.example has the same names, with fake values. Anyone who receives the project sees what they need to fill in, but gets no access to anything.

The course kit includes TELEGRAM_BOT_TOKEN=fill_in_locally. You replace the value only in your private copy, the .env. With the example value, no bot works.

Denise shared the reports project with the vice-director using the .env.example. The vice filled in her own .env with the password she received from the office.

4AI needs the variable name, not the value

Real values don't go in prints, in course examples, or in a file you send to the AI without need. To help, the AI almost always only needs to know that the variable exists.

Did you paste a key by mistake? Deleting the message isn't enough. Replace the key on the site that generated it, in the security area or the account keys area. If you never generated a key, keep this rule for when you generate one.

Lúcia's report wasn't connecting to the school's spreadsheet. Instead of pasting the .env, she told the AI which variables had been filled in.

1The .gitignore separates what the team reads from what stays at home

Each version saved by Git is called a commit. The .gitignore is a text file in the project folder with the list of what Git should leave out.

This list includes the .env, its private variants, and the temporary folders that programs create on their own.

In the reports project, Denise put the .env in the list before saving the first version. The file with the notes system password never made it into the history.

2Each line in .gitignore is a pattern

The .env line picks up the .env file. The .env.* line picks up variants like .env.local: the asterisk matches any ending. The line that starts with ! opens an exception.

So !.env.example returns the example to the list of what’s kept. The last lines cover temporary folders and files that some programs create on their own. You don’t need to touch them.

Lúcia found the exclamation strange on the third line of the kit file. It was the one that kept the .env.example in the project, so her math classmate would know what to fill in.

3Ignoring only applies to what hasn’t been saved yet

The .gitignore doesn’t apply to a file that’s already been saved, the tracked file. If the .env already entered a commit, the line written afterward doesn’t remove it from the history.

It’s like the office courier envelope: the paper that shouldn’t go out stays in the pile until the envelope is sealed. After the envelope has left, scratching the paper off the list doesn’t bring it back.

A coworker of Denise put the .env into the .gitignore a week after the first version. The file with the password was still there, in the old version.

4Leaked? Rotate the key before you clean the file

If a key was published, the first fix is to revoke the key at the source—meaning cancel it on the site that created it. This is in the keys or security area of the account, like the API platform’s keys page. Deleting the line from the file doesn’t invalidate a copy that someone already saw.

Only then comes the fix to the history, depending on the case. Module 6 shows how.

The API key from a Lucia project appeared in a version shared with the team. She canceled the key on the platform site in the same minute and created a new one. Only then did she take care of the file.

1The AI reads what you point to, not the entire folder

The AI doesn't automatically read every computer file in Markdown. You tell it which documents it should consult.

When a reference applies to the whole project task, it goes in AGENTS.md, the project's instruction file. Module 5 takes care of that.

Denise asked for a draft of the council report without citing any file. The AI didn't consult decidedes.md, and the format came out different from what the team had decided.

2The Read first points to three paths, in order

In the README, the Read first section lists the files that any project task must open before starting. Three paths are enough.

Write each path starting from the project folder. The ## makes a subtitle, like in lesson 2 of this module. Read ../ as "go up one folder": from meu-primeiro-projeto you go to projetos and, from there, enter config.

In the science fair project, Lúcia put the fair regulations second. In your training project, use the three paths from the board below.

3 An expired file causes more trouble than anything

The teachers’ lounge bulletin board with the notice of a March meeting confuses more than an empty board. The same happens with AI memory.

An old file can bring the address of a service or process that has already changed. Before a task, update the expired decision and remove from the working folder what doesn’t matter.

Lúcia’s decisoes.md still said "exams with 10 questions". The AI built the exam with 10. It added the new line and marked the old one as replaced, as in lesson 3 of this module.

4Check the paths, and then the content

When you start a task, ask for the README and the decision that matters to be read. Don’t load contact lists or passwords just because they’re in the same folder.

Review now and then. First check whether each path exists; then open the file and see if it still describes today’s situation.

Denise put on the coordination calendar: every first Monday of the month, ten minutes to review the council project’s first read.

$ ls AGENTS.md ../config/decisoes.md ../config/memoria.md
AGENTS.md  ../config/decisoes.md  ../config/memoria.md

1The AGENTS.md is the sign on the door of the folder

In a science lab, the sign on the door tells you how to work inside. AGENTS.md does the same for a project folder. The Codex looks for that file by itself when it starts working in the folder.

It’s a text file in Markdown. You open and edit it in a text editor, like any other text.

Lúcia created the training folder in module 3 and completed it in module 4. Inside it, next to the README, there’s AGENTS.md. It’s the first file she will improve.

2It explains how to work, it doesn’t tell the story

Four topics fit in AGENTS.md: where to start reading, how to check the result, what not to do, and the delivery format. The school story and the reasons behind each decision are left out.

A short file is read in full. A long file hides the rule that matters in the middle of paragraphs.

Denise opened the AGENTS.md she had written for the meeting minutes project. They were two paragraphs about the school’s founding and only one work rule. She deleted the paragraphs.

3An observable rule has action and evidence

Do the plate test. "Use protective eyewear before starting the experiment" can be checked by looking. "Be careful" can’t.

In AGENTS.md it’s the same. A good rule asks for an action and leaves evidence you can see in the delivery.

In the training report, Lúcia replaced "be excellent" with a checking rule. In the next delivery, the agent wrote the sum and the difference it found. She checked it in one minute.

4Five short rules are enough to get started

Start with five rules and run each one through this question: can I observe whether it was followed? If the answer is no, rewrite it with an action. If the rule changes nothing in the work, delete it.

The board below is the course template, with rules like this. You adapt the purpose to your folder.

Denise started from these five rules for the AGENTS.md of the minutes and only changed the folder names. Most useful: "Don’t invent missing data: describe the pending item."

1 The global applies everywhere; the project one, only in the folder

The rule book applies across the whole school. The class agreement applies in the room. With AGENTS.md, it’s the same: by default, the global one is in the hidden folder .codex, inside your personal folder. The project one is in the project folder.

In the terminal, the ~ sign is a shortcut to your personal folder. Folders with a name starting with a dot are hidden.

Denise wants the agent to always include what it checked, in any project. This rule was for the global. "Compare the total with the frequency sheet" only makes sense in the frequency project.

2The closest file can decide there

A subfolder can have its own AGENTS.md. With Codex open in it, both apply, and the closest instruction takes precedence, like a lab agreement inside the school.

"Can" because it applies to what it covers. What the nearby rule doesn’t mention keeps coming from the upper file.

Lúcia created a provas subfolder inside her science project, with an AGENTS.md that asks for a separate answer key. When she opens the Codex inside provas, this rule applies. If it’s opened in the exercise lists, it doesn’t.

3The AGENTS.md doesn’t override everything

None of these files beats three things. The system instructions, which are the tool’s factory rules. The permissions, which you approve or deny, like in module 3. And what you explicitly ask for in the conversation. They guide; they don’t unlock what the tool blocks.

Denise’s AGENTS.md says "submit in bullet points". Today she asked, in the conversation, for a continuous paragraph for the email to the administration. Today’s request is valid.

4Ask for the summary and check in the files

Inside the folder, ask the Codex to summarize the instructions it loaded and to say which file each one came from. Then open the files and compare.

The summary cites a rule that isn’t in any file? Or does it forget one that is? That’s where you found the cause before blaming the model.

Lúcia asked for the summary in the training folder. The rule showed up: "relate what you checked", which she hadn’t written there. It was in global, which she created in March and forgot.

1Rule always applies; Skill kicks in when it’s needed

The lab door plate is valid every day. The experiment script comes out of the notebook only on the day of that experiment. The AGENTS.md file is the plate. The Skill is the script.

A Skill brings together the instructions for an activity that repeats. The agent triggers it when the task calls for it.

Lúcia explained every Friday to the agent how to set up the weekly exercise list: read the lesson, choose five questions, and separate the answer key. This step-by-step became a Skill. The AGENTS.md kept five rules.

2The file starts with name and description

The Skill lives in a folder named after it, in a file called SKILL.md. At the top, between two lines of three dashes, the name and description appear. This block is the header.

After the header comes the procedure: what goes in, the steps, what comes out, and how to check. In the terminal, a command shows the beginning of the file.

Before writing the Skill for the list, Lúcia opened the course report Skill—the same one used in the practice—to understand the format. In four lines, she learned the name, when to use it, and when not to use it.

$ head -4 .agents/skills/relatorio-semanal/SKILL.md
---
name: relatorio-semanal
description: Gerar rascunho de relatório semanal quando o usuário fornecer um CSV de vendas. Não usar para enviar relatórios ou tratar credenciais.
---

3The description says when to use and when not to

The description is what the agent reads to decide whether to activate the Skill. It needs to say in what situation to use it. And it’s worth saying where the Skill stops.

In this description, "credentials" are passwords and access keys: the Skill doesn’t touch them.

The first description of Denise’s report Skill was "help with reports". The agent activated the Skill even in a request for meeting minutes. She rewrote it, stating the situation and the limit, in the same way as the card.

4The right folder decides who uses it

The project Skill goes in .agents/skills, inside the project’s folder. Personal Skill—one you want in all projects—goes in ~/.agents/skills. The folder ~/.codex is for the Codex: it stores the configuration and the global AGENTS.md from the previous lesson. Skills don’t go there.

Skill notes only serve the notes project: Denise saved it in the project. Her spelling review Skill she uses for everything: she put it in the personal folder.

1Memory is a file that someone maintains

The model doesn’t change because you chatted with it. The course’s operational memory is a set of files that the agent reads when you indicate them.

It works with two conditions: the agent reads the part that matters, and someone keeps the file updated. In practice for this lesson, the one reading is the Codex, opened in the terminal as in module 3.

Denise created the config folder in module 4, next to the projects. That’s where the files that apply to multiple projects for the coordination are kept.

2Keep what still applies

Three things deserve to go into memory: stable facts, decisions, and causes of failures. Every sentence from each conversation does not.

Copying the entire history increases the volume and can bring back an old instruction. No one can verify an enormous file.

Lúcia noted that the course materials use accessible language and fictional examples. In the next task, she pointed to that file instead of repeating the entire conversation about the class.

3Indicate the file and ask for the fact used

Having the file exist in the folder doesn’t guarantee the agent will read it. In your request, tell it which file to consult.

And ask it to cite which fact it used. That way you can check whether the memory was used, instead of assuming.

Denise asked the parent meeting reminder to include the memory. The answer ended by saying which fact it had used, and she checked it in the file.

4Revision date keeps memory alive

Stable facts also change. Mark at the top when the file was reviewed. In the next review, delete what’s expired and confirm the rest.

Write down where each fact came from: a meeting, a document, a decision. This helps you verify later.

In the September review, Denise deleted the fact "notices are printed on the backpack". The school started sending the notices through the app. She changed the top date.

1Symptom is not the cause

"The report came out empty" is the symptom: what you saw. The cause is the reason you observed, like "the spreadsheet had no records". Write both separately.

Then, the smallest correction and how to verify it works. It’s four content columns, plus the date and type, all in a single line of a table in Markdown.

In the training project, Lúcia saw the report come out empty. Before changing anything, she wrote down the symptom and opened the input spreadsheet: it had no records at all.

2Request failure or infrastructure failure

Request failure is when the goal was ambiguous or information was missing. Infrastructure failure is when the text was good, but something outside it failed: a missing or empty file, a process that stopped.

The fix changes depending on the type. Requests are fixed in the text. Infrastructure is fixed with a check.

Denise had two failures in the same week. The summary of the minutes came out too long: she hadn’t mentioned the size. The attendance report didn’t come out: the spreadsheet wasn’t in the folder.

3The smallest fix, not a rebuild

Redoing the entire project can hide a simple problem. A small protection is easier to test and maintain.

Given the empty report from step 1, with the spreadsheet in CSV with no rows, Lúcia thought about switching models. The fix was different: check the header and the number of records before generating the report.

4The protection goes where the next execution reads

A record only teaches something when the following procedure changes. That’s why the protection goes into the AGENTS.md or in the Skill, which the agent reads again for every task.

At the end of the practice, the Codex shows whether the rule worked. Before you write the rule, see the check working yourself in the terminal.

Denise added to AGENTS.md for the frequency: "Before you read, check whether the spreadsheet exists. If it’s missing, stop and say which file is missing." The following week, the agent stopped and warned.

$ cd ~/projetos/meu-primeiro-projeto
$ ls entradas/
vendas.csv
$ ls entradas/vendas-outubro.csv
ls: cannot access 'entradas/vendas-outubro.csv': No such file or directory

1 Three cases, each with the expected result

Before you run it, write in the checklist what each case should produce. That way you compare to a reference, not to your impression in the moment.

The normal case uses the complete data. The incomplete case is missing a value. The not as agreed case asks for something the Skill must not do. Each case runs on the Codex, opened in the terminal inside the training folder.

Denise set up the checklist the way you set up the simulation worksheet: first what should happen in each scenario, then the run-through.

2 Incomplete: separate what’s known from what’s pending

In the incomplete case, the correct result doesn’t invent the missing value. It shows the total of what you know and makes the pending part clearly visible.

In the first version that Lúcia wrote of the Skill relatorio-semanal, the rule "sem inventar ausências" was missing. In the incomplete case, the agent filled in the missing value. It was the test that showed that.

3Out of agreement: stop at the draft

The third case asks for something the Skill shouldn’t do, like sending the report. The expected behavior is to prepare only the draft and say why it stopped.

Denise requested, on purpose, "generate and send to management." The Codex can’t send an email there anyway; the test checks whether it respects the limit and tells you where it stopped.

4Measure the behavior and correct the smallest amount

Looking for the Skill name in the response isn’t testing. Testing is checking the data, the pending part, and where it stopped.

If a case fails, add to the Skill the smallest rule that fixes that failure. Then run the three cases again.

When the incomplete case failed, Lúcia didn’t rewrite the Skill. She added a line: "empty value turns into a pending item; never fill it in". She ran the three cases, and all three passed.

1Git records each version, like a class diary

In the class diary, each day gets a line with date and signature. Nobody deletes yesterday’s line: they add today’s.

The Git does the same for a folder. The folder tracked by it is called a repository. Each saved version is called a commit and includes a message that explains the change.

Lúcia asked a agent to reorganize the experiment lab worksheets. It edited six files and cut a section from the density worksheet. Using the history, she found the previous version and recovered the section.

2 GitHub is somewhere else, and it’s optional

Git works only on your computer, without the internet. The GitHub is a website that can store a copy of the repository.

You can use Git for months without publishing anything. Sending a copy to GitHub is a separate decision, which the module covers in lesson 6.

Denise keeps on her notebook the history of the coordination reports folder. None of that is on the internet. The copy on GitHub will only exist if the school decides that another person needs to work in the same folder.

3History isn’t a full backup of everything

Git stores only what’s in the folder and what you told it to store. It doesn’t replace the backup of the rest.

Files that you tell it to ignore, the school’s systems, and spreadsheets in the cloud need their own protection.

Denise’s attendance spreadsheet lives in the secretary’s system. The history of the reports folder stores the report text, but it doesn’t store that spreadsheet.

4Start the history only in the training folder

On the terminal, git --version confirms that Git is on your computer. Then, inside a new folder, git init -b main starts the history.

mkdir -p creates the folder, and cd takes you into it. The -b main just gives the name main to the main working line. Never run git init in your entire personal folder: Git would start tracking everything that’s in there.

Lúcia created the treino-git folder inside projetos, entered it, and only then started the history. The terminal response cited the folder path, and she checked that it was the training one.

$ git --version
git version 2.43.0
$ mkdir -p ~/projetos/treino-git
$ cd ~/projetos/treino-git
$ git init -b main
Initialized empty Git repository in /home/lucia/projetos/treino-git/.git/