Build · Flagship builder curriculum

Vibe Coding, Properly.

Turn natural-language direction into working software without surrendering architecture, security, testing, or ownership to the model.

AccessFree · public

Structure7 modules · 5 hours

LevelBuilder

Fieldwork7 operating artifacts

Who this is for

Founders, operators, designers, and ambitious nontraditional builders using Claude, Codex, Copilot, or another coding agent to ship real products.

Course outcome

Leave with a production-ready repository, a repeatable agent workflow, a review checklist, an acceptance suite, and a release process you can explain and operate.

Brief the product before the agent

Translate the idea into users, outcomes, constraints, states, and acceptance criteria before asking for implementation.

Lessons

↳Problem statements, user jobs, and the smallest valuable release
↳Constraints, non-goals, edge cases, and irreversible decisions
↳Acceptance criteria an agent and a human can both verify

Field assignment

Write a one-page build brief for one product slice, including five acceptance criteria and three explicit non-goals.

Read the system you are changing

Learn enough repository anatomy to keep the agent inside the product's actual structure instead of generating a second architecture beside it.

Lessons

↳Routes, components, data, configuration, and environment boundaries
↳Dependencies, scripts, conventions, and existing tests
↳How to ask an agent for an evidence-backed implementation plan

Field assignment

Produce a repository map naming the entry points, systems of record, risky surfaces, and commands that prove the project is healthy.

Direct agents in bounded passes

Use small, observable assignments that preserve intent and make incorrect work inexpensive to catch.

Lessons

↳Context packets, scoped prompts, and definition of done
↳Planning, implementation, review, and repair as separate passes
↳When to let an agent continue and when to reset the approach

Field assignment

Break the product slice into four bounded agent tasks with dependencies, verification steps, and a stop condition for each.

Review the diff, not the confidence

Treat generated explanations as a hypothesis and the actual file changes as the evidence.

Lessons

↳Reading diffs for unintended scope, duplication, and hidden coupling
↳Checking data flow, error paths, accessibility, and mobile behavior
↳Using a second review pass without creating review theater

Field assignment

Review one agent-produced change line by line and record every decision you can verify, cannot verify, or need to reverse.

Turn requirements into tests

Make the promised behavior executable so the next prompt cannot silently break the last successful release.

Lessons

↳Unit, integration, end-to-end, visual, and manual acceptance checks
↳Happy paths, boundary cases, and failure recovery
↳Build, type, lint, and smoke-test gates before release

Field assignment

Create an acceptance suite for the product slice with at least one normal, empty, invalid, unauthorized, and downstream-failure case.

Protect the dangerous boundaries

Keep secrets, identity, payments, uploads, permissions, and destructive actions out of improvisational code paths.

Lessons

↳Server versus client trust boundaries and environment variables
↳Authentication, authorization, validation, rate limits, and audit trails
↳Dependency review, least privilege, and safe operational defaults

Field assignment

Complete a threat pass on the product slice and document who may read, create, update, delete, or trigger each sensitive action.

Ship, observe, and own it

A generated feature becomes a product only when it can be deployed, measured, recovered, and changed safely.

Lessons

↳Preview environments, migrations, release gates, and rollback
↳Logs, analytics, alerts, and first-week operating review
↳Documentation, handoff, and the maintenance backlog

Field assignment

Publish a release runbook covering preflight, deployment, smoke tests, monitoring, rollback, and the named owner after launch.

Next course

Coding Foundations for AI-Assisted Builders

Learn the parts of programming that make AI-generated code understandable: the browser, data, logic, state, Git, databases, errors, and deployment.

Continue learning

— Turn the fieldwork into a system

Need the studio to own the outcome?

Use the tools Tell us the goal