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:
---
name: new-sdk-integration-example
description: Use when adding or updating integrations for this SDK.
---
1. Inspect the installed package version, exports, and type definitions.
2. Read the official documentation for that exact version.
3. Find the closest working integration in this repository.
4. Match its configuration, error handling, and test shape.
5. Run the smallest live smoke test that proves the interface works.
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 frozen. You give the model an instruction, a few examples, an API reference, a file from your repository, or the output of a failed test. Its parameters stay frozen, but its behavior changes.
For an agent, context includes much more than the chat transcript:
- files it reads
- tools it can call
- documentation it needs
- logs/errors from compiler or runner
- conventions written into a skill
- results of its previous attempts
What happens when facts go into weights
Charles O'Neill tested in context learning directly with Qwen3-4B and 247 invented facts, including a metal called "Zorvathine" that melts below -10°C. Bare-statement training repeated each fact in 2 framings, while study training used 24 generated paraphrases, questions, implications, and contrasts.
After 20 sequential writes, bare-statement facts retained 1% accuracy and study-trained facts retained 46%; a separate 100-write prior-conflict experiment found a 25–28% study-retention plateau.
Forgotten facts kept 57–67% of the original write's drift-corrected log-probability lift, and supplying a forgotten study fact in the prompt restored 77–80% accuracy, versus 14% for the collapsing bare-statement sequence.
We've seen similar results in previous research. In 2021, DeepMind published RETRO, a 7.5 billion parameter model connected to a database of 2 trillion tokens. It reached comparable performance to GPT-3 and Jurassic-1 on the Pile with 25× fewer parameters, while retrieving relevant text in roughly 10ms.
What belongs in weights, context, and skills
Weights hold durable capabilities: language, code structure, reasoning patterns, tool use, and the ability to learn from examples should work across millions of tasks. Context holds task state: the user's request, current files, live API responses, private data, and the exact problem being solved belong in the active context because they change every run.
Skills sit in the useful middle, they are editable, versionable, searchable, and cheap to improve. A corrected skill can change the next run immediately because the model can learn from it in context.
This suggests a different agent improvement loop, without post-training:
- Observe the failure: Capture the wrong assumption, missing source, or skipped verification.
- Repair the procedure: Update the skill with the source or check that would have prevented it.
- Retrieve it precisely: Load the skill only for tasks where it applies.
- Evaluate the workflow: Run the same task again and measure the outcome.
The agent stack should optimize context delivery
The best agent systems will get very good at 4 things: retrieving the right context, packaging procedures as skills, preserving useful state, and verifying work against the real environment.
Agent teams should be collecting failed runs, compiler errors, corrections, repo conventions, and the tiny procedural details to improve them. Much of that data should improve the context pipeline before it becomes a fine-tuning dataset.
I care less about whether a model saw an SDK during pretraining. I care whether the agent can find the right interface today, understand it, and prove that it works.
→ Kyle