A hands-on workshop for learning AI-assisted software development using Claude Code.

Software engineers who want to master agentic development patterns — from basic AI-assisted coding to orchestrating multi-agent workflows. No prior Claude Code experience required.

• A Claude account with Claude Code access (sign up)
• GitHub account (free account works)
• One of:
  • GitHub Codespaces (recommended, zero local setup)
  • Docker Desktop + VS Code with Dev Containers extension
  • Local setup: Python 3.11+, Node.js 18+, uv

Follow the steps below to prepare your development environment for the exercises. You have three options: GitHub Codespaces (recommended), Dev Container (local Docker), or local setup (no containers).

• Benefit of GitHub Codespaces: No local setup required, works on any machine, quickest to get started
• Benefit of Dev Container: Works offline, more control over environment
• Benefit of local setup: Full control, no Docker overhead

You need your own fork to push changes. See also: Keeping your fork in sync if the original repository is updated later.

1. Click the Fork button at the top-right of this page
   

2. Select your personal GitHub account as the owner of the fork
   
   Note: Do NOT fork to an organization account, as this may cause issues with GitHub Codespaces access.

# macOS
brew install gh

# Windows
winget install --id GitHub.cli

# Ubuntu / Debian
sudo apt update && sudo apt install gh

gh auth login
# Follow the prompts: select GitHub.com, HTTPS, and authenticate via browser

gh repo clone YOUR_USERNAME/agentic-swe-2026

# Generate a key
ssh-keygen -t ed25519 -C "[email protected]"

# Copy the public key
cat ~/.ssh/id_ed25519.pub
# (copy the output)

git clone [email protected]:YOUR_USERNAME/agentic-swe-2026.git

Choose one of the three options below.

1. On your fork's GitHub page, click Code → Codespaces → Create codespace on main
2. Wait for the codespace to build (~3-5 minutes first time)
3. Once loaded, open the terminal

1. Clone your fork locally
2. Ensure Docker Desktop (or your preferred Docker environment) is running
3. Open the project in VS Code
4. When prompted, click Reopen in Container
   
   If not prompted, open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P), type Dev Containers: Reopen in Container, and select it
5. Wait for the container to build — this may take several minutes on first run

1. Clone your fork locally
2. Install prerequisites:

   # Python (3.11+)
   python3 --version
   
   # uv package manager
   curl -LsSf https://astral.sh/uv/install.sh | sh
   
   # Node.js (18+, needed for MCP servers)
   node --version
   
   # Claude Code
   npm install -g @anthropic-ai/claude-code

3. Set up the todo app:

   cd todo-app
   uv sync

Open the terminal and run:

claude

On first launch, Claude Code will ask you to authenticate. Select the option to sign in with your Claude subscription and follow the browser-based authentication flow.

Note: When using GitHub Codespaces or dev containers, the authentication flow might not work correctly the first time due to the isolated environment. If you retry, you should get a code that you can directly paste into the terminal.

Optional — install the VS Code extension:

code --install-extension anthropic.claude-code

# Check Claude Code
claude --version

# Start the todo app
cd todo-app
uv run uvicorn app.main:app --reload
# Open http://localhost:8000
# Login: [email protected] / demo123

Interactive Course Navigator — Click any exercise to see descriptions, concepts, WISC strategies, and concept threads. Filter by phase, concept thread, or WISC strategy.

The workshop has three phases. Phase 1 is linear and designed as a standalone half-day. Phase 2 is non-linear — students choose 2-3 Theme Labs based on what matters most to them. Phase 3 is open-ended — one challenge, student's choice of approach.

├── docs/                           # Exercises, reference cards, guidelines
│   ├── exercises/                  # Workshop exercises
│   │   ├── warmup/                 # Gilded Rose kata
│   │   ├── part-1-fundamentals/    # Exercises 1-4 (Phase 1: Guided Foundations)
│   │   ├── part-2-intermediate/    # Labs A-E (Phase 2: Theme Labs)
│   │   ├── part-3-advanced/        # Challenges A-D (Phase 3: Open Challenges)
│   │   └── templates/              # Lab and challenge format templates
│   ├── reference/                  # Quick-reference cards (WISC, PIV loop, failure patterns, etc.)
│   ├── rules/                      # Development guidelines
│   ├── todo-app-requirements/      # App specifications
│   └── misc/                       # Tips and references
│
├── gen-image/                      # Image generation CLI (exercise)
│
├── gilded-rose/                    # Refactoring kata (warmup)
│
└── todo-app/                       # Full-stack todo application
    ├── src/app/                    # FastAPI application
    │   ├── main.py                 # App entry point
    │   ├── database.py             # SQLAlchemy models
    │   ├── utils.py                # Shared utilities
    │   ├── core/deps.py            # Auth dependencies
    │   ├── routes/                 # API endpoints
    │   ├── templates/              # Jinja2 HTML templates
    │   └── static/                 # CSS, JS, images
    └── tests/                      # Test suite

Linear. Every participant does every exercise in order. Builds the shared vocabulary and habits for Phases 2 and 3.

Non-linear. After a 15-minute plenary intro for each theme, students choose 2-3 labs. Each lab is self-contained and anchored to a WISC strategy.

Open-ended. Students choose one challenge and apply everything they've learned without step-by-step guidance.

Quick-reference cards available in docs/reference/ — consult during exercises:

• Briefing Template — Five-part task brief, Osmani six-section, three-tier boundaries
• Context Economics — thresholds, instruction compliance research, multi-agent ROI
• Delegation Decision Tree — HITL/HOTL/HOOTL, Skills vs Sub-agents vs MCP
• Failure Patterns — 10 named patterns + WISC diagnostic lens
• PIV Loop — Plan→Implement→Verify, Sandwich Principle
• Trust Spectrum — vibe coding → agentic engineering, METR data
• Agentic Patterns — Willison's 10 patterns quick reference
• Spec-Driven Development — SDD tools (AndThen, PRP, Spec Kit, BMAD), when overhead is worth it

The exercises use a full-stack todo application as the learning vehicle:

• Backend: Python + FastAPI
• Frontend: HTMX + Shoelace Web Components
• Database: SQLite + SQLAlchemy
• Templates: Jinja2

The app supports multiple lists, priorities, due dates, search, drag-and-drop reordering, and dark mode.

Some exercises use external services. Create a .env file from the template:

cp .env.example .env
# Edit .env with your keys

• Claude Code Documentation
• CLAUDE.md Best Practices
• AndThen Plugin — Structured workflows for Claude Code (clarify → spec → implement → review). Used in Exercises 3, 4 and Lab D.
• MCP Servers
• Agentic Coding Tips

If the original repository is updated after you fork, you can pull in those changes.

Option 1: Via GitHub UI (easiest)
On your fork's GitHub page, click "Sync fork" if your branch is behind:

(Then select "Update branch" if prompted.)

Option 2: Via command line

# Check if upstream remote exists
git remote -v

If upstream is not listed, add it:

git remote add upstream https://github.com/IT-HUSET/agentic-swe-2026.git

Then fetch and merge:

git fetch upstream
git checkout main
git merge upstream/main

# Optional: push to your fork's remote
git push origin main