AI Builder Bootcamp
Eight weeks, ten-plus projects, one deployed product with real users.
Most people who "learn AI" end up with a folder of notebooks and nothing anyone uses. The bottleneck is never the model call — it is everything around it: auth, state, cost, the retrieval step that works on your five test documents and collapses on five thousand. This bootcamp is deliberately brutal about that. You build more than ten projects in eight weeks, in person, because shipping badly ten times teaches what shipping perfectly once never will. Week one you deploy something ugly to a public URL. By week eight you have an AI product with real users, a cost per request you can defend, and a monitoring dashboard that tells you when it breaks. The 1-on-1 architecture mentorship exists because architecture is where beginners lose months: they pick a vector database before they know their access pattern, or bolt an agent onto a problem a single function call would solve. We will tell you when your idea is over-engineered. This is an advanced track — it assumes you can already write code and read an API reference without hand-holding.
Prerequisites
- Comfortable writing code in at least one language (Python or JavaScript)
- Able to read API documentation without step-by-step guidance
- Basic Git and command line
- Availability for in-person sessions plus weekly live check-ins
What you can do afterwards
- Design and ship a full-stack AI application end to end
- Build a retrieval system that survives contact with real documents
- Decide when an agent is warranted and when it is over-engineering
- Deploy behind an API you designed, with versioning and fallbacks
- Defend your cost per request and cut it without losing quality
- Monitor a live product and diagnose failures from its traces
Sessions
Ship on day one
Before any theory, you put something live on a public URL. It will be ugly and that is the point: the deployment pipeline is a prerequisite, not a finale, and teams who leave it for the end never get there. Everything you build afterwards lands in a slot that already works.
Covered
Retrieval that survives real documents
RAG demos work on five clean documents and collapse on five thousand messy ones. You will build the pipeline properly: chunking that respects meaning, a vector store chosen after you know your access pattern, and an evaluation set that tells you whether retrieval or generation is at fault.
Covered
Agents, tools, and when not to use them
An agent is a loop with tools and a budget, not magic. You will build one that calls real functions, handles a tool that fails, and stops instead of looping forever. You will also learn the unglamorous lesson: most tasks people give agents are better served by one deterministic call.
Covered
Architecture review, 1-on-1
You bring your capstone design to a mentor and defend it. This is where over-engineering dies: the agent that should be a function, the vector database for four hundred rows, the fine-tune that a better prompt would beat. Expect your plan to shrink, and expect that to be the most valuable hour of the bootcamp.
Covered
Production: cost, monitoring, and the 3am question
A product with users is a different animal from a demo. You will instrument yours, watch what real people actually do with it, halve its cost, and answer the only question that matters at 3am: what broke, and how do you know?
Covered
Launch your own AI project: a full-stack product deployed to a public URL with real users, an architecture you defended in a 1-on-1 review, a documented cost per request, and monitoring that catches failures before your users report them.
Offered in
Questions
How much code do I need to know before starting?
Enough to build a small application on your own without following a tutorial line by line — one language, Python or JavaScript, plus Git and the command line. This is the advanced track: eight weeks and ten-plus projects leave no room to teach loops and functions. If you are not there yet, the earlier modules exist precisely for that, and arriving prepared is worth far more than arriving early.
Ten-plus projects in eight weeks — is that not too shallow?
That is the point, and it is deliberate. Most of the projects are small and disposable: you build a retrieval pipeline, break it, throw it away, and build a better one on Thursday. Repetition is what turns architecture from a topic you have read about into a reflex. Only the capstone is meant to last — the other projects are the reps that make it good rather than your first attempt at everything.
Will the stack we learn be obsolete in a year?
Parts of it, yes — specific libraries and providers move fast, and anyone promising otherwise is selling something. What does not move is the reasoning: how to scope a product, why an access pattern precedes a database choice, how to isolate a retrieval failure from a generation failure, how to defend a cost per request. Those transfer to whatever ships next. We teach a concrete stack because you cannot learn architecture in the abstract, not because the stack is the lesson.
Other modules
Ready to take this module?