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

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

Courses for AI-DS students

Building Apps with LLMs

Prompt Engineering Masterclass