📁 Folders and files: the project’s home
Every AI solution lives somewhere: a set of folders and files inside a computer. It may seem trivial, but it’s the physical foundation of everything. A well-organized project is like a tidy house—you can find what you need in seconds. A messy project is a junk drawer: everything is there, but nobody can find anything. You don’t need talent for this, just a simple convention and the habit of following it.
🏠 The golden rule of organization
One folder per project. Inside it, folders by topic (input, output, notes). Use lowercase names without spaces or accents, separating words with hyphens. This convention alone solves 90% of the mess — and works the same on your computer, on the server, and on GitHub.
A simple, clear structure
Illustrative folder structure example — adapt the names to your project. The pattern matters, not these exact names.
✓ Helpful names
- ✓
relatorio-vendas— lowercase, hyphen - ✓
2026-06-orcamento— putting the date first sorts it automatically - ✓One folder = one clear purpose
✗ Names that get in the way
- ✗
Relatório Final (2).docx— spaces and accents - ✗
novo,teste,aaa— say nothing - ✗Everything scattered across the Desktop
⌨️ The terminal: overcoming your fear
The terminal is that little black screen from hacker movies. It’s intimidating because it seems like you have to memorize a thousand commands—but the truth is simpler: the terminal is just a conversation with the computer by text, instead of clicking with a mouse. You type a command, press Enter, and it responds. The goal here isn’t to become a command-line expert: it’s to lose your fear, understand that it’s a friendly tool, and know how to ask for the few things that matter.
Illustrative recreation of a terminal, not a real screenshot. The commands are only there to show the rhythm “I type → Enter → response.”
💡 Practical tip: three commands are enough to get started
You don't need to memorize anything. To get by at first, three commands will handle almost everything: cd (enter a folder), ls (see what's there) and pwd (knowing where you are). With this, you can already navigate. You can ask AI to write the rest — and then it's easy to understand what it wrote.
| You type | What happens |
|---|---|
| cd pasta | Open a folder (like double-clicking it) |
| cd .. | Go back one folder |
| ls | List the files and folders where you are |
| pwd | Shows the full path from where you are |
Illustrative table of the commands most commonly used day to day. Some names differ on Windows, but the idea is identical.
🌿 Git and GitHub: versioning means saving versions
Imagine a video game where you can save at any time and return to any save if you make a mistake. That’s exactly what the Git does with your project: every time you “save,” it stores a complete snapshot of everything — this is called commit. O GitHub is where these snapshots are stored on the internet, away from your computer. Git is the tool that takes the snapshot; GitHub is the cloud album. Version control isn’t just for advanced programmers — it’s simply the habit of saving with a history.
A task's path to the cloud
You work
Edits files in the project folder, just as you always have.
Does one commit
Take a “snapshot” of the current state and write a sentence about what changed: "I added the notes folder".
Does one push
Upload the photos to GitHub. Now your work is safe in the cloud, with its full history.
The cycle, in three lines
Illustrative commands—you’ll paste them once and repeat the process every time. You don’t need to memorize them: you need to understand that each line is a step in "saving with a history."
📜 History and Collaboration: The Project’s Memory
Version control isn't just about making sure you don't lose your work. When the history is on GitHub, it becomes the project memory: you can see who changed what, when, and why. And that unlocks something essential—multiple people (or multiple AIs) working on the same project without getting in each other's way. Real solutions are almost never built alone. The history is what lets you safely go back and what lets you trust the work when someone else makes a change.
✓ With history (GitHub)
- ✓"Something breaks? I can go back to yesterday's version in 1 minute."
- ✓You can see who changed each line and why.
- ✓Two people work on the same project without overwriting each other’s work.
- ✓The project has memory—nothing gets lost when you "save over" it.
✗ No history (loose files)
- ✗
projeto_final_v3_AGORA_VAI.zip - ✗No one knows which version is correct.
- ✗One overwrites the other, and the work disappears.
- ✗"It worked last week"—and there's no way to go back.
How the history appears
Illustrative recreation of a GitHub history. Each dot is a commit—a snapshot with a caption, author, and date.
🗺️ Understand the Map, Not Master Everything
Here’s the freedom this module brings: you you don't need to master the infrastructure like a senior engineer. You need to understand the map. A taxi driver didn’t build the roads or study asphalt engineering—but knows the city and gets where they need to go. That’s your goal with folders, the terminal, and Git: know enough to make decisions, ask for the right thing, and get through the process without depending on anyone.
🧭 Map × mastery: the difference that sets you free
- Master would mean knowing every command, every detail, every edge case — years of study, and that's not your job.
- Understand the map is knowing what exists, what it’s for, and when to use it — weeks of familiarity, and exactly what the architect needs.
- AI fills in the rest: it writes the difficult command; you understand what it wrote and decide whether it’s right.
💡 Practical tip: the right question to ask AI
When you get stuck on the infrastructure, don’t ask “how do I do all of this?” Ask: "explain in one sentence what this command does and what the risk is of running it". You remain in control of the decision—the AI becomes your technical copilot, not your boss.
🧰 The architect's environment: set it up once
Finally, the architect builds a work environment — the minimum set of tools you build with. It’s not much: an editor for writing, the terminal open beside it, a GitHub account, and the habit of staying organized. You set up this environment just once, and it saves hours on every project that follows. It’s like organizing your workbench before you get started: five minutes at the beginning saves you a whole day of searching for tools.
An editor
Where you write and read the project files.
The terminal
Open on the side, ready for quick commands.
GitHub account
The cloud album that stores everything.
Habit of organizing
The folder and naming convention, always.
✅ Checklist for the configured environment
cd e ls.Self-check (optional): what is this module's goal regarding infrastructure?
📁 Module summary
Next module:
1.4 — Publishing to the World: taking the solution off your computer and putting it online for the world to use.