Learn to think in systems before you command the machines.
Anyone can make AI produce code. Almost nobody starting out can tell whether that code is right, safe, or sane — and that gap is the difference between a builder and a bystander. This course builds the foundation the AI era actually demands: mental models first, machine leverage second.
Why this course exists
A beginner with an AI assistant can produce more code in a weekend than a 2015 bootcamp student produced in a month. Producing it isn’t the problem anymore. Understanding it — debugging it, securing it, changing it without breaking it — is.
Most beginner courses respond in one of two bad ways: pretend AI doesn’t exist and teach syntax drills, or lean on AI so hard that graduates can’t function when it’s wrong. Both produce people who stall at the first real problem.
This course takes the third path. You build genuine mental models — how programs run, how the web fits together, how engineers decompose problems — and then, deliberately, you learn to multiply that understanding with AI tools. Understanding first isn’t nostalgia. It’s what makes the leverage usable.
Fit matters
Small cohorts mean we’d rather turn you away than waste your next 8 weeks. Read both lists honestly.
Expected outcomes
Outcomes are written as capabilities, because that’s what reviews test and what employers probe.
Read, write, and debug real programs — and explain them line by line
Decompose fuzzy problems into buildable pieces, the core skill AI can’t do for you
Understand how the web actually works: requests, servers, databases, deployment
Build and ship a full-stack application end to end
Use AI coding tools with supervision discipline: prompt, verify, correct, repeat
Enter AI-Native Software Engineering — or any serious learning path — with real footing
The learning journey
Every phase has an entry state, an exit state, and a Waypoint Review gating the way forward — so progress is never a feeling, it’s a fact.
Weeks 1–3
Programming mental models, problem decomposition, and tool fluency — with AI used only as an explainer while your own models form.
Waypoint 1 · The Glass-Box Build
Build a command-line tool, test it, and walk a mentor through every line. Nothing in it may be a mystery to you.
Weeks 4–6
How the pieces of an application fit: HTTP, data, APIs, and interfaces — the map every engineer carries.
Waypoint 2 · The Working System
A working API and database behind a simple interface, demoed live — including tracing one request through every layer, out loud.
Weeks 7–8
The deliberate inversion: now that you can verify, you learn to delegate. AI-paired building of a full project, with supervision discipline as the graded skill.
Waypoint 3 · Summit — The Supervised Build
A full-stack app built AI-first, deployed, and defended: you present what the AI did, what you corrected, and how you knew.
The curriculum, week by week
Lesson-level detail is refined with each cohort; the weekly structure below is the commitment.
Wk 01
How programs actually run: values, control flow, and the machine’s point of view
Ships: First working programs + terminal and Git set up for real
Wk 02
Decomposition: turning fuzzy problems into steps a program can take
Ships: A small tool built from your own written plan
Wk 03
Debugging as method: hypotheses, evidence, and reading error messages
Ships: The Glass-Box Build, ready for Waypoint 1
Wk 04
The web’s contract: requests, responses, and what a server really is
Ships: A tiny server you built and can interrogate
Wk 05
Data: modeling the world in tables, and talking to a database
Ships: Your API storing and serving real data
Wk 06
Interfaces: enough frontend to make a system usable
Ships: The Working System, ready for Waypoint 2
Wk 07
AI-paired building: prompting, reviewing, and correcting generated code
Ships: Summit project core built with documented AI collaboration
Wk 08
Shipping: deployment, polish, and the honest retrospective
Ships: Summit deployed and defended; build log complete
Projects
Every phase produces something reviewable; the Summit produces something you defend.
Phase 1
A real command-line tool where every line is yours to explain. The anti-black-box exercise.
Phase 2
An API, a database, and an interface that fit together — and a map of how.
Summit project
A deployed full-stack app built with AI leverage and human verification — your first act of AI-native engineering.
Mentorship
Small pods, senior mentors, and promises with numbers attached — mentorship here is a system, not a Slack channel.
You’re placed in a pod of six in week one and climb with them to the end. Small enough that your absence is noticed; strong enough to survive a hard week.
A live session with your pod mentor every week: demos, unblocking, and group review of real work.
Thirty minutes with your mentor, agenda owned by you — career, code, or the thing you’re stuck on.
Every weekly deliverable gets a real review — line comments and questions — within one day. That’s a promise, not an aspiration.
Twice a week, drop in with anything. No booking, no agenda.
Foundations mentors are chosen for teaching ability first — patient, Socratic, and allergic to letting you cargo-cult.
Extra structure for beginners: guided pairing sessions in weeks 1–2 so nobody stalls at setup.
The Ship Week Rhythm
Courses fail when weeks drift. Ours can’t: every week ends with something shipped, and going quiet triggers a human, not a reminder email.
You post the week’s targets to your cohort space. Everyone sees them.
Three times a week, two sentences: what moved, what’s stuck.
The week’s increment goes up for review and gets demoed in your pod. Shipped beats perfect.
Silent for two days? A mentor reaches out personally. Not a bot — a person who knows your project.
Your public record of the whole journey — and the proof of work employers actually read.
Waypoint Reviews
No exams. Each phase ends with a Waypoint Review — you present working software against a rubric published on day one, the way real engineering teams review real work.
Forty-five minutes: you demo the milestone, walk the code, and answer questions about why it’s built the way it’s built.
Functionality, code quality, AI-collaboration quality, and reasoning under questions. No surprises, no trick questions.
Prompt hygiene, verification discipline, knowing when not to use the tool — assessed explicitly, because that’s the craft now.
Miss a waypoint and you get a week to close the gap, like a returned pull request. Rigorous, not punitive.
From the trail
“Phase one banning AI from writing my code annoyed me — until phase three, when I could suddenly tell exactly when the machine was lying to me. That ordering is the whole course. My Summit app is deployed and I can defend every line.”
Career switcher from finance · Software Foundations
Pricing
No fake discounts, no upsells inside the course, no “premium tier” of attention. Everyone gets the whole thing.
Software Foundations for the AI Era
₹45,000
Or 3 monthly installments of ₹16,000
One-time, all-inclusive. The shorter, lower-commitment path — if you know you want the whole climb, the flagship costs less than Foundations plus the flagship separately.
Every cohort reserves need-based scholarship seats. If the price is the only thing stopping you, apply anyway and say so.
Questions, answered straight
Yes — the course assumes zero experience and a real appetite for work. What it doesn’t assume is that you need to be “technical by nature.” Decomposition, debugging, and systems thinking are trainable skills, and the pod structure exists so you never stall alone.
Because supervision requires understanding. For three weeks AI acts as your explainer, not your author, while your mental models form. Then we invert it deliberately in phase 3 — and the leverage lands, because you can now tell right from plausible.
Bootcamps optimize for placement statistics; we optimize for capability. Eight honest weeks, no job guarantee, no fake discounts — and a curriculum built around understanding-then-leverage instead of framework drills. Graduates typically continue into AI-Native Software Engineering.
Python for the thinking and backend phases, plus enough HTML, CSS, and JavaScript to build real interfaces. The point is the mental models — they transfer to any stack you meet next.
It’s demanding but designed for it: 12–15 hours a week, live sessions in working-professional hours, everything recorded, and the Ship Week Rhythm keeping you honest. If your next two months are already chaos, wait for a later cohort.
Every session is recorded and available the same day. Live attendance is strongly encouraged — the studio format is interactive — but the program is built to survive real life and real time zones.
Cohorts are scheduled around Indian evenings and weekend mornings (IST), which also works for the Gulf and Southeast Asia. Everything is recorded, and async reviews mean your work never waits for a meeting.
Full refund within the first two weeks of the cohort, no questions and no forms-designed-to-exhaust-you. After that, fees are non-refundable but you can defer to a later cohort once, free.
Yes — installment options are listed with each course’s pricing, and every cohort reserves need-based scholarship seats. If price is the only thing stopping you, apply and say so plainly.
Graduates receive a completion credential — but the artifacts that actually open doors are the ones you build: a public build log, defended projects, and a published case study. We optimize for those.
Working developer → AI-Native Software Engineering. New to code → Software Foundations. Already AI-native and choosing a depth → the specializations. Bringing a whole team → For Teams. Still unsure? Write to us with two lines about where you are; a human replies.
Cohorts are capped at 24
Applications take ten minutes and are read by an engineer. If a different course fits you better, we’ll tell you straight.