Case Study 1: Setting Up a Complete Development Environment from Scratch

A Complete Beginner's Journey on a Fresh Windows Laptop

Background

Maria is a 34-year-old marketing analyst who has never written code before. She recently heard about AI-assisted coding at a conference and decided to try building a simple tool to automate some of her repetitive data tasks. She purchased this book and is ready to set up her environment.

Maria has a two-year-old Dell laptop running Windows 11 Home with 8 GB of RAM and a 256 GB SSD. She has about 40 GB of free disk space. Her only development-related software is Microsoft Office. She has a stable home Wi-Fi connection.

This case study follows Maria through the complete setup process, including the mistakes she makes and how she resolves them.

Step 1: Creating the Required Accounts

Maria starts by creating the accounts she will need. She opens her browser and visits GitHub, Anthropic, and Cursor to sign up.

GitHub signup goes smoothly. She chooses a username, verifies her email, and enables two-factor authentication using her phone's authenticator app.

Anthropic signup is also straightforward. She creates an account at console.anthropic.com and adds a payment method. She starts with the free tier, which gives her enough usage for learning.

Cursor signup is the quickest — she signs in using her GitHub account, which she just created.

Lesson learned: Creating accounts first, before installing any software, saves time. Several installation steps later require signing in, and having accounts ready means Maria does not have to interrupt her flow.

Step 2: Installing Python

Maria downloads the Python 3.12.4 installer from python.org. She runs the installer and clicks "Install Now" without reading the screen carefully.

After installation, she opens PowerShell (by searching for it in the Start menu) and types:

python --version

She sees the error: 'python' is not recognized as an internal or external command, operable program or batch file.

Maria's stomach drops. She checks the book again and realizes she forgot to check the "Add python.exe to PATH" checkbox on the installer's first screen. She follows the book's advice: she uninstalls Python through Settings > Apps > Installed Apps, then downloads and runs the installer again. This time, she carefully checks the PATH checkbox before clicking Install Now.

She also clicks the "Disable path length limit" button on the final screen, as the book recommends.

After reopening PowerShell (closing the old window and opening a new one — important!), she tries again:

python --version

Output: Python 3.12.4

She also checks pip:

pip --version

Output: pip 24.1.2 from C:\Users\Maria\AppData\Local\Programs\Python\Python312\Lib\site-packages\pip (python 3.12)

Lesson learned: The PATH checkbox is the single most critical step in the Windows Python installation. Missing it is the number one beginner mistake, and the fix is to uninstall and reinstall. Trying to manually fix the PATH is more error-prone than simply reinstalling.

Step 3: Installing VS Code

Maria downloads VS Code from code.visualstudio.com and runs the installer. She checks all the boxes on the "Additional Tasks" screen, including "Add to PATH" and the context menu options.

After installation, she launches VS Code and is greeted by the Welcome tab. The interface looks overwhelming at first — there are icons on the left, a file explorer panel, and various menus. She takes a few minutes to look around.

She installs extensions by clicking the Extensions icon (the four squares) on the left sidebar:

1. She searches for "Python" and installs the one published by Microsoft (it has millions of downloads, which reassures her).
2. She installs "Pylance" next.
3. She installs "Error Lens" and "indent-rainbow" for better visual feedback.
4. She installs "Material Icon Theme" to make the file explorer look nicer.

She does not install GitHub Copilot yet — the book says to do that in a later section.

Maria opens the settings (Ctrl+,) and changes the font size to 15 (her eyes prefer slightly larger text). She also enables format on save and word wrap by searching for those settings.

Step 4: Installing Node.js and Claude Code

Maria downloads Node.js from nodejs.org. She picks the LTS version (v20.15.0) and runs the installer with default settings.

She reopens PowerShell and verifies:

node --version
# Output: v20.15.0
npm --version
# Output: 10.7.0

Now she installs Claude Code:

npm install -g @anthropic-ai/claude-code

The installation takes about 30 seconds. She verifies it:

claude --version

She sees the Claude Code version number. Now she needs to set up her API key.

Maria goes to console.anthropic.com, navigates to API Keys, and creates a new key named "Maria Laptop". She copies the key (it starts with sk-ant-) and pastes it into a text file temporarily so she does not lose it.

She sets the environment variable in PowerShell:

$env:ANTHROPIC_API_KEY = "sk-ant-her-key-here"

She tests Claude Code:

claude "Say hello and tell me what Python version is on this system."

After a few seconds, Claude responds with a greeting and correctly identifies Python 3.12.4. Maria grins — she is talking to an AI that can see her computer.

Lesson learned: Maria later discovers that the $env: method only sets the variable for the current PowerShell session. When she opens a new terminal, the key is gone. She fixes this by adding the line to her PowerShell profile (she learns how to do this in the Terminal Configuration section).

Step 5: Installing GitHub Copilot

Maria has the free tier from her GitHub account. She opens VS Code, goes to Extensions, searches for "GitHub Copilot", and installs it.

VS Code prompts her to sign in to GitHub. She clicks the button, and her browser opens a GitHub authorization page. She clicks "Authorize" and is redirected back to VS Code.

To test Copilot, she creates a new file called test.py and types:

def greet(name):

After a brief pause, she sees a grayed-out suggestion appear:

    return f"Hello, {name}!"

