In which I collect my thoughts on many topics but mainly about systems engineering, software engineering, and system/software architecture

Architecture Metrics Are Not Scores: Diagnosing Constraint, Encounter, and Drift

Organizations like metrics because metrics appear to make architecture governable. A number can be reported. A trend can be shown. A threshold can be assigned. A dashboard can be reviewed. Once this happens, the architecture appears to have been made visible. But architecture is not made safe merely because something has been counted.

A metric can illuminate an architecture, but it can also become another second-order representation as a compressed artifact that is easier to govern than the architecture itself. The danger is not measurement but forgetting what kind of thing has been measured, what has been omitted, and what architectural claim the metric does not establish.

This matters because architecture is not simply the designed structure, the approved model, the interface document, or the review package. Architecture is also lived as we discussed in previous posts. It is encountered by engineers, operators, maintainers, suppliers, testers, safety assessors, manufacturing planners, governance boards, and users. Each of these agents encounters the architecture through a different locality of action.

A useful architecture metric therefore does not measure “the architecture” in the abstract. It diagnoses traces of architectural consequence.

Metrics as Diagnostic Traces

Most useful architecture metrics are not measurements of architectural substance. They are measurements of architectural consequence. This is consistent with a long-running tension in software and systems work: the architecture is not only a decomposition, but also a structure that affects change, aging, modular option value, and the cognitive work required to reason about the system [Jr.86, Par94, BC00, BG+01, FFF+23].

We observe the architecture through effects such as change effort, integration friction, decision latency, verification expansion, cognitive burden, option loss, rework pressure, governance delay, representation mismatch, and debt migration. These are not the architecture itself. They are traces of how architectural structure constrains action over time.

This distinction is important. A modularity metric may suggest that the decomposition is clean. However, if every significant change still requires coordination across five teams, the lived architecture is telling a different story. A dashboard may indicate that requirements coverage is complete. But if the evidence cannot support a safety claim, the dashboard has compressed away the architectural limitation that matters. A model may show an interface boundary. But if the meaning of that interface is unstable across teams, the lived coupling remains.

Architecture metrics should therefore be treated less like scores and more like diagnostic probes. A probe is useful because it has a declared purpose, a declared region of application, and known limitations. It tells us something. It does not tell us everything.

Other engineering disciplines routinely use metrics as part of correction. A tolerance measurement in mechanical engineering is not merely a status report. Instead, it determines whether the process is producing an admissible part. An electrical measurement is not merely a dashboard value. It provides evidence about circuit behavior that may require design or process adjustment. Software and systems engineering have many metrics, but too often those metrics become status reports rather than control instruments. They describe activity, maturity, or status without forcing reconsideration of the requirements, architecture, decision sequence, locality assignment, or process that produced the observed condition.

Architecture metrics should be recovered as part of a feedback loop. A metric should help determine what must be adjusted: the architecture, the requirement, the representation, the decomposition, the verification strategy, the governance path, or the process by which decisions are being made. Otherwise the metric may be visible while remaining architecturally inert.

CCC: From Dissertation Metric to Architectural Diagnostic

Encountered cognitive complexity, or CCC, did not begin in this blog series as a convenient label for architectural difficulty. It originated in my dissertation work on service-oriented robotic platforms [Hes11]. The path by which it entered that work is important. During my preliminary defense, one of my committee members asked a simple but difficult question: assuming he accepted that service orientation might be a preferred approach to integration in robotics, how would I prove it? My answer was that the claim would require metrics. But I also knew that the metrics I needed did not really exist, at least not in a form adequate to the architectural claim I was making. His response was direct: the next task part to get to completion was to develop a metric adequate to the claim.

I spent the next year working through that problem. CCC or the Complexity Change Cost of integration actions on an architecture became the main result of that effort. In hindsight, the original thesis about service orientation in robotics now feels less important than the metric that emerged from the attempt to justify it. The deeper question was not only whether service orientation helped integration. The deeper question was how architectural claims can be made observable at all.

In that dissertation setting, the problem was not merely that robotic systems were technically complex. The problem was that architectural choices changed how that complexity was encountered by developers, integrators, operators, and maintainers.

A service-oriented robotic architecture could separate concerns, expose reusable capabilities, and make some forms of integration easier. But it could also move complexity. A capability that looked clean at the service boundary might still create cognitive burden in discovery, coordination, semantic interpretation, timing assumptions, failure handling, or operational use. The architectural problem was then not simply whether the system contained complexity. The problem was where that complexity was encountered, by whom, and in the context of what action.

