Batch Setup:
Get Your Machine Ready in One Sitting

A local LLM runs on your own machine: no key, no bill, no data leaving your laptop. We use Ollama, the simplest way to pull and run open models. This is what you use for private client data and offline practice.

Install Ollama

Mac

brew install ollama
# or download the app from https://ollama.com/download

ollama serve &      # start the local server (the app does this for you)

Windows download and run OllamaSetup.exe from ollama.com/download, or:

winget install Ollama.Ollama
# reopen PowerShell afterwards

Pull your first model

Model size must fit your RAM. Pick one row and stick to it.

Check it works

ollama list                        # shows what you pulled
ollama run llama3.1:8b "Write one Playwright test case title for a login page"   # one-shot: prints and exits
# for an interactive chat instead, run: ollama run llama3.1:8b   (then /bye to exit)

curl http://localhost:11434/api/tags   # the API LangFlow and n8n will call

Groq gives you a free API key and runs open models extremely fast. This is the batch's cloud brain: when your laptop cannot keep up, or you need speed for a live demo, you point the same tool at Groq instead of Ollama.

Get the key

1. Go to console.groq.com and sign in with Google or GitHub.
2. Open API Keys in the left menu, then Create API Key. Name it ai-tester-blueprint.
3. Copy the key, it starts with gsk_. It is shown once, so paste it somewhere safe now.
4. Store it as an environment variable, never inside code you commit.

Mac

echo 'export GROQ_API_KEY="gsk_your_key_here"' >> ~/.zshrc
source ~/.zshrc
echo ${GROQ_API_KEY:0:6}...   # prints only the first few chars, not the whole key

Windows PowerShell

setx GROQ_API_KEY "gsk_your_key_here"
# reopen PowerShell, then check:
echo $env:GROQ_API_KEY

Check it works

curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"llama-3.3-70b-versatile",
       "messages":[{"role":"user","content":"Reply with the word ready"}]}'

Windows PowerShell, where curl is an alias and the variable syntax differs

$body = '{"model":"llama-3.3-70b-versatile","messages":[{"role":"user","content":"Reply with the word ready"}]}'
Invoke-RestMethod -Uri "https://api.groq.com/openai/v1/chat/completions" -Method Post `
  -Headers @{ "Authorization" = "Bearer $env:GROQ_API_KEY"; "Content-Type" = "application/json" } `
  -Body $body

A JSON reply containing ready means you are done. An invalid_api_key error means the variable did not load: reopen the terminal and echo it again.

Local or cloud, when

Two editors, two jobs. VS Code with GitHub Copilot is your daily driver for the whole batch. Antigravity is Google's free agent-first IDE, worth installing to see how an agent-led workflow feels next to a copilot-led one.

VS Code + GitHub Copilot

1. Install VS Code from code.visualstudio.com. On Windows you can use winget install Microsoft.VisualStudioCode, on Mac brew install --cask visual-studio-code.
2. Open the Extensions panel, search GitHub Copilot, install it. Install GitHub Copilot Chat too.
3. Click Sign in when prompted and authorize with your GitHub account. Students get Copilot free through the GitHub Student Pack; otherwise there is a free tier with monthly limits.
4. Confirm the Copilot icon in the status bar is not crossed out, then open Chat with Ctrl+Alt+I (Windows) or Cmd+Ctrl+I (Mac).
5. Switch the Chat dropdown to Agent mode. That is the mode we use for the multi-file work in the batch.

Turn on Agent Skills (we use these in the skills module)

Copilot reads the same SKILL.md format as Claude Code. Enable it once:

# VS Code Settings (Cmd/Ctrl + ,) then search:
chat.useAgentSkills          ->  tick the checkbox

# skills are then discovered from, among others:
.github/skills/     .claude/skills/     ~/.copilot/skills/

Recommended extensions for this batch

Antigravity

Google's agent-first IDE, free during public preview. The layout is familiar (it is VS Code based) but the centre of gravity is the Agent Panel: you describe an outcome and watch the agent plan, edit across files, and verify.

1. Download the installer for your platform from antigravity.google/download. It detects Windows, Mac, or Linux automatically.
2. Run the installer, then sign in with your Google account.
3. Open a small project folder first, not your main repo, so you can watch what the agent changes.
4. Open the Agent Panel and give it an outcome, for example: "add a Playwright test for the login page and run it".

Every project in this batch gets pushed. A GitHub account is how you version AI-written code, share skills with the batch, and end the course with a portfolio a hiring manager can actually open.

Install Git first

# Mac
brew install git

# Windows
winget install Git.Git

# both: reopen the terminal, then check
git --version

Account and identity

