Stratpoint Engineering

AI Foundational Training

Sign in with your Stratpoint Google account to continue.

AI SDLC Training
AI Foundational Training · Dev Track
Dev 1 · Day 0

Nexus Setup & the Day 0 Scaffold

Install the toolkit, initialize the project, generate the production scaffold — before any feature work starts.

INSTALL  →  INIT  →  GRAPH  →  SCAFFOLD

Module Overview

This is the Dev Track's equivalent of Module 1 (AI Tools Setup) plus the Day 0 half of Module 5. You install nexus-dev-toolkit and a knowledge-graph backend, initialize the project, and run /scaffold to turn an approved Architecture Document and Figma export into a running, production-grade shell — before a single Dev Task is implemented.

At a glance
CoversInstalling uv, Claude Code/OpenCode, graphify/codegraph, and nexus-dev-toolkit; nexus init; building the knowledge graph; running /scaffold
When it runsBefore Week 3 (Development) begins — once the core program's BRD, PRD, Architecture Document, and Figma export are approved
Builds onThe core program's Weeks 1–2 artifacts (BRD, PRD, Architecture, ADRs, Dev Tasks)
Leads intoDev 2 — the EPAV workflow, run against the scaffold this module produces

What you'll produce

A working nexus install; an initialized project (.claude/, knowledge/, .mcp.json); a built knowledge graph; and a running Day 0 scaffold — npm install && npm run dev (or the equivalent for your stack) works from commit one, with zero credentials configured.

Part 1 — Install Prerequisites

Same AI toolchain as Module 1 — Claude Code or OpenCode, terminal-first. nexus-dev-toolkit is a layer on top: it doesn't replace the CLI, it gives the CLI a repeatable set of skills to run.

# uv (recommended package manager for nexus itself)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Claude Code
npm install -g @anthropic-ai/claude-code
claude login

# OpenCode (the open, provider-flexible alternative)
curl -fsSL https://opencode.ai/install | bash

Most of this cohort trains on OpenCode — not Claude Code

Claude Code needs a Claude Pro/Team seat or an Anthropic API key, and most teams don't have enough paid seats for everyone during training. Every skill and command in this track exists identically for both tools — nexus init scaffolds .claude/ or .opencode/ depending on --tool, and the slash commands (/evaluate, /plan, /apply, /validate, /code-review, etc.) are the same names either way. Where the two tools genuinely differ, this track calls it out explicitly in an OpenCode callout like this one — everywhere else, assume "Claude Code" in the text means "whichever tool you're on."

OpenCode is for practicing, not for client work: real client engagements standardize on Claude Code only. Use OpenCode here to learn the EPAV cycle on your own time or a training sandbox; don't expect it to carry over as the tool you'll use once you're staffed on billable work.

OpenCode Zen: free models if you have zero paid seats

OpenCode Zen is OpenCode's curated model gateway (/connect → /models). It regularly runs free preview models with no credit card required — currently Big Pickle (200K context, strong at code analysis, documentation, and implementation planning — a good fit for /evaluate and /plan) and Ox Alpha (a newer stealth model, 1M+ context, multimodal). Both are free-preview models: quality and availability can change or expire without notice, and providers may use free-tier traffic to improve the model, so don't point either at real client code — the training sandbox and personal projects are the right use, since client engagements run on Claude Code only, not OpenCode or these free models. Context discipline still applies regardless of the advertised window — see Dev 4.

opencode
# then: /models   (look for Big Pickle or Ox Alpha under the Zen provider)

graphify or codegraph — pick one

EPAV skills query a knowledge graph to understand blast radius before touching code. Without one, they fall back to grep-based, best-effort context loading — still functional, just slower and less precise.

# graphify (strongly recommended)
uv tool install graphifyy   # PyPI name has double y; the command is "graphify"
graphify install             # registers /graphify skill into Claude Code

# codegraph (the alternative — pick one, not both)
npm i -g @colbymchenry/codegraph
codegraph install

Part 2 — Install and Initialize nexus-dev-toolkit

uv tool install nexus-dev-toolkit

cd my-project
nexus init .                             # Claude Code (default)
nexus init . --tool opencode              # OpenCode
nexus init . --graph-backend codegraph    # skip the prompt, use codegraph

What nexus init creates (Claude Code)

.claude/
├─ commands/          ← EPAV skills (/evaluate /plan /apply /validate /epav)
│                          + 5 reviewer skills (/code-review, /database-review, ...)
│                          + 2 git skills (/commit, /create-pr)
├─ agents/            ← 5 reviewer subagents (code-reviewer, database-reviewer, ...)
└─ settings.json      ← PostToolUse hook: graphify auto-updates after every edit
knowledge/
├─ rules/             ← coding standards, arch decisions
├─ patterns/          ← reusable implementation patterns
├─ prompts/dev/       ← task prompt templates
└─ retros/            ← retrospective notes
.mcp.json              ← MCP server config (nexus tools)