That original framing is important because it prevents CCC from becoming a generic synonym for “complicated.” CCC was never intended to be just a global complexity score. It was a way of reasoning about the cognitive burden induced by architectural form in a localized context of use. In that sense, it sits near software-engineering work on essential complexity and cognition, but it remains specifically architectural in its emphasis on locality, integration, and action context [Jr.86, BG+01, FFF+23].

The concept has evolved since then. In the dissertation context, CCC was tied closely to software and robotic platform architecture through services, interfaces, reuse, command and control, integration, and human–robot interaction. In the present architecture framework, CCC is broader. It is treated as a diagnostic trace of lived architecture or a way to observe how architectural constraints become cognitively expensive for agents acting within a particular locality.

This evolution does not replace the original idea. It generalizes it. CCC remains concerned with encountered complexity, but the relevant encounter is no longer limited to a software developer or robotic-platform integrator. The encounter may belong to a verification engineer constructing evidence, a safety assessor interpreting a claim, a manufacturing planner absorbing a design decision, a governance board approving a change, or an operator working within the system’s actual constraints.

The important continuity is that CCC is about understanding complexity as encountered through architecture, not complexity as an abstract property floating above the system.

From Integration Difficulty to the “-ilities”

The original CCC work also raised a broader question. If integration difficulty can be understood as encountered cognitive complexity, then perhaps other architectural “-ilities” can be understood in a similar way.

Integrability, modifiability, verifiability, maintainability, evolvability, governability, certifiability, and usability are often described as useful qualities of a system. That description is useful, but incomplete.

These qualities are also ways of naming how future agents will encounter the consequences of present architectural decisions.

  • A modifiability decision made now changes the future complexity of change
  • A verifiability decision made now changes the future complexity of evidence
  • An integrability decision made now changes the future complexity of convergence
  • A governability decision made now changes the future complexity of authority, escalation, and constraint

This framing is compatible with modularity and option-value arguments in design theory, but it shifts the emphasis toward the agentic encounter with future architectural consequence [BC00].

The causal framework makes this extension more precise. Architectural decisions are made in the causal present, but their consequences extend into the causal frontier. The “-ilities” are therefore not merely static properties. They are projected modes of future encounter. Architectural “-ilities” are not merely qualities possessed by a system. They are structured expectations about how future agents will encounter the consequences of present architectural decisions.

CCC Is Local, Not Global

This is especially important for encountered cognitive complexity, or CCC.

CCC should not be treated as a single global score assigned to the system. That would break with the motivation of the original formulation. Its value depends heavily on how locality is assigned within the architecture. A software maintainer, verification engineer, systems architect, operator, safety assessor, manufacturing planner, supplier, and governance board may each encounter a different architectural region and therefore a different cognitive burden.

This does not make CCC subjective in the casual sense. It makes CCC situated. The metric must declare the locality within which it is recovered: the component boundary, interface region,

integration path, verification cone, operational workflow, governance path, supply-chain boundary, or cross-layer decision surface being examined.

The same architecture may therefore contain multiple CCC fields at once. A design can be locally simple for one team while generating high encountered complexity for another. It can simplify implementation while increasing verification burden. It can reduce near-term decision effort while increasing future recovery cost. It can make the software locally coherent while making the safety case harder to construct.

For that reason, a global CCC score risks compressing away the very architectural information the metric is supposed to reveal.

A better formulation is this

CCC is recovered relative to a declared architectural locality, agentic perspective, and action context.

There may be many CCC values within the same architecture because there are many legitimate localities of encounter.

The more important diagnostic may not be the absolute CCC value in one region. It may be the pattern of CCC variation across regions.

  • Where does CCC concentrate?
  • Where does it move when a decision is made?
  • Where does it decrease locally while increasing downstream?
  • Where does an interface boundary reduce one team’s cognitive load by exporting ambiguity to another?
  • Where does governance reduce near-term risk by increasing long-term architectural friction?

These are architectural questions, not merely measurement questions.

Locality Is Not Fixed

The locality of CCC is not fixed by the decomposition diagram alone. It can change as the architecture changes, but it can also change as the question changes.

  • A component boundary may define one locality
  • An integration path may define another
  • A verification cone may cut across both
  • A safety claim may impose a locality that ignores the software team’s decomposition
  • A manufacturing constraint may join regions that appear independent in the functional architecture
  • A regulatory interpretation may make distant design decisions part of the same effective locality.

