The program

Ship your first app in five weeks. Then ship the next ten on your own.

Most people can't ship the app in their head. The ones who try burn thousands on credits and end up with something half-built. We teach you to build your first app with us, live on the web by the final Friday, and the next one without us.

Run with
Direct Claude Code Cursor Codex GitHub Copilot Build on Cloudflare Workers
01/The curriculum

Five modules. Five meta-skills. One shipped app as the proof.

Each module teaches a single meta-skill — the kind that transfers to the next domain, the next stack, the next model. Two live sessions per module. One deep takeaway you keep.

01
Week 1

The Operator's Mindset

You stop treating the agent as a slot machine. You see five things you control. You know which one to pull.

By Friday of week one you've shipped one screen. You also know which of the five things you control got you there. That vocabulary is the floor everything else is built on.

Sessions
  • Five things you control
    How to write a tight prompt by naming the five controls: autonomy (how much the agent decides on its own), context (what it can see when it acts), verifiability (the check that catches it being wrong), instructions (the brief itself, written as a spec not a question), and scaffolding (the rails around the loop — a Ralph loop, a bash script, a slash command). Plus a 15-minute demo across three domains that resets what you think "agent" even means.
  • Setup
    Your CLAUDE.md, your hooks, your slash commands. A configured environment you own by Friday.
TAKEAWAY →
A prompt is a brief, not a question.
02
Week 2

Thinking Tools

Most operators grind harder when they're stuck. Pros switch modes. Week two teaches the switch.

Three plain moves: inversion, decomposition, and knowing when to stop. You learn what each one does and when to pull it out.

Sessions
  • First Principles & the Pre-Mortem
    ask the agent what would make this fail before asking it to succeed; the pre-mortem prompt
  • Plan Mode vs. Ship Mode
    six prompting modes from one-shot to spec-driven; how to pick the lightest one that works, and when 'plan mode' is worth the extra minutes
TAKEAWAY →
If you've been wrong twice, switch modes. Don't grind harder.
03
Week 3

The Verification Reflex

Closing the loop so the agent self-corrects before you read the diff.

The biggest improvement a builder can make: build feedback the agent runs on itself. Week three gives you a verification ladder, nine rungs from type-check to expert review. And the reflex of asking “how will I know this is wrong?” before “how do I fix it?”.

Sessions
  • The Verification Ladder
    the break-it-tomorrow test: design the smallest check that catches the agent breaking your most important feature
  • Research-Plan-Implement
    the three-phase workflow where you review the plan, not the code. The agent then builds against its own spec.
TAKEAWAY →
Review the plan, not the diff.
04
Week 4

Context as Craft

Engineering what enters and leaves the agent's mind. What you don't put in context matters more than what you do.

After 40% of an agent's context window is used, the agent gets measurably dumber. Week four teaches three habits. Compact on purpose. Use sub-agents as context isolators, not role-players. Treat the skill folder, not the agent, as the unit you reuse.

Sessions
  • The Dumb Zone & Intentional Compaction
    the 40% rule, summarize-and-restart, sub-agents as context isolators (not role-players)
  • Skills, not Agents
    Anthropic's late-2025 paradigm pivot: one general agent plus many skill folders beats a fleet of specialized agents
TAKEAWAY →
Three habits: compact, isolate, reuse.
05
Week 5

Ship & Transfer

Articulating the method so it generalizes to your next ten apps.

Shipping the app is the easy part. Naming why you made the calls you made, so the skill travels to a domain you've never touched, is the work of week five.

Sessions
  • Demo Day Dress Rehearsal
    present the live app plus one meta-decision you made; peer review on the decision, not the app
  • The Reflection
    the structured writeup: five named moves you used, a Week-1 plan for a totally different domain, three failure modes you'd expect there
TAKEAWAY →
Name the hard part of a domain you don't know. That's the test.
THE THESIS →
“The deliverable is a method that travels.”
02/The philosophy

