Everyone is now expected to work alongside AI, almost nobody was taught what it actually is, and the gap between the two is where bad grades, bad hires and bad decisions happen. This course closes that gap in ten modules and forty lessons: first the honest technical foundation — what AI, machine learning and deep learning really mean, how a neural network learns, how a large language model reads text and predicts tokens, and how a frontier model is built from internet-scale pretraining through supervised fine-tuning to RLHF. Then the practical half: prompting that works (structure, system instructions, few-shot examples, step-by-step reasoning, iteration like debugging), the tools landscape (chat vs coding vs search, media generation, free vs paid vs local), and the everyday uses that matter — research, learning code, drafts, exam prep and resumes — each welded to a verification routine rather than a leap of faith.

The last stretch is the part most courses skip: limits and safety (hallucination, bias, privacy, academic integrity, deepfakes, the honest jobs picture) and then your own practice — workflows with humans placed where the stakes are, a prompt library you reuse, rubrics for judging output, and a short ethics code you wrote yourself. It ends with a capstone that is a real artifact, not a quiz: five AI use-cases you actually ran, ten prompts with before/after evidence, your verification checklist, one hallucination you caught, and the rules you will keep. The certificate is issued for that document, not for notes about it.

**Who this is for:** any student — any branch, technical or not — who uses (or is expected to use) AI tools and wants to know what they are doing when they do; placement-prep students who need AI literacy for aptitude rounds and interviews; working professionals who must supervise AI output rather than be supervised by it.

**What you need:** no mathematics, no programming, no prior AI course. A browser, and — for the practice lessons — access to any free AI chat tool. Everything else is taught here from first principles.

From "what is AI" to a toolkit you actually run — how the models work, how to prompt them, how to verify what comes back, and how to keep your name on work you can defend

AI Literacy for Everyone

Every AI course starts by assuming you already speak Python. This one does not. It is the complete zero-to-first-model path in ten modules: the language itself (variables, strings, structures, functions, control flow, errors), the two libraries AI work actually runs on (NumPy at array speed, pandas on real tables), how to look at data without lying to yourself (honest charts, file and API workflows, a re-runnable cleaning pipeline), the statistics every model sits on (mean, variance, distributions, correlation versus causation), and finally scikit-learn — where you split honestly, beat a baseline, and read your first LinearRegression and DecisionTree with the numbers they deserve.

Every lesson follows the same nine steps (objective, hook, concept, worked example, practice task, common mistakes, exam/interview angle, four-question quiz, summary), so the format never becomes another thing to learn. The course ends with a capstone: one notebook, a stranger can run it top to bottom, and it goes from raw data to a defensible model verdict — the artifact you show, not the notes you took.

**Who this is for:** any student — any branch — who was told to "learn Python for AI" and wants one honest course that finishes with a real pipeline, not a certificate for watching videos.

**What you need:** a browser (Google Colab needs zero install) or any machine that can install Python 3.9+. No prior programming assumed.

Forty lessons from your first print() to a shipped end-to-end notebook — Python, NumPy, pandas, honest charts, core statistics and your first scikit-learn models

Python for AI

Everyone can call an API; almost nobody designs what sits around the call. The difference shows up as bots with amnesia, JSON that half-parses, tool loops that retry into hallucination, and a first invoice nobody budgeted for. This course builds that surrounding system in ten modules and forty lessons.

Modules 1 to 5 fix the shape before the code. Module 1 places the model in an architecture: why message-based chat displaced completions, why streaming is an architecture decision rather than polish, why the model remembers nothing and your state layer must remember everything. Module 2 is API engineering: credentials with least privilege, the parameters that actually shape output, structured responses, and the failure surface — errors, backoff, rate limits, idempotency, provider abstraction. Module 3 is the AI surface: rendering tokens and surviving partial JSON, surfacing the model's own hedges honestly, error states with distinct language, and feedback loops that feed your eval set. Module 4 treats the context window as what it is — a scarce, metered resource — covering system contracts, memory strategies, token budgeting and truncation. Module 5 is the bridge to shipping: the request lifecycle as named testable stages, prompts as versioned config, model-and-task fit including when not to use an LLM at all, and the thin slice with a real baseline.

Modules 6 to 10 are the production half. Module 6 turns the model into something that acts: JSON-schema tool contracts, the deterministic split between what the model judges and what code computes, confirmation flows for irreversible actions, and tool errors as structured feedback. Module 7 makes extraction a data source: schemas the model can fill honestly, validation with bounded repair, the PDF/OCR path, confidence and entity resolution. Module 8 builds the discipline: golden sets, LLM-as-judge with its bias traps, regression tests in CI, tracing every call, and the eval-to-fix loop. Module 9 changes the threat model: direct, indirect and multi-turn injection, exfiltration and secrets hygiene, quotas and moderation, and a one-page abuse-case threat model with owners and a kill switch. Module 10 closes the gap between demo and product: latency decomposed, caching at three levels, batch, routing and scaling — capped by a capstone that ships a full mini-app end to end.

