Prompt

Posts that use this term

• Observability: what a production AI system actually logs

  Closing the AI Engineering series. Tracing prompts and tool calls, tracking spend and latency, and catching failures that don't throw an error.

• Evals: how you actually know it got better

  Feeling better isn't the same as measurably better. Offline eval sets, LLM-as-judge, human eval, and regression testing for prompts and RAG pipelines.

• Guardrails: schema validation, filtering, and trust

  A model's output isn't trusted just because it came from your own system. JSON-mode reliability, schema validation, content filtering, and basic jailbreak resistance.

• Multi-agent systems: orchestration and handoffs

  Adding a second agent doesn't halve your problems, it multiplies them. Supervisor patterns, handoffs, and the real cost of splitting one agent into several.

• The agent loop: plan, act, observe

  Most agent failures look the same: stuck calling the same tool forever. The plan-act-observe loop, why it gets stuck, and the fixes that actually work.

• Prompting as an engineering discipline

  A prompt that runs a thousand times a day needs to be treated like code, not a note you typed once. Few-shot, chain-of-thought, and structured output, with the trade-offs.

• Troubleshooting local LLMs (and how to keep up after this series)

  The full catalog of local-LLM failures: OOM, slow tok/s, garbage output, instruction drift, bad RAG hits, tool-call hallucination. Plus where to follow the field once you're on your own.

• Fine-tuning a model locally

  When fine-tuning is actually the right call (it usually isn't) and how to pull off a LoRA run on a 16GB Mac, with a worked Llama 3.2 3B example.

• Local agents and tool use

  Function calling on open models in 2026. Which ones actually work, why local agents break when they break, and the scaffolding that keeps them upright.

• Local RAG and embeddings

  Build a working local RAG pipeline in about 30 lines using nomic-embed-text, Chroma, and Llama 3.2. And why running it on your own machine beats the cloud for personal notes.

• Your first local LLM, start to finish

  Install Ollama, pull Llama 3.2 3B, chat with it, hit its API, and fix the five things that break on a first install. You finish with a working local LLM.

• Streaming, throughput, and the KV cache

  Why TTFT and tok/s are different numbers, why streaming feels faster than it is, and the KV cache that makes the 1000th token cost about the same as the first.

• Quantization, distillation, pruning: how a 140GB model fits on your laptop

  Three ways to shrink an LLM, and why one of them does almost all the work. What Q4_K_M actually means and what each shortcut costs you.

• The local-LLM vocabulary

  Parameters, B, dense vs MoE, base vs instruct, tokens, context windows, chat templates, GGUF, and quant suffixes. Read it once and any HuggingFace model card stops being scary.

• The pitch for local LLMs in 2026

  The case for running an LLM on the machine you already own. Privacy, no per-call cost, faster first token, no rate limits, and it works on a flight.

• What leaves your machine when you use AI

  What providers actually see, log, and keep when you call an LLM API in 2026. What "we don't train on your data" really means, how free and paid tiers differ, and when local is the only safe choice.

• LLM API bills, and why a token costs what it costs

  How input and output tokens get priced, why output runs 5-6x more, and how prompt caching cuts the input bill by 10x. Plus the hidden costs that ambush people.

• The runtimes: llama.cpp, Ollama, LM Studio

  llama.cpp is the engine. Ollama and LM Studio wrap it. What each one does, when to reach for which, and why the OpenAI-compatible APIs are mostly but not entirely interchangeable.

• Why Apple Silicon punches above its weight on local LLMs

  Unified memory lets the GPU see all of RAM. Here's why that beats a discrete-GPU PC past 32B parameters, what fits in 16/32/64/128/192GB, and where Apple Silicon still loses.

• What it takes to run a model on your own machine

  Why VRAM is the one number that decides whether a local LLM runs, what quantization really does to a model file, and the hardware ladder from an 8GB laptop to a 192GB workstation.

• The major LLMs in 2026

  A field guide to the closed frontier models and the open weights you can actually run. What the "B" numbers mean, and which size fits your machine.

• Where AI actually runs: cloud, local, edge

  When you use AI, a model file is sitting on a real machine. There are only three places it can be, and which one decides almost everything else.

• Prompt, RAG, fine-tune: three ways to shape a model

  Three levers for shaping what an LLM does: prompting (ask better), RAG (give it the right context), fine-tuning (change the weights). What each costs, what each fixes, and how to pick.

• RAG: giving a model memory it doesn't have

  RAG is the pattern of fetching relevant text from a search system and putting it in the LLM's context window before asking your question. Not magic, not fine-tuning, just better prompts.

• The context window, and why models hallucinate

  An LLM only sees a fixed-size slice of text at a time. When it doesn't know something, it predicts anyway. That's a hallucination, not a bug.

• Install the Anthropic SDK

  Install the official Claude SDK for Python and Node, set your API key the safe way, and prove it works with a one-line call.

• Install llama.cpp

  Build llama.cpp from source with Metal or CUDA, then run a GGUF model with llama-cli. The closest thing to bare-metal local inference.