You do not need to write Python to scope an AI product. You do need to know what the model is actually doing — because almost every bad AI PRD I have read in the last year asked the model to do something its mechanics do not allow. Founders who scope well in 2026 know five things about how a language model produces a token, three implications, and four myths to retire before they end up in the spec.
The non-engineer’s mechanics primer for 2026. It grows out of the eval-first build playbook and the idea-to-product manifesto.
Scope
A founder-facing mechanics piece — enough vocabulary to scope an AI feature, read a vendor proposal, and call out a broken spec. Not a transformer-paper recap.
The five mechanics every non-engineer founder should know
1. Token-by-token prediction
A language model does not write a sentence. It writes one token at a time, choosing each by predicting which is most plausible given everything before. A token is a chunk of text — usually 3–4 characters in English. A 500-token answer is 500 forward passes through the network. The architecture under the loop is the transformer (Vaswani et al., 2017), but the operational fact is simpler: the model never sees its own output as a finished thing. It writes a token, appends it to the input, predicts the next one. There is no draft and revise.
This explains most of the weird behavior — why the model loses track of a constraint stated 4,000 tokens earlier, why it commits to a wrong premise in token 12 and defends it through token 800.
Scoping consequence: any feature that depends on the model “going back” — auditing its output, retracting mid-paragraph, enforcing a global constraint — needs a second pass. A critic call, a structured-output decoder, or human review.
2. The context window
The context window is the maximum number of tokens the model can hold in working memory for a single call. System prompt, conversation history, retrieved documents, the user’s question, and the generated output all have to fit.
Frontier 2026 numbers: Gemini 2.5 Pro at 2M tokens, GPT-5 at 400K, Claude Opus 4.8 at 200K. A token is roughly 0.75 of an English word, so 200K is about a 150K-word book. Two non-obvious properties:
- The model attends unevenly. The “lost in the middle” research line (Liu et al. 2024) consistently finds that information near the start and end of the window is recalled more reliably than information in the middle. Packing the window does not mean the model uses it.
- Cost scales with context length. Every token is processed on every forward pass. A 2M-token call is dramatically more expensive than a 20K-token one in dollars and latency.
Scoping consequence: do not design as if the window were a database. Design as if it were a desk — what is on it gets attended to, but only the foreground reliably gets used.
3. Temperature
Temperature is a number, usually between 0 and 2, that controls how the model picks the next token from its predicted distribution. At 0 it picks the single most likely token (deterministic-ish — see below). At 1 it samples the distribution as produced. Above 1 the distribution flattens and outputs get wilder.
A practical mapping:
- 0–0.3 — extraction, classification, summarization, anywhere you want the same answer twice.
- 0.5–0.8 — drafting, ideation, writing.
- 1.0+ — creative writing, brainstorming.
The most common scoping error is leaving temperature at the vendor default (often 0.7) for a task that wants 0.1, then complaining the model is “inconsistent.”
4. Sampling
Sampling is the broader rule that converts the model’s probability distribution into a chosen token. Temperature reshapes the distribution; top-p (nucleus sampling) and top-k truncate it. Top-p of 0.9 keeps the smallest set of tokens summing to 90% probability. Top-k of 50 keeps the 50 highest-probability tokens.
For most products: temperature 0–0.3, top-p at vendor default, top-k off. The reason to know top-p and top-k exist is so you do not confuse “temperature 0” with “completely deterministic” — different claims.
5. Pre-training vs post-training
A modern LLM is built in two stages.
Pre-training: the long one. The model is shown a huge corpus of text and trained to predict the next token. The result knows how language and the world fit together but has no idea how to be helpful, refuse, or follow instructions. Frontier 2025–2026 runs use multi-trillion-token datasets and cost hundreds of millions of dollars per run.
Post-training: the shorter, concentrated stage. The pre-trained model is fine-tuned on demonstrations of helpful, honest, safe behavior. The canonical paper is Ouyang et al. (2022) on RLHF; Anthropic’s constitutional AI and OpenAI’s 2024–2025 successors layer on top.
Knowledge comes from pre-training. Behavior comes from post-training. When the model refuses a safe question, that is post-training. When it confidently fabricates a citation, that is pre-training pattern-matching bumping into post-training that did not penalize unsupported claims hard enough.
Scoping consequence: switching models means picking a different post-training regime as much as a different brain. Models that excel at one task and flunk an adjacent one usually differ in post-training — which is why eval-driven model selection beats vibe-driven selection.
The three implications for how you scope
Implication 1: deterministic outputs require temperature 0 and a fixed seed
At temperature 0 the model picks the most likely token deterministically, but GPU floating-point math, batched inference, and server-side sharding introduce non-determinism. OpenAI exposes a seed parameter on some models; Anthropic does not as of mid-2026.
Temperature 0 gets you ~95–99% identical outputs. The remaining 1–5% is the system telling you “deterministic AI” is a research problem, not a checkbox. Any product needing byte-exact determinism — regulatory, legal, contractual — needs a deterministic post-processing layer downstream. The model is the draftsman; the schema enforcer is the signatory.
Implication 2: context window size dictates RAG design
Retrieval-augmented generation — RAG, covered in the RAG explainer — is the standard pattern when the model needs to know something past its pre-training.
With Claude Opus 4.8’s 200K you have room for ~50 medium documents before “lost in the middle” effects degrade recall. Gemini 2.5 Pro’s 2M fits a small company’s knowledge base — but you pay for it on every call. The number that matters is the effective window — how many tokens you can pack before retrieval quality degrades. For most frontier 2026 models, roughly 30–60% of the headline.
Implication 3: “the model is wrong” often means the prompt is wrong
The reflexive reaction to a bad output is to blame the model. The second is to blame the user. Both miss the mechanic. The model is a function from input to output. If the input under-specifies the task — implicit constraints, ambiguous evidence, an unexpected synonym — the output is correctly wrong.
The prompt is the only specification the model has. If your PRD says “the agent should refuse confidential queries” and the system prompt does not encode what counts as confidential, the model is being asked to read your mind. See what is prompt engineering and how much does it actually matter.
The four myths to retire
Four anthropomorphic shortcuts produce more broken AI PRDs than any other failure mode.
Myth 1: the model “knows”
The model has no knowledge in the human sense. It has a probability distribution over tokens, shaped by training. A frontier model answers “population of France in 2023” reliably because the training data made that token sequence overwhelmingly likely. Ask for the population of a small Belgian municipality and you will get a confidently formatted, possibly fabricated number. Same mechanic, different data distribution.
Replacement: instead of “the model knows X,” say “the model reliably produces correct outputs on tasks of class X under conditions Y.” A measurable, eval-able claim.
Myth 2: the model “thinks”
Reasoning models — OpenAI’s o-series, Claude’s extended-thinking mode, Gemini’s deep-think — emit intermediate tokens before the final answer. Marketing calls this “thinking.” Mechanically it is the same next-token loop, run on a sequence the post-training has shaped into a reasoning-like trace. Reasoning models genuinely solve harder problems, but the gain comes from more sequence to predict, not from a cognitive module being switched on.
Replacement: “extended reasoning mode increases token spend per answer in exchange for higher accuracy on multi-step tasks.” True, and lets you cost it.
Myth 3: the model “remembers”
A model has no memory between calls. Each API call is independent. What looks like memory in a chat product is the application stuffing the last N turns into the context window on every call; cross the window and the earliest turns silently drop out. ChatGPT’s “memory” feature is a separate system — a profile string the application maintains across sessions and prepends to the system prompt. Product engineering, not model engineering.
Replacement: “the application maintains a conversation history included in the model’s context window up to N tokens.”
Myth 4: the model “agrees”
When you tell the model “you’re right, my mistake,” and it says “you’re right, thanks for the correction,” it has not agreed. It produced the highest-probability continuation. Post-training has heavily rewarded agreement-shaped outputs in apology contexts. The “yes” carries no epistemic weight.
This is the most expensive myth because it produces requests like “let the user correct the model and it’ll learn.” It will not learn — not within the conversation, not across them — unless you ship explicit fine-tuning infrastructure.
Replacement: “the model produces agreement-shaped responses when post-training rewards them. Disagreement requires explicit configuration in the system prompt.”
A worked example: one query, token by token
A founder runs this against a frontier chat model:
“Summarize this customer interview in 3 bullet points. Focus on retention pain. [pastes 1,400-word transcript]”
What happens:
- Tokenization. Transcript and instruction split into ~1,800 tokens. The vendor’s system prompt adds ~400. Total input: ~2,200 tokens.
- Forward pass 1. The model produces a probability distribution over its ~100,000-token vocabulary. Top candidates are summary-starting tokens: “Here”, ”•”, “Three”, “1.”, “The”. At temperature 0 it picks the highest — say ”•”.
- Forward pass 2. Input is now 2,201 tokens. The model predicts the next token, probably ” ” (a space).
- Forward passes 3 through ~120. The loop builds each bullet one token at a time, each choice conditioned on the entire growing context.
- Cross-bullet attention. Writing bullet 3, the model attends to bullets 1 and 2. It avoids repetition and structures the output coherently — not because it “planned” three bullets but because training data is full of coherent three-bullet summaries.
- Stop. The model emits a stop token (or hits max-tokens).
Total: ~120 forward passes for ~120 tokens. Wall-clock on a 2026 frontier model: 1–3 seconds.
The model never planned three bullets. It planned the next token, 120 times in a row, in a context where three bullets was the most plausible structure. Every parameter covered above shows up here as a decision lever.
FAQ
Do I need to learn the math to ship an AI product?
No. You need to know what the model is doing well enough to write a spec that does not contradict its mechanics. The five mechanics here are the floor. If a vendor proposal violates one, push back.
Is “the model is a stochastic parrot” the right mental model?
Half-right. The Bender et al. (2021) paper made a valid point about training-data risks. The parrot metaphor has not held up — frontier 2026 models compose, abstract, and follow reasoning chains. A more useful mental model: “the model is a large interpolator over the training distribution.” Excellent inside it, unreliable at the edges.
What is the actual difference between GPT-5, Claude Opus 4.8, and Gemini 2.5 Pro under the hood?
Architecturally they are all transformers with mixture-of-experts variants and different training data and post-training recipes. The user-visible differences come almost entirely from post-training — what behaviors were rewarded, what refusals tuned in, what context-window engineering was prioritized. See decoding “production-ready” in AI agency proposals for evaluating model choices in vendor pitches.
Why does the model give different answers to the same question?
Sampling. Unless temperature is 0 and the vendor exposes a seed parameter, the model samples from a probability distribution and identical prompts can produce different outputs. Set temperature low for tasks needing consistency, and accept that “low” is not “zero.”
Can I trust the model when it says “I don’t know”?
More than when it says it does know, but not unconditionally. Post-training has gotten much better at calibrated abstention since 2023, but the model still hallucinates abstentions and hallucinates confidence. See AI hallucination explained.
How big a context window do I actually need?
Most production AI features in 2026 need 20K–80K tokens of effective context — enough for a system prompt, a few retrieved documents, and a conversation. The 2M-token windows are useful for narrow document-comprehension tasks and expensive for general use.
What is “fine-tuning” and do I need it for my MVP?
Fine-tuning is a small training run on top of a pre-trained model with examples of your task. For most MVPs the answer is no — a well-designed prompt and a retrieval layer outperform fine-tuning at lower cost and risk. Fine-tuning becomes interesting when prompt-engineering hits a ceiling on a specific behavior at high volume.
How fast are these models?
Frontier reasoning models in mid-2026 run at 50–150 output tokens per second, with reasoning modes adding 5–30 seconds of pre-output thinking tokens. Non-reasoning models hit 200–500 tokens per second.
Why does the model invent fake citations even when I tell it not to?
The fluency objective is older and stronger than the no-fabrication post-training. “Don’t make things up” lowers the rate; it does not eliminate it. Stack a retrieval layer, a structured-output constraint, and a verification step. One instruction is not architecture.
If I learn one more thing after reading this, what should it be?
Run a 20-prompt eval set against two different frontier models on your actual task. You will learn more in 90 minutes than from any explainer, including this one.
Next step
Mechanics are entry-level vocabulary. The payoff is turning vocabulary into scoping: which model, which context-window strategy, which temperature, which fallback when the model refuses. The next chapter — the eval-first build playbook — turns those decisions into a test set, and the test set into a production gate. Want the weekly version in your inbox? Subscribe to the SFAI Labs newsletter — one founder-grade explainer per week, no model marketing.
Dirk Jan van Veen, PhD
