Course · Training · Workshop

AI-Assisted Architecture Engineering

Create and challenge software architecture in arc42 format with Claude Code, OpenCode or GitHub Copilot Agent Mode, then translate it directly into actionable implementations.

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

Tailored for your team.

Request

No suitable date?

Request a new public date.

Request a date

Trainers

Andreas Deicha

Instructor

What participants say

These customers booked courses in the same topic cluster.More customers →

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.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.

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

Format

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 group

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.

Prerequisites

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 this course in-house

Request a public date

No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.

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.

Further resources:

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.