CURRICULUM DETAIL

Exactly how the 7 weeks work.

A clear breakdown of the program structure, daily flow, support model, and what happens in each phase — from the first weekend through Ship Night.

Read this before you apply: This is not an academic program. There are no lectures. There are no slides. There is no "watch and take notes." You will be building from the first hour. If something breaks — and it will — you fix it. Dave is in the room to point you in the right direction, not to do it for you. The discomfort is the point.

This page is for people who have applied or are seriously considering the bootcamp and want to understand the exact rhythm and commitments before deciding. It is a curriculum guide, not a sales page.

Pre-Work (T-4 weeks) Weekend 1 The Week Between Weekend 2 After Action
Pre-Work
Four weeks before Weekend 1 — you arrive ready or you don't arrive

Nobody shows up to Weekend 1 cold. The pre-work is not optional. If you haven't completed it, your seat becomes available to the next person on the list. The cohort does not wait.

Week 4
out
Tools and Accounts
Create every account: GitHub, Vercel, Supabase, Namecheap, Anthropic API, OpenAI, Perplexity or Grok. Register your domain. Confirm your laptop can push code to GitHub. Budget $75–150 and spend it. These are your tools. They don't work if they're not set up.
Week 3
out
Run the Diagnostic
Open Claude. Play the Project Sponsor: what problem are you solving, for whom, and what does success look like? Then play the Product Manager: what is Phase 1 — the minimum version that proves the concept? What is explicitly NOT Phase 1? Submit your brief to Dave.
Week 2
out
Brief Review and Scope Lock
Dave reviews your brief. You get back: approved, adjusted, or narrowed. If it's too big, it gets scoped down. You agree on Phase 1 before Weekend 1 starts. Your parking lot is documented. You know what you're building and what you are not.
Week 1
out
Pre-Call With Dave
You've already talked to him before you walk in the room. Problem statement confirmed. Tech setup verified — can you push to GitHub, deploy to Vercel, connect to Supabase? If not, fix it this week. Prompt library distributed and reviewed.
Weekend One
Saturday + Sunday · Define, architect, build, deploy
Day 1 — Saturday
9:00
AM
Introductions and Brief Presentations
Each person has 5 minutes. Problem statement. What Phase 1 does. What it doesn't do. What success looks like by Sunday of Weekend 2. No decks. Just talk. If you can't explain it in 5 minutes you don't understand it well enough to build it yet.
10:00
AM
Architecture Workshop
Dave reviews every brief with the group. Scope confirmed or adjusted. Data model outlined. Tech decisions made: what goes in Supabase, what does Pabbly handle, what does the Claude agent do. You are making real decisions that affect real code you write in two hours.
Every person has an approved architecture before this ends
11:00
AM
Environment Confirmed
GitHub repo created. Vercel connected. Supabase project live. First commit pushed. If your environment doesn't work, you fix it now. Not tomorrow. Now. Dave circulates.
Repo live, first commit visible on GitHub
12:00
PM
Lunch
Working lunch. Questions welcome. Dave is eating too. If something from the morning is bothering you, this is a good time.
1:00
PM
Build Sprint 1 — Core Data Model and First Component
You are building. Not planning. Not researching. Building. First table in Supabase. First HTML component. First form that submits something somewhere. It doesn't have to be beautiful. It has to exist.
You will not know where to start. Open the prompt library. Ask Claude to help you design the data model. That is not cheating. That is the skill.
4:00
PM
Show the Room What You Have
Screen share. What's working? What's broken? What did you try that failed? This is not a presentation. This is a status check. Honest. Fast. The cohort is paying attention and you are learning from everyone else's problems, not just your own.
Shared understanding of where every build stands
4:30
PM
Common Blockers Addressed
Dave addresses the patterns he saw in the last 3 hours. Probably two or three things everyone ran into differently. Probably one concept that needs more explanation. Not a lecture. Targeted.
5:00
PM
Day 1 Ends
You go home. The build continues.
Evening Homework — Day 1
  • Extend the core component you started. Add the next piece.
  • Break something intentionally. Find an edge case. See what happens.
  • Fix it. Document what you learned in your notes.
  • Post your evening commit to the cohort channel. One line: what you built.
  • The person who posts first doesn't win anything except the respect of the cohort. That turns out to matter.
