Choose your course

What you'll build

• A deployed agent doing a real job on a schedule
• A single tool-calling agent that grows into a multi-agent workflow
• A packaged business Ops Agent handed to a non-technical user

Curriculum

1. What an agent actually is - LLM + a loop + tools + memory; goal in, actions out, when it stops
2. Your first tool-calling agent - function/tool calling, the agent loop, parsing tool requests, termination
3. Tools & integrations - connect web search, files, a database, a Google Sheet, email
4. Memory & context - short-term vs long-term, retrieval (RAG basics), managing the context window
5. Planning & multi-step reasoning - task decomposition, ReAct, reflection and self-correction
6. Reliability & guardrails - structured/JSON output, validation, retries, human-in-the-loop, cost control
7. Multi-agent systems - orchestrator + worker agents, handoffs, when multiple agents genuinely help
8. Deploy your agent - run it on a server/schedule, a minimal UI, logging and monitoring
9. Ship a real business agent - package the Ops Agent, hand it to a non-technical user, measure time saved

What you'll build

• The judgment to command an AI coding agent - read its code, catch its mistakes, ship faster and safer
• A live job pipeline run in parallel from week one (resume, outreach, applications, mocks)
• An agent-assisted capstone project for your portfolio

Curriculum

1. Complexity & the operator's eye - Big-O, arrays, hashing, two-pointers, sliding window; reading AI code. Job: resume + LinkedIn rebuilt for remote
2. Linear structures, search & trees - stacks/queues, binary search, linked lists, trees, tries. Job: remote-company list + referral outreach
3. Recursion, backtracking & graphs - subsets/permutations, BFS/DFS, topological sort, DP intro. Job: first applications go out
4. DP, greedy, heaps + first mock - knapsack/LIS/interval DP, greedy, heaps, intervals. Milestone: first timed DSA mock. Job: GitHub/portfolio polish
5. Low-Level Design (LLD) - OOP, SOLID, top 5 design patterns, API design. Job: STAR story bank, first screens
6. High-Level Design I - caching, databases, load balancing, CAP, back-of-envelope estimation. Job: phone-screen practice
7. High-Level Design II - message queues (Kafka vs RabbitMQ), sharding, rate limiting, idempotency, observability. Job: take-home playbook
8. System-design case studies - design Twitter, YouTube, Uber, Splitwise, Google Drive. Milestone: mock interviews with real engineers
9. The AI-command round (signature) - critique an agent's design, spot hallucinated APIs, find the bugs while they watch
10. AI pair-programming under pressure - spec -> generate -> review -> test loop; refactor, debug, security review. Job: final rounds
11. Targeted revision + your-stack depth - doubt-sheet sweep, CS fundamentals, resume projects deep. Job: negotiation + evaluating offers
12. Final mocks, capstone & close - full-loop mocks + agent-assisted capstone. Capstone: portfolio build + close the remote offer

What you'll build

• A small model built and trained end-to-end on a real GPU
• A neural net and training loop coded from scratch, then rebuilt in PyTorch
• A capstone ML project - classifier, embedding search, or generator

Curriculum

1. The map - what ML is, the faculties-of-mind frame, supervised / unsupervised / RL in one picture
2. The math you actually need - vectors, matrices, dot products, gradients, visual and intuitive
3. Intuition = function approximation - a neuron, a layer, a network, the forward pass, by hand
4. Getting better = gradient descent - loss, backpropagation, the training loop coded from scratch
5. From scratch -> PyTorch - the same network in a real framework on a real GPU; tensors, autograd
6. Meaning = embeddings & vector space - word and image embeddings, similarity, vector search
7. Imagination = generative models - autoencoders -> intuition behind diffusion -> a tiny generator
8. Attention & transformers - why attention won, and a minimal transformer block built piece by piece
9. Training in practice - data, overfitting, regularization, evaluation, the real GPU training workflow
10. A real ML project, end-to-end - pick a classifier, embedding search, or generator; train, evaluate, show

What you'll build

• A control policy you trained yourself in simulation
• A PPO-trained robot that learns to reach its goal
• Your trained policy exported, rendered, and viewed running in VR

Curriculum

1. Simulation & digital twins - why we train robots in sim first; what a physics simulator does
2. Isaac Sim / Isaac Lab setup (provided) - get into the NVIDIA stack on provided GPU
3. RL basics for control - agents, environments, rewards, episodes, aimed at movement not games
4. Designing the reward - the craft that makes or breaks a policy; shaping behavior through reward
5. Training your first policy - run PPO, read the curves, get a robot that learns to reach its goal
6. Sim-to-real concepts - domain randomization, the reality gap, moving a policy toward the real world
7. Teleoperation & VR embodiment - drive and watch the policy from a Quest headset
8. Deploy & view your trained policy - export the policy, render it, watch your trained robot run in VR

