CLAUDE COMPUTING

How a language model tokenizes input, generates output, and what you choose to put in the window this turn.

Ng’s first sub-skill under building applications. Understanding tokenization, sampling, knowledge cutoffs, cache hits, and context-window tradeoffs is how you decide when to trust a model and which one to call. “Context engineering” is the craft of what the model is allowed to see this turn — not dumping the whole repo into the prompt.

How much the model can see at once — the working memory of one call.

Every token you send (prompt, files, tool traces) counts against the context window. Harness design is partly memory design: what to keep, what to summarize, what to store outside the window. “Just paste the whole repo” stops working.

Getting relevant data into the model so it is not guessing from memory.

RAG with vector search was the early version. The menu is bigger now: retrieve on demand with tools, a knowledge graph, or a semantic layer over structured records. You also turn PDFs and HTML into LLM-ready inputs and keep that data fresh. It is a lookup plus a write-up until you wrap it in a loop.

Fetch relevant docs at ask-time and stuff them into the prompt, instead of hoping the model memorized them.

Retrieval-Augmented Generation: search your files or a vector index, then answer with that context. Still the default way to give a model private knowledge without fine-tuning. Combine it with a loop when the job needs multiple lookups and actions.

A model wrapped in tools and a loop — plus the scaffolding that lets it finish a job.

Ng’s “building agentic systems” sub-skill. A workflow is a fixed sequence of LLM calls. A harness lets the model repeatedly decide the next step: tools (including MCP), memory, context over a long session, and when to use one agent vs many. On this board, harness / graph / loop are the three words that unpack that sentence.

The scaffolding around a model: tools, permissions, a loop, and checks that let it finish a job.

A model is a brain in a jar. A harness is everything that lets it act: the tools it can call, the files it can touch, the loop that retries, and the evals that say “good enough.” In 2026 this is the main craft. If you only study prompts, you are studying the brain and ignoring the hands.

A map of steps, branches, and handoffs — not one agent going in circles.

A loop is one worker repeating look → act → check. A graph is the org chart of that work: which specialist runs next, when to retry, when to ask a human, how to resume after a crash. LangGraph popularized this for builders.

Look at the world, do something, check the result, repeat until the job is done.

The smallest useful agent is not a chatbot. It is a loop. Read the repo, edit a file, run the tests, read the failure, try again. Karpathy’s autoresearch is a loop with a timer and a metric. If your product is a single prompt with no retry, you built a form, not an agent.

A model wrapped in tools and a loop so it can pursue a goal, not just answer one question.

Without tools it is a chatbot. Without a loop it is a one-shot workflow. The interesting engineering is the wrapper, not the marketing name. Multi-agent just means more than one of these, with a conductor.

Letting the model call functions — search, shell, browser, APIs — instead of only writing text.

You expose typed functions; the model picks one, your code runs it, you feed the result back. MCP, OpenAI tools, and most agent SDKs are dialects of this idea.

A USB port for tools: one protocol so many apps can plug capabilities into many models.

Model Context Protocol is an open standard for connecting tools, files, and services to models without a custom integration per vendor. Useful when your harness should not be married to one lab’s SDK.

The conductor: which agent or tool runs next, with what budget, under whose rules.

Once you have more than one loop, you need a conductor. Orchestration is routing, retries, timeouts, and policy. It is software, not a prompt.

Letting an agent click, type, and look at a real desktop or browser, not just an API.

Powerful, slow, and messy. You need a harness: screenshots, action spaces, allowlists, and evals. It is how agents touch software that has no API.

The boring code around the model: parsers, retries, scratchpads, and guardrails.

Scaffolding is the unglamorous twin of “harness.” A surprising amount of agent magic is a well-written scaffold.

Tests for model systems — not vibes. Did the agent actually finish the job?

Ng’s “evaluation-driven development.” Look at traces, decide what to measure, mix code-based checks with LLM-as-judge and humans, then iterate. If you cannot measure the loop, you cannot improve it. Verifiers for coding agents are the same idea: a test the agent can run without you.

Shipping the loop: cost, latency, drift, guardrails, and knowing when it broke.

Operating AI software is different because the output is unpredictable. You need observability on real usage, regression tests that are statistical, and a mix of model choice, distillation, and simpler workflows to hit cost and latency. Guardrails and prompt-injection belong here, not in a later security appendix.

A saved snapshot so a long agent run can crash, resume, or branch without starting over.

Long jobs die. Checkpointing writes the graph’s state so you can resume. Production agent systems that cannot checkpoint are demos.

Training, bias/variance, and data — the floor under LLMs.

Every engineer Ng knows who is good with LLMs also understands machine learning at some depth. Supervised learning, RL, error analysis, and engineering the data still decide a lot of application work — including when you should not train anything and should wrap a model instead.

Train extra on your data so the model’s weights change — heavier than prompting, lighter than pretraining.

Prompting changes the question. Fine-tuning changes the weights. Use it when the style or task is stable and you have data (and a way to eval). Most product problems in 2026 are still harness problems, not fine-tune problems.