AI Best Practices

Simple: Showing the AI two or three examples tells it the pattern you want far better than just asking.

Deep: A large language model is an in-context learner: it conditions on everything in the context window as evidence about the task. Examples act as a task specification in the model's own modality — instead of describing a desired function in prose (which the model must then interpret), you demonstrate it, and the model performs implicit pattern completion over the prompt. This is few-shot prompting, and it works without any weight updates, which is the remarkable part. The mechanism is still debated — likely a combination of locating similar patterns in training data and conditioning the output distribution on the demonstrated format.

Simple: Telling the AI to "think step by step" genuinely makes it answer better.

Deep: A transformer has a fixed compute budget per token — a constant number of layers and operations, no matter how hard the problem. Chain-of-thought works by serializing reasoning into the token stream, effectively giving the model more sequential compute steps: each generated reasoning token becomes context that informs the next. This converts an otherwise single-pass, fixed-depth computation into a variable-length one allocated by the problem's difficulty. Modern reasoning models make this explicit by generating long internal deliberation before the final answer — trading inference cost and latency for accuracy, which is exactly the tradeoff the technique exposes.

Simple: If you tell the AI exactly how to answer, it stops being vague.

Deep: The model outputs a probability distribution over the next token. Specifying a format constrains that distribution, reducing the space of admissible outputs and therefore the variance of results — which is why structured formats (JSON, tables, fixed sections) dramatically improve consistency and make outputs machine-parseable. This is also why schema-based techniques work: when the model generates into a constrained grammar or function signature, invalid outputs are structurally impossible rather than merely discouraged. For production systems, the output contract isn't a nicety — it's the interface.

Simple: The AI is built to produce plausible text, not guaranteed truth — so it can sound confident while being wrong.

Deep: Models are trained to maximize the likelihood of the next token, not to be calibrated about truth. A fluent fabrication and a correct statement can be equally probable under the objective, so nothing in training directly penalizes confident error. Grounding methods address this by moving the source of truth outside the weights: retrieval-augmented generation supplies retrieved evidence the model must condition on; tool use replaces recall with deterministic computation; verifier models and self-consistency check outputs across samples; and citations with source grounding make claims auditable. The professional habit is architectural: don't ask a model to remember what you can make it look up.