From Prompt Spaghetti to Bounded Contexts: DDD for Agentic Codebases

Bookmark
Rate this content

This presentation shows how Domain-Driven Design (DDD) turns agentic coding from “prompt spaghetti” into a maintainable engineering approach. Instead of one giant prompt and ad-hoc tools, it proposes bounded contexts for agent responsibilities, a ubiquitous language for consistent tool inputs/outputs, and a context map that makes integrations explicit. Attendees will learn how to design stable tool contracts (ports/adapters), add CI/evaluation gates that keep agents honest, and implement traceability and replay so agent actions remain auditable and debuggable. The result: agentic systems that scale to real codebases and teams without collapsing into chaos.

This talk has been presented at AI Coding Summit 2026, check out the latest edition of this Tech Conference.

FAQ

A JNTX system refers to a coding system that uses agents and prompts to ship new features and functionality. It often faces challenges as it scales, leading to complex integration issues.

The main challenge in scaling JNTX systems is managing complex integration issues, where prompts become too large and difficult to debug, often leading to broken systems and long deployment cycles.

The 'prompt spaghetti' problem occurs when the integration logic in JNTX systems becomes overly complex and unmanageable, resulting in prompts filled with parsing logic and integration instructions instead of being written in structured code.

Domain-driven design principles help by providing a structured approach to handle complexity through bounded contexts, contracts as schemas, anti-corruption layers, and context maps, which makes the system more maintainable as it scales.

A bounded context in domain-driven design refers to a defined boundary within which a specific domain model is applicable, ensuring clear responsibility and separation of concerns.

JNTX systems should avoid using natural language as an API because it leads to unstructured outputs and inconsistencies. Instead, structured schemas should be used as contracts to ensure reliable integration and communication between agents.

The four core patterns are: bounded context, contract as schema, anti-corruption layer, and context map. These patterns help manage complexity and improve maintainability.

Contracts and schemas in JNTX systems define structured expectations for agent outputs, enabling clear communication and integration between different system components.

CI gates automate pre- and post-deployment checks, tests, and validations, ensuring that contracts are adhered to and the system remains stable and consistent.

A context map is important in a JNTX system because it provides an executable configuration that describes and enforces the integration architecture, ensuring clear relationships between different contexts.

