Module Overview

Module 1 gets your environment ready before the program starts. You install and verify the AI tools, connect them to your project’s services through MCP, and set up the home where your three weeks of artifacts will live. It is self-paced and done before Week 1 — walk in on Monday with everything working, so the first session is about the framework, not troubleshooting installs.

The AI Toolchain

Two ways to work with AI

For document-shaped artifacts — the BRD, PRD, Architecture Document, ADRs, even your Dev Tasks — you do not need a paid plan or the command line. A web chat tool is enough, and both of the following are free to sign up for:

claude.ai (free) — sign up with your email at claude.ai. The free plan is session-based: usage resets on a rolling five-hour window, and how much you can send varies with overall demand. In practice you produce an artifact, hit the limit, and pick up again after the window refreshes. Plan your Tuesday–Thursday work around that rhythm — draft in focused sessions rather than one long marathon.

Gemini on the web (free) — available through your Google account at gemini.google.com, and through your @stratpoint.com Workspace account for longer documents. Use it as a genuine alternative: generate the same artifact in both, then keep whichever output better satisfies the quality-bar checklist and passes the Friday gate.

Part 1 — Claude Code

Terminal-first AI tool. Primary for development, testing, automation, and DevOps.

Prerequisites

Node.js 22 or LTS, Git, terminal access. Claude Code needs a Claude Pro/Team subscription or an Anthropic API key — if you don’t have one yet, you can still do the Week 1 document work on the free claude.ai or Gemini web (see “Two ways to work with AI” above), and set up the CLI when you reach the development weeks.

Install and Authenticate

# Install globally
npm install -g @anthropic-ai/claude-code
 
# Authenticate
claude auth login
 
# Verify
claude --version
claude auth status

Test It

# Navigate to any project folder
cd ~/projects/your-project
 
# First test
claude "Summarize the files in this directory"
 
# Follow-up (tests context retention)
"Which file should I look at first for authentication logic?"

OpenCode (the second standard CLI)

OpenCode is an open-source, terminal-first AI coding agent — the second tool we standardize on alongside Claude Code. You get bring-your-own-provider flexibility (Anthropic, OpenAI, Gemini, Bedrock, and OpenCode’s own Zen gateway) and an MIT-licensed tool you can inspect and extend. It supports MCP, LSP, custom commands, agents, skills, and Plan/Build modes. The methodology transfers directly: prompting, context loading, agents, and rules work the same as in Claude Code — only the commands differ.

# Install (either method)
curl -fsSL https://opencode.ai/install | bash
# or
npm i -g opencode-ai
 
# Initialize in a project (reads your codebase)
opencode
# then run: /init

OpenCode Zen and the Big Pickle model

OpenCode Zen is OpenCode's curated model gateway — a tested set of models served by the OpenCode team, used like any other provider (sign in, get an API key, run /connect, then /models to pick one). Big Pickle is a stealth model on Zen — free during its current preview period, with a 200K-token context window and tool-calling and reasoning support. It is strong at code analysis, documentation, and implementation planning, which makes it a low-cost way to practice the framework's planning steps.

# In the TUI, pick the model interactively
opencode
# then run: /models   (look for Big Pickle)
 
# Or select it directly from the CLI
opencode run --model opencode/big-pickle "explain this module"

Part 2 — Verify OpenCode

You installed OpenCode in Part 1. Now confirm it works end to end — a model is connected, it can read your project, and it can make an edit you approve.

Connect a model

OpenCode is bring-your-own-provider. Connect whichever you have access to — an Anthropic or Gemini key, or the OpenCode Zen gateway (including the free Big Pickle model covered in Part 1).

opencode
# then run:
/connect          # choose a provider, paste your API key
/models           # pick the model to use (e.g. Big Pickle)

Test It

Verification Checklist

• opencode launches and a model is connected (/models shows your selection)
• It answers questions about your project structure
• Plan mode analyzes without modifying files; Build mode produces a diff you can accept or reject
• You can switch primary agents with Tab and invoke a subagent with @

Part 3 — Gemini & Figma Make

Gemini (via Google Workspace)

Access through your @stratpoint.com account. No separate API key needed.

# Sign in at:
https://gemini.google.com
 
# Or use the Gemini app in Google Workspace
# (Docs, Sheets, Drive integration)

Best for: Long-context work — processing full PRDs, BRDs, architecture docs, large requirements documents. Integrates with Docs, Sheets, and Drive.

