feat: flesh out SOLUTION.md for all 15 level-00 beginner exercises

Replace skeleton placeholders with complete, beginner-friendly solutions
for exercises 01-first-steps through 15-putting-it-together. Every solution
includes WHY-comments on every line, design decision tables, alternative
approaches, common pitfalls for absolute beginners, and key takeaways
connecting to future concepts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: travisjneuman

projects/level-00-absolute-beginner/01-first-steps/SOLUTION.md

@@ -0,0 +1,86 @@
+# Solution: 01-first-steps
+
+> **STOP** — Have you attempted this project yourself first?
+>
+> Learning happens in the struggle, not in reading answers.
+> Spend at least 20 minutes trying before reading this solution.
+> If you are stuck, try the [Walkthrough](./WALKTHROUGH.md) first — it guides
+> your thinking without giving away the answer.
+
+---
+
+
+## Complete solution
+
+This exercise is done in Python's **interactive mode** (the `>>>` prompt), not by writing a file. Here is what you should have typed and seen:
+
+```python
+# Step 1: Open your terminal and type "python" to start interactive mode.
+# You should see the >>> prompt.
+
+# Step 2: Try basic math.
+2 + 2          # WHY: This tests that Python is working — it should respond with 4
+10 - 3         # WHY: Subtraction works with the minus sign, just like on paper
+5 * 6          # WHY: The * symbol means multiply (the x key is used for variable names)
+100 / 4        # WHY: The / symbol means divide — Python gives you 25.0 (a decimal number)
+
+# Step 3: Print a message.
+print("Hello, I am learning Python!")  # WHY: print() displays text on screen — the quotes mark where the text starts and ends
+
+# Step 4: Exit interactive mode.
+exit()         # WHY: This tells Python you are done — it closes the interactive session
+```
+
+If you ran the `exercise.py` file directly, here is what it does:
+
+```python
+print("If you can see this, you successfully ran a Python file!")  # WHY: Confirms the file ran — if you see this, Python found and executed the file
+print()                                                            # WHY: Prints a blank line to add visual spacing between sections
+print("Here is some math Python can do:")                          # WHY: Labels the section so you know what comes next
+print("2 + 2 =", 2 + 2)      # WHY: Python calculates 2+2 and prints the label and result together
+print("10 - 3 =", 10 - 3)    # WHY: Shows subtraction — the comma between items adds a space automatically
+print("5 * 6 =", 5 * 6)      # WHY: Shows multiplication — * is the multiply symbol in programming
+print("100 / 4 =", 100 / 4)  # WHY: Shows division — notice the result is 25.0 (decimal), not 25
+print()                        # WHY: Another blank line for visual breathing room
+print("You are off to a great start.")  # WHY: Encouragement — learning to code is a big step
+```
+
+## Design decisions
+
+| Decision | Why | Alternative considered |
+|----------|-----|----------------------|
+| Use interactive mode first | Seeing instant results builds confidence — you type something, Python responds immediately | Could have started with writing a file, but that adds extra steps before seeing results |
+| Show math before text | Numbers are familiar to everyone — math gives instant proof that Python works | Could have started with print(), but math is more concrete and universal |
+| Use `*` for multiply and `/` for divide | These are the standard symbols in all programming languages — your keyboard does not have a x or / key for math | None — this is universal across programming |
+| Include `exit()` instruction | New users often get stuck in interactive mode, not knowing how to get back to their terminal | Could use Ctrl+D (Mac/Linux) or Ctrl+Z (Windows), but exit() works everywhere |
+
+## Alternative approaches
+
+### Approach B: Run the file directly instead of using interactive mode
+
+```python
+# Save this in a file called first_steps.py and run it with: python first_steps.py
+print(2 + 2)          # WHY: Same math, but written in a file instead of typed interactively
+print(10 - 3)         # WHY: Every line runs automatically, top to bottom
+print(5 * 6)          # WHY: You do not have to wait for each result — they all print at once
+print(100 / 4)        # WHY: This is how you will write most Python code going forward
+print("Hello, I am learning Python!")  # WHY: Files let you save and re-run your code
+```
+
+**Trade-off:** Running a file is how you will work most of the time, but interactive mode is better for experimenting because you see each result immediately. Interactive mode is like a calculator; a file is like a recipe.
+
+## What could go wrong
+
+| Scenario | What happens | Prevention |
+|----------|-------------|------------|
+| Typing `python` and getting "command not found" | Python is not installed, or your terminal cannot find it | Revisit the setup guide (03_SETUP_ALL_PLATFORMS.md) and make sure Python is on your PATH |
+| Seeing `>>>` but not knowing what to do | You are in interactive mode — Python is waiting for you to type something | Type any math like `2 + 2` and press Enter. Type `exit()` to leave |
+| Forgetting the quotes around text in print() | You get a `NameError` because Python thinks the words are variable names, not text | Always wrap text in quotes: `print("Hello")` not `print(Hello)` |
+| Typing `print "Hello"` without parentheses | You get a `SyntaxError` — Python 3 requires parentheses around print | Always use `print("Hello")` with parentheses |
+| Pressing Enter after `python exercise.py` and nothing happens | You might be in the wrong folder — your terminal cannot find the file | Use `cd` to navigate to the folder containing exercise.py first |
+
+## Key takeaways
+
+1. **Python's interactive mode (`>>>`) is your playground** — use it to experiment, test ideas, and see instant results. You will use it throughout your learning.
+2. **Python does math with symbols you mostly know** — `+` for add, `-` for subtract, `*` for multiply (not x), `/` for divide.
+3. **`print()` is how you make Python talk to you** — everything you want to display on screen goes inside `print()`. This is the foundation of every program you will write from here on.