She presses Tab and the suggestion is accepted. She deletes the file — it was just a test.

Step 6: Installing Cursor

Maria downloads Cursor from cursor.com. The installer runs quickly. On first launch, Cursor asks if she wants to import her VS Code settings. She clicks "Yes" and her Python extension, theme, and font size carry over.

She signs in with her GitHub account. Cursor offers a free trial of the Pro features, which she accepts.

She creates a test file and presses Ctrl+L to open the chat panel. She types: "Write a function that adds two numbers together." The AI generates a clean function, and she clicks "Apply" to insert it.

Maria now has two editors — VS Code and Cursor — that both work. The book suggests starting with one, so she decides to use VS Code with Copilot as her primary editor for now, and explore Cursor later.

Step 7: Installing and Configuring Git

Maria downloads Git from git-scm.com. During installation, she keeps the default options, including "Git from the command line and also from 3rd-party software" and "Checkout Windows-style, commit Unix-style line endings."

She notices that the installer also installs "Git Bash" — a terminal that looks like Linux. She makes a mental note but continues with PowerShell for now.

In PowerShell, she configures Git:

git config --global user.name "Maria Rodriguez"
git config --global user.email "maria.r@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

She verifies with git config --list and sees her settings listed.

Step 8: Setting Up Her First Project

Maria creates a workspace directory:

mkdir C:\Users\Maria\vibe-coding-workspace
cd C:\Users\Maria\vibe-coding-workspace
git init

She sees: Initialized empty Git repository in C:/Users/Maria/vibe-coding-workspace/.git/

Next, she creates a virtual environment:

python -m venv .venv

She tries to activate it:

.venv\Scripts\Activate.ps1

She gets an error: cannot be loaded because running scripts is disabled on this system.

This is the Windows PowerShell execution policy issue mentioned in the book. She follows the instructions:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

She confirms with "Y" when prompted, then tries activation again:

.venv\Scripts\Activate.ps1

This time it works. She sees (.venv) appear at the beginning of her prompt.

She installs packages:

pip install requests python-dotenv rich
pip freeze > requirements.txt

She creates a .gitignore file using VS Code (by opening the workspace folder in VS Code with code ., then creating a new file):

.venv/
.env
__pycache__/
*.pyc

She creates a .env file:

ANTHROPIC_API_KEY=sk-ant-her-key-here

And a .env.example file:

ANTHROPIC_API_KEY=your-key-here

She makes her first commit:

git add .
git status

She checks git status to make sure .env is not in the list of staged files (it should be excluded by .gitignore). It is properly excluded. She commits:

git commit -m "Initial project setup"

Lesson learned: Always run git status before your first commit to verify that .gitignore is working correctly. If Maria had not checked, she might have committed her API key to the repository.

Step 9: Making the PowerShell Profile Permanent

Maria realizes she needs to set her ANTHROPIC_API_KEY permanently so it persists across terminal sessions. She checks her PowerShell profile path:

echo $PROFILE

Output: C:\Users\Maria\Documents\PowerShell\Microsoft.PowerShell_profile.ps1

The file does not exist yet, so she creates it:

New-Item -Path $PROFILE -ItemType File -Force
code $PROFILE

In the file, she adds:

$env:ANTHROPIC_API_KEY = "sk-ant-her-key-here"

She saves the file and opens a new PowerShell window. She verifies:

echo $env:ANTHROPIC_API_KEY

The key is displayed. It is now set permanently for all future PowerShell sessions.

Step 10: Running the Verification Script

Maria copies the verification script from the book's code examples to her workspace and runs it:

python code\example-01-verify-setup.py

The script runs through all checks. She sees green checkmarks for Python, pip, Git, Node.js, Claude Code, and VS Code. She sees a yellow warning for one missing package, which she installs and re-runs the script to confirm all checks pass.

She then runs the Hello Vibe test:

python code\example-03-hello-vibe.py

The program runs successfully, confirming that her entire environment is set up correctly.

Summary of Issues Encountered

Total Setup Time

Maria's complete setup took approximately 2 hours and 15 minutes, including troubleshooting. An experienced user following the same steps would complete the setup in about 45 minutes.

Maria's Reflection

"The setup was more involved than I expected, but the step-by-step instructions got me through it. The three problems I hit were all mentioned in the book, which was reassuring — I was not the only one to make those mistakes. The moment Claude Code responded to my first prompt was magical. I could see how this was going to change the way I work. The verification script at the end gave me confidence that everything was actually working, not just partially installed."

Key Takeaways from This Case Study

1. Read installation screens carefully. The Python PATH checkbox is easy to miss but critical.
2. Always reopen your terminal after installing new tools. Old terminal sessions do not see new PATH entries.
3. Windows PowerShell has an execution policy that blocks scripts by default. The Set-ExecutionPolicy fix is a one-time change.
4. Environment variables set with $env: in PowerShell are temporary. Use the PowerShell profile for persistent settings.
5. Verify .gitignore works before your first commit. Run git status and confirm that .env is not listed.
6. A verification script provides confidence. Running an automated check after setup confirms that nothing was missed.
7. Expect the setup to take 1-2 hours. This is normal for a first-time setup. The investment pays off immediately when you start coding.