• Gemini responds when signed in with your Workspace account
• Can process a long document (paste a sample PRD and ask for a summary)

Figma Make (Design Track Only)

If your role includes design, use Figma Make directly inside Figma. No separate CLI or integration. Skip this section if you are not on the design track.

# Access at:
https://www.figma.com/make/

• Figma Make opens and responds to design prompts

Part 4 — MCP Setup

Model Context Protocol (MCP) connects your AI tools to live project data — repositories, filesystems, databases, documentation. Think of MCP servers as plugins.

Scopes

Core MCP Servers

Set these up to be productive on day one:

GitHub

claude mcp add github \
  -- npx -y @modelcontextprotocol/server-github \
  --scope user
 
# Test:
# claude "show me my open PRs on the ai-sdlc repo"

Filesystem

claude mcp add fs \
  -- npx -y @modelcontextprotocol/server-filesystem \
  /path/to/project \
  --scope project
 
# Test:
# claude "read docs/known-issues.md and summarize"

Google Drive

claude mcp add gdrive \
  -- npx -y @anthropic-ai/mcp-gdrive \
  --scope user
 
# Test:
# claude "list documents in my project folder on Drive"

Supabase (if applicable)

claude mcp add --scope project --transport http \
  supabase "https://mcp.supabase.com/mcp"

NeonDB (if applicable)

# Remote MCP server (OAuth — recommended)
claude mcp add --scope project --transport http \
  neon "https://mcp.neon.tech/mcp"
 
# Or quick setup (creates API key, wires editors + skills)
npx neonctl@latest init

Verify MCP Setup

# List all configured MCP servers
claude mcp list
 
# Inspect a specific server
claude mcp get github

• claude mcp list shows your configured servers
• GitHub MCP responds to queries about your repo
• Filesystem MCP can read project files

Part 5 — Set Up Your Training Project

Over the next three weeks you will produce a full artifact chain — BRD, PRD, Architecture, Dev Tasks, then code — built from scratch on one project. You pick that project from the sample-project library, and this section sets up the home for the work before Week 1.

The principle (not a rigid structure)

Whichever project you pick, everything you produce lives in one project folder with two homes inside it:

docs/ — your artifacts: the BRD, PRD, Architecture Document, ADRs, and Dev Tasks you create in Weeks 1–2. This folder is documentation, not code — keep it beside the code repo and do not commit it to any repository. The Architecture work and Dev Tasks are segregated by epic: one unified Architecture Document plus one ADR file per epic, and one Dev Tasks CSV per epic.

knowledge/ — your reusable AI assets: the prompts, rules, agents, and patterns you build and contribute back. This lives inside the code repo, alongside AGENTS.md and CLAUDE.md.

Exact subfolder names are yours to shape. There is no required skeleton — as long as artifacts have a home and your AI assets have a home, the structure is working.

What you create now vs. what the AI generates later

Create now (by hand): just the parent project folder and an empty docs/ for the artifacts you’ll produce starting Week 1. That’s all you need before Monday — two empty folders.

Generated as you go (by AI, you driving): every artifact that fills docs/ — the BRD and PRD in Week 1, the Architecture Document, ADRs, and Dev Tasks in Week 2 — is produced by running the agents against the inputs, reviewed by you, and signed off at each gate. You are not transcribing a finished document; you are generating it and holding it to the quality bar.

Generated in Week 3 (by AI, from your approved artifacts): the code repo itself — source folders, configuration, AGENTS.md, CLAUDE.md, and the knowledge/ directory — is scaffolded by the AI from your approved Architecture Document. You do not hand-create the code structure now; it is derived from decisions you haven’t made yet.

Example layout (reference — yours may differ)

One common shape, shown as a best-practice reference. The arrows mark what the AI generates in Module 5 — you do not build those by hand now.

my-project/                      # parent project folder (create now, empty)
├── docs/                         # your artifacts — NOT committed to any repo
│   ├── brd/                      ← AI-generated, Week 1 (from the RFP + estimation)
│   ├── prd/                      ← AI-generated, Week 1 (from the approved BRD)
│   ├── arch-docs/                ← AI-generated, Week 2 (one ARCH doc + one ADR per epic)
│   │   ├── ARCH-<code>-v1.0.md
│   │   ├── ADR-<code>-E001-...md
│   │   └── ADR-<code>-E002-...md
│   ├── dev-tasks/                ← AI-generated, Week 2 (one CSV per epic)
│   │   ├── epic-0-...-tasks.csv
│   │   └── epic-1-...-tasks.csv
│   └── generated-figma/          ← AI-generated, Week 1–2 (UI/UX prototype)
│
└── <app-repo>/               ← AI-generated, Week 3 (this is what gets committed)
    ├── AGENTS.md             ←   cross-tool rules
    ├── CLAUDE.md             ←   tool-specific overrides
    ├── knowledge/            ←   your reusable AI assets
    │   ├── prompts/
    │   ├── rules/
    │   ├── patterns/
    │   └── agents/
    └── ...                   ←   source, config (depends on the stack)

