Preventing the Erosion of Architectural Design Rationale

47 concepts35 papers1 proposal

When we look at a complex system—whether it is a software codebase, a chemical processing plant, or a multi-layered data ontology—we are looking at the final state of a long sequence of human decisions. We see what was built: the classes, the pipes, the geometric constraints, and the data schemas.

What we rarely see is why it was built that way.

The underlying logic, the rejected alternatives, the hard trade-offs, and the negotiated compromises form the design rationale. When a system is maintained over years, this rationale frequently disappears—a phenomenon researchers call architectural knowledge vaporization. Without this invisible context, the physical or digital structure of the system begins to decay. New modifications inadvertently violate the original design principles, turning elegant architectures into unmaintainable, fragile systems.

Understanding why this knowledge evaporates, how it causes systems to erode, and how we can systematically capture it is a vital frontier in systems engineering.


The Gap Between Structure and Intent

The core problem stems from a fundamental asymmetry in engineering tools: they excel at capturing the final structure of a design but are blind to the process that created it.

As Terveen et al. (A Tool for Achieving Consensus in Knowledge Representation) observed, traditional tools record the final artifacts of a system but fail to document the arguments exchanged during the decision-making process. Future contributors are left understanding what was decided, but not why specific alternatives were rejected. This focus on the final product is embedded deep within industry standards. In manufacturing, Niu et al. (Product design lifecycle information model (PDLIM)) point out that traditional product lifecycle standards heavily prioritize technical specifications and geometry over early-stage rationale, completely losing the contextual "why" behind the physical dimensions.

This lack of internal context cripples a system's ability to explain itself or adapt. In the domain of artificial intelligence, Neches et al. (Explainable (and Maintainable) Expert Systems) argued that because design decisions and trade-offs are not captured within the software itself, systems lack the necessary context to explain their own behavior to users. Similarly, a landmark panel report by Amarel et al. (AI and Design) concluded that without a record of why specific choices were made, automated systems cannot facilitate meaningful design reuse or provide robust explanations for their outputs.

[Design Process] ──(Discussions, Trade-offs, Rejected Alternatives)──┐
                                                                     ▼
[Traditional Tools] ──────────────────────────────────────────► [Final Structure Only]
                                                                     │
                                                                     ▼
                                                        (Context is Vaporized)

Why Architectural Knowledge Vaporizes

