Context Is the New Code — Patrick Debois, Tessl

Key Concepts

• Context Development Life Cycle (CDLC): A framework for managing the creation, testing, distribution, and observation of AI context, analogous to the Software Development Life Cycle (SDLC).
• Context as Code: The shift from writing raw code to crafting reusable, structured context (prompts, instructions, and specifications) that guides AI agents.
• Skills: Reusable, modular units of context that encapsulate workflows, documentation, and instructions for AI agents.
• Evals (Evaluations): Automated tests designed to validate the output of AI agents against specific criteria or organizational standards.
• Context Filter: A security mechanism, similar to a Web Application Firewall (WAF), that inspects and sanitizes incoming context to prevent prompt injection or unauthorized access.
• AI SBOM (Software Bill of Materials): A manifest detailing the components, models, and provenance of a specific context package.

---

1. The Context Development Life Cycle (CDLC)

The speaker proposes that as developers move from writing code to "vibe coding" (prompting), the industry needs a formal lifecycle for managing context. This loop consists of four main stages:

• Generate: Creating context through manual prompting, reusable instruction files (e.g., agent.md), and pulling in external documentation or repository data (GitLab/GitHub/Slack).
• Test (Evaluate): Validating context to ensure it produces consistent, high-quality results. This includes linting (checking format/length) and using LLMs as "judges" to verify if generated code adheres to company conventions (e.g., enforcing specific URL prefixes).
• Distribute: Packaging context into "skills" or libraries that can be shared across teams via registries, similar to package managers like npm or pip.
• Observe: Monitoring agent logs and production performance to identify missing context or failures, which then triggers a new iteration of the CDLC.

2. Methodologies and Frameworks

• Spec-Driven Development: Writing prompts as formal specifications, which the agent then breaks down into a planning mode and step-by-step execution prompts.
• LLM-as-a-Judge: Using an LLM to evaluate the output of another LLM. By providing the "judge" with specific criteria, developers can automate the verification of code quality and adherence to organizational standards.
• Error Budgets for AI: Because LLMs are non-deterministic, the speaker suggests applying "error budgets" to test suites rather than expecting 100% pass rates on every run, acknowledging that some variance is inherent.

3. Real-World Applications and Challenges

• Standardization: The speaker notes a trend toward standardizing context files (e.g., agent.md) to make AI behavior more predictable across different coding agents.
• Dependency Hell: As context becomes modularized into packages, developers will face "context dependency hell," where conflicting instructions from different packages may degrade agent performance.
• Security: The rise of shared skills necessitates security scanning. Tools like Snyk are being adapted to scan context for credential leaks or malicious instructions. The speaker emphasizes the need for a Context Filter to prevent agents from accessing sensitive environment variables or memory files.

4. Key Arguments

• Context is the New Fuel: The speaker argues that LLMs are merely engines; their performance is entirely dependent on the quality of the "fuel" (context) provided.
• Scaling Context: Individual "solo" crafting of prompts is insufficient for enterprise needs. Organizations must move toward a "team of teams" model where context is treated as a shared library, maintained through feedback loops and CI/CD-like pipelines.
• Shift in Developer Effort: While AI reduces the time spent writing boilerplate code, developers must shift their effort toward writing robust evals and maintaining the quality of the context library.

5. Notable Quotes

• "Context is the new code because it's being generated."
• "If you give the engine the wrong fuel, which is context, they're not going to perform."
• "You're going to spend time on writing the right evals... now you don't only have one prompt that you're trying to get right. It's like all the prompts of the evals."

6. Synthesis and Conclusion

The transition to AI-assisted development requires a fundamental shift in how we manage software projects. Rather than focusing solely on code, developers must become "context engineers." By applying DevOps principles—testing, versioning, distributing, and observing—to the context that drives AI agents, organizations can move away from "YOLO" (You Only Look Once) prompting toward a reliable, scalable, and secure development process. The ultimate takeaway is that the future of software engineering lies in the rigorous management of the instructions and data that define how AI agents interact with our systems.