Your Machine, Your Map
- Install Python 3.12+ and VS Code, and verify both from the terminal
- Explain the difference between the REPL and a script, and run code in both
- Edit a program, rerun it, and read the error message when it breaks
- Describe the daily 2-hour protocol and why active recall beats rereading
- Ask the AI tutor for a hint on a stuck problem without asking for the answer
| Orientation: read the ELI5 + why + how the 2-hour protocol works | 15 min |
| Install & verify: Python 3.12+, VS Code, open a terminal | 25 min |
| Guided: REPL session, first script, break-it-on-purpose | 40 min |
| Practice: the expedition manifest | 15 min |
| Project: base camp folder + journal entry | 15 min |
| Quiz + make your first flashcards | 10 min |
Before a long expedition, experienced hikers do something that looks boring: they lay every piece of gear out on the floor, light the stove once, fill the water filter once, and walk around the block with the loaded pack. Not to get anywhere — to make sure that on day 40, in the rain, nothing surprises them. Today is that floor. Your gear: Python (the stove — it turns your written instructions into action), VS Code (the multi-tool — where you write and edit those instructions), and the terminal (the map and compass — a text window where you tell the computer directly what to do).
A program is just a text file of instructions that Python reads from top to bottom and performs, one line at a time. You will write one today, break it on purpose, and fix it. That last part matters most: on this expedition, error messages are signposts, not injuries. By tonight, every tool will have been used at least once — which means day 40 can't ambush you.
Every AI engineer lives in exactly these three tools: an editor, a terminal, and a language runtime. Forward-deployed engineers feel it hardest — on a customer site you may have one hour to get a working environment on an unfamiliar laptop before a demo, and "it works on my machine" is not an answer you can give a client. The habits you set today (verify versions, run from the terminal, read errors calmly) are the same ones you will use on Day 151 when you deploy a real service to a cloud server you have never touched before.
Guided practice
Meet the REPL — the conversation window
15 min- Open a terminal (macOS: Terminal app; Windows: PowerShell; Linux: any terminal). Type
python --versionand press Enter. If that prints an error or Python 2.x, trypython3 --version. You want 3.12 or newer. - Start the REPL: type
python(orpython3) with nothing after it. You should see a>>>prompt — Python is now listening. - Type each line below, pressing Enter after each, and watch what comes back. Predict the result BEFORE pressing Enter — that prediction habit is active recall and you will use it every day for 180 days.
- Note the one that surprises you (for most people it is
7 / 2vs7 // 2). - Exit the REPL with
exit()— you are back in the shell. Notice the>>>prompt is gone: shell commands and Python code live in different worlds, and typing one into the other is the classic Day-1 error.
Your first script — from scratchpad to saved program
15 min- In VS Code, create a folder called
ai-engineer-journeysomewhere you can find it (Desktop is fine). Open the folder in VS Code (File > Open Folder). - Create a new file named
hello.pyand type (do not paste — typing builds muscle memory) the starter code below. - Save it, open VS Code's built-in terminal (View > Terminal), and run it:
python hello.py. - All four lines print in order — Python read your file top to bottom. Now edit line 2 to use your actual name, save, and run again. This edit-save-run loop is the fundamental rhythm of programming; you will do it thousands of times.
- Add a fifth print line of your own that computes something (e.g. how many minutes 180 days of 2 hours is:
print(180 * 120)). Run it. Congratulations — you extended a program.
Break it on purpose — error messages are signposts
10 min- Errors will happen every single day of this program, so meet the three most common ones now, in a safe place. In
hello.py(or the REPL), cause each error below, one at a time. - For each, read the LAST line of the output first — that is the error type and description. Then look at the line number Python points to.
- Write one sentence in your own words for each: what did Python object to?
- Rule to keep forever: an error message is Python telling you exactly where it got confused. Read it before you change anything. Guess-and-retype without reading is the slowest possible way to debug.
On your own
The expedition manifest
15 minWrite a new script manifest.py from a blank file, without looking at hello.py.
Goal: print a 6-line "packing manifest" — a title line, your name, your target role (AI Engineer / FDE), today's date typed as text, the total study hours remaining (compute it with arithmetic: 179 days x 2 hours — let Python do the math, do not type 358), and a decorative border line made with string repetition ("-" * 40).
Constraints: at least one line must mix text and a computed number in one print, and you must run it from the terminal, not the editor's run button.
Hints (only if stuck): print takes several items separated by commas and puts spaces between them. Multiplying a string repeats it.
Base camp: your journey folder
Set up the folder that every one of the next 180 days will use. Inside ai-engineer-journey, create a week-01 subfolder and move today's scripts into it. Create a file journal.md at the top level and write your Day 1 entry: three sentences on why you are doing this program, the exact commands you used to check your Python version and run a script, and the one error message you met today with what it meant. Finally, run manifest.py from the terminal one more time, from OUTSIDE its folder (python week-01/manifest.py) — proof you understand that the terminal has a current location. On Day 8 this whole folder goes under version control, so keep it tidy from the start.
Common mistakes & misconceptions
- Typing Python code at the shell prompt (or shell commands at the >>> prompt). They are different programs: the shell runs commands, the REPL runs Python. Check which prompt you see before typing.
- Expecting a script to show values like the REPL does. The REPL echoes bare expressions; a script only shows what you pass to print().
- Guess-editing when an error appears instead of reading it. The last line of a traceback names the problem and the arrow points at the line — read first, edit second.
- Studying by rereading and highlighting. Familiarity is not memory. Predict-before-run, close-the-book recall, and the daily quiz are what actually store knowledge.
- Asking the AI tutor to "write it for me." You lose the exact struggle that builds skill. Ask "what should I look at?" or "why does this error happen?" instead.
- Having two Pythons installed and editing with one while running the other. Always verify with python --version in the same terminal you run scripts from.
Q1. You type 2 + 3 into a running Python REPL and press Enter. What happens?
Q2. Your script crashes with a screenful of text. Where do you look first?
Q3. Why does this program schedule a 10-minute flashcard review at the start of every day?
Go deeper — curated resources
- What happens between your .py file and the CPU? — CPython compiles your source to bytecode (.pyc files in __pycache__) and a virtual machine executes that. You will care about this again on Day 39 (processes) and Day 40 (the GIL).
- python --version shows 3.12+ and both scripts run from the terminal
- All three guided exercises done, including all three deliberate errors read and explained
- Base camp folder exists with journal.md Day 1 entry
- Quiz ≥ 2/3 (reread the tech section and retake if lower)
← Back: This is Day 1 — nothing behind you but the decision to start. Everything ahead compounds from the edit-save-run loop and the recall habit you set today.
Forward →: On Day 6 the terminal you only peeked at becomes a full lesson, and on Day 8 this exact folder goes under git — your first commit will be the journal you started tonight. The error-reading ritual pays off daily, and becomes a formal debugging method on Day 19.
Unlocks: D2 Variables, Types & Control Flow · D3 Functions, Scope & Modules · D6 The Terminal & Linux