AI-Assisted Architecture Engineering 

Course & Training

Learn to create, challenge and evolve software architecture in arc42 format using Claude Code, OpenCode or GitHub Copilot Agent Mode — and derive directly actionable implementations from it.

Modern software architecture needs more than good documentation — it must be living, challengeable, and actionable. In this hands-on course, you'll learn to combine arc42 as a structured framework with the power of agentic AI tools like Claude Code, OpenCode or GitHub Copilot Agent Mode. You'll create and maintain architecture documents, generate views and diagrams, write Architecture Decision Records (ADRs), challenge existing architecture decisions with AI support, and implement features directly based on the specification. The course is aimed at architects and engineers who understand architecture as a living, central part of the development process.

In-House Course:

We are happy to conduct tailored courses for your team - on-site, remotely or in our course rooms.

Request In-House Course

Public Course Schedule:

   

Content:


In this course, you work with agentic AI tools like Claude Code, OpenCode or GitHub Copilot Agent Mode to professionally create, maintain, challenge, and translate software architecture in arc42 format into concrete implementations. Working together on a prepared example project, you learn how to feed the AI agent with the right architecture context so it acts precisely and correctly within the defined architecture.

- arc42 as an architecture framework: structure and the 12 chapters, goals, quality requirements and context scope, building block view, runtime view and deployment view, crosscutting concepts and architecture decisions
- Agentic AI tools as an architecture partner: setting up and configuring the tools, CLAUDE.md as a living architecture context document, feeding architecture context effectively into the agent
- Creating and documenting architecture with AI: generating arc42 chapters from requirements, creating and iterating diagrams with PlantUML and Mermaid, ensuring consistency and completeness
- Architecture Decision Records (ADRs): understanding the ADR format and lifecycle, creating ADRs, deriving them from existing codebases and requirements, discussing alternatives and trade-offs with the agent
- Challenging and validating architecture: challenging existing architecture decisions with AI support, reviewing quality attributes and fitness functions, identifying and documenting technical debt and risks
- From architecture to implementation: implementing features end-to-end based on the arc42 specification, ensuring architecture conformance, regression safety through agent-assisted testing
- Keeping architecture and codebase in sync: living documentation, detecting drift between architecture and implementation, continuous architecture maintenance in daily development
- Team collaboration and handover: architecture as shared context, agentic AI tools in team workflows (reviews, onboarding, knowledge transfer), boundaries and responsibility in the human-agent collaboration

You'll leave the course with a living arc42 architecture document, a structured ADR collection, and the know-how to use agentic AI tools as a permanent architecture and implementation partner.


Disclaimer: The actual course content may vary from the above, depending on the trainer, implementation, duration and constellation of participants.

Whether we call it training, course, workshop or seminar, we want to pick up participants at their point and equip them with the necessary practical knowledge so that they can apply the technology directly after the training and deepen it independently.

Goal:

After this course, you'll be able to create, maintain and challenge professional software architecture in arc42 format with AI support. You'll know how to provide agentic AI tools like Claude Code, OpenCode or GitHub Copilot Agent Mode with architecture context so that features and changes are implemented directly based on the specification — architecture-conformant and traceable.


Duration:

 2 Days (Is individually adapted for in-house courses.)


Form:

A proven mix of concept delivery, live demos with Claude Code, OpenCode or GitHub Copilot Agent Mode, and collaborative practical work on a prepared architecture project. Architecture decisions are discussed, challenged and fed directly into the agent. The theory-to-practice ratio is approximately 30:70 — the focus is consistently on doing.


Target Audience:

Software architects, tech leads and experienced software engineers who see architecture as a central part of their work and want to learn how to integrate modern agentic AI tools into their architecture and development process.


Requirements:

Experience in software development and basic knowledge of software architecture. Comfortable working with Git and a terminal. Prior knowledge of arc42 is helpful but not required — the fundamentals are covered in the course.


Preparation:

Each participant receives a questionnaire and installation instructions after registration (Node.js, Claude Code CLI or OpenCode, Git, VS Code or JetBrains IDE). The shared example project is provided as a Git repository before the course begins. During the course, necessary AI API tokens will be provided for local use.

Request In-House Course:

In-House Kurs Anfragen

Waitinglist for public course:

Sign up for the waiting list for more public course dates. Once we have enough people on the waiting list, we will determine a date that suits everyone as much as possible and schedule a new session. If you want to participate directly with two colleagues, we can even plan a public course specifically for you.

Waiting List Request

(If you already have 3 or more participants, we will discuss your preferred date directly with you and announce the course.)

More about arc42 and AI-assisted architecture



arc42 is a proven, open template standard for software architecture documentation. It structures architecture knowledge into 12 clearly defined chapters — from goals and quality requirements to building block and runtime views through to architecture decisions and technical risks. Combined with agentic AI tools like Claude Code, OpenCode or GitHub Copilot Agent Mode, a powerful duo emerges: structured, living documentation meets an agent that understands this documentation, challenges it, and uses it as the basis for concrete implementations.




History


arc42 was developed around 2005 by Peter Hruschka and Gernot Starke and released as an open template. It emerged from practical work on real projects with the goal of making architecture understandable, communicable and maintainable. Today arc42 is widely used, particularly in the German-speaking world, and is recognised by iSAQB as an established architecture framework.


Architecture Decision Records (ADRs) were popularised by Michael Nygard in 2011 and established themselves as a simple, versionable method for documenting architecture decisions in a traceable way. With the emergence of agentic AI tools like Claude Code (2024), entirely new possibilities opened up: the agent can not only generate and structure ADRs, but also act on their basis during implementation.


The combination of structured architecture documentation and agentic AI is one of the most exciting developments in software engineering in recent years. It makes it possible to treat architecture not as a static artefact but as a living, machine-readable context — the foundation for reliable, architecture-conformant development with AI agents.