Leet School
SHORT COURSE

AI Engineering in Production

Take one LLM feature from a demo that impresses to a service you can measure, afford and operate.

  • About 8 weeks
  • Advanced
  • About 10 hours a week
  • Self-paced, text-based
  • Code checks and AI feedback
$250One price, any pace

One payment. Every lesson unlocks at once.

Start this course

Start today. 14-day full refund.

Pace
Yours, about 8 weeks
Level
Advanced
You build
One deep project
Lessons
23 text lessons, about 10 hours of reading
Feedback
Code checks every project, then AI

{about this course}

What it is

You have an LLM feature in production, or close to it. It works in the demo. Nobody can say how often it is wrong, what one answer costs, or what happens when the model is slow. This course closes that gap in about 80 hours of work: about 8 weeks alongside your job, at about 10 hours a week.

It is built around one deep project for one client: a support answerer for an online bus ticket company, over its own help and policy documents. Each module ends in a milestone you can hand in alone: a golden dataset with a judge you have calibrated against human labels, retrieval with measured recall and answers whose citations are checked, a cost budget and a latency budget you can prove, and a release process with tracing, injection tests and a way back.

The code is TypeScript on Node.js with PostgreSQL. The examples call the Claude API through the official Anthropic SDK, and embeddings and reranking come from Voyage AI. The methods carry over to any provider. Every lesson's code runs, and its real output is in the lesson. Where a lesson calls an outside service, it was checked against a stand-in that answers as the provider's API reference says, and you run the same code with your own key.

{outcomes}

By the end you can

  • Turn a vague feature request into written behaviours with pass conditions, and build a golden dataset from real traffic
  • Grade outputs with code checks and an LLM judge whose agreement with human labels you have measured, and block a merge in CI when quality drops
  • Build hybrid retrieval with PostgreSQL full text search and vector similarity, and report recall at k before you touch the prompt
  • Return schema-validated answers with checked citations, and run tool calls that fail safely, with a bounded repair step
  • Set a cost budget per answered question and meet it with token accounting, prompt caching, model routing and batch work
  • Set a latency budget and meet it with streaming, parallel steps, timeouts, retries and fallbacks
  • Trace every request, test for prompt injection, and roll a prompt change out and back the way you release code

{projects}

The one project you build

  1. Project 1: A support answerer, from demo to production

    A service that answers customer questions about tickets, payments and refunds from a bus company's own documents. You take it from a demo to production in four milestones: an eval suite with a calibrated judge, measured retrieval with checked citations, proven cost and latency budgets, and a release process with tracing and a way back.

    • TypeScript
    • Node.js
    • PostgreSQL
    • Anthropic TypeScript SDK
    • Voyage AI
    • Zod
    • OpenTelemetry
    • GitHub Actions

{syllabus}

Everything you will read and build

5 modules · 23 lessons · 5 projects

How the school and this short course work, the six-step method and the debugging loop applied to an LLM feature, and the accounts, keys and spend limits you set up before module 1.

  • How Leet School works

    You can describe the loop of a lesson, a week and a milestone in this course, and plan about eight weeks of about ten hours each alongside your job.

    15 min
  • The method, debugging and asking for help

    You can use the six-step method and the debugging loop on a feature whose output changes from run to run, and write a question that gets a useful answer.

    20 min
  • Your accounts, keys and learning in public

    You can set up the accounts and keys the course uses with a spend limit, run the course stand-in when you have no key, and write a log entry that never leaks a secret or customer data.

    20 min
  • Weekly check and weekly article

    A few questions answered in your own words, marked at once, and one article about the week.

  • Your learning home and project repository

    You publish a GitHub profile page that says who you are and what you are learning, create the repository for Ruta Andina's answerer from the module 1 starter, and write your first public post.

    Set-up project

{is this for you}

Who AI Engineering in Production is for

It suits you if

  • Engineers who have shipped an LLM feature and cannot yet say how often it is wrong
  • Backend and full stack developers who own a retrieval or support feature and get the questions when it misbehaves
  • Tech leads who need a release process for prompts and models that a whole team can follow
  • Developers who work in TypeScript, or who work in another backend language and can read TypeScript

Pick something else if

  • You have not yet called an LLM API from code. Build something small first, then come back.
  • You want model training, fine-tuning or the mathematics of transformers. This course is about the engineering around a model that you call.
  • You want a tour of agent frameworks or vector databases. The course uses a provider SDK, PostgreSQL and plain code.
  • You are new to programming. Start with the Free Track or a full programme.

{before you start}

What you need

  • You have built or maintained a feature that calls an LLM API from code.
  • Working TypeScript or JavaScript on Node.js: async code, modules, environment variables and npm scripts.
  • Basic SQL, and PostgreSQL 17 or newer that you can run on your own machine.
  • Git and a GitHub account. The CI lesson runs GitHub Actions on your project repository.
  • About $25 of Claude API credit, with a $40 spend limit, or the course stand-in if you cannot pay. Embeddings use Voyage AI's free tier.

{tools}

Tools you will use

  • TypeScript
  • Node.js
  • PostgreSQL
  • PostgreSQL full text search
  • pg_trgm
  • Claude API
  • Anthropic TypeScript SDK
  • Voyage AI embeddings and reranking
  • Zod
  • OpenTelemetry
  • GitHub Actions
  • Git

{faq}

Questions about this course

Something else? Ask us directly.

The examples call the Claude API through the official Anthropic TypeScript SDK, with Claude Haiku 5.5 answering and Claude Sonnet 5.5 judging. Model names are read from configuration and never written into code. Anthropic has no embedding model, so retrieval uses Voyage AI, which Anthropic's documentation names. Evals, retrieval measures, budgets and rollout work the same way with any provider, and you can build the project against the one your company uses.

Start AI Engineering in Production today.

$250. No application. Change your mind within 14 days for a full refund.