projects/level-00-absolute-beginner/02-hello-world/SOLUTION.md

@@ -0,0 +1,85 @@
+# Solution: 02-hello-world
+
+> **STOP** — Have you attempted this project yourself first?
+>
+> Learning happens in the struggle, not in reading answers.
+> Spend at least 20 minutes trying before reading this solution.
+> If you are stuck, try the [Walkthrough](./WALKTHROUGH.md) first — it guides
+> your thinking without giving away the answer.
+
+---
+
+
+## Complete solution
+
+```python
+# Display the classic first-program message.
+print("Hello, world!")  # WHY: This is the traditional first program in every language — it proves you can make the computer display text
+
+# Print a custom message to show you can change the text.
+print("My name is Python and I do what you tell me.")  # WHY: Demonstrates that you can put any text inside the quotes
+
+# Print a number — no quotes needed for numbers.
+print(42)  # WHY: Numbers do not need quotes because Python already knows they are numbers, not commands
+
+# Print a math result — Python calculates it first, then displays the answer.
+print(7 + 3)  # WHY: Python does the math (7+3=10) and then prints the result — you never see "7 + 3", just "10"
+
+# Print text and a calculated number together using a comma.
+print("The answer is", 6 * 7)  # WHY: The comma lets you mix text and numbers — Python adds a space between them automatically
+
+# Print a blank line to create visual spacing.
+print()  # WHY: An empty print() outputs a blank line — useful for making output easier to read
+
+# Show that single quotes and double quotes both work.
+print('Single quotes work too.')   # WHY: Python treats 'text' and "text" exactly the same — use whichever you prefer
+print("Double quotes also work.")  # WHY: Most programmers pick one style and stick with it — double quotes are more common in Python
+```
+
+## Design decisions
+
+| Decision | Why | Alternative considered |
+|----------|-----|----------------------|
+| Start with `"Hello, world!"` | This is a tradition going back to 1978 — nearly every programmer's first program prints this message | Could use any message, but this connects you to millions of other learners |
+| Use double quotes for strings | Double quotes are the most common convention in Python and many other languages | Single quotes work identically — `'Hello'` and `"Hello"` do exactly the same thing |
+| Show commas for mixing text and numbers | Commas are the simplest way to combine different types in `print()` — no conversion needed | Could use f-strings (covered in Exercise 06), but commas are simpler for beginners |
+| Include `print()` with no arguments | Blank lines make output much easier to read, and this teaches that print() can be called empty | Could skip blank lines, but cluttered output is harder to understand |
+
+## Alternative approaches
+
+### Approach B: Using f-strings (a preview of Exercise 06)
+
+```python
+name = "Alice"                        # WHY: Store your name in a variable so you can reuse it
+age = 25                              # WHY: Store a number in a variable
+print(f"Hello, my name is {name}!")   # WHY: f-strings let you insert variables directly into text — the f before the quote enables this
+print(f"I am {age} years old.")       # WHY: {age} gets replaced with the value 25 when Python runs this line
+print(f"Next year I will be {age + 1}.")  # WHY: You can even do math inside the curly braces
+```
+
+**Trade-off:** f-strings are more powerful and readable than commas, but they require understanding variables first (Exercise 04). For this exercise, plain `print()` with commas is the right starting point.
+
+### Approach C: Using string concatenation (joining strings with +)
+
+```python
+print("Hello" + ", " + "world" + "!")  # WHY: The + operator glues strings together — but you must handle spaces yourself
+print("The answer is " + str(42))      # WHY: You cannot use + to join a string and a number — str() converts the number to text first
+```
+
+**Trade-off:** Concatenation with `+` requires you to manually add spaces and convert numbers to strings with `str()`. Commas handle this automatically. Concatenation is useful when you need precise control over spacing.
+
+## What could go wrong
+
+| Scenario | What happens | Prevention |
+|----------|-------------|------------|
+| Mismatched quotes: `print("Hello')` | `SyntaxError` — Python sees a double quote opening but a single quote closing, and they do not match | Always use the same quote type to open and close: `"Hello"` or `'Hello'` |
+| Forgetting the parentheses: `print "Hello"` | `SyntaxError` — Python 3 requires parentheses around everything you print | Always write `print("text")` with parentheses |
+| No quotes around text: `print(Hello)` | `NameError: name 'Hello' is not defined` — Python thinks Hello is a variable name, not text | Wrap text in quotes so Python knows it is a string: `print("Hello")` |
+| Forgetting the closing quote: `print("Hello)` | `SyntaxError: unterminated string literal` — Python reached the end of the line without finding the closing quote | Always close your quotes — most code editors highlight unclosed strings |
+| Trying to use `+` with a string and number: `print("age: " + 25)` | `TypeError` — Python refuses to glue text and numbers together with `+` | Use a comma instead: `print("age:", 25)` or convert: `print("age: " + str(25))` |
+
+## Key takeaways
+
+1. **`print()` is your primary tool for seeing what your program does** — every time you want to check a value, display a result, or show a message, you will use `print()`. It is the most used function in all of Python.
+2. **Strings (text) must always be wrapped in quotes** — without quotes, Python thinks your words are commands or variable names. Quotes are how Python tells the difference between code and data.
+3. **You can mix text and numbers in `print()` using commas** — Python automatically adds a space between each item. This simple technique carries you through most beginner programs before you learn fancier methods like f-strings.