What nexus init . --tool opencode creates

.opencode/
├─ commands/          ← same skills, same names — /evaluate /plan /apply /validate /epav
│                          + reviewer skills + /commit + /create-pr
├─ agents/            ← same 5 reviewer subagents, adapted for OpenCode
│                          (Claude-specific frontmatter — tools, model — stripped on copy)
└─ plugins/
│   └─ graphify.js    ← tool.execute.after hook: graphify auto-updates after every edit
│                          (this is OpenCode's equivalent of Claude Code's settings.json hook above —
│                          only scaffolded if you picked graphify at init; codegraph wires itself)
knowledge/                ← identical structure to the Claude Code layout
opencode.json              ← MCP server config (nexus tools)

Bridging from the core program

If your team already ran Modules 2 and 4 by hand, you have a BRD, PRD, Architecture Document, ADRs, and a Dev Tasks CSV sitting in docs/. Nothing about that changes. Those files are exactly what /scaffold and later /evaluate consume — nexus doesn't ask you to redo Weeks 1–2, it starts from their output.

Part 3 — Place Reference Docs

Before running /scaffold, everything Claude needs must be in docs/:

docs/
├─ arch-docs/   ← Architecture Document, ADRs (from core Module 4)
├─ figma/       ← Figma export ZIP
├─ brd/         ← Business Requirements Document
└─ prd/         ← Product Requirements Document

Don't have a real project handy? Use the sample project

The Dev Track ships a complete, real artifact chain for LeaveTrack — the same app the core program's Module 1 calls "the safest first pick" — at the Sample Project: a BRD (BR-01..07), a PRD (US-01..08), an Architecture Document with an ADR, and a Dev Tasks CSV (TASK-010..018) — each rendered for reading, with a raw-file link underneath for copying into your project's own docs/. Run /scaffold against it — no Figma export is included, so the UI-shell fidelity checks in /scaffold's VALIDATE step won't apply, but the EPAV walkthroughs in Dev 2 onward all reference tasks from this exact CSV.

Part 4 — Build the Knowledge Graph

/graphify .                              # if you chose graphify
codegraph install && codegraph init      # if you chose codegraph, in your terminal

nexus doctor                             # confirms which backend is active
With graphifyWithout graphify
Context loadingScoped subgraph — fast, low token costFull file reads — slow, high token cost
Blast radiusAccurate, graph-backedBest-effort, grep-based
Auto-updatePostToolUse hook keeps graph currentN/A
EPAV skillsFull capabilityDegraded but functional

Part 5 — Run /scaffold

Day 0 is a one-person job

One owner — usually the Tech Lead — runs /scaffold once, before anyone starts feature work. Individual developers should never run /scaffold during Day 1: doing so re-scaffolds the project. Once Day 0 is done, every developer works exclusively in Day 1 (Dev 2 onward) for the rest of the project.

/scaffold is Day 0, run once per project. It runs EVALUATE first, then stops — you drive each phase explicitly:

/scaffold → (review) → /plan → (review) → /apply → (review) → /validate

Structure and standards, not live integrations

Day 0 produces mock auth (a cookie-based session, no real provider) and mock data — no Supabase Auth, no live DB queries, no external services. The install + dev command must work with zero credentials: npm install && npm run dev. Real auth and real data wiring happen in Day 1, task by task, via /apply (Dev 5).

Never write package versions from memory

APPLY's mandatory first step is calling the resolve_package_versions MCP tool — it runs the real package manager in a temp directory and returns exact pinned versions from the lock file. No "latest", no ^/~ ranges, no version guessed from training data. VALIDATE then requires the build to actually pass (npm run build or the stack equivalent) before any other check runs — a failed build is an automatic [BLOCKER] that overrides everything else.

Verification Checklist

  • nexus --version shows the installed CLI
  • nexus doctor reports a clean setup and shows which graph backend is active
  • npm install && npm run dev (or the stack equivalent) runs with zero credentials configured
  • AGENTS.md exists at the project root, derived from the Architecture Document
  • knowledge/ is populated with an initial rules/coding-standards.md and a saved design-system spec
  • All dependency versions are exact (no ^/~), sourced from resolve_package_versions

Self-Check

  • I have nexus-dev-toolkit installed and a graph backend chosen (graphify or codegraph, not both).
  • I understand why /scaffold stops after EVALUATE and waits for me to type /plan.
  • I know what Day 0 does NOT implement — no business logic, no real auth, no live data.
  • I know where the BRD/PRD/Architecture/Figma inputs live and that they come from the core program's Weeks 1–2.
  • I've run nexus doctor and confirmed a clean setup.