This means locality is not just spatial. It is causal, operational, semantic, organizational, and temporal.

A region is local when action within that region can be understood, governed, changed, verified, or operated without pulling too much of the architecture into the active field of concern. When that condition fails, the experienced locality expands. What looked local in the representation becomes nonlocal in the lived architecture.

This is one reason architecture metrics cannot be interpreted independently of viewpoints, concerns, and stakeholders. Architecture description standards emphasize that views and viewpoints exist to address stakeholder concerns; the same architecture must be made visible in different ways because different concerns expose different relevant structure [iso22, SEB25]. Metrics inherit this same condition. A metric without a declared locality and decision-use boundary is an under-specified representation.

Antichains Can Redefine Locality

Antichain considerations make this even sharper.

An architectural antichain is a set of options, decisions, or design states that are not yet causally ordered with respect to one another. They remain incomparable at the current frontier. In ordinary trade-study language, they are still live alternatives. In architectural language, they are unresolved future-shaping possibilities.

While an antichain remains open, locality may be distributed across the frontier. Different options may carry different CCC profiles. One option may be easy for software and hard for verification. Another may be hard for manufacturing but easier for sustainment. A third may preserve option entropy while increasing governance burden.

Before selection, there may be no single correct CCC locality. The locality depends on which antichain element is being examined and which future cone is being projected. When a decision collapses part of the antichain, the locality changes. The chosen option places some regions into the causal past of future action. What was previously optional becomes inherited structure. What was previously a trade-space comparison becomes a committed constraint. The agents who act afterward do not encounter the same architecture that existed before the decision.

This is why CCC should be evaluated not only at architectural states, but across transitions. A decision can reduce CCC for the current decision-maker while increasing CCC for downstream implementation. It can reduce integration ambiguity while increasing verification burden. It can simplify near-term governance while narrowing future architectural options.

The antichain therefore acts like a locality-transforming structure. It defines multiple possible localities of encounter before commitment and a different locality after commitment.

This also explains why trade studies are not merely selection exercises. They are disciplined transformations of future locality.

Vertical Influence Can Shift Locality Nonlinearly

Vertical architectural layers complicate the picture further.

Architecture is not only arranged horizontally across components, functions, interfaces, and subsystems. It is also layered vertically across mission, business, operations, functions, physical realization, software, verification, manufacturing, service, regulation, safety, security, and governance.

  • A change in one vertical layer can alter the effective locality in another
  • A new safety interpretation can make a software detail architecturally significant
  • A manufacturing constraint can pull a previously internal design choice into a cross-layer trade
  • A regulatory concern can transform an implementation shortcut into a certification problem
  • A governance decision can force an integration path to absorb complexity that had been invisible at the component level

These shifts are often nonlinear. A small change in one layer may have little effect until it crosses a threshold. Then the locality expands abruptly. A local software issue becomes a verification issue. A verification issue becomes a safety issue. A safety issue becomes a governance issue. A governance issue becomes a business or mission issue. The metric did not merely change value. The region over which the metric must be recovered changed.

This is why a localized CCC framework is more useful than a global score. It allows us to ask where locality is stable, where it is expanding, where it is being shifted onto another layer, and where an apparently local decision is becoming cross-layer architectural constraint.

CCC and TTD: From Encounter to Deferral

The link between CCC and Total Technical Debt follows naturally.

When localized CCC exceeds the capacity of an agent, team, or organization, deferral becomes rational. The actor simplifies the present field of action in order to keep moving. They postpone a decision, narrow a representation, accept an interface ambiguity, defer verification, create a workaround, preserve an unstable assumption, or move the burden to another team. This is not necessarily incompetence. Often it is local rationality under excessive encountered complexity.

The complexity has not disappeared. It has been displaced.

Technical debt is often the fossil record of locally rational encounters with excessive architectural complexity. Each deferral preserves near-term action, but it also deforms the future cone. Over time, these deformations can accumulate. Debt piles up in regions where future agents must repeatedly pay for prior simplifications. This connects debt to the broader software-aging problem: past choices can make future change increasingly difficult even when the system continues to function in the present [Par94]. Eventually, the architecture develops basins of attraction: regions where the easiest next move is not the architecturally best move, but the move made likely by accumulated constraint.