1. Sign up at github.com. Use a professional username, this ends up on your resume.
2. Turn on two-factor authentication in Settings. GitHub requires it for contributors and it protects your keys.
3. If you are a student, apply for the GitHub Student Developer Pack: it includes Copilot free.
4. Set your git identity locally so commits are attributed to you.

git config --global user.name "Your Name"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main

Install the GitHub CLI (easiest auth)

Mac

brew install gh
gh auth login        # choose GitHub.com, HTTPS, login with a browser

Windows

winget install GitHub.cli
# reopen PowerShell
gh auth login

Check it works

gh auth status                       # should say "Logged in to github.com"

mkdir blueprint-test
cd blueprint-test
git init
echo "# AI Tester Blueprint" > README.md
git add .
git commit -m "first commit"
gh repo create blueprint-test --public --source=. --push

If the repo opens on github.com with your README, your account, auth, and git are all correct.

Two visual builders where you drag nodes instead of writing orchestration code. LangFlow is the AI-first canvas we use to build QA agents. n8n is the automation workhorse that connects Jira, Slack, and your test runs. Both talk to Ollama and Groq.

LangFlow

Python based. Use uv if you have it, plain pip otherwise.

Mac Windows same commands, in a virtual environment

# Mac / Linux
python3 -m venv langflow-env
source langflow-env/bin/activate
pip install langflow
langflow run                            # opens http://localhost:7860

# Windows PowerShell
python -m venv langflow-env
.\langflow-env\Scripts\Activate.ps1     # if this is blocked, see the note below
pip install langflow
langflow run                            # opens http://localhost:7860

Docker, if you would rather not touch Python:

docker run -it --rm -p 7860:7860 langflowai/langflow:latest

Point LangFlow at your models

n8n

Node based. Two ways, pick one.

# A. run instantly with npx, nothing installed globally
npx n8n
# opens http://localhost:5678

# B. install globally
npm install -g n8n
n8n start

Docker, with your workflows persisted between restarts:

docker volume create n8n_data
# Mac / Linux
docker run -it --rm --name n8n -p 5678:5678 \
  -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

# Windows PowerShell: one line, backslash continuations do not work there
docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Check both

Command Code is a terminal coding agent that learns your style as you accept, reject, and edit its output. Install is one npm command; the only real gotcha is the command name on Windows.

Install

Mac Windows Linux

npm i -g command-code@latest
cmd --version        # Mac and Linux
cmdc --version       # Windows, see the warning below

Sign in and run

cmd login            # cmdc login on Windows, opens a browser
cd your-project
cmd                  # start it in the project you care about

Sync it with VS Code

Launch it from the VS Code integrated terminal and the companion extension installs itself, so the agent can see the file you have open and the lines you selected.

# inside the VS Code integrated terminal
cmd                  # extension auto-installs on first run
/ide                 # check or repair the editor connection
cmd --ide-setup      # non-interactive install, for scripts

When it is connected you will see IDE ✓ near the input, plus the current file, for example In login.spec.ts.

Check it works

cmd -p "print a one-line hello and exit"     # headless one-shot
# Windows: cmdc -p "..."

OpenCode is an open-source terminal agent that works with many providers, including a local Ollama model. It is the one to reach for when you want an agent that is fully yours: no vendor lock, and it can run entirely offline against your local LLM.

Install

Mac Linux

curl -fsSL https://opencode.ai/install | bash
# or:
brew install anomalyco/tap/opencode
# or, any platform with Node:
npm install -g opencode-ai

Windows

choco install opencode
# or
scoop install opencode
# or
npm install -g opencode-ai

Connect a model

cd your-project
opencode              # starts the terminal UI

# inside the UI:
/connect              # pick a provider and paste your key
/init                 # let it read the project and write its notes

Point it at Groq with the key from tab 2, or at your local Ollama model for a fully offline agent.

Check it works

opencode --version

# then inside a project, in the UI, ask for something small:
#   "list the test files in this repo and tell me which lack assertions"

Which terminal agent, when

Final check before class

Run these. Every line should print a version or a sensible answer.

node -v                      # the base
npm -v
ollama list                  # local models
echo $GROQ_API_KEY           # cloud key   (Windows: echo $env:GROQ_API_KEY)
gh auth status               # GitHub
code --version               # VS Code
cmd --version                # Command Code (Windows: cmdc --version)
opencode --version           # OpenCode

Nine stages, in this exact order, because each one is the floor for the next. You cannot evaluate an LLM (stage 7) until you have built one that does something (stages 4 to 6), and you cannot build an agent until you understand what a model actually is (stages 1 to 3). Everything ends in the same place: 35+ shipped projects.

The path

The nine stages

Which setup unlocks which stage