Day 2 — Sunday
9:00
AM
Homework Review
What did you build last night? What broke? What did you fix? What surprised you? Two minutes each. Fast. Honest. The people who built in the evening are ahead. That's by design.
9:30
AM
Build Sprint 2 — Core Functionality and Integration
The core of what your build does gets built today. The form submits to Supabase. The AI agent responds. The automation fires. The dashboard reads data. By noon, the main thing it's supposed to do should work — even if it's rough.
If you're stuck on the integration, that's where most of the morning goes. That's expected. That's where the learning is.
Core functionality working — data flows from input to output
12:00
PM
Lunch
If something is this close to working, eat fast and keep going. Dave has been in that situation. He'll leave you alone.
1:00
PM
First Deployment
You push to GitHub. Vercel deploys. You open a browser. Your app is at a URL that anyone in the world can visit. This is the first win. It may be rough. It may have broken pieces. It is live. Nothing before this moment felt quite like this moment.
Every person has a live URL before 3pm
3:00
PM
QA Begins — Test Your Own Build
You are now the QA engineer. Use your build wrong. Enter bad data. Click things in the wrong order. What breaks? What gives a confusing error? What silently fails? Document everything. Don't fix anything yet. Find it first.
4:30
PM
Weekend 1 Ends
You have a live URL. You have a list of what's broken. You have five days to fix it and build the rest of Phase 1. The week between starts now.
Weekend 1 — What You Have
  • A live URL with something working at it
  • A GitHub repo with at least 3 commits
  • A Supabase project with at least one table capturing data
  • A QA list of what's broken and what needs building
  • One week to make it Phase 1 complete
The Week Between
Monday through Friday · This is where the real learning happens

You go home Sunday with something half-built. You stare at it Monday evening. You try four things. Three fail. The fourth works. You don't know exactly why it works. You dig until you do. That knowledge is yours permanently now. Nobody gave it to you. You found it.

Minimum: 1–2 hours per day. More if the project demands it. The milestone: by Thursday, the core feature of Phase 1 works end-to-end. Data in, data stored, automated response out. If it doesn't work by Thursday, Friday is for fixing it.

Monday
Fix the top three things from your QA list. Deploy after each fix. Confirm the fix is real.
Prompt: "Ask Claude to review your code for security issues and tell you the three most likely ways a user could break it."
Tuesday
Build the next feature of Phase 1. The one you haven't started yet. If you don't know where to start, run the architecture prompt.
Prompt: "Use Perplexity to research whether anyone else has built something similar. What can you learn from how they solved it?"
Wednesday
Integration day. Make the pieces talk to each other. Form to Supabase to automation to email. The full flow, working together.
Prompt: "Ask Claude to suggest the three most important features for Phase 2. Write them all in your parking lot. Touch none of them."
Thursday
Milestone day. Core feature works end-to-end. If it doesn't, this is a Thursday-only problem. Everything else waits.
Prompt: "Run your Phase 1 as a stranger who has never seen it. Find three things that could confuse a first-time user. Fix at least two."
Friday
Polish and prepare for Weekend 2. What's on your QA list? What's still in the backlog? Triage: must-have vs. nice-to-have. Start writing your Playbook — document what you built this week while it's fresh.
Prompt: "Write the first three entries of your Playbook. Document one architecture decision you made this week and why you made it."
Evening Support — Monday and Wednesday 8–10pm ET
Dave is on Slack. Not lecturing. Not hosting a call. Available. The difference between stuck-and-quitting and stuck-and-figuring-it-out is knowing that someone who has done this is one message away. You will get stuck. This is that night. Post what you're seeing. He'll point you in a direction. You finish the work.
The honest version of this week

Some nights you won't feel like opening the laptop. The build isn't working the way you expected. You're not sure you picked the right problem. You wonder if the seven weeks were a mistake. This is normal. This is the curriculum. Every builder has this week. The ones who push through it own the skill. The ones who don't were going to stop anyway. Post in the channel. You're not the only one.