You walk out with three habits, not a stack. The next ten apps run on them.

Most cohorts ship one app and disappear. Raft is built on a sharper claim: three principles run through every session.

01
Context engineering

We don't teach prompt-craft. We teach you to engineer what enters and leaves the agent's working memory — the only craft that survives the next model release.

02
Plan review > code review

Non-coders should never have to read diffs. You review the agent's plan before it codes. Intent first, implementation second.

03
The unit of reuse is a skill

You don't leave with one app. You leave with portable skill folders (markdown plus scripts) that direct any agent. Any domain. Any model. Anytime.

03/A typical week

A typical week. About six hours of your time.

  • Two live sessions a week. Tuesday is concept and demo. Thursday is clinic and co-working.
  • Two office hours a week. Craft on Wednesday, Shipping on Friday for auth, deploys, payments.
  • A daily Slack channel with your cohort and both instructors.
Mon
Tue
Wed
Thu
Fri
Sat
Sun
9am
12pm
3pm
6pm
9pm
Live session · concept + demo
Craft office hours
Live session · clinic + co-working
Shipping office hours
Friday ship review
Optional build weekend
Live session · 90 min Craft office hours Shipping office hours Friday ship review Optional weekend
04/The stack

The stack you'll learn to direct.

You won't memorize APIs. You'll learn which tool solves what, then direct the agent to wire it up.

The tools will rotate. The workflow won't.

05/The bill

The credit roulette stops here.

Every vibe-coding tool you've tried charges by the prompt. Every fix costs you again. Three weeks in, you've burned $3,000 and have nothing live. The workflow we teach runs on fixed-billing tools. About $100 a month, flat.

Your monthly stack, itemized
The agent Claude Code or Codex
$20-100
Hosting + deploy free tier covers most cohort apps
$0
Database free tier — scales when you do
$0
Auth, file storage, emails free tier each, until traction
$0–20
Domain annualized
$10
Total, predictable ~$100/mo
HIRE A DEV
SELF-PACED COURSE
RAFT COHORT
Upfront cost
$15k–50k
$200–500
$2,500
Time to ship
8–12 weeks
forever
5 weeks
You own the workflow
—
watch, don't do
yes
Help when stuck
one dev on Slack
forum, slow
daily channel, 2 instructors
AI bill after
n/a
pay-per-prompt
~$100/mo flat

Pay $2,500 once for the cohort. Then your AI stack costs the same whether you ship one app or ten — and the first app you ship pays for the rest.

06/The instructors

Two engineers who've built what you're trying to build.

We've built AI agents and apps that have served millions of users across complex systems. Five weeks of the lessons we learned in the trenches — the patterns and best practices for directing agents that ship.

Jon O'Bryan — Raft School co-founder, Engineer · YC Founder · Stanford

Jon O'Bryan

Engineer · YC Founder · Stanford

SHIPPING WITH AGENTS SINCE 2024

Divyam Chandel — Raft School co-founder, Agent Engineer · IIT Kharagpur

Divyam Chandel

Agent Engineer · IIT Kharagpur

SHIPPING WITH AGENTS SINCE 2024

07/After the cohort

The channel stays open.

Most cohort programs end on demo day and disappear. Raft's whole point is the opposite: the network you build in five weeks is worth more than the curriculum, so we keep it open.

PATH 01

The channel stays open

Cohort 02's daily channel becomes Raft's alumni room on the final Friday. You stay in. New cohorts join in.

PATH 02

Build weekends, monthly

One Saturday a month, alumni-only, a fresh problem on the screen. Three hours, deploy by lunch.

PATH 03

First call on the next cohort

Every cohort gets early access to the next, before public applications open. Returning operators skip the interview.

08/Apply for Cohort 02

Ready when you are.

We interview every applicant personally. 20 minutes, on Zoom. If we're not a fit, we'll point you somewhere that is.

Apply for Cohort 02

$2,500 · 5 weeks · ship-or-refund