The most useful data arrives after trainingThe most useful data arrives after training<br>August 4, 2026 · 7 min read<br>By Kyle Jeong<br>In 2023, we wrote elaborate system prompts. In 2024, we built prompt optimization tools that searched for better instructions and examples. In 2025, everyone started context engineering. In 2026, we packaged the most relevant context into skills.

The names changed as the systems around the model became more sophisticated, but the learning mechanism behind them stayed almost exactly the same.

Better context produces better behavior.

In-context learning is the public secret behind the new age of AI applications. A model can absorb instructions, examples, tools, documents, and feedback during inference, then act like it learned how to do the task without needing a gradient update.

This matters more as Agents get better, their work now depends on code and private data (something the base model never saw), SDKs released after its training cutoff date, and user feedback that never appeared in training.

TLDR; In-context learning is the silent driver of every major LLM application paradigm. Training creates a general learner, but the info that makes an agent useful on a specific task is usually better retrieved into context than written into its weights.

New name, same mechanism

The app layer evolved through 4 rounds.

Round one was the system prompt. One block of text defined how the model should behave. You described the role, listed the rules, added a few examples, and hoped the model followed them. When it failed, you changed the wording and tried again. "Prompt engineering" was a cool way to say that you were changing a few words to see if output was better.

Round two was prompt optimization. Prompts became artifacts that could be measured and improved. You could generate alternative instructions, test them against an eval set, keep the best examples, and repeat. The system prompt is an essential part of the software. These optimizations leave the model itself untouched, instead searching for context that gives you better behavior from the same weights.

Round three was context engineering. The evolution of Agents made the input much larger than a prompt. Tool definitions, retrieved files, message history, memory, runtime state, and previous errors all became part of the model's working context. Andrej Karpathy describes context engineering as filling the context window with the right information for the next step. Anthropic describes it as the natural progression of prompt engineering.

Round four was skills. Anthropic introduced Agent Skills in October 2025 as folders of instructions, scripts, and resources loaded only when relevant. They started taking off around January when Vercel launched Skills.sh. Skills turned context engineering composable, and scoped it into a reusable package format. Instead of stuffing every instruction into one global prompt, an agent can keep thousands of procedures outside its active context and retrieve one when the task matches: improving routing, maintenance, and execution, while in-context learning makes the loaded material useful.

System prompts, prompt optimizers, context engineering, and skills all improve the same moment: the tokens and tools available to a model before it chooses its next action.

SDKs make the case obvious

A model post-trained in January can correctly use an SDK released in July.

The SDK did not exist in its training set. No gradient update taught the agent its classes, methods, response shapes, or weird authentication flow. The agent can read a skill, inspect the installed types, study a few examples, write the integration, run it, and fix what breaks. (Yes I know most Agents have search tools as well, but assuming you give it a skill first).

SDK interfaces are perfect skill material because they are volatile knowledge. Method names change, types move, and defaults flip. One major version uses Completions while the next uses Responses. Authentication might come from an env variable, credential broker, or a workspace-scoped token.

A skill can give the agent a current operating procedure:

markdown

name: new-sdk-integration-example<br>description: Use when adding or updating integrations for this SDK.

1. Inspect the installed package version, exports, and type definitions.<br>2. Read the official documentation for that exact version.<br>3. Find the closest working integration in this repository.<br>4. Match its configuration, error handling, and test shape.<br>5. Run the smallest live smoke test that proves the interface works.<br>6. Treat compiler errors and runtime responses as new context, then repair.

The skill doesn't need to contain the whole SDK (but some do). It should however teach the agent how to retrieve the source of truth, which evidence to trust, and how to verify the result.

Learning without a gradient update

Model behavior can change from information inside the current input while the model's parameters stay...