Paid Cohort · 4 Weeks · Starts 5 July 2026

Build with Claude Code.
Ship 3 real products in 4 weeks.

A small live cohort. Real Next.js, Vercel, Supabase, Claude API. You leave with 3 deployed products — two we build together, one is your own idea — and the skill to build more, even if you've never written code.

$450 $600 25% OFF — EARLY BIRD
Reserve your seat →

Use code CCEB150 at checkout. Early bird ends 21 June 2026.

5 July 2026Cohort starts
4 weeks4 live sessions
60 seatsCohort cap

What you leave with. Real products, real URLs.

Not slides. Not notes. Not a certificate. Three deployed products and the workflow to keep shipping.

3
Deployed products with live URLs
4
Live sessions with Sid
60
Other builders alongside you

What you actually learn.

Each week is a skill you walk away with. The three products you ship are the proof you can use it.

WEEK 01
Claude Code as your build partner
Activity 1 — Second Brain. A single-user personal knowledge tool. Paste links, drop PDFs, drag in screenshots, type notes. Claude tags everything, summarises it, and answers questions across your whole library with citations back to the source. Shipped to a live URL by Friday.
Objectives — by the end of Week 1 you can
  • Explain how Claude Code works as an agent — what it sees, does, and remembers
  • Use the core primitives — CLAUDE.md, plans, sub-agents (Task tool), slash commands
  • Direct Claude through the 5-step build loop: scaffold → implement → review → refactor → ship
  • Use the built-in tools — vision, files, web search, code execution — on real inputs
  • Pick between Opus, Sonnet, and Haiku for a given task
  • Ship the Second Brain to a real URL
Topics
  • The agent loop in plain English — read context, pick a tool, act, read result, repeat
  • CLAUDE.md — the memory file Claude reads every session; the highest-leverage thing in the course
  • Plans + TODOs — when to ask Claude to plan, when to just let it run
  • Sub-agents via the Task tool — parallel helpers (one tags notes, one summarises, one indexes)
  • Slash commands / custom skills — shortcuts you build and reuse forever (e.g. /summarise)
  • Model selection — Opus / Sonnet / Haiku, plus extended thinking
  • Vision + Files API — Claude reads PDFs, images, and screenshots directly
  • Built-in tools — web search and code execution
  • The modern AI app stack — Next.js, Vercel, Supabase, Anthropic SDK
Live session (90 min)

45 min — Sid builds the Second Brain live, empty folder to deployed URL

45 min — live student debugging on what broke for them

Deliverable: a live Second Brain. Drop in 3 documents, ask 3 questions, get answers cited back to the source.
WEEK 02
Make it real: connect to the world
Activity 2 — AI Interview Coach. A multi-user B2C web app. A user uploads their resume and a job posting, then completes a tailored mock interview. Three Claudes work together — an interviewer asks the next question, a grader scores the answer, a coach explains why. Per-user history. Anki-style export of weak spots as a custom Skill. The headline build of the cohort.
Objectives — by the end of Week 2 you can
  • Connect Claude to a real external app via MCP (Gmail, Slack, Calendar…)
  • Write a custom Skill (Skills 2.0)
  • Build a multi-user app — sign-up, sign-in, isolated data per user
  • Apply cost engineering — prompt caching, batch API, per-feature model routing
  • Handle Claude's five common production failure modes
  • Run a basic evaluation suite on AI output quality
  • Ship the AI Interview Coach — a real B2C app strangers can sign up to and use
Topics
  • MCP — connectors that let Claude talk to your real apps; turns Claude from chatbot into worker
  • Skills 2.0 — executable mini-programs Claude can install and run on demand
  • Hooks — automatic triggers (on sign-up, on deploy, on a schedule)
  • Background / scheduled work — Claude on a cron, the "works while you sleep" pattern
  • Auth (Clerk) + data isolation (Supabase Row Level Security)
  • The five Claude failure modes + the claude-utils.ts library that handles all five
  • Cost engineering — prompt caching (up to 90% cheaper), batch API (50% cheaper), model routing
  • AI UX patterns — streaming, optimistic UI, graceful failure
  • Evals — one Claude grading another; in Activity 2 this is literally the product
  • Anthropic's first-party Multi-Agent Orchestration (shipped May 2026 in Claude Code)
Live session (90 min)