projects/level-00-absolute-beginner/03-your-first-script/SOLUTION.md

@@ -0,0 +1,85 @@
+# Solution: 03-your-first-script
+
+> **STOP** — Have you attempted this project yourself first?
+>
+> Learning happens in the struggle, not in reading answers.
+> Spend at least 20 minutes trying before reading this solution.
+> If you are stuck, try the [Walkthrough](./WALKTHROUGH.md) first — it guides
+> your thinking without giving away the answer.
+
+---
+
+
+## Complete solution
+
+```python
+# Step 1: Print a greeting.
+print("Welcome to your first Python script!")  # WHY: This is the first line Python runs — it tells the user the script has started
+
+# Step 2: Do some math and print the result.
+print("Let me calculate something for you...")     # WHY: Gives context for what is about to happen — good programs tell you what they are doing
+print("If you have 24 hours in a day and 7 days in a week:")  # WHY: Explains the calculation in plain English before showing the math
+print("That is", 24 * 7, "hours in a week.")       # WHY: Python calculates 24*7=168 and prints it between the two text strings
+
+# Step 3: Print a blank line for readability.
+print()  # WHY: A blank line separates sections visually — without it, all the text runs together
+
+# Step 4: Print a closing message.
+print("This script ran from top to bottom.")   # WHY: Reinforces the key lesson — Python executes line 1, then line 2, then line 3, and so on
+print("Every line executed in order.")          # WHY: There are no jumps or skips (yet) — the order in the file IS the order of execution
+print("That is how all Python scripts work.")   # WHY: This top-to-bottom flow is called "sequential execution" and is the foundation of all programs
+```
+
+## Design decisions
+
+| Decision | Why | Alternative considered |
+|----------|-----|----------------------|
+| Write commands in a file instead of interactive mode | Files let you save, edit, and re-run your code — interactive mode loses everything when you close it | Interactive mode (Exercise 01) is good for experimenting, but real programs live in files |
+| Use comments (lines starting with #) | Comments explain WHY the code does something — they are notes for humans that Python ignores entirely | Could write code without comments, but then you would forget what each line does tomorrow |
+| Calculate `24 * 7` inline inside print() | Keeps the example simple — no variables needed yet (those come in Exercise 04) | Could store the result in a variable first, but that adds a concept not yet introduced |
+| End with a message about sequential execution | The most important lesson is that scripts run top-to-bottom — this makes the lesson explicit | Could leave it implicit, but beginners benefit from having concepts stated directly |
+
+## Alternative approaches
+
+### Approach B: A personal introduction script
+
+```python
+# My personal introduction script
+# This file tells the world about me.
+
+print("=== About Me ===")           # WHY: The === creates a visual header — it makes the output look organized
+print()                              # WHY: Blank line after the header for readability
+print("Name: Alice")                 # WHY: Each print() is one line of output — put one fact per line
+print("Hobby: Learning Python")      # WHY: You can put any text you want — make it personal
+print("Fun fact: I just ran my first script!")  # WHY: This is YOUR script — personalize it
+print()                              # WHY: Spacing before the closing line
+print("Script complete!")            # WHY: A clear ending tells you the script finished successfully
+```
+
+**Trade-off:** Both scripts teach the same concept (top-to-bottom execution). Making it personal helps you feel ownership over the code — it is YOUR script, not just an exercise you copied.
+
+### Approach C: A script with commented-out lines
+
+```python
+print("Line 1: I will print")         # WHY: This line runs because it is valid Python code
+# print("Line 2: I am commented out") # WHY: The # at the start makes Python skip this entire line
+print("Line 3: I will also print")    # WHY: Python skips the comment and continues to the next real line
+```
+
+**Trade-off:** This version directly teaches commenting and un-commenting. Try adding and removing the `#` to see lines appear and disappear from the output.
+
+## What could go wrong
+
+| Scenario | What happens | Prevention |
+|----------|-------------|------------|
+| Running `python exercise.py` from the wrong folder | `FileNotFoundError` — Python cannot find the file because you are not in the right directory | Use `cd` to navigate to the folder first, then run the command. The terminal prompt usually shows your current folder |
+| Misspelling the filename: `python exorcise.py` | `FileNotFoundError` or `No such file or directory` — the filename must match exactly | Check the spelling. Tab-completion (pressing Tab after typing a few letters) can auto-fill the filename |
+| Forgetting to save the file before running | Python runs the last saved version, not what is currently on screen | Always save (Ctrl+S) before running. Some editors auto-save, but do not rely on it |
+| Adding code with wrong indentation | `IndentationError` — Python is strict about spacing at the beginning of lines | For now, start every line at the very left edge (no spaces before print). Indentation becomes important in Exercise 08 |
+| Using a `.txt` extension instead of `.py` | The file might still run, but your editor will not give you Python syntax highlighting, making it harder to read | Always name Python files with the `.py` extension |
+
+## Key takeaways
+
+1. **A Python script is just a text file full of commands that run top-to-bottom** — the order you write them is the order Python executes them. This is the most fundamental concept in programming: you are writing a sequence of instructions.
+2. **Comments (lines starting with #) are notes for humans** — Python ignores them completely. Use comments to explain what your code does and why. Your future self will thank you when you re-read your code weeks later.
+3. **The ability to save code in a file changes everything** — unlike interactive mode, files let you build up complex programs, edit them, share them, and run them as many times as you want. Every real program you use (websites, apps, games) started as files of code like this one.