
Quick Verdict: If you want to build real products with large language models and learn from people who have actually shipped them, Stanford CS 224G is the best hands-on AI course at Stanford right now. It skips the theory and goes straight to building: agent workflows, voice AI, production deployments, the full stack. You don’t leave this class knowing theory. You leave with a shipped product and a Pitch Day audience of investors.
Stanford offers a lot of AI courses. CS229 covers machine learning fundamentals. CS224N covers natural language processing. CS336 builds language models from scratch. But none of them answer the question that matters most to builders in 2026: “How do I take a language model and turn it into an actual product people pay for?” That’s the gap Stanford CS 224G fills.
I took a close look at the syllabus, the instructor background, the project structure, and how it compares to Stanford’s other AI offerings. Here’s what I found.

This course is a project-based class at Stanford’s Computer Science department focused entirely on building and scaling applications powered by large language models. It ran for the first time in the Winter 2025-2026 quarter: January 6 to March 12, 2026, with a Demo Day on March 19.
The class meets twice a week, Tuesday and Thursday 10:30-11:50 AM, in person at 420-040. Attendance is mandatory and classes aren’t recorded or streamed. That’s by design. The course runs like a startup incubator, not a lecture hall. You form teams of 2-5, work through four two-week sprints, and present your progress at each checkpoint.
The instructors are John Whaley and Jan Jannink, both CS PhDs from Stanford with multiple startup exits between them. John founded Inception Studio after selling UnifyID and Redcoat. Jan founded Synthpop AI after his exit from VoiceBase. These aren’t academics who read about startups. They have been through it.
The course description frames it in an interesting way. It calls the class “managerial training for an army of AI agents.” The idea is that you aren’t just learning to code with LLMs. You’re learning to orchestrate them: treating the model as a CPU and the conversation as code. That framing is what separates CS 224G from every other AI course at Stanford.
The class is structured around four sprints, each building toward the final Demo Day. Every sprint ends with a presentation where teams show working prototypes and get feedback from instructors and guest lecturers.
Sprint 1 (Weeks 1-3): Context engineering and RAG architecture. You start with project ideation and team formation, then move into the core skill set every LLM builder needs: managing context windows, prompt injection defenses, system prompt design, and the “compiled request” model. The focus is on making LLMs reliable, not just impressive.
Sprint 2 (Weeks 4-6): Agentic workflows and production evaluation. This is where things get interesting. Guest lecturers from Vunda AI and real-world product builders walk through agent architectures (ReAct, multi-agent systems), orchestration frameworks (LangGraph, CrewAI), and the Theory of Constraints for LLM products. You also get a dedicated session on code generation with LLMs from a guest lecturer who built production coding agents.
Sprint 3 (Weeks 7-8): Agentic orchestration with PydanticAI and data strategy. A guest lecture from Dryft shows how to build production-ready agents for manufacturing. John covers data moats, feedback loops, and the data flywheel effect: how companies like ElevenLabs and Harvey AI build defensible advantages in the age of generative AI.
Sprint 4 (Weeks 9-10): Realtime voice AI, safety, and pitching. A hands-on workshop covers building voice AI apps with WebRTC integration. The final week includes a lecture from Dalton Caldwell (Standard Capital / YC) on how investors evaluate AI startups, followed by Demo Day where teams pitch to an audience of investors and entrepreneurs.
| Component | Weight | Details |
|---|---|---|
| Participation | 10% | Class attendance and Slack engagement |
| Sprint Checkpoints | 45% | 3 bi-weekly demos and code reviews (Sprints 1-3) |
| Demo Day + Final | 45% | Technical excellence, product thinking, presentation |
The grading breakdown tells you everything about the course philosophy. There are no exams. No problem sets. No final paper. Your entire grade comes from building something real and presenting it well. That’s either terrifying or liberating depending on your learning style.
| Course | Focus | Best For | Workload | Prerequisites |
|---|---|---|---|---|
| CS 224G | Building and scaling LLM applications | Product builders, founders, engineers who want to ship | High (project-based, 4 sprints) | Python + ML fundamentals |
| CS336 | Language modeling from scratch | Researchers, ML engineers who need to understand internals | Very high (implement a full transformer) | Strong math + systems programming |
| CS146S | AI coding agents | Developers who want to build developer tools | Medium (coding agent projects) | Strong software engineering background |
Here’s the honest breakdown. CS336 is the deepest of the three. You implement a full transformer, train it, and learn everything about how language models work under the hood. It’s an incredible course for researchers and engineers who want to work on model architecture. But it won’t teach you how to ship an LLM product.
CS146S, run by Chris Ré and his team, focuses specifically on AI coding agents: tools that write code. It’s a great pick if you want to build developer tools like Cursor or Copilot. But it’s narrower in scope than CS 224G.
This course is the broadest and most practical. It covers the full stack from prompt engineering to production deployment to investor pitching. If your goal is to start an AI company or build LLM-powered products, this is the one. If your goal is to understand the math behind attention mechanisms, take CS336. Different tools for different jobs.