If design rationale is so critical, why isn't it routinely documented? Research highlights a combination of human friction, organizational behavior, and informal communication channels.

  1. The Friction of Active Development: Documenting rationale requires cognitive context-switching. Katz et al. (Towards a Programmer's Apprentice (Again)) note that developers frequently bypass documenting their reasoning because the manual effort disrupts their active development workflow. Furthermore, Terveen et al. (A Tool for Achieving Consensus in Knowledge Representation) point out that capturing rationale is often perceived as an unproductive, secondary task compared to shipping features.
  2. The Informality of Decision Making: Architecture is rarely decided in formal, structured documents; it is negotiated dynamically. Bi et al. (Architecture Information Communication in Two OSS Projects: the Why, Who, When, and What) and Tempich et al. (An Argumentation Ontology for DIstributed, Loosely-controlled and evolvInG Engineering processes of oNTologies (DILIGENT)) demonstrate that critical design rationales are routinely buried in unstructured communication channels like mailing lists and email archives. Because these decisions are made informally, Fu et al. (A Machine Learning Based Ensemble Method for Automatic Multiclass Classification of Decisions) observe that time and budget constraints prevent them from ever being translated into formal documentation.
  3. Personnel Turnover: When documentation is neglected, the architecture lives solely in the heads of individual engineers. Abran (The Software Architecture Mapping Framework for Managing Architectural Knowledge) notes that design risks and rationales are frequently confined to the expertise of individual senior designers. When these key individuals leave a project, Li et al. (Understanding Architecture Erosion: The Practitioners' Perceptive) and Wan et al. (Software Architecture in Practice: Challenges and Opportunities) show that the underlying design context vanishes entirely, leaving behind opaque, problematic dependencies that subsequent teams cannot decipher.

The Cost of Vaporization: Architecture Erosion

When the "why" behind a system disappears, the system enters a state of architecture erosion (AEr)—the progressive drift between a system's intended design and its actual implementation.

Without historical context, new contributors struggle to adhere to established design conventions. As a result, new entries often violate the implicit consensus of the original architecture. In a systematic mapping study, Li et al. (Understanding Software Architecture Erosion: A Systematic Mapping Study) established that the loss of architectural rationale is a primary driver of structural decay; when the underlying reasons for design choices are forgotten, subsequent modifications are highly likely to inadvertently violate the intended architecture. This structural drift directly accelerates system degeneration and technical debt, a pattern confirmed empirically by Liang et al. (Causes of Architecture Changes: An Empirical Study through the Communication in OSS Mailing Lists).

[Original Intended Architecture]
               │
               ▼  (Personnel turnover & undocumented changes)
[Vaporization of Rationale]
               │
               ▼  (Subsequent modifications violate invisible constraints)
[Architecture Erosion / Structural Decay]

The consequences of this erosion vary across domains, but they are universally costly:

  • In Software Systems: Erosion creates opaque dependencies and poorly understood constraints, making it incredibly difficult for future developers to evolve the software without introducing unintended side effects (Wan et al.).
  • In Physical Infrastructure: In chemical plant lifecycle engineering, Takeda et al. (S172022 Management of Change based on Business Process Model of Chemical Plant Lifecycle Engineering) demonstrated that when the original logic and philosophy behind engineering choices are lost by the time a facility reaches its maintenance phase, engineers can no longer accurately predict the safety implications of even minor physical modifications.
  • In Component Reuse: If engineers cannot access the decision-making logic or simulation results that justify a specific component's design, they cannot safely evaluate whether that component is suitable for a new application, rendering design reuse impossible (Wu et al.).
  • In Information Retrieval: O'Sullivan et al. (Capturing and Reusing Case-Based Context for Image Retrieval) show that when expert knowledge and decision-making rationale are lost after a task is completed, subsequent users are forced to re-discover how to interpret and select data from scratch.

Solutions: Formalizing and Automating Capture

To stop architectural knowledge from vaporizing, researchers are developing methods to turn informal, ephemeral discussions into structured, queryable knowledge bases. This work proceeds along two main trajectories: formal ontologies and automated extraction.

Formalizing Rationale as Data

Rather than treating design rationale as unstructured text side-notes, modern frameworks treat arguments and justifications as first-class, formal entities. Gangemi et al. (C-ODO: an OWL Meta-model for Collaborative Ontology Design) pioneered frameworks where semantic justifications and evidence are treated as formal entities that can be tracked, visualized, and queried by both humans and automated systems.

Similarly, El-Boussaidi et al. (An approach for classifying design artifacts) developed structured methodologies to adapt enterprise architecture principles to granular design patterns, turning informal design text into a traceable knowledge base. By breaking down design patterns into fine-grained artifacts and weighted arguments, frameworks like the Software Architecture Mapping (SAM) framework developed by Abran (The Software Architecture Mapping Framework for Managing Architectural Knowledge) allow teams to explicitly map out which architectural choices pose the greatest risks to a project's budget and quality.

Automating the Capture Pipeline

Because manual documentation introduces high friction for developers, recent work focuses on mining rationale automatically from the places where developers already talk.

Instead of forcing engineers to write separate documentation, the authors of modern automated systems use machine learning to parse informal communication archives. For example, Fu et al. (A Machine Learning Based Ensemble Method for Automatic Multiclass Classification of Decisions) developed a machine learning ensemble method that automatically scans developer mailing lists and classifies text into distinct decision types (such as Design, Requirement, or Management).

By automatically extracting and categorizing these decisions from everyday communication, these tools construct a continuous, low-friction project history. This bridges the gap between the chaotic reality of collaborative engineering and the structured context required to keep a system alive and healthy over its entire lifecycle.

Key Foundational Work

An Intelligent Aid for Circuit Redesign (1983) — contributed 1 concept elements to this direction.
Explainable (and Maintainable) Expert Systems (1985) — contributed 1 concept elements to this direction.
History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 33 papers
  2. Version 1 · 2026-10-04 · 19 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_design_rationale_loss_9ac55f27,
  title = {design rationale loss},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/design-rationale-loss/rdr_9ac55f270a5b41c28e154854d5b37fef},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_design_rationale_loss_9ac55f27_v2,
  title = {design rationale loss},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/design-rationale-loss/rdr_9ac55f270a5b41c28e154854d5b37fef/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake