Coding skill alone is not enough to get or keep a job in an AI world, no matter how good you are. You need architectural skills and systems thinking. These are core technical skills, maybe more so than coding, and essential if you want to stay relevant, whether or not AI is on the scene.

Good architecture makes your system easy (and less expensive) to build, maintain, and grow, whether or not an AI is helping with the code. A perfect implementation of an inappropriate architecture is a liability. Architecture also impacts how you work, touching everything from process to organizational and team structure. A team cannot work effectively when it's fighting the architecture every time it needs to make a small change, and agility is impossible in that situation.

Architecture is particularly important when you work with AI-assistance or integrate AI into your products. An LLM can code, but it can't design, which requires judgment. Even Spotify, which claims that 100% of its new code is machine-generated, does not entrust its LLM with architectural decisions. AI-Assistance requires an architecture within which the LLM can work effectively at minimal cost. A non-AI-focused architecture is literally too expensive to be viable.

There is no one-size-fits-all "best" architecture, however. An architecture that's appropriate in one context will work against you in another. You'll learn a wide range of patterns in this class, and how to combine them to create an optimal architecture for the problem at hand. Architecture is all about informed trade offs, and this class will show you how to make them.

Finally, there are architectures that use embedded intelligent "agents" to do their work. You'll learn about those, as well.

In this class:

• You'll learn how to create effective software architectures for your products and systems, whether or not AI is involved.
• You'll learn how to create architectures that welcome changing requirements and facilitate teamwork without adding dependencies that can slow you down.
• You'll learn how to design systems that support AI-assisted software engineering, make it easy to incorporate the code the LLM writes and manage contexts effectively to improve accuracy and keep token costs down and limit the blast radius when the LLM makes a mistake.
• You'll acquire a pallet of architectural patterns that help organize your thinking.
• You'll learn how to make effective architectural trade-offs.
• You'll learn how to design systems that can evolve incrementally over time. Incremental architectures start simple and grow as you learn and the need for scaling emerges.
• You'll learn to design "Agentic" (LLM-based) software systems based on modern component architectures (agents, microservices, components-in-a-monolith, etc.).
• You'll learn to design systems that work well in distributed or cloud environments, are highly reliable, secure, and fault tolerant.
• You'll learn how to build effective APIs for both human and intelligent agent-to-agent communication.
• You'll learn how to design domain-focused event-based systems using DDD and event storming. These systems are particularly well suited to adapt to rapidly changing requirements and discoveries made in tight customer-feedback loops.

Outline:

The role of the Architect

Architectural and systems thinking

AI-appropriate architecture

• components and context management

Incremental architecture

• Integrating coding and product development
• The inspect-and-adapt loop.
• Taming the AI assistant

Working with architectural patterns

• Managing trade-offs
• Architectural characteristics
• Defining -ilities
• Architectural Decision Records (ADRs)

AI impacts the structure of our programs in two ways. First, the program must be designed to work well in an AI-assisted software engineering environment. The blast radius of a change must be contained, for example, and the "context" must be managed to improve accuracy and minimize the cost of using the LLM to generate or change code. Next, the systems that we create that have AI embedded in them have to be secure, fault tolerant, and structured to ease agent-to-agent communication. In this session, you'll learn how to architect systems that support one or both of these goals.

You'll learn about:

• LLM Contexts and context management
• Micro-component and micro-Agent architectures that allow for incremental changes as we work with the LLM.
• Test-friendly architectures for LLM-generated applications.
• Building both REST and lightweight-messaging APIs for both human and agent-to-agent use.
• Agent-to-Agent communication strategies and the Model Context Protocol