LLM Course for Software Engineers

Not how transformers work. How the model behaves when it is behind your API, under load, with a user typing something you did not anticipate.

For engineers integrating an LLM into a real application, who need to predict and control what comes back.

What you will be able to do

• Reason in tokens rather than characters, and know why a 4,000-word document does not fit in a window that claims to hold 4,000 tokens.
• Predict what a context window will drop, and structure a prompt so the part that matters is not the part that falls off.
• Control determinism deliberately — temperature, sampling and seeds — instead of discovering a test is flaky in CI.
• Get structured JSON out of a model reliably: schema-first generation, validation at the boundary, and a retry strategy that does not loop forever.
• Tell the difference between a prompting problem, a retrieval problem and a model-capability problem, which is the diagnosis that decides what you build next.

Curriculum

LLM Foundations

• What Is a Large Language Model?
• LLM Strengths & Limitations
• Tokens: The Basic Unit of LLM Text
• Tokens: The Basic Unit of Text
• How LLMs Read Text (Tokenization)
• Tokenization & Encoding Schemes
• Embeddings vs Tokens
• Context Windows
• Context Windows: Capacity & Limits
• Next-Token Prediction
• Next-Token Prediction & Probability Distributions
• Probability Distributions
• Temperature
• Top-k & Top-p Sampling
• Why LLMs Hallucinate

Prompt Engineering

• Prompt Basics
• System vs User Prompts
• Zero-shot Prompting
• One-shot Prompting
• Few-Shot Prompting
• Few-Shot Prompting: Choosing and Ordering Examples
• Chain of Thought
• Structured Output
• Schema-First Prompts
• Output Validation
• Prompt Debugging
• Prompt Injection

Structured Output & Validation

• Why JSON Matters
• Schema-First Generation
• Output Validation in Production Pipelines
• Retry Strategies
• Guardrails
• Production Reliability

A lesson from this track

Every cost estimate, every context-window limit and every truncation bug in your application is measured in tokens, not words or characters. Getting this one unit wrong is why a feature that worked in testing bills three times what was budgeted.

Tokens: The Basic Unit of LLM Text

What you build

• A token-budget calculator that shows exactly what a request will cost and what will be truncated before you send it.
• A schema-first generation service in Spring Boot: JSON out of a model, validated against a schema, with bounded retries and a dead-letter path for what never parses.

Questions

Is this about building an LLM or using one?

Using one. Nothing here trains a model. The subject is the behaviour of a model you call over an API and the engineering around it — which is what almost every production system actually needs.

Which model does it use?

The lessons are provider-neutral, because the behaviour being taught is not provider-specific. The runnable projects default to a local Ollama model so nothing costs you anything to run, and can be pointed at OpenAI or Bedrock with your own credentials.

What if I only care about getting reliable JSON out?

Start with Structured Output & Validation. It is the module engineers reach for first in production, and it stands alone — though the prompting module is what stops you needing the retries.

Do the examples run offline?

Yes. Every project ships configured for a local model, so you can work through the track on a laptop with no API key and no per-token cost.

Start the curriculum