What you'll build

• A real VR/MR app running on your headset
• An app submitted to Meta's App Lab - something you can hand an interviewer
• Multiplayer, mixed-reality passthrough, and hand-tracking features

Curriculum

1. Setup - Unity, Quest & your dev environment; Unity 6 + Meta XR SDK, a room running on your headset
2. Your AI coding partner - building VR with Claude Code; the 5-part VR prompt template
3. Hands & controllers - hand tracking + controllers, grab/throw with physics, haptic feedback
4. VR UI - world-space menus, buttons & panels; poke + laser interaction without making people sick
5. Environment & audio - skyboxes, Quest-friendly lighting, particles, spatial audio
6. Locomotion - teleport, smooth move, snap turn, comfort vignette, letting the user choose comfort
7. Saving data & session logic - PlayerPrefs + JSON persistence, a Menu->Session->Summary state machine
8. Multiplayer basics - Photon Fusion free tier, networked head+hands avatars, spatial voice chat
9. Mixed reality & passthrough - Quest 3 passthrough, Scene API, spatial anchors
10. Performance & polish - profiler, draw-call batching, ASTC textures, holding 72fps, the Meta VRC checklist
11. Ship it - developer account, keystore signing, release APK, store listing, submit for review

What you'll build

• A complete, playable VR game on your headset - enemies, progression, game feel
• A Meta Store submission - the portfolio piece that proves you can ship, not just prototype

Curriculum

1. Game design for VR - the core loop, player fantasy, comfort-first design, scoping a game you can finish
2. Project architecture & your AI coding partner - scene/manager structure, game state machine, Claude Code
3. Player & game locomotion that feels powerful - smooth move, teleport, dash, climb; comfort options
4. Hands as gameplay - grab, wield, throw; two-handed weapons, physics interactions, holstering
5. Your core mechanic & game systems - health, score, combos, inventory; iterate one mechanic to fun
6. Enemy AI & combat - NavMesh agents, behavior state machines, wave spawning, melee + ranged, hit detection
7. Game feel & juice - haptics, hit-stop, particle FX, screen effects; making hits land
8. Spatial audio & adaptive music - 3D positional sound, dynamic music layers, audio cues
9. Levels & environment - level design for VR, set dressing, lighting and occlusion, a full playable level
10. In-game UI & menus that don't break immersion - diegetic HUD, main menu, pause, score screen
11. Save, progression & balancing - persistence, unlocks, difficulty curves, playtesting to fun
12. Optimize & ship to the Meta Store - hold 72 fps under combat load, build, store listing, submit

What you'll build

• A complete, playable flat-screen game with your own Blender-modelled 3D assets
• A game published to itch.io and ready for Google Play
• The full pipeline: art AND code AND ship

Curriculum

1. Game design & scope for a flat-screen game - genre, core loop, top-down vs 3rd-person vs 2.5D
2. Your toolchain - Blender + Unity + AI coding agents; how the three fit; project setup
3. Blender fundamentals - model your first game asset; low-poly, game-ready topology
4. UV unwrapping & texturing - UVs, materials, baking, PBR textures; look good AND run fast
5. Rigging & animation in Blender - armatures, skinning, idle/walk/run/action
6. The Blender -> Unity pipeline - exporting FBX/glTF, import settings, materials in URP, the round-trip
7. Player controller & camera - character movement, the new Input System, Cinemachine cameras
8. Core mechanic & game systems - the central mechanic plus health, score, inventory, iterated to fun
9. Enemy AI & challenge - NavMesh agents, behavior state machines, encounters by genre
10. Game feel, FX & audio - particles, juice, screen feedback, sound design and music
11. Levels, UI & progression - level design, menus and HUD, save systems, difficulty tuning, playtesting
12. Optimize & ship to PC + mobile - frame budget, draw calls, LODs, builds for PC and Android, publish to itch.io and Google Play

What you'll build

• A working AI video factory you own (the skill, not a subscription)
• Your first 3 published videos in any style - faceless explainers, motion-graphics, b-roll, shorts, bilingual
• A one-command, reproducible factory with presets per style

Curriculum

