Context is the New Code: Patrick Debois on the Context Development Lifecycle
YouTube
Patrick Debois, widely recognized as the founder of DevOps, introduces a significant paradigm shift in software development where context becomes the primary artifact for engineers to manage. In this vision, as AI agents increasingly handle the direct generation of syntax and logic, the developer's role moves from writing manual code to engineering the data, instructions, and environmental references that guide AI agents. Debois argues that this shift necessitates the creation of a formal Context Development Lifecycle (CDLC) to bring software engineering rigor to prompt engineering and agentic workflows.
The CDLC framework is composed of four critical stages: Generate, Evaluate, Distribute, and Observe. Throughout the talk, Debois details how context must be curated through tools like the Model Context Protocol (MCP), tested using non-deterministic evaluation strategies and LLM-based judging, packaged for organizational distribution, and monitored in production through agent logs. By treating context as a versioned, tested, and observable artifact, engineering teams can move beyond simple prompt engineering into a scalable, industrial-grade AI development process that ensures consistency and security across agent-led projects.
The video 'Context is the new Code' by Patrick Debois provides an in-depth exploration of the Context Development Lifecycle (CDLC), a framework designed to bring traditional software engineering discipline to the management of AI agents. Debois posits that as AI agents take over more coding tasks, the developer's primary job shifts from writing code to managing the context—prompts, documentation, and data—that fuels these agents. The talk outlines a structured approach to generating, evaluating, distributing, and observing context to ensure reliable and secure AI outputs.
Key Takeaways
Context is the new Code: Software engineering is shifting from manual coding to 'context engineering,' where the primary task is providing the right data and instructions to AI agents.
The CDLC Framework: A formal lifecycle (Generate, Evaluate, Distribute, Observe) is needed to handle context with the same rigor as source code.
Evaluation is Critical: Because LLMs are non-deterministic, testing context requires multiple trials, error budgets, and 'LLM-as-a-judge' strategies.
Standardization through MCP: The Model Context Protocol (MCP) and agent.md files are becoming essential for distributing structured context across different AI tools.
Timestamps
00:00
IntroductionOpening of the AI Engineer London conference and introduction to the 'vibe coding' concept.
03:17
The Context Development Lifecycle (CDLC)Patrick Debois introduces the CDLC as the AI equivalent of the SDLC.
03:50
Generate: Creating and Curating ContextDiscussing human prompts, instructions, agent.md, and MCP connectors.
06:43
Evaluate: Testing and Measuring Context QualityHow to implement linting, LLM-as-a-judge, and unit testing for AI prompts.
14:00
Distribute: Packaging and Sharing ContextThe distribution journey, registries, marketplaces, and dependency management for context.
17:50
Observe: Monitoring and Improving in ProductionLearning from agent logs, traces, and feedback loops in live code.
23:36
ConclusionFinal summary: Context as the fuel and AI models as the engine.
Target Audience
Software engineers, AI developers, DevOps practitioners, and technology leaders looking to standardize how their organizations use and manage AI agents and large language models.
Use Cases
-Implementing a structured workflow for testing AI agent instructions.
-Standardizing AI documentation and context sharing within large engineering teams.
-Building automated evaluation pipelines to ensure AI generated code meets corporate standards.
-Managing dependencies and security vulnerabilities within shared AI context packages.
Feedback Loops: Real-world observation through agent logs and production feedback is necessary to iteratively improve the context provided to agents.
The Generate Stage: Creating High-Quality Inputs
The first step in the CDLC is generating the context. This goes beyond simple prompt engineering. Debois highlights the importance of making implicit knowledge explicit. This involves curating documentation, using version-specific libraries, and utilizing context connectors. Tools like the Model Context Protocol (MCP) allow agents to connect to knowledge sources like GitHub, Slack, or internal databases directly. He also discusses 'spec-driven development,' where prompts are written as formal specifications that the agent then breaks down into actionable steps.
The Evaluate Stage: Testing Non-Deterministic Artifacts
Testing context is inherently different from testing traditional code because AI responses are non-deterministic. Debois suggests several levels of evaluation:
Linting: Basic checks for prompt length, syntax, and adherence to formatting standards (e.g., agent.md).
Grammarly for Context: Using tools to see if the agent actually 'understands' the verbosity and completeness of the instructions.
LLM as Judge: Using a second LLM to evaluate if the agent's output meets specific criteria, such as including required API prefixes or following style guides.
E2E and Unit Tests: Running the generated code in sandboxed environments and measuring its performance against a suite of tasks.
The Distribute Stage: Context as a Package
Once context is generated and tested, it needs to be shared across teams and projects. Debois envisions 'Context Packages'—reusable libraries of prompts and instructions. This stage requires dependency management (to avoid 'dependency hell' where different context modules conflict) and centralized registries where developers can discover high-quality, verified agent instructions. He emphasizes that just as we have npm for JavaScript, we will soon have similar registries for AI agent skills and context modules.
The Observe Stage: Monitoring Agents in the Wild
Engineering doesn't end when the agent is deployed. Developers must observe agent logs to see where context might be failing. Debois introduces the 'Agent Trace Spec,' a living record of decision-making. By analyzing these logs, engineers can identify missing pieces of information that lead to errors and feedback those findings into the Generate stage. Furthermore, 'Harness Engineering' allows developers to instrument production code to understand how AI-generated logic behaves at runtime, providing a complete observability stack for agentic workflows.
Practical Applications
To apply the CDLC, developers should start by centralizing their 'system prompts' and instructions into version-controlled files like agent.md or instructions.md. Teams should establish a baseline 'eval' suite that runs every time a prompt is changed, ensuring that improvements in one area don't break logic in another. Organizations can also implement 'Context Filters' (analogous to Web Application Firewalls) to scan outgoing context for secrets or improper instructions before they reach the LLM.
Frequently Asked Questions
What is the Context Development Lifecycle (CDLC)?
The CDLC is a four-stage framework (Generate, Evaluate, Distribute, Observe) proposed by Patrick Debois to manage the inputs fed into AI agents. It aims to bring the rigor of DevOps and software engineering to the otherwise informal process of prompt engineering.
Why is context called 'the new code'?
Debois argues that in the era of AI-native development, the AI model is the engine and context is the fuel. Since AI can generate the syntax, the human developer's unique value lies in providing the precise, structured context required to produce the desired result, making context the primary artifact developers 'engineer.'
How do you evaluate context if it is non-deterministic?
Evaluation involves running multiple trials (e.g., 5+ runs) and using statistical 'error budgets' rather than simple pass/fail assertions. Advanced techniques include 'LLM-as-a-judge,' where a separate model evaluates the agent's output against a set of scoring dimensions like specificity and completeness.