DevTalk LA

This week's topic: Context Engineering

Discussion resources to help guide the conversation will be posted below a few days before the meetup.

Zoom link will be added about 5 min before the event starts.

As described in Thoughtworks Technology Radar Vol. #34.

Context engineering has evolved from an optimization tactic into a foundational architectural concern for modern AI systems. Unlike prompt engineering, which focuses on wording, context engineering treats the context window as a design surface and intentionally constructs the AI’s information environment.

As agents tackle more complex tasks, dumping raw data into large context windows leads to “context rot” and degraded reasoning. To combat this, teams are shifting from static, monolithic prompts to progressive context disclosure. Instead of front-loading every instruction and reference an agent might need, these systems start with a lightweight index of what’s available. The agent determines what prompts or contexts are relevant and pulls in only what’s needed, keeping the signal-to-noise ratio sharp at every step.

We’re seeing several techniques mature in this space: Context setup leverages prompt caching to front-load static instructions, reducing costs and improving time to first token. Dynamic retrieval goes beyond basic RAG by selecting tools and loading only the necessary MCP servers, avoiding unnecessary context expansion. Context graphs model institutional reasoning — such as policies, exceptions and precedents — as structured, queryable data. Context management techniques use stateful compression and sub-agents to summarize intermediate outputs in long-running workflows.

Treating AI context as a static text box is a fast track to hallucinations. To build resilient enterprise agents, teams must engineer context as a dynamic, precisely managed pipeline.

Discussion Resources :

The rise of "context engineering" By Harrison Chase
https://www.langchain.com/blog/the-rise-of-context-engineering

Context Engineering By The LangChain Team
https://www.langchain.com/blog/context-engineering-for-agents

Context Engineering with OpenAI: Making Enterprise AI Agents Production-Ready By Shikhar Kwatra (OpenAI), Soumo Chakraborty, Sakshi Ray, Amey Gujre, Suvam Ray
https://fractal.ai/blog/context-engineering-openai/

Context Engineering for Personalization - State Management with Long-Term Memory Notes By Emre Okcular
https://developers.openai.com/cookbook/examples/agents_sdk/context_personalization

Inside the LangChain x Manus Webinar on Context Engineering By Duarte Caldas Cardoso
https://medium.com/@caldasdcardoso/inside-the-langchain-x-manus-webinar-on-context-engineering-69166ee404db

Context Engineering in 29 Minutes: Complete Cours By Marina Wyss - AI & Machine Learning
https://www.youtube.com/watch?v=-h9VVJIqtvA

Context Engineering Clearly Explained By Tina Huang
https://www.youtube.com/watch?v=jLuwLJBQkIs

Context Engineering Explained (5 Practical Tips) By Shaw Talebi
https://www.youtube.com/watch?v=zKHSpwayPBU

Context Engineering Explained: How to Build Reliable AI Agents By VectorLab
https://www.youtube.com/watch?v=oDUnErN6z3w

Context Engineering Our Way to Long-Horizon Agents: LangChain’s Harrison Chase By Sequoia Capital
https://www.youtube.com/watch?v=vtugjs2chdA

This week's topic: Agent Trace

Discussion resources to help guide the conversation will be posted below a few days before the meetup.

Zoom link will be added about 5 min before the event starts.

As described in Thoughtworks Technology Radar Vol. #34.

Agent Trace is an open specification proposed by Cursor looking to standardize AI code attribution. As adoption of coding agents increases, understanding who has modified code now extends beyond human developers to include AI-generated changes. We’re seeing early interest from teams that need better traceability around these changes. Existing tools such as git blame can show a line of code has been modified, but fail to capture whether that change was made by a human, an AI or both. Agent Trace takes a vendor-neutral approach to defining how code changes are traced and is unopinionated about how those traces are stored. It’s compatible with multiple version control systems, including Git, Mercurial and Jujutsu. The specification defines contributor types such as human, AI, mixed and unknown, along with a trace record describing the origin of each contribution. There are early signals of adoption, with support from tools such as Cline and OpenCode as well as implementations like Git AI. Teams adopting coding agents should assess tooling that implements the Agent Trace specification to improve code attribution.

Discussion Resources :

Will be added a few days before the event.

This week's topic: OpenAI Codex

Discussion resources to help guide the conversation will be posted below a few days before the meetup.

Zoom link will be added about 5 min before the event starts.

As described in Thoughtworks Technology Radar Vol. #34.

OpenAI Codex has evolved into a standalone agentic coding tool, available via a dedicated macOS app and CLI. It’s designed for autonomous task delegation: given a prompt, it plans, implements and iterates across files with minimal intervention. Our teams have found it effective as a high- velocity drafting tool, particularly for greenfield tasks and repetitive implementation work. However, its tendency to suggest logically sound but functionally outdated library patterns means that automated testing and human review are essential. As with other agentic tools in this Radar, the risk of accumulating subtle technical debt is real and proportional to the level of autonomy teams grant it.

Discussion Resources :

Will be added a few days before the event.

This week's topic: GitHub Spec Kit

Discussion resources to help guide the conversation will be posted below a few days before the meetup.

Zoom link will be added about 5 min before the event starts.

As described in Thoughtworks Technology Radar Vol. #34.

Spec-driven development featured prominently in our discussion this cycle. Two broad camps are emerging: teams that rely on the continually improving capabilities of coding agents with minimal structure, and those that favor defined workflows and detailed specifications.

Several of our teams are experimenting with spec-driven practices using GitHub Spec Kit, mostly in brownfield environments. A key concept in Spec Kit is the constitution, a foundational rulebook that aligns the software development lifecycle. In practice, teams reported that a useful constitution typically captures project scope, domain context, technology versions, coding standards and repository structure (for example, hexagonal architecture or layered modules). This shared context
helps agents operate within the intended architectural boundaries.

Teams also encountered challenges such as instruction bloat, where continually adding project context led to a growing agent instruction set and eventually context rot. One team addressed this by extracting reusable guidance into skills, keeping agent instructions lean and loading detailed context
only when needed.

In brownfield systems, much rework stems from unclear intent, hidden assumptions and late discovery of constraints. One team adopted a lifecycle of spec → plan → tasks → coding → review, which helped surface issues earlier. Over time they also moved repeatable context into files such as .github/prompts/speckit..prompt.md, making prompts shorter and agent behavior more consistent. Teams did report rough edges, including unnecessary defensive checks and overly verbose markdown outputs that increased cognitive load. Customizing Spec Kit templates and instructions — for example limiting the number of generated markdown files and reducing console verbosity — helped address some of these issues. Ultimately, experienced engineers, particularly those with strong clean coding and architectural practices, tend to extract the most value from spec-
driven workflows.

Discussion Resources :

Will be added a few days before the event.