| Pros | Cons |
|---|---|
| Instructors have real startup experience: not just academic theory | No recordings or remote option: you must attend in person |
| Project-based with real investor audiences at Demo Day | Prerequisites are steep without formal CS background |
| Covers the full LLM stack: context engineering, agents, voice, safety, pitching | 3-4 units of work can be intense alongside other classes |
| Guest lecturers from companies actively building in AI | First run of the course: some lectures may still be evolving |
| No exams or problem sets: pure build-and-present | Team-based grading means outcomes depend on team dynamics |
The biggest downside is the lack of recordings. For a course covering the latest AI content, having no remote access or recorded lectures limits who can benefit. The instructors made this choice deliberately: the class is designed for in-person interaction and startup-style energy. But it’s worth knowing going in.
This isn’t a course you can coast through. Here’s what I would recommend based on the syllabus structure:
Come with a project idea. The first lecture includes student project pitches. If you walk in with a rough idea of what you want to build, you’ll save weeks of indecision. Read the project guidelines before the first class and have a contender ready.
Pick your team carefully. The course encourages teams of 2-5. Your grade depends heavily on team output. Find people with complementary skills: someone strong at frontend, someone who understands the backend, someone who can speak to the product vision. A well-rounded team produces a much stronger Demo Day project.
Use the office hours. John, Jan, and the TAs hold office hours every week. The instructors are serial entrepreneurs. They can help with product strategy, technical architecture, and even investor connections. Treat office hours as free consulting. For more context on choosing the right Stanford AI course for your goals, check out our guidance on comparing AI programs.
Go to every guest lecture. The guest speaker lineup is stacked. Ryan Brandt from Vunda AI, Andy Bromberg on the Theory of Constraints, Dalton Caldwell from Standard Capital. These aren’t filler sessions. The guest lectures cover the real-world challenges of building AI products that the core lectures skip over.

Stanford CS 224G fills a gap that has been open for too long. There are plenty of courses that teach you how transformers work or how to train a language model. There are very few that teach you how to take a language model, wrap it in a product, and get people to pay for it. That’s what this course does.
If you’re a Stanford student wondering whether to take CS 224G next quarter, the answer depends on what you want. Do you want to understand the math of attention? Take CS336. Do you want to build the next great AI product? Take this class instead. Its real strength isn’t just the syllabus but the network: the instructors, the guest speakers, the Demo Day audience. These are the people funding and building the AI industry in 2026.
And if you aren’t a Stanford student? The course materials aren’t publicly available, but the syllabus itself tells you what the industry values. Learn context engineering. Build agents. Ship real products. The same skills the course teaches are exactly what the AI job market demands right now.
You need Python proficiency (CS 106B or equivalent), ML fundamentals (CS 221 or CS 229 level), and experience with PyTorch, TensorFlow, or JAX. Students with substantial practical LLM experience can get instructor permission without formal prerequisites.
No. The course is in-person only, attendance is mandatory, and lectures aren’t recorded or available via Zoom. This is a deliberate choice to maintain the startup-incubator atmosphere.
It teaches you to build applications with LLMs. CS336 teaches you to build language models from scratch: implementing a full transformer, training it, and understanding internal architecture. They complement each other but serve different goals.
Students form teams of 2-5 and build LLM-powered applications over four sprints. Past projects span agentic workflows, voice AI, RAG systems, and AI-native products. All projects culminate in Demo Day where teams present to investors and entrepreneurs.
John Whaley and Jan Jannink. Both hold CS PhDs from Stanford and have founded multiple startups. John exited UnifyID and Redcoat before founding Inception Studio. Jan exited VoiceBase and founded Synthpop AI.