Nikita Golovko
Nikita Golovko
16 min
26 Feb, 2026

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Nikita, AI Architect at Siemens, discusses challenges in JNTX system development, emphasizing domain-driven design for scalability and stability. Clear responsibilities, bounded contexts, and structured schemas are crucial for reducing complexity. The anti-corruption layer and context maps play vital roles in integration architecture. Key takeaways include the importance of contracts, firewalls, and CI gates for system development.
Video transcription and chapters available for users with access.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Scaling Up with Remix and Micro Frontends
Remix Conf Europe 2022Remix Conf Europe 2022
23 min
Scaling Up with Remix and Micro Frontends
Top Content
This talk discusses the usage of Microfrontends in Remix and introduces the Tiny Frontend library. Kazoo, a used car buying platform, follows a domain-driven design approach and encountered issues with granular slicing. Tiny Frontend aims to solve the slicing problem and promotes type safety and compatibility of shared dependencies. The speaker demonstrates how Tiny Frontend works with server-side rendering and how Remix can consume and update components without redeploying the app. The talk also explores the usage of micro frontends and the future support for Webpack Module Federation in Remix.
Understanding React’s Fiber Architecture
React Advanced 2022React Advanced 2022
29 min
Understanding React’s Fiber Architecture
Top Content
This Talk explores React's internal jargon, specifically fiber, which is an internal unit of work for rendering and committing. Fibers facilitate efficient updates to elements and play a crucial role in the reconciliation process. The work loop, complete work, and commit phase are essential steps in the rendering process. Understanding React's internals can help with optimizing code and pull request reviews. React 18 introduces the work loop sync and async functions for concurrent features and prioritization. Fiber brings benefits like async rendering and the ability to discard work-in-progress trees, improving user experience.
Thinking Like an Architect
Node Congress 2025Node Congress 2025
31 min
Thinking Like an Architect
Top Content
In modern software development, architecture is more than just selecting the right tech stack; it involves decision-making, trade-offs, and considering the context of the business and organization. Understanding the problem space and focusing on users' needs are essential. Architectural flexibility is key, adapting the level of granularity and choosing between different approaches. Holistic thinking, long-term vision, and domain understanding are crucial for making better decisions. Effective communication, inclusion, and documentation are core skills for architects. Democratizing communication, prioritizing value, and embracing adaptive architectures are key to success.
Full Stack Components
Remix Conf Europe 2022Remix Conf Europe 2022
37 min
Full Stack Components
Top Content
RemixConf EU discussed full stack components and their benefits, such as marrying the backend and UI in the same file. The talk demonstrated the implementation of a combo box with search functionality using Remix and the Downshift library. It also highlighted the ease of creating resource routes in Remix and the importance of code organization and maintainability in full stack components. The speaker expressed gratitude towards the audience and discussed the future of Remix, including its acquisition by Shopify and the potential for collaboration with Hydrogen.
The Dark Side of Micro-Frontends
React Advanced 2025React Advanced 2025
29 min
The Dark Side of Micro-Frontends
In the Talk, various key points were discussed regarding micro-front-end architecture. These included challenges with micro-intents, common mistakes in system design, the differences between micro-intents and components, granularity in software architecture, optimizing micro-front-end architecture, efficient routing and deployment strategies, edge computing strategies, global state and data sharing optimization, managing data context, governance and fitness functions, architectural testing, adaptive growth, value of micro-frontends, repository selection, repo structures, and web component usage.
The Eternal Sunshine of the Zero Build Pipeline
React Finland 2021React Finland 2021
36 min
The Eternal Sunshine of the Zero Build Pipeline
For many years, we have migrated all our devtools to Node.js for the sake of simplicity: a common language (JS/TS), a large ecosystem (NPM), and a powerful engine. In the meantime, we moved a lot of computation tasks to the client-side thanks to PWA and JavaScript Hegemony.
So we made Webapps for years, developing with awesome reactive frameworks and bundling a lot of dependencies. We progressively moved from our simplicity to complex apps toolchains. We've become the new Java-like ecosystem. It sucks.
It's 2021, we've got a lot of new technologies to sustain our Users eXperience. It's time to have a break and rethink our tools rather than going faster and faster in the same direction. It's time to redesign the Developer eXperience. It's time for a bundle-free dev environment. It's time to embrace a new frontend building philosophy, still with our lovely JavaScript.
Introducing Snowpack, Vite, Astro, and other Bare Modules tools concepts!

Workshops on related topic

AI on Demand: Serverless AI
DevOps.js Conf 2024DevOps.js Conf 2024
163 min
AI on Demand: Serverless AI
Top Content
Featured WorkshopFree
Nathan Disidore
Nathan Disidore
In this workshop, we discuss the merits of serverless architecture and how it can be applied to the AI space. We'll explore options around building serverless RAG applications for a more lambda-esque approach to AI. Next, we'll get hands on and build a sample CRUD app that allows you to store information and query it using an LLM with Workers AI, Vectorize, D1, and Cloudflare Workers.
High-performance Next.js
React Summit 2022React Summit 2022
50 min
High-performance Next.js
Workshop
Michele Riva
Michele Riva
Next.js is a compelling framework that makes many tasks effortless by providing many out-of-the-box solutions. But as soon as our app needs to scale, it is essential to maintain high performance without compromising maintenance and server costs. In this workshop, we will see how to analyze Next.js performances, resources usage, how to scale it, and how to make the right decisions while writing the application architecture.
Model Context Protocol (MCP) Deep Dive: 2-Hour Interactive Workshop
AI Coding SummitAI Coding Summit
86 min
Model Context Protocol (MCP) Deep Dive: 2-Hour Interactive Workshop
Workshop
Stepan Suvorov
Stepan Suvorov
Join a focused 2-hour session covering MCP's purpose, architecture, hands-on server implementation, and future directions. Designed for developers and system architects aiming to integrate contextual data with ML models effectively. Agenda:- Introduction & Why MCP? Key challenges MCP solves and core benefits.- Architecture Deep Dive: components, interactions, scalability principles. - Building Your Own MCP Server: guided walkthrough with code snippets and best practices; live demo or code review.- Future of MCP Developments: potential enhancements, emerging trends, real-world scenarios.
Key Takeaways:- Clear understanding of MCP's rationale.- Insight into design patterns and scaling considerations.- Practical steps to implement a prototype server.- Awareness of upcoming trends and how to apply MCP in projects.