Your first AI script
Your own API key, your own code, calling a frontier model — before the first session ends.
free · open · hands-on · runs in your browser
Learn how AI actually works — by building it.
Six sessions, six things you ship. One weekend or six evenings. Any laptop. ₹0.
6sessions · 12 h50+live demos6things you ship₹0no card
you are the model · round 1/3
The capital of Tamil Nadu is
ChatGPT’s entire job: pick the next token. Your turn — tap your guess.
built at TCE Maduraitaught by a working CTOopen sourceworks offlineno trackers131 slides · 50+ live widgets6 labs · 6 notebooks · 6 cheatsheets₹0 · no card · any laptop
look inside
Eight real slides. Every one is a live widget.
what you ship
Walk out with six things you built.
Every session ends with working code in your hands — not notes about someone else's code.
S1 · predict
S2 · measure
An eval harness
A tester that measures whether AI answers are right — like an engineer, not a fan.
S3 · see
A vision app
Upload a photo, interrogate it. AI that reads documents, receipts and handwriting.
S4 · know
Chat with your notes
An AI that answers from your material — RAG, the pattern behind most real AI products.
S5 · act
A tool-using assistant
AI that calls tools your code controls — and the judgment to know when not to build an agent.
S6 · ship · capstone
A hardened, shipped app
Attack each other's apps, patch the holes, then demo a real product to the room.
play
Don't take our word for it. Touch the machine.
Two widgets lifted straight from the decks. This is how the course teaches: you play first, the explanation lands second.
Temperature — the randomness knob
Same prompt, same model, different answers. That is not a mood. The model never simply takes the best word: it rolls a weighted die. Temperature reshapes the dice before the roll.
the prompt
The capital of Tamil Nadu is ___
temperature T = 1.00
0.1 · same answer forever2.0 · anything goes
the model’s odds at this setting always adds to 100%
Every roll is a fresh draw from those odds. Roll twenty times and watch how often the underdogs win.
The six candidates and their starting odds are illustrative. What the dial does to them is exact: each probability is raised to the power 1/T and renormalised, which is softmax with the scores divided by T. T = 1 leaves the odds exactly as the model produced them, below 1 sharpens them, above 1 flattens them, and T near 0 is plain argmax: the top word, every single time.
Semantic search — meaning becomes coordinates
You ask in your own words. Your notes were written in someone else’s. Ctrl-F needs the exact word and comes back empty. Embeddings turn every line into coordinates, so the closest meaning still wins.
ask in your own words
step 1 · what Ctrl-F finds in your notes
Pick a question above. Ctrl-F hunts for its literal words and finds them in none of these six notes.
step 2 · the same 6 notes, ranked by meaning
0.00 unrelatedcloseness in meaning-space1.00 identical
The same six notes then get ranked by meaning, and the right one wins even with zero words in common.
These are real cosine scores from a live embedding model: every line turned into 768 numbers, measured once, frozen into this page. In session 4 you compute your own.
All of it on one worked example: a GPT that writes Thirukkural.
A real 164k-parameter model trained on the 1,330 kurals, running in your browser — tokens, embeddings, attention, prediction, fine-tuning, RLHF.
curriculum
Six sessions, one throughline.
Each session hands its verb to the next. Pick a node to open a session, see every slide, and tick it off when you've shipped its artifact — progress stays in this browser.
your progress0 / 6
S1session 01 · predict
29 slides · ~2 hHow Machines Learned to Talk
Next-token prediction, tokens, embeddings, attention, training vs inference — the whole engine, every idea a live demo, including a neural network you watch think.
you build: your first AI API call
S2session 02 · measure
21 slides · ~2 hTalking to AI, and Catching Its Lies
Prompt engineering that works, why polished prompts still lie beautifully, and how engineers measure quality with numbers instead of vibes.
you build: an evaluation harness
S3session 03 · see
17 slides · ~2 hAI Beyond Text
Vision that reads documents, diffusion that paints from static, voices cloned in seconds — and why it's all the same loop.
you build: a vision app
S4session 04 · know
20 slides · ~2 hGiving AI Your Own Knowledge
Embeddings, semantic search, chunking, and RAG end to end — the single most useful pattern in applied AI.
you build: chat with your own notes
S5session 05 · act
23 slides · ~2 hMaking AI Do Things
Tool use, the agent loop, MCP, why workflows beat agents most days — plus a frontier model running on a bare laptop.
you build: a tool-using assistant
S6session 06 · ship
21 slides · ~2 hBreaking, Securing, Shipping
Live prompt-injection attacks, defense in depth, what production actually costs — then you demo your capstone.
you build: a hardened, shipped app
colab notebooks for all six labs ship in the labs/ folder of the course repo · progress is saved only in this browser — nothing leaves your machine · ←/→ moves between sessions
format
One weekend. A rhythm, not a lecture.
Half the course is laptops-open lab time. The talks exist to make the labs land — not the other way around.
day 1 · sessions 1–3
Understand the machine
Next-token prediction, prompting and evals, vision and images. Overnight: bring your own documents for Day 2.
day 2 · sessions 4–6
Arm it, then ship it
RAG on your own notes, tool use and agents, security and production — ending in capstone demos.
This is for you if
- you can write a for-loop in any language
- you want to build things, not just read about them
- you have a laptop and a browser — that's the whole setup
Not for you if
- you want a certificate without building anything
- you want to train frontier models from scratch
- you expect a math-heavy ML course — one equation appears, once
the arguments
Every session stops once to pick a fight.
One deliberately debatable claim per session, defended on stage; the strongest counter-argument gets named on the closing slide.
session 01 · predict
If autocomplete can pass your exam, your exam was never testing understanding.
session 02 · measure
Hallucination is an expected failure mode. That does not make it acceptable.
session 03 · see
Your mother's voice is no longer proof of your mother.
session 04 · know
Your final-year project needs a user, a baseline, and a number — not a demo.
session 05 · act
Most production "AI agents" are a guarded while-loop in a trench coat.
session 06 · ship
There is no perfectly secure AI agent. Build one whose blast radius you can survive.
Why it's built this way.
This course exists to prove a point about teaching AI, and it wants to be copied.
Vote before the reveal
Every big idea arrives as a game: the room predicts, shouts, commits — then the answer lands. A brain that guessed wrong remembers forever.
Build before the jargon
Raw API calls before frameworks, your own retrieval loop before "vector database" is ever said. You earn every abstraction before you use it.
Honest failure is curriculum
Demos that can fail live stay in the deck. Hallucinations get measured, not apologized for. The fine print is taught with the magic.
Measure, don't vibe
"It worked when I tried it" is not evidence. From Session 2 onward, every claim about AI quality must survive an eval.
If you only listen, you forget. Here, everyone ships — in every session, on any laptop, for free.
Built by someone who ships this for a living.
Karthikeyan NGTEDx · SOA University
Karthikeyan NG heads engineering at Vision, a fintech and crypto platform in Dubai — where RAG pipelines, eval harnesses and agent guardrails are production reality, not slideware. Along the way: two startups founded, two published books on machine learning, eighteen hackathon wins, and stages at TEDx, Google, IIT Kharagpur and Seoul.
The course began where he once sat — an engineering classroom at TCE Madurai (CSE '09). He built the course he wishes he'd had, and credits most of what it teaches to the hundreds of things he shipped that failed.
the kit
Everything is in the box. Take it, teach it.
Six interactive decks, six labs with notebooks and handouts, six cheatsheets, a complete learning guide, per-slide timing, and instructor prep packs. Swap Madurai for your city and run it anywhere — there is a swap-kit for exactly that.
for students & self-learners
playHow a language model worksA real GPT trained on 1,330 Thirukkural couplets, running in your browser: tokens, embeddings, attention, prediction, pretraining, fine-tuning, RLHF, and the code to build your own
colabBuild your own poetOpens in Google Colab: upload one text file, press run, get a small language model that writes in its style — no programming needed
or download the .ipynb from the repo
guideLearning GuideEvery concept of the course, one honest document — plus a depth layer that goes to mechanism
buildCollege Project TracksWhere ideas come from, how to form the team, a twenty-idea wall, and engineering and research tracks with baselines, metrics, and ablations
sheetCheatsheetsOne printable page per session — start with Session 1
labLab handoutsStep-by-step, checkpoint-driven — start with Lab 1
setupAccess & fallback guideNo local install; check provider access, and the
rubricMOCK = True offline switch every notebook carriesCapstone rubricWhat a defensible project looks like — the 100-point breakdown your demo is graded on, in the Course Plan's Capstone section
careerPlacement RoadmapTwelve honest weeks from this course to an offer — including the Forward Deployed Engineer path
for instructors
howtoTeach This YourselfRun the course at any scale — college, meetup, company
planCourse PlanThe full design: goals, arc, capstone rubric
timingTiming GuidePer-slide budgets for all six sessions
deckHow a language model works — the deck18 slides, every widget live, speaker notes on S — the Thirukkural machine as a talk for any audience
deckPresenter modeOpen any deck, press S — timer, pace badge, speaker notes
prepDeep prep packsMaster every concept one level below the slides — start with Session 1
masterInstructor Mastery GuideThe layer above the prep packs: the mental model, every concept to mechanism level, a 140-question bank, the failure playbook, and the ten-day plan
localTeaching this elsewhereSwap-kit: what to localize, what is load-bearing, what not to touch
pdfAll notes, one PDF95 pages: mastery guide + six deep preps + run sheets + facilitation guide, printable
presenting? open any deck and press S for presenter mode — a live timer, per-slide budgets, a pace badge, and speaker notes · arrow keys navigate · F fullscreen · O overview grid
faq
The ones everyone asks.
Does it really cost nothing?
The designed path uses Google AI Studio's free tier and free Google Colab, but quotas, account access, and provider terms can change. Check access before class. If the live API is unavailable, set MOCK = True in Cell 1 of any notebook to run the offline path: every cell then runs on canned responses (prefixed [MOCK]), so the lab still teaches its lesson at reduced fidelity.
How long does it take self-paced?
About two hours per session — roughly an hour of deck and an hour of lab. Six evenings, or one weekend. Every lab has checkpoints, so you can stop mid-way and pick up where you left off; tick sessions off in the curriculum above and this browser remembers.
What laptop do I need?
Anything that opens a browser. All heavy computation happens in Google's cloud; your machine just needs a keyboard and Wi-Fi. A ₹15,000 laptop is exactly as capable here as a MacBook Pro.
Do I need math or ML background?
One line of school math appears in the whole course: y = wx + b. If you can write a for-loop in any language, you have every prerequisite.
Do I need to be in Madurai?
No. The course was born in a classroom at TCE Madurai, and the examples carry that accent on purpose — jigarthanda, Meenakshi temple, the college's own rules as a RAG corpus. Every one of them is swappable; LOCALIZATION lists what to localize and what is load-bearing. The Madurai flavour is the point, not the barrier.
Can I self-study without an instructor?
Yes. The decks are self-contained and interactive, every lab has a step-by-step handout with checkpoints, and pressing S in any deck shows the full speaker narration. The Learning Guide covers every concept in prose.
Is it too basic for someone who already knows some ML?
The main line is built so anyone can follow it. Underneath, every deck carries collapsible depth panels — press D on a slide — that go to mechanism: logits and softmax, positional encoding and attention’s n² cost, the KV cache behind every latency and caching claim, MoE and distillation, reranking and cross-encoders, retrieval metrics, agent trajectory evaluation, and why prompt injection has no fix. They are collapsed by default, so they never slow the room down. Part 8 of the Learning Guide is the same material in prose.
Is my data private on free tiers?
Assume free-tier conversations may train future models. The course drills one rule from Session 1: never paste anything you couldn't survive seeing on the front page of the newspaper.
Can this become my final-year project?
That is half the point. The scoping rule: one user, one data source, one measurable claim. Your Session 4 RAG notebook plus Session 2's eval harness is already the skeleton; what turns it into a project is a person-written test set, a baseline you beat, documented failures, and cost/latency arithmetic. College Project Tracks gives scoped codebase RAG, multimodal document QA, evaluation dashboards, department knowledge services, and subject-tutor ideas. Learning Guide 7.5 explains the measurement principle.
I want to do research. Where does this lead?
To measurement, which is where application-layer research lives. The course already teaches the method: baselines, one variable at a time, sample size, spread over mean. Learning Guide 7.6 shows where papers appear and how to read them. Good student research questions include multilingual evaluation, chunking strategies, judge bias, and injection-defense measurement.
Can I teach or translate this?
Please do — that's the point. Teach This Yourself covers running it at any scale, and the Madurai references are designed to be swapped for your own city's.
You came as a user. Leave as a builder.
Six sessions. Six things you ship. One honest claim: after this you can explain how a language model works — and build something on top of it that you can measure.