# Context Is the New Code

Patrick Debois, Tessl | AI Engineer Europe 2026 | 27:14

Source: https://www.youtube.com/watch?v=bSG9wUYaHWU
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/context-is-the-new-code
Published: 2026-05-03
Tags: agents, coding-agents, context-engineering, evals, security

## TL;DR
- Context for coding agents should be generated, evaluated, distributed, and observed through a lifecycle similar to software delivery.
- Evals need to test whether context changes agent output, and repeated runs are needed because agent results are nondeterministic.
- Shared context should be packaged, secured, monitored, and improved from agent logs, code reviews, and production failures.

## Summary
Patrick Debois argues that coding agents make prompts, instructions, documentation, skills, tickets, and workflows part of the software development process. He proposes a Context Development Lifecycle with four stages: Generate, Evaluate, Distribute, and Observe. Teams generate reusable context, test its effect on generated code and running systems, package it for reuse, and collect feedback from logs, pull requests, and production behavior. Because eval results can vary between runs, teams should measure success across repeated attempts and set error budgets for tests. Debois also discusses context registries, dependencies, security scanning, provenance, sandboxing, and context filters for prompt injection. The talk moves from individual markdown files toward team and organizational practices, where a missing piece of context discovered by one developer can be improved centrally and reused elsewhere.

## Key ideas
### Coding agents turn reusable workflows into context
[01:00](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=60s)
Debois says context is becoming the material people create when they work with coding agents. He describes turning large pieces of code and helper logic into a reusable skill. One example asks the agent to identify a project's package manager and ecosystem, then guide the user through the right steps. That workflow can handle Python, Node.js, and other setups without requiring every variation to be coded separately. He also includes prompts, instructions, library documentation, tickets, GitHub or GitLab content, Slack messages, and specifications in the context being assembled for an agent.

### The Context Development Lifecycle has four stages
[02:37](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=157s)
Debois proposes a lifecycle that parallels software development and DevOps practices. Teams generate context, test or evaluate it, distribute it to colleagues and projects, and observe whether it works. The loop then uses those observations to adapt and regenerate the context. He presents this as an infinity loop because context is expected to improve through repeated feedback. The model applies to an individual writing an agent.md file and to an organization maintaining reusable context for many teams.

### Context needs tests that check both format and meaning
[06:26](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=386s)
A small edit to Claude.md or agent.md can change how an agent behaves, so Debois recommends writing evals for context. Some checks resemble linting, such as verifying that a skill has a description within the allowed length. Other checks ask an LLM whether the instructions are explicit and complete enough to understand. He compares this to Grammarly for context. A stronger test gives the agent a rule, such as requiring every API endpoint to use the /awesome/ prefix, then checks whether the generated code follows it.

### Agent evals can run code in a sandbox
[10:55](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=655s)
Debois distinguishes checking generated files from testing the behavior of the running result. A judge model can receive tools, operate in a sandbox, execute the application, and use curl to test an endpoint. That turns a context check into an end-to-end scenario. Teams can associate a scenario with a repository commit and ask whether a particular piece of context changed the result. The resulting test suite can cover code, configuration files, and company-specific conventions.

### Nondeterministic evals require repeated runs and error budgets
[12:28](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=748s)
Debois warns that an eval may produce different results on different runs. A single pass or failure is therefore hard to interpret. He suggests running a test several times and measuring how often it succeeds. Some tests may pass every time, while others will vary as context changes. He describes using error budgets so that tests tied to important behavior are allowed very little failure, while less important checks can tolerate more variation. Context optimization can then use the feedback from these runs.

### Context packages create registries, dependencies, and security work
[13:59](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=839s)
Once context is reused across projects, Debois says it starts to resemble a library. Teams can package guidelines, frontend practices, skills, scripts, and documents, then install them where needed. Registries help people discover packages. Packages can also depend on other context, which creates the possibility of dependency conflicts and version management. Distribution adds security concerns because skills may run code on a developer's laptop. Debois mentions scanning for credential handling and third-party exposure, along with recording how a skill was built and which model was used.

### Logs, pull requests, and production failures improve context
[17:49](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=1069s)
Observation supplies feedback for maintained context. Agent logs can reveal that developers repeatedly lack the same piece of information, which gives a team a reason to create and distribute it. An incomplete pull request also provides feedback about the context that produced it. Production behavior adds another source: instrumentation can identify changed code that fails, connect the failure to inputs and outputs, and suggest a regression test. These observations turn individual fixes into improvements that other users of the shared context can receive.

### Agents need context filters alongside sandboxes
[20:38](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=1238s)
Debois says a sandbox limits what an agent can do, but it does not automatically stop a coding agent from loading agent.md or skill.md files. Those files may be loaded immediately, including content downloaded from an unknown source. He proposes a context filter that checks incoming context for prompt injections and other dangerous patterns. He compares it to a web application firewall. This security layer fits with harness engineering practices that inspect logs, traces, and feedback while agents run.

### Context improvement can become a team and organization flywheel
[22:33](https://www.youtube.com/watch?v=bSG9wUYaHWU&t=1353s)
Debois describes two connected loops. An individual or library author creates context, tests it, and improves it. An organization then watches how shared context works for its users and updates the package for everyone. He asks teams to make missing context a routine signal: when a developer finds a gap, they add the information rather than solving the same problem privately each time. Better context produces better agent output, which creates better observations and gives teams more material for the next improvement.

## Notable quotes
- "Context is the new code because it's being generated." (01:26)
- "You have to think about how do we test things?" (06:19)
- "With context we're going to have dependency hell." (16:22)
- "If you give the engine the wrong fuel, which is context, they're not going to perform." (23:46)

## Tools & references mentioned
- Tessl
- AI Engineer
- Claude.md
- agent.md
- GitHub
- GitLab
- Slack
- Python
- Node.js
- Gemini
- Copilot
- MCP
- Snyk
- OpenClaw
- AI DevCon

## Who should watch
- You are building software with coding agents and need a way to manage prompts, instructions, skills, or project documentation across changes.
- Your agent output varies between runs and you want evals that check both generated files and running behavior.
- You maintain shared agent skills and need ideas for packaging, versioning, security checks, and feedback from real usage.

## Related talks

- [How to Generate Mergeable Code with a Context Engine](https://aietalks.com/talks/how-to-generate-mergeable-code-with-a-context-engine) (Peter Werry, Unblocked, 18:36)
- [Self Coding Agents](https://aietalks.com/talks/self-coding-agents) (Colin Flaherty, Augment Code, 17:23)
- [Building Agents Is Trivial Now, Context Is the Next Frontier](https://aietalks.com/talks/building-agents-is-trivial-now-context-is-the-next-frontier) (Jeff Ng, Unblocked, 13:22)
- [The Emerging Skillset of Wielding Coding Agents](https://aietalks.com/talks/the-emerging-skillset-of-wielding-coding-agents) (Beyang Liu, Sourcegraph / Amp, 35:06)
- [Developer Experience in the Age of AI Coding Agents](https://aietalks.com/talks/developer-experience-in-the-age-of-ai-coding-agents) (Max Kanat-Alexander, Capital One, 18:20)