Listen up. If you're building modern applications, understanding Intro to AI Products is non-negotiable. This is where simple logic turns into intelligent behavior.
1From Deterministic Code to Probabilistic Models
Every piece of traditional software you've written follows the same rule: given identical inputs, you always get identical outputs. Building with LLMs breaks that assumption, since the same prompt can produce a different (but equally valid) response each time.
This isn't a bug to eliminate — it's the core tradeoff of working with generative models, and understanding it changes how you test, cache, and design AI features from the ground up.
// Example
console.log("Running AI concept...");AI logic processed successfully.
2What Deterministic Logic Actually Looks Like
A function like calculateTax(amount, rate) returning amount * rate is deterministic by definition — you can write a unit test with a fixed input and assert on one exact expected output, and that assertion will hold forever.
This is the mental model most backend and frontend engineers bring to a new domain, and it's exactly the assumption that breaks the first time that same testing approach is pointed at an LLM call.
// Traditional Deterministic Function
function calculateTax(amount, rate) {
return amount * rate;
}
calculateTax(100, 0.2); // Always returns 20AI logic processed successfully.
3Temperature: The Randomness Dial
The temperature parameter controls how much the model's next-token choice is allowed to deviate from the single most statistically likely option. temperature: 0 pushes the model toward its most predictable, repeatable response for a given prompt, while temperature: 0.7 or higher introduces real variance and more creative phrasing across repeated calls.
A data-extraction feature should almost always use a low temperature for consistency, while a creative-writing assistant benefits from a higher one — picking the wrong value for the task is a common early mistake.
// Probabilistic AI Call
const response = await openai.chat.completions.create({
model: 'gpt-4o',
messages: [{ role: 'user', content: 'Explain taxes' }],
temperature: 0.7
});AI logic processed successfully.
4The Three Ingredients of an AI Call
Every LLM request is built from three parts: the system prompt (persistent rules and persona), the user input (what's actually being asked right now), and API parameters (model choice, temperature, max tokens) that shape how the response is generated.
Treat these as three separate concerns during development — mixing user input directly into the system prompt string, for instance, is a common source of prompt-injection vulnerabilities covered in later lessons.
const systemPrompt = 'You are a helpful tax assistant.';
const userMessage = 'What is VAT?';
// Constructing the Context Window...AI logic processed successfully.
5Three New Constraints: Latency, Cost, Hallucinations
AI products introduce failure modes that don't exist in a normal REST endpoint: a completion can take seconds to generate (latency), every request costs real money proportional to tokens processed (cost), and the model can state a falsehood with total confidence (hallucination).
The rest of this course is largely about managing these three constraints — streaming responses to hide latency, caching and trimming context to control cost, and RAG/grounding to reduce hallucinations.
// Managing Constraints:
// 1. Stream for speed
// 2. Cache for cost
// 3. RAG for accuracyAI logic processed successfully.
6The Context Window Limit
Every model has a fixed maximum number of tokens (input plus output combined) it can process in a single request — the context window. Exceeding it doesn't degrade gracefully; the API rejects the request outright with an error.
This is why long conversations need trimming or summarization strategies, and why a naive implementation that just keeps appending to an ever-growing history array will eventually break in production.
// Context Window Management
const truncatedHistory = history.slice(-5);
const tokensUsed = countTokens(history);AI logic processed successfully.
7Solving Static Knowledge with RAG
A model's training data has a cutoff date and no awareness of your private documents — asking it about last week's news or your internal wiki will either fail or produce a hallucinated guess. Retrieval-Augmented Generation fixes this by searching your own documents for relevant passages and pasting them into the prompt before the model answers.
This is the same 'grounding' concept covered in depth in the RAG lesson, applied here as one of the standard tools for keeping AI products factually current.
// RAG Flow
const docs = await searchDocs(query);
const prompt = `Use these docs to answer: ${docs} --- ${query}`;AI logic processed successfully.
8The Foundations You Now Have
You now have the vocabulary and mental model that every later lesson in this course builds on: probabilistic vs. deterministic behavior, temperature, the system/user/parameters split, and the latency/cost/hallucination triad of production constraints.
Every subsequent lesson — RAG, streaming, function calling, agents — is really just a specific technique for managing one or more of these fundamentals.
AI: Foundations Mastered
AI logic processed successfully.
9Next: Generating Images with DALL-E
With the foundational model of how AI products work in place, the next lesson moves from text into another modality entirely: generating images from text prompts using the DALL-E 3 API.
DALL-E Next
AI logic processed successfully.
10Step-by-Step Breakdown
Building AI apps requires a paradigm shift. We move from deterministic logic to probabilistic models.
In traditional software, inputs strictly map to outputs. If A happens, do B. The result is always identical.
AI Products use Large Language Models (LLMs). The same input might yield different, context-aware outputs based on 'temperature'.
Checkpoint: What happens when an LLM has a 'temperature' greater than 0?
- →Outputs become completely identical
- →Outputs introduce variance and creativity
An AI call relies on three things: the System Prompt (rules), User Input, and API Parameters like model choice.
However, AI products face new constraints: Latency (speed), Cost (per token), and Hallucinations (made-up facts).
Checkpoint: Which term describes an AI model generating plausible but false or invented information?
- →Latency
- →Hallucination
Context is king. Models have a 'Context Window' limit—the amount of data they can process in one go.
To solve the 'static knowledge' problem, we use RAG. It feeds the model live documents before it answers.
Checkpoint: What is the main purpose of RAG (Retrieval-Augmented Generation)?
- →To make the model generate text faster
- →To provide the model with up-to-date, external facts
Foundations mastered! Your journey into the AI development landscape has officially begun.
Next, we'll learn how to generate custom images using the DALL-E API.
Make a Real Build-vs-Buy Call. Finish the rule that recommends building in-house only when you have the team and enough runway.
Level Up 🚀
Advanced cheat sheets, SEO tricks, and interview prep for this topic.
Browser Support
Fully supported.
Fully supported.
Fully supported.
Fully supported.
Accessibility (A11y)
1Announce Long AI Response Delays
Because LLM latency (unlike a normal API call) can regularly run several seconds, a loading state announced via aria-live="polite" ('Generating response...') is important for screen reader users who otherwise have no indication that anything is happening.
<div aria-live="polite">Generating response…</div>SEO Implications
- 1
Variable Model Output Has No Bearing on This Page's Indexing
The probabilistic, non-deterministic nature of LLM responses described in this lesson applies to runtime API calls your application makes, not to this documentation page itself — this page's own text is fixed, server-rendered prose, exactly as indexable as any other static content.
Best Practices
Use temperature: 0 for Extraction and Classification Tasks
When a feature needs consistent, structured output (pulling fields out of an invoice, classifying support tickets), set temperature to 0 or close to it so repeated runs on similar input produce stable, comparable results.
Budget for Cost and Latency from Day One
Estimate token usage per request (system prompt + typical user input + expected output length) and multiply by expected request volume before shipping a feature, rather than discovering the real per-request cost only after a usage spike.
Frequent Bugs
Writing a unit test that asserts on an exact LLM response string.
Because output is probabilistic, an assertion like expect(response).toBe('The tax is $20') will flake even when the model is behaving correctly. Test for structural properties instead — does the response contain a valid number, does it match a JSON schema — rather than exact text equality.
Real-World Examples
A Structured Data Extraction Endpoint
An invoice-processing API sets temperature: 0 and a strict system prompt ('Extract only the fields listed, output JSON'), because the business logic downstream needs the same invoice to always parse to the same total and vendor name, not a creatively-rephrased summary.
const res = await openai.chat.completions.create({
model: 'gpt-4o',
temperature: 0,
messages: [{ role: 'system', content: 'Extract vendor, total as JSON.' }, { role: 'user', content: invoiceText }]
});