**Who this is for:** full-stack and backend developers adding AI features; technical founders building an LLM product; engineers moving from notebook demos to services with budgets and alerts.

**What you need:** proficiency in Python or JavaScript, and basic comfort with HTTP APIs. No prior LLM experience — every provider-specific detail is hedged against its docs, because those move.

Architecture, API engineering, UX, context, tools, extraction, evaluation, safety and cost — forty lessons to shipping an LLM feature that survives production

Building Apps with LLMs

Most GenAI courses stop at the demo: a prompt that worked once, a slide about transformers, a list of tools. This one starts where those end. Forty lessons, ten modules, one exam bank and a capstone that forces the whole thing into a single defensible document — the spec you would actually put in front of a team.

It runs from the generative landscape (GANs, VAEs, diffusion, the transformer, foundation models) down into LLM mechanics — tokenization, embeddings, the sampling pipeline, the KV cache — then out to the decisions engineers actually make: open versus closed weights, small models versus frontier APIs, context windows, image/audio/video pipelines. From there it is reliability (hallucination, grounding, structured outputs, guardrails, evals), cost engineering (token arithmetic, caching, routing, quality-per-rupee), applied patterns (summarization that keeps the numbers, extraction, classification, code generation with tests as the oracle), safety and compliance (memorisation, copyright, data governance, DPDP and the EU AI Act), and a capstone that assembles all of it into a spec with a cost model, a failure register and a rollout plan.

**Who this is for:** anyone who has taken a basics GenAI course — or watched a demo — and wants the engineering underneath it. Developers shipping features, students preparing for AI rounds, product people who must evaluate a vendor's claim, and anyone tired of "the model said so".

**What you need:** basic AI literacy (you know what an LLM is and have used a chat assistant). No coding required — the Python snippets are read-only worked examples. You will write, not code, for the capstone.

Forty deep lessons from generative foundations to a production GenAI spec — mechanics, models, reliability, cost, applied pipelines, safety and compliance

Generative AI Essentials

Most people meet machine learning as a library call: fit, predict, submit. This course treats it as a discipline of decisions — which problem shape you have, which metric your errors actually cost, which split your data allows, when the number you are quoting is noise, and what happens to the model on the Tuesday after it ships. Forty lessons, ten modules, one level: intermediate, with Python and basic statistics assumed and nothing else waved through.

Modules 1 to 5 build the modelling core. Module 1 fixes vocabulary and honesty — the four task families, the three paradigms, features versus labels with prediction-time availability, the leakage taxonomy and the baseline you must beat. Module 2 is data work in service of a model: EDA with a purpose, missing data without leakage, encoding and scaling with the reasoning that explains why trees shrug, and surviving 99:1 datasets with splits that do not lie. Modules 3, 4 and 5 carry the classical toolkit — linear and logistic regression with hand-computed gradient steps and odds ratios, decision trees with Gini arithmetic, random forests and boosting, then k-nearest neighbours, naive Bayes, support vector machines and PCA.

Modules 6 and 7 turn modelling into evidence. Module 6 derives every metric from the cost of errors — the confusion matrix and its prices, PR versus ROC at rare base rates, MAE versus RMSE, cross-validation against baselines. Module 7 names the two failure modes and their levers (bias and variance, learning curves), the regularisation dial across model families, the three species of hyperparameter search with their budget arithmetic, and the honest reading of feature importance. Module 8 works without labels — k-means and choosing k honestly, hierarchical dendrograms, anomaly detection under an alert budget, and the strict list of sentences a t-SNE plot is allowed to claim. Module 9 is production: drift with PSI arithmetic and root-cause-first repair, the monitoring stack including slices and training-serving skew, fairness with its incompatibility limits, and the judgement of when rules beat models. Module 10 closes with the lifecycle itself, experimentation hygiene, the model card, and a capstone where you defend an end-to-end system under attack.

Every lesson runs the same nine steps — objective, hook, concept, worked example with real arithmetic, practice task, common mistakes, exam/interview angle, a four-question quiz, and a revision summary — and every module feeds a 30-question final-exam bank drawn as a balanced 15-question paper. You finish with a certificate gated on defending a real project, and with the classic interview questions answered from memory with numbers behind them.

From "what is a label" to defending a deployed system — the forty-lesson path through modelling, evaluation, tuning, production and interviews

Machine Learning Fundamentals