45 min — Sid builds Activity 2 live: three-agent setup, auth, prompt caching, eval; types a deliberately bad answer and shows Claude grading Claude in real time

45 min — student share-outs of what broke when their first stranger tried it

Deliverable: a live, multi-user AI Interview Coach. A stranger signs up, uploads a resume + job posting, gets scored and coached. Sid tries every student's app.
WEEK 03
Your idea, the right shape
Activity 3 — Your own idea. The thing you've been thinking about for months — cut to a 7-day build and deployed in its appropriate shape. By Demo Day at least one stranger has used it.
Objectives — by the end of Week 3 you can
  • Cut a vague idea down to a 7-day buildable version
  • Pick the right product shape for your idea
  • Pick the right agent architecture for the problem
  • Build a v1 of your own idea, deployed in its appropriate shape
Topics
  • The scoping cut — vague idea → 7-day version, done live on real student ideas
  • The one-page spec — what it is, who it's for, the core loop, the stack + agent pattern, the biggest risk
  • Product shapes — web app, background agent, MCP server, Skill-as-product, Slack/Discord bot, CLI tool, and when each is the right pick
  • Agent architectures — single Claude call, fixed pipeline, sub-agents, or full Multi-Agent Orchestration
  • The pattern-selection rule — three questions that decide the architecture
  • Extended thinking — when slowing Claude down is worth the latency
  • Claude Agent SDK — building Claude programs that aren't web apps
  • Design-as-you-build — prototype the riskiest part first, ugly, by hand
  • Deploying each product shape
Live session (90 min)

45 min — each student gives a 2-minute pitch; Sid names the one scope risk per project

45 min — 3–4 students get a full live architecture review

Deliverable: v1 of your own idea, deployed in its appropriate shape. Core loop works end-to-end.
WEEK 04
Polish, evaluate, demo, keep going
Demo Day. Every student demos live for 3 minutes. Real URL, real input, real output. No slides. Sid closes with the post-cohort path forward.
Objectives — by the end of Week 4 you can
  • Honestly evaluate your product against stranger-usability
  • Run a real evaluation suite on AI output quality and act on the results
  • Polish to demo-ready
  • Demo live in 3 minutes
  • Keep building and stay current with Anthropic's release velocity post-cohort
Topics
  • Honest self-evaluation — the three-question test, done aloud, away from the laptop
  • Evals on AI quality (deepened) — a golden set for your product, LLM-as-judge, catching regressions
  • The five edge cases — empty/one-word input, the paste-bomb, prompt injection, the "is this output good?" UI moment, the undo flow
  • The 10-minute polish checklist — loading / error / empty states, above-the-fold copy, mobile, one-sentence description
  • Demo craft — opening claim → single core flow → one wow moment → clear close
  • Computer Use (March 2026) — Claude controlling your actual desktop
  • Post-cohort trajectory — Anthropic's release cadence, how to stay current, what to ship next
Live session — Demo Day (120 min)

Every student demos live for 3 minutes; the cohort reacts; Sid closes with the path forward

Deliverable: a polished, evaluated AI product demoed live to 60 people.
Threaded through all 4 weeks — sharper each time:
  • Directing Claude Code — briefing-first prompts, not typing
  • Reading what Claude wrote — when to accept, push back, or ask for a redo
  • Model selection — rule of thumb in Week 1, measured framework in Week 4
  • Cost discipline — Week 1 awareness → Week 2 caching and batching → Week 4 monitoring
  • The 5-step build loop — run dozens of times across the cohort

The stack. What you'll actually use.

Modern, industry-standard. You don't need to know any of it upfront — every piece is introduced when it's needed and explained in plain English.

LayerTechnologyWhat it does
FrontendNext.js (React)The interface users see
DeploymentVercelOne-command deploy to a live URL
BackendNext.js API routesServer logic, handles requests
DatabaseSupabase (Postgres)Stores user data, persists state
AuthClerkUser accounts, login, per-user data
AI runtimeAnthropic SDKPowers the intelligence (Claude API)
Build agentClaude CodeWrites the product itself
ConnectorsMCP serversConnect Claude to real apps
SkillsSkills 2.0Reusable, executable workflows
Multi-agentMulti-Agent OrchestrationLead + specialist Claudes, native
Non-web shapesClaude Agent SDKBackground agents, CLI tools, MCP servers

What you keep. Forever.