This is where CCC and TTD become tightly coupled. CCC helps diagnose where action has become cognitively expensive. TTD helps diagnose where the consequences of prior simplifications have accumulated. The relationship is not one-way. High CCC can produce deferral and debt. Accumulated debt can then increase CCC for future work. The architecture becomes harder to reason about because the past has been compressed into unresolved obligation.

A Diagnostic Family, Not a Master Metric

CCC is only one diagnostic. It should sit within a broader family of architecture metrics:

DiagnosticWhat It Reveals
CCCWhere architecture becomes cognitively expensive to engage or act within
TTDWhere deferred architectural consequence accumulates and reshapes future action
Option entropyWhere architectural futures are being preserved, narrowed, or prematurely collapsed
Verification burdenWhere evidence obligations expand across causal structure
Governance latencyWhere decision authority lags architectural consequence
Representation fidelityWhere artifacts fail to preserve decision-use meaning and known limitations
Coupling propagationWhere change propagates across supposedly separated regions
Basin exit costWhere prior decisions have created local architectural traps

No single metric can measure architecture because architecture is not a single kind of thing. It is causal structure, decision memory, constraint field, lived encounter, representation, governance object, verification burden, operational reality, and future-option structure.

A responsible metric must therefore carry its limitations forward with the number. It should declare what it observes, what locality it assumes, what action it is meant to inform, what it ignores, and what architectural claim it does not establish.

What a Responsible Architecture Metric Should Declare

A useful architecture metric should answer at least the following questions:

  1. What architectural locality is being measured?
  2. Which agent, role, or stakeholder perspective is assumed?
  3. What action context is being evaluated?
  4. Which vertical layers are included or excluded?
  5. What antichain, frontier, or decision state is assumed?
  6. What changes when the antichain collapses or a decision is committed?
  7. What does the metric reveal?
  8. What does the metric hide?
  9. What decision is the metric allowed to inform?
  10. What claim does the metric not establish?

This is not overhead. It is what prevents the metric from becoming a misleading dashboard element.

Conclusion: Make Consequence Harder to Ignore

The goal is not to make architecture measurable in the simplistic sense. The goal is to make architectural consequence harder to ignore.

Metrics are necessary because architecture is too large, layered, causal, and temporally extended to inspect by intuition alone. But metrics are dangerous when treated as complete representations.

They are diagnostic instruments, not substitutes for architectural judgment.

CCC shows why this matters. If we treat CCC as a global score, we lose the local structure of encounter. If we localize it carefully, we can see where cognitive burden concentrates, where it moves, where decisions shift it, where antichains preserve or transform it, and where vertical-layer influence expands it nonlinearly.

That is the deeper value of architecture metrics. They do not simply tell us whether the architecture is good or bad. They help us see where the architecture is becoming difficult to live within, where local rationality is producing future obligation, and where the next decision may reshape the field of action for everyone who follows.

References

[BC00] Carliss Y. Baldwin and Kim B. Clark. Design Rules, Volume 1: The Power of Modularity. MIT Press, 2000.

[BG+01] Alan F. Blackwell, Thomas R. G. Green, et al. Cognitive dimensions of notations: Design tools for cognitive technology. In Cognitive Technology: Instruments of Mind, pages 325–341. Springer, 2001.

[FFF+23] Fabian Fagerholm, Michael Felderer, Davide Fucci, Michael Unterkalmsteiner, Bogdan Marculescu, Markus Martini, Lars G.ranWallgren Tengberg, Robert Feldt, Bettina Lehtel., Bal.zs Nagyv.radi, and Jehan Khattak. Cognition in software engineering: A taxonomy and survey of a half-century of research. ACM Computing Surveys, 2023.

[Hes11] Paul D. Hestand. A Service Oriented Architecture for Robotic Platforms. Ph.D. thesis, University of Massachusetts Lowell, March 2011.

[iso22] ISO/IEC/IEEE 42010:2022, software, systems and enterprise – architecture description, 2022.

[Jr.86] Frederick P. Brooks Jr. No silver bullet: Essence and accidents of software engineering. In Proceedings of the IFIP Tenth World Computing Conference, 1986.

[Par94] David Lorge Parnas. Software aging. In Proceedings of the 16th International Conference on Software Engineering, 1994.

[SEB25] SEBoK Editors. System architecture design definition. Guide to the Systems Engineering Body of Knowledge (SEBoK), 2025.

Leave a Reply