Everyone writes prompts; almost nobody engineers them. The gap shows up as generic drafts, JSON that half-parses, agent loops that retry into hallucination, and "the model is bad" verdicts that a five-minute diagnosis would have replaced with a specification fix. This course closes that gap in ten modules and forty lessons — taught as one continuous craft, not a bag of tricks.

Modules 1 to 5 build the foundations from first principles: what each message role actually does and who wins when seats contradict; the role/task/constraints/format skeleton and the discipline of spending tokens only where they change output; few-shot examples as conditioning — how to choose them, how many, and why demonstrated behaviour outranks prose; the reasoning toolkit (chain-of-thought, staged decomposition, self-consistency voting, self-critique, step-back) with honest costs and failure modes; and the professional frame: prompts as programs over a probabilistic interpreter, iterated with test sets, version discipline and a failure taxonomy that turns every error into an action.

Modules 6 to 10 are the production half. Module 6 turns output into contracts: JSON mode versus schema-constrained decoding, choosing shapes by consumer, tool schemas with a decides/computes split, and bounded validation loops. Module 7 covers code prompting: specs that pin edge cases, test-first generation, refactoring under invariants, debug loops with repo-context engineering, and review prompts with a severity taxonomy. Module 8 handles long documents: summarization patterns, semantic chunking with stitching state, RAG context packing with citations and refusal clauses, and the needle-trap and injection-fence discipline. Module 9 is agent-style prompting: tool instructions as decision rules, plan-first contracts with replan triggers, class-mapped error recovery with an intermediate state block, and verification loops tied to the eight-class agent failure taxonomy. Module 10 makes it measurable and defensible: golden sets that turn vibes into regressions, A/A-then-A/B methodology and version records, an injection taxonomy with layered defenses, and production hygiene — libraries, templating, caching, cost per resolved task — capped by a full prompt pack for one real use-case.

Every lesson runs the same nine steps — objective, hook, concept, worked example with real before/after prompts, practice task, common mistakes, exam/interview angle, quiz, summary — and every worked example is something you would actually ship, not a toy that flatters the technique.

**Who this is for:** developers building LLM features who need structured outputs, tools and evals rather than vibes; content creators and analysts who use AI daily and want reliable, reusable workflows; students and placement-prep candidates who will be asked how to make a model do a specific job; anyone who has said "the model is bad at this" and wants the diagnostic that proves it usually is not.

**What you need:** comfort using any AI chat tool; no programming required (code lessons are explained line-by-line and the techniques apply with or without a code harness); a willingness to test claims against small fixed sets instead of vibes.

From first principles to production: structure, few-shot teaching, reasoning, structured outputs, code, long context, agents, evaluation and a prompt pack you can defend

Prompt Engineering Masterclass

Deep learning is not a bag of architectures — it is one chain of ideas: the chain rule makes layers learn, scale makes gradient descent survive depth, convolutions and attention are two answers to the same locality-and-relationship problem, and every training run since 2015 is the same loop with better bookkeeping.

This advanced course walks that chain end to end in forty lessons across ten modules. Modules 1–5 build the foundations and the vision/sequence/transformer stack with hand-computable arithmetic at every step. Modules 6–10 go where most courses stop: embeddings and contrastive learning, the full LLM training pipeline (data, tokenizer, scaling laws, post-training), decoding and diffusion, PyTorch as an engineering system (autograd, data loops, AMP, checkpointing), and finally the economics — compression, serving, honest evaluation, and a capstone design document with every number attached.

**Who this is for:** final-year students and engineers who can already train a model with a tutorial and now want to know exactly what happens inside it — and to pass the interviews that ask.

Forty lessons from the perceptron to shipped transformers — backprop by hand, attention arithmetic, LLM training pipelines, PyTorch debugging, and a capstone you can defend line by line

Deep Learning with Neural Networks

Generative AI stopped being a novelty and became a baseline skill on job descriptions. This course gives you the mental model and the working habits: how language models actually predict text, why they hallucinate, how to write prompts that behave like briefs, how retrieval-augmented generation grounds answers in real documents, and how to evaluate, cost and secure a GenAI feature.

Four modules, eight lessons on the nine-step standard: objective, hook, concept, worked example, practice, common mistakes, exam angle, server-graded quiz and revision summary. A 30-question bank feeds the timed final exam; passing earns a verifiable TieEdu certificate.

**Who this is for:** students and early-career engineers who use chatbots daily but cannot yet explain tokens, context windows or RAG — and who need repeatable workflows for research, writing, coding and placement prep without getting burned by fabricated citations.

**What you need:** access to any mainstream chat assistant for the practice prompts. No coding is required, though Module 3 shows how engineers wire models into products.

Courses for AI-DS students