You don't just leave with products — you leave with a forkable library you reuse on every build after.

The commitment. Time and cost, no surprises.

Total effort: 15–25 hours over 4 weeks. Pre-cohort setup (~1 hr) the week before: a laptop, Claude Pro ($20/mo) + Claude Code, and free-tier GitHub, Vercel, Supabase, and Clerk accounts.

Time investment

ComponentHours
4 live sessions6.5 hrs
Own building (2–4 hrs × 4 weeks)8–16 hrs
Pre-cohort setup1 hr
Total15–25 hrs / 4 weeks

Running cost after the cohort

ServiceFree tier covers
VercelHobby — thousands of users
Supabase500 MB DB, 50k monthly users
Clerk10k monthly active users
Claude API~free to ~$5–15/mo with caching
Total$0–$25/mo for the first few months

Who this is for.

You don't need to code. Claude Code writes the code. You make the decisions.

The AI-curious
You've heard about building with AI and want to understand what it actually means. You've used ChatGPT but never shipped anything.
The AI enthusiast
You follow the space, you've tried tools, you know the concepts. You haven't built a real product yet.
The AI builder
You've built small things — agents, automations, scripts. You want to go from tinkering to shipping something real.
The idea person
You have product ideas you can't execute because you don't know how to build. This course closes that gap.

What's not in this course.

Being honest about what this isn't matters more than promising everything.

Reserve your seat.

60 seats. First 25 get early bird pricing.

Early Bird · Ends 21 June
$450 $600
YOU SAVE $150 · 25% OFF
Use this code at checkout:
CCEB150
Code expires 21 June 2026 at 23:59 BST.
  • 4 live sessions with Sid (Weeks 1–4)
  • 3 deployed products by end of cohort, with live URLs
  • Full Claude Code + Next.js + Supabase stack — taught from zero
  • Cohort Slack — 60 builders going through it alongside you
  • Demo Day — 3-minute live demo to the whole cohort
  • Recordings of every live session, yours to keep
Reserve my seat — $450 →

Cohort starts 5 July 2026. Live sessions times TBD.

Before you reserve.

Do I need to have done the free course first?
Recommended but not required. The paid cohort introduces Claude Code basics in Week 1 for students who haven't done the free course — but if you have time before 5 July, the free course at buildwithcc.vercel.app is the fastest way to walk in already comfortable.
How much time do I need to commit?
Roughly 2–4 hours per week outside the live sessions, plus the 4 live sessions themselves. Most of the work is building, not watching.
Do I really not need to code?
Correct. Claude Code writes the code. You direct it — decide what to build, review what it produces, iterate. We teach you how to direct it well. Many of the strongest builds in cohorts like this come from people who've never opened a terminal before.
What does it cost to run my product after the cohort?
For a small product with a handful of users: roughly $0–$25 a month. Vercel, Supabase, and Clerk all have generous free tiers that cover early usage. Claude API costs scale with use. We cover cost control explicitly in Week 2.
When are the live sessions?
Times TBD — announced before cohort start. All sessions are recorded, so you can catch up if you can't attend live. The cohort runs from 5 July through early August 2026.
What's the refund policy?
Refund policy TBD — finalise before launch. Default plan: full refund within 14 days if you complete Week 1 in full and decide it's not for you.
Where do I check out?
Click any "Reserve your seat" button. You'll go to Samcart (our checkout partner). Pay with card or Apple Pay. You'll get an immediate confirmation email with your Slack invite and cohort details.
S
Sid Arora
Head of Product, Gen AI & Agentic Solutions · Yelp

Two years ago I started building AI products in production. Agents, orchestrators, MCP integrations, the performance trade-offs that aren't in any tutorial — I had to figure all of it out the hard way.

I built the free course because the patterns shouldn't take months to find. I built this paid cohort because going from "I get the patterns" to "I shipped a real product" is a different kind of work — one that needs live feedback, peer accountability, and someone in the trenches with you for 4 weeks.

If you've watched the AI space for a year and still haven't shipped, this is the cohort that closes that gap. By 2 August 2026, you'll have three deployed products with live URLs — two we build together and one of your own. That's the deal.

Reserve your seat.

$450 with early bird code CCEB150, valid through 21 June 2026. Cohort starts 5 July.

Reserve my seat — $450 →

60 seats total. First 25 get the early bird price.