How LLMs Can Transform Software Architecture Governance and Code Generation

Background and Motivation

In early 2023 the authors presented at QCon the idea that "architecture is code" and built the ArchGuard governance feature to convert architectural rules into executable code. Later they explored how LLMs can boost R&D efficiency, noting three emerging challenges: faster code generation raises the importance of sound architecture, architecture evolution becomes a new bottleneck, and architectural knowledge must be tool‑enabled to fully leverage LLM capabilities.

Embedding Architecture Rules into Development Tools

To address these challenges the team created the AutoDev IDE plugin, which integrates architectural styles (e.g., three‑layer architecture) into automated requirement analysis and code generation. By embedding architecture specifications directly into the tool, generated code adheres to the desired architectural constraints.

LLM‑Enhanced Architecture Lifecycle

The authors define a "three‑state two‑party" model: design, development, and runtime phases (the three states) and the architecture team versus the architecture users (the two parties). LLMs can add value at each phase:

Design Phase

LLMs use natural‑language processing to extract business concepts and relationships from requirements, enabling rapid architectural modeling and even pre‑validation of designs through simulated scenarios.

Development Phase

LLMs translate architectural specifications into code by leveraging two core abilities:

Abstract understanding – mapping design patterns, interfaces, and component interactions to language‑specific templates.

Pattern recognition – learning coding conventions to produce code that complies with both architecture and best‑practice standards.

This reduces developers' workload, improves consistency, and maintains maintainability.

Runtime Phase

LLMs can interpret external or user requests, dynamically compose context, verify permissions, and orchestrate resources across multiple services, effectively extending the open‑layer capabilities of the architecture while preserving security and controllability.

Design Principles for AIGC‑Friendly Architecture

Three core elements are proposed:

Explicit Architecture Knowledge – transform tacit conventions into clear, machine‑readable artifacts (text, DSL).

DSL‑Based Context Refinement – use domain‑specific languages to compress and structure the necessary architectural context for LLMs.

Full‑Process Guidance – steer AIGC from requirement gathering through design, coding, and deployment toward the target architecture.

These principles address the common problem that many organizations have undocumented or unenforced architectural rules, leading to low adoption.

Practical Explorations

Example 1: End‑to‑End Architecture Generation Tool

AutoDev integrates GitHub issues as a lightweight requirement source, applies layer‑specific standards, and generates code for Controllers, Services, and Repositories according to the corresponding DSLs.

Example 2: LLM‑Assisted Architecture Governance

In ArchGuard Co‑mate, architectural rules are converted into DSLs that can be dynamically generated per team, supporting layered, API, and model specifications.

Example 3: AIGC‑Assisted Architecture Design DSL

A DSL is used to compress user journeys into a concise representation that fits LLM context limits.

caseflow("MovieTicketBooking", defaultActor="User") {
    activity("AccountManage") {
        task("UserRegistration") {
            stories = listOf("Register with email", "Register with phone")
        }
        task("UserLogin") {
            stories += "Login to the website"
        }
    }
}

This DSL can later be rendered into UI components for interactive editing.

Conclusion

Integrating LLMs throughout the software architecture lifecycle—by making architectural knowledge explicit, refining context with DSLs, and guiding AI‑generated artifacts—can significantly improve code generation quality, reduce bottlenecks, and deliver tangible benefits to both development teams and end users.