Going Deeper — Learning Resources

This handbook gets you set up. If you want to build fluency before Week 1 — or reinforce a concept later — these are the resources worth your time. They cover the same four pillars this program is built on: the basics, MCP, skills, and agents. You do not need to watch everything; treat this as a menu, and remember the rule that matters most — you learn by building, not by watching.

Start here — official and free

Anthropic Academy is Anthropic’s official training platform: structured, self-paced, free courses with certificates. Four foundational courses map directly to this program — Claude Code in Action, Introduction to Model Context Protocol, Introduction to Agent Skills, and Introduction to Subagents — roughly ten hours total. If you do only one thing on this page, start here.

Claude Code — video walkthroughs

Documentation tells you what each feature does; video shows the workflow in motion — prompt phrasing, when to compact context, how a subagent gets invoked. A few creators are consistently strong on agentic Claude Code work:

IndyDevDan — planning-first, agentic workflows with a heavy emphasis on MCP and thinking before building; the closest match to this program’s Evaluate → Plan → Apply → Validate discipline. Channel: youtube.com/@indydevdan. Start with his “Claude Code Deep Mastery” playlist.

Two condensed courses worth bookmarking: “Claude Code Full Course (2026)” (youtube.com/watch?v=05aY2LRIC3s) for a multi-hour, project-based pass beginner to advanced; and “Anthropic’s 7-Hour Claude Code Course in 27 Minutes” (youtube.com/watch?v=XuSFUvUdvQA) for a fast revision of the official material. Use the long one to learn, the short one to revise.

OpenCode — video walkthroughs

If you plan to use OpenCode (and the Big Pickle model on Zen), these cover setup through agents end-to-end. The methodology is identical to Claude Code — only the commands differ.

“OpenCode Tutorial for Beginners: Setup, Agents, Skills & MCP” (Leon van Zyl) — covers all four pillars in one beginner-friendly video; the single best starting point for OpenCode. youtube.com/watch?v=uZGDO0L-Dr4

“OpenCode Crash Course — Open Source AI Coding Agent” — a complete tool walkthrough from install to first real task. youtube.com/watch?v=WXffHkvfRpM

“OpenCode MCP Servers: Connect ANY Tool to Your AI Agent” — a dedicated MCP deep-dive, from basic setup through OAuth authentication. youtube.com/watch?v=nUCwPxMgz_8

“OpenCode AI Agent Setup: From Zero to Custom Skills” — installation through building your own skills and memory. youtube.com/watch?v=vHkLrDD2xrU

Companion reference: the community guide “OpenCode — Everything You Need to Know” walks through installation, Zen model setup, the TUI, commands, skills, agents, plugins, and MCP servers with real examples. github.com/wesammustafa/OpenCode-Everything-You-Need-to-Know

Setup Complete Checklist

Every item must be checked before Week 1 Monday.

Tools

• Claude Code installed, authenticated, responding to prompts
• OpenCode installed, a model connected, Plan/Build modes working (Part 2)
• Gemini accessible via Google Workspace account
• Figma Make accessible (design track only)

MCP

• GitHub MCP connected and responding to repo queries
• Filesystem MCP connected to project directory
• claude mcp list shows all configured servers

Project Setup

• Parent project folder created, with an empty docs/ for your artifacts (Part 5)
• AI can read project files via Filesystem MCP (verified in Part 4)

Understanding

• I know when to use Claude Code vs OpenCode vs Gemini
• I understand MCP scopes (local, user, project)
• I know which MCP servers are approved for my project

What’s Next

Week 1 Monday: Module 2 (End-to-End AI SDLC Workflow) and Module 3 (Prompt Engineering Fundamentals) are taught back-to-back. Everything you configured today gets used immediately.

References

Links last verified: April 2026. If a link is broken, search the vendor’s main site.