Weekend Two
Saturday + Sunday · Ship it, document it, own it
Day 3 — Saturday
9:00
AM
Week Review
Each person: what got built, what changed, what surprised you. Two minutes each. The cohort has been building separately all week and this is the first time the group sees where everyone landed.
9:30
AM
Build Sprint 3 — Integration, Edge Cases, Polish
No new features today. The parking lot is closed. You are finishing what's on the Phase 1 list. Edge cases: what happens when the input is empty, when the API doesn't respond, when someone uses the thing wrong. Handle it.
If you're still building core features today, scope was too large. Narrow to what can be done by 3pm and ship that. An incomplete app that deploys beats a complete app that doesn't exist.
12:00
PM
Lunch
1:00
PM
QA Intensive — You Test Mine, I Test Yours
Swap builds. You are now using someone else's app as a real user. Find what breaks. Document what you find. Give it back. They do the same for yours. This is the QA cycle that professional teams use. You're doing it now.
Every build has been tested by someone other than the builder
3:00
PM
UAT — Use It as a Stranger
You get your own build back. You use it as someone who has never seen it. Not as the person who built it. As the first person who finds it through Google. What's confusing? What's missing? What would make you leave without converting?
4:30
PM
Day 3 Ends
Final fix list confirmed for Day 4. The morning is the last time you build. Anything not on the list does not get built tomorrow.
Day 4 — Sunday
9:00
AM
Final Build — Last Fixes Only
The parking lot is sealed. You are fixing the list from yesterday. No new features. If something occurs to you this morning that isn't on the list, write it in the parking lot and keep building what's in front of you.
11:00
AM
Playbook Time
Everyone writes. Dave circulates. You are documenting every decision you made — the data model and why it was designed that way, every integration and how it works, every automation and what it triggers, how to maintain the system, how to extend it. This is the thing that makes your build a product instead of a project.
If you can't explain a decision you made, you don't fully understand it yet. That's what the Playbook surfaces. Document it anyway and research it after the bootcamp ends.
First draft of your Playbook — minimum 10 documented decisions
1:00
PM
Lunch
2:00
PM
Final Deployments
Every person deploys their final Phase 1. The URL is live. The code is committed. The Supabase tables are capturing. You check it one more time in incognito — not as the builder, as a visitor. If it works, you're done building.
Every person has a live, deployed Phase 1 application
3:00
PM
Presentations
Five minutes each. The problem you came in with. What you built. How it works. One live demo. What's in the parking lot. No slides. Just the live app and your explanation of it. This is the moment you realize you understand what you built — because you can explain it to someone who doesn't.
4:00
PM
The Win
Dave talks about what comes next. Mastermind groups announced. The co-working schedule set. What Phase 2 might look like for each person.
Mastermind groups formed — three to four people, meet every two weeks
5:00
PM
Done
You go home with something real. The building continues on your timeline from here.
Weekend 2 — What You Leave With
  • A deployed Phase 1 application at your own domain
  • A GitHub repo you own — your code, your infrastructure
  • Your Playbook — decisions documented, system explained, ready to hand to someone else
  • A parking lot that is the roadmap for Phase 2
  • A mastermind group that meets every two weeks
  • The story you now get to tell — and the proof to back it up
After Action
What happens when you go home and keep building

Dave thought HomeSwerv was a six-week project. Hundreds of hours later it became an eight-platform network. Not because the plan failed — because the foundation worked and the vision kept expanding. That's what happens when a real builder engages with a real problem.

Phase 1 deploys on Day 4. The parking lot is your roadmap. Phase 2 builds on your own timeline. The mastermind group keeps you honest. The co-working sessions keep you building. The community stays active because everyone in it has done the same hard thing.

The guarantee

Complete all four days. Build every day of the week between. Do the work. If you leave Weekend 2 without a deployed Phase 1 application, you get your money back.

Nobody has collected on that yet.

The Prompt Library

Distributed before Weekend 1.
Used every day of the program.

The prompt library is organized by role and tool. You are not guessing how to use Claude, Perplexity, or ChatGPT. You are running proven prompts that Dave uses in production — adapted for the problems you'll encounter during the bootcamp.

Claude — Architecture
Design a Supabase data model for [X].
Show me the tables, columns, data
types, and relationships. Explain
the reasoning for each decision.
Perplexity — Market Research
What is the market size for [X]?
Who are the current players?
What do customers complain
about most?
Claude — Debugging
This code is supposed to [do X]
but instead it [does Y].
Here is the error: [error].
Here is the code: [code].
What is wrong and how do I fix it?
ChatGPT — Branding
Create a simple, professional
logo for [product name].
Style: minimal, modern, works
on light and dark backgrounds.
No text in the image.
Claude — Security Review
Review this code for security
issues before I deploy it.
I am especially concerned
about [X]. [code]
Claude — Scoping
Act as a product manager.
Define Phase 1 of [project].
What is the minimum version
that proves the concept?
What is NOT Phase 1?

Apply

Now you know
what you're signing up for.

8 seats. Application only. $4,500 solo, $7,000 for two. The only question left is whether you're ready to do the work.

Book a Strategy Call → ← Back to Bootcamp

dave@2weekai.com · responses within 24 hours