1. The AI Video Factory - the script-in/video-out model; the 5 layers (brain, voice, visuals, captions, compositor)
2. Your cloud GPU + the brain - cheapest GPU options (RunPod / Vast.ai / AWS); LLM + image + voice behind one proxy; cost control
3. Script -> narration - writing scripts for TTS; voice engines (edge-tts -> F5-TTS -> premium); per-scene audio
4. Visuals I - AI images - photoreal & stylized stills; prompt craft for b-roll; building a shot list
5. Visuals II - image -> motion - animating stills into living clips; subtle vs strong motion; multi-shot scenes
6. Captions that pop - word-synced kinetic captions (auto-timed); lower-third labels; fonts & styling
7. The compositor - layering background + overlays + captions + audio; clean export. Milestone: first complete faceless video
8. Music & sound, copyright-clean - AI music beds; ducking under the voice; why copyright-clean matters
9. Style 2 - motion-graphics / explainer - teaching diagrams, kinetic text, animated cards
10. Style 3 - shaders + the talking-head reality - audio-reactive backgrounds; the honest truth about AI talking-heads
11. Localization & reach - translate + re-voice into other languages with a one-swap workflow; bilingual channels
12. Automation & the one-command factory - templates, presets per style, batching, reproducible runs
13. Your factory, your way - tailor it to faceless YouTube, course/edu, product/marketing, social shorts; SEO basics
14. Productize - clients & B2B - packaging as a service; pricing; intake -> delivery; the support trap to avoid
15. Ship & scale - publishing workflow (YouTube API + scheduling); content calendar; 30-day plan. Capstone: publish your first 3 videos

What you'll build

• A working AI music factory you own
• Your own AI singer - a voice you own, consistent across every song
• Your first released tracks - songs, beats, focus/meditation, in 50+ languages, monetization-safe

Curriculum

1. The AI Music Factory - prompt/lyrics -> finished mastered track; the model landscape; copyright-clean = monetization-safe
2. Your GPU + the engine - cheap cloud GPU; install the copyright-clean engine (ACE-Step class); cost control
3. Prompting music: style & control - prompt craft for genre/mood/instruments/BPM; style presets; reference-style matching, legally
4. Songs with vocals & lyrics - AI-written lyrics; lyric -> full vocal song; 50+ languages; song structure
5. Any length: extend & structure - seamless crossfade extension; intros/outros; loop-ready beds; 2 min -> 1 hour
6. Focus / study / sleep + brainwave tones - isochronic & binaural (beta/alpha/theta); 432Hz; honest claims
7. Meditation, raga & wellness - 432Hz Indian-classical, sitar/sarangi healing, ambient drones. Milestone: a complete meditation track
8. Beats, lofi & instrumentals - lofi chill, hip-hop beats, instrumental beds for creators; stems
9. Build your AI singer I - record the voice; the recording protocol (consent, vowels & sargam, ~25-30 min)
10. Build your AI singer II - train & sing; voice-conversion (RVC) training. Milestone: a song in your own AI singer's voice
11. Precise melodies - singing synthesis (SVS / DiffSinger): render a melody you compose (MIDI) vs dice-roll generation
12. Mastering & polish - loudness (LUFS for streaming), EQ, stereo width, fades; final MP3 / WAV
13. Automate the factory - one-command presets per style; batching; templates; a repeatable pipeline
14. Publish & monetize, copyright-clean - distribution (DistroKid / YouTube / Spotify); proving tracks are clean; sync / licensing
15. Ship & scale - a release calendar; building a catalog; your AI singer as a brand. Capstone: release your first 3 tracks + your AI singer

What you'll build

• An AIPM one-pager that scopes a real AI product end to end (problem -> data -> approach -> metrics -> responsible-AI -> ops)
• A 'should this use ML / generative AI?' feasibility decision for one of your own features, with the non-ML baseline
• A data-readiness + responsible-AI ship-gate checklist applied to a live case

Curriculum

1. The AI PM mindset - the PM as translator between business value, user need, and what data makes possible; the 5 shifts an AI product forces
2. AI landscape I - AI vs ML vs DL vs Data Science; supervised / unsupervised / reinforcement learning; the 'is this even an ML problem?' checklist
3. AI landscape II + AI-first thinking - matching problem shape to model family; designing for the wrong answer, confidence in the UX, cold-start, the feedback loop
4. AI/ML strategy I - prioritizing initiatives by value x feasibility, build vs buy vs API, the non-ML baseline, and data foundations (quality, splits, leakage, bias)
5. AI/ML strategy II - the ML lifecycle / MLOps, model drift, latency-cost tradeoffs; the responsible-AI gate (fairness, privacy, explainability, human-in-the-loop)
6. Generative AI for product - generative vs discriminative, LLMs, hallucination and context window; the prompt -> RAG -> fine-tune ladder; prompt engineering as a craft
7. Reading a model - linear regression as the worked example: features, fitting, error, R-squared / MAE / RMSE, overfitting vs underfitting, trust the test set
8. Capstone - the reusable AIPM one-pager applied end to end to a real AI product