How to Teach Your Agents About Architecture

1. Abstract
   

   emphemerality: the concept of things being transitory, fleeting, or existing only for a short time.

   Suddenly, one of the most important considerations for code is emphemerality–how long will this code live? If it's a quick vibe-coded solution then no one cares about good architecture. However…if what you're building is the foundation for future building, you need ways to ensure that agents (either humans or machines) build proper software.

   How To Teach Your Agents About Architecture represents several years thinking about how to concretely define nine different intersections of software architecture with how humans and agents build software. This class shows developers and architects how to define architecture rules embedded within specifications and how to use the same rules to generate deterministic guardrails. Even with the best models, developers should trust but verify. How To Teach Your Agents About Architecture provides techniques to both teach your agents about architecture and govern non-emphemeral code.

   We define architecture in code in the following nine intersections:

   • GenAI
   • Implementation
   • Infrastructure
   • Engineering
   • Data
   • Integration architecture
   • Team topologies
   • Enterprise Architecture
   • Business

   For each of these, we provide examples of how developers and architects can build rules that provide fast feedback when important things happen. For example, this framework allows developers to define rules that prevent developers (or agents) from "cheating" in a mono-repo source code repository. Similarly, when architects need to break a database apart for scalability, we show techniques to restore data consistency and referential integrity.

   This class begins with how to "wire" rules into agentic generation and how to use the same intent to generate concrete guardrails. Then, we cover nine different dimensions of software architecture and how to concretely define each intersection in ways that constrains agents (and humans) to build proper software.

   A common target of agentic code generation is microservices, equating small scope with "micro". While often a good idea, architects must understand the implications of microservices architecture in terms of scope of architectural characteristics and five different types of potential coupling. This class shows architects how to objectively define the scope of agentic regeneration using proven architectural concepts. This class shows a number of proven ways to reason about the mix of human-and-agentic code generation and its implications (both good and bad) for software architecture.

2. Duration
   
   1. 3-day hands-on workshop
      
   2. 2-day hands-on workshop
      
   3. 1-day optional consulting to implement these ideas at your organization
      
3. Outline
   
   1. What
      
      1. From prompt-to-context engineering
         
      2. setting foundational rules for agentic code generation
         
   2. How
      
      1. Building deterministic guardrails for agentic behavior
         
         • architectural fitness functions
           
           • Scope
             
           • Platforms
             
         • LLM as an interpolator: generating fitness functions
           
         • Architecture Definition Language
           
           • Defined
             
           • Examples
             
           • Alternatives
             
      2. exercise: generating concrete fitness functions
         
      3. MCP and governance Mesh
         
      4. Break
         
      5. Case study: Building implementation constraints
         
         • code quality
           
         • code structure
           
         • code constraints/governance
           
      6. exercise: Make the Grade guardrails
         
   3. Where
      
      1. Engineering practices
         
         • controlling version control
           
           • Preventing cheating in mono-repos
             
           • Preventing code duplication in repo-per-service
             
         • preventing churn
           
      2. exercise: how much copy/paste is OK?
         
      3. Break
         
      4. Integration
         
         • architecture quantum coupling
           
           • static
             
           • exercise: limiting static coupling
             
           • dynamic
             
           • exercise: limiting dynamic coupling
             
           • contract
             
           • temporal
             
      5. Infrastructure
         
         • Architecture as Code -> Infrastructure as Code
           
         • Governing generated infrastructure
           
         • ADL alternatives
           
      6. exercise: translate CALM to ADL
         
      7. Break
         
      8. Data
         
         • Handing problems in distributed architectures
           
           • data consistency
             
           • referenial integrity
             
           • cascading updates/deletes
             
         • controlling data coupling
           
      9. exercise: Math the Grade data integrity
         
      10. Team topologies
          
          • How to tell if you have the correct distribution of agents/team members
            
          • building process feedback loops
            
      11. Enterprise architecture
          
          • global governance
            
          • Governance strategies
            
            • Centralized
              
              • Prescriptive
                
              • Classic alternative
                
            • Decentralized
              
              • Distributed
                
              • Durable interface
                
          • Adapting governance to the AI age
            
      12. Summary
          
4. 45min overview outline
   
   1. Why?
      
      1. Prompt -> context -> harness engineering
         
      2. new level of abstraction
         
      3. Capabilities versus behavior
         
         • guard rails
           
           • capabilities
             
             • verification: ALWAYS
               
           • behavior
             
             • verification: ALWAYS to SOMETIMES (based on emphemerality)
               
      4. capabilities verification: fitness functions
         
      5. Two phases of verification
         

         Just fitness functions are not enough, you need to guide the agent to create better code to begin with

         • in-agent: ADL
           
         • extermal: fitness functions
           
   2. How?
      
      1. wiring skills
         
      2. ADL
         
         • succinct
           
         • less context
           
         • less ambiguous
           
         • good for fitness function interpolation
           
      3. fitness functions
         
      4. interpolating ADL -> fitness functions
         
   3. What?
      
      1. Impl
         
         • structure
           
         • constraint
           
      2. Data
         
         • referential integrity
           
      3. Engineering
         
         • mono-repo versus repo-per-service
           
      4. Infrastructure
         
         • broker ownership
           
   4. Where?
      
      1. Agentic mesh
         
      2. fitness function-driven architecture