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

Encountered Complexity: Architecture as Cognitive Constraint

Complexity in an architecture is not the same for everyone, from everywhere.

A software developer modifying a service, an integration engineer tracing a failure, a verification engineer assembling evidence, and a program manager approving a change may all be acting within the same system. Yet they do not encounter the same architecture. Different dependencies become visible. Different decisions become relevant. Different constraints must be preserved. Different histories must be recovered.

To speak of the complexity of the architecture as though it were a single property hides an important question

Complex for whom, acting where, trying to do what?

That question has been present in my own work for a long time, although I did not originally frame it in those terms. It emerged while I was developing a service-oriented architecture for robotic platforms and was challenged to demonstrate that service orientation actually improved integration [Hes11].

During my preliminary dissertation defense, a committee member asked me a simple question: assuming service orientation really was a preferred approach to integration in robotics, how would I prove it? I answered that proving such a claim would require metrics—but that I did not believe adequate metrics existed for what I was trying to demonstrate.

The response was “Then develop one!”

I spent much of the following year doing exactly that.

The result was Complexity Change Cost, or CCC, a metric intended to characterize the complexity encountered within a declared architectural locality and the impact that localized complexity has on resource consumption – budget, time, cost – in changing that complexity. At the time, I understood CCC primarily as a way to reason about integration complexity in service-oriented robotic platforms.

I now think it was pointing toward something broader. CCC was never really trying to answer

How complex is this architecture?

It was trying to answer a more situated question

How much architectural structure must be cognitively encountered from this location in order to act?

That distinction matters.

Complexity from Somewhere

Consider a large system containing hundreds of subsystems, services, interfaces, requirements, verification activities, organizational boundaries, and accumulated decisions. From a sufficiently distant view, we might attempt to describe its total structural complexity. We could count components. We could count connections. We could examine graph density, coupling, hierarchy, centrality, dependency depth, or any number of other structural properties.

Those measures may be useful but they do not necessarily tell us what any particular person must actually encounter in order to make a decision.

A developer changing one software service may need to understand only a small part of the system. Or that seemingly local change may unexpectedly require knowledge of several external interfaces, a safety constraint, a timing assumption established years earlier, a hardware limitation, an undocumented operational dependency, and a verification procedure owned by another organization.

The relevant complexity is not simply everything that exists. It is the portion of the architecture that becomes causally relevant to the action being attempted.

That relevance depends on locality.

By locality, I do not mean only physical location or graph-theoretic neighborhood. An architectural locality is the situated region from which an agent acts: a position defined by the action being attempted, the decisions currently available, the information accessible, the constraints that must be preserved, the dependencies that can propagate consequence, and the organizational or technical boundaries through which the agent may have to pass.

Two people may therefore act on the same system for different purposes and legitimately encounter very different architectures.

The architecture is the same. The encounter is not.

The Architecture That Must Be Encountered

This idea has important parallels in work on situated and distributed cognition. Situated approaches reject the assumption that cognition can always be adequately understood in isolation from the environment in which action occurs [RA09]. Distributed cognition goes further by examining how cognitive activity can be spread across people, artifacts, representations, and organized activity systems [Hut95]. Ecological psychology similarly emphasizes the relation between an acting organism and an environment that presents possibilities for action [Gib79].

I am not claiming that these traditions already contain the architectural framework developed here. They do, however, support a broader principle

Cognition happens from somewhere, under certain conditions, in relation to an environment in which action must occur.

Architecture participates in creating that environment.

A systems engineer trying to assess a proposed change does not interact with an abstract architecture in its entirety. The engineer encounters requirements documents, models, interface definitions, test results, historical decisions, experts, organizational authorities, tools, simulations, assumptions, and gaps in knowledge

  • Some of these representations faithfully expose the relevant architecture
  • Others obscure it
  • Some dependencies are obvious
  • Others become visible only when something fails.

The architecture that must be encountered may therefore extend far beyond what is immediately visible.

A seemingly local decision may force an agent to cross mission, operational, functional, physical, software, verification, manufacturing, regulatory, or governance layers. The agent does not encounter those layers because they exist in a diagram. The agent encounters them because they become causally relevant to responsible action.

This is why encountered complexity is not merely a synonym for being complicated.

The real question is not

How many things are there?

It is

How much structure must be recovered, understood, reconciled, and preserved in order to act without unacceptable consequence?

From Architecture as Object to Architecture as Lived Constraint

In an earlier post, I introduced the idea of Lived Architecture: the architecture as encountered through situated action rather than merely represented as an external object. That distinction changes how we can interpret CCC.

In its original form, CCC was a localized architecture metric concerned with cognitive complexity and coupling. From within the causal framework developed through this series, I now see it more broadly

CCC diagnoses how architectural structure becomes cognitively encountered by an agent acting within a declared locality.

This moves CCC from a measure of architecture as object toward a measure of architecture as lived constraint.

The architecture constrains

  • What can be changed
  • What must be known
  • Which decisions remain available
  • What evidence must be produced
  • Whose authority must be consulted
  • Which assumptions must remain valid
  • What consequences can propagate into the future

An agent encounters those constraints through action.

This is why the same architecture can appear relatively simple from one locality and overwhelmingly complex from another.

  • A service may expose a clean interface to one developer while concealing substantial complexity elsewhere
  • An abstraction may successfully reduce cognitive burden for one team while transferring additional verification burden to another
  • A decomposition may create local clarity by moving dependencies across an organizational boundary

The complexity has not necessarily disappeared. It likely moved.

This is one of the most important lessons I take from my original CCC work

Architectural complexity can be redistributed across localities.

That redistribution is not inherently good or bad. Much of architecture consists precisely in making complexity manageable when encountered so it can be responsibly managed.

But moving complexity and removing complexity are not the same thing. A good abstraction can reduce unnecessary encounter while preserving the constraints and evidence needed for responsible action. A bad abstraction can merely hide complexity until it reappears later, perhaps during integration, verification, certification, operation, or failure.

The distinction becomes critical.

The Encountering Agent Has a Lived Architecture Too

There is another consequence of taking lived architecture seriously.

The architecture being encountered is not the only architecture in the relation. The encountering agent also has a lived architecture. That agent brings prior experience, domain knowledge, habits, expectations, internalized abstractions, learned patterns, professional language, tool fluency, organizational knowledge, and memories of earlier success and failure. The agent may also rely on external cognitive scaffolding

  • Colleagues
  • Models
  • Checklists
  • Automation
  • Simulations
  • Documentation
  • Decision records
  • Many other representations.

Distributed-cognition research makes this broader unit of analysis important

Effective cognition may be spread across people, artifacts, and organized activity rather than residing within an isolated individual [Hut95].

The same nominal architectural structure can therefore impose very different burdens on different agents.

  • A highly experienced engineer may recognize a familiar pattern immediately. A novice may have to reconstruct it element by element
  • A maintainer who has lived with a system for ten years may know which apparently important dependencies can safely be ignored. A newcomer may have no basis for that discrimination
  • A verification specialist may see an evidence gap that remains invisible to a designer
  • A software engineer may traverse a dependency structure fluently that a program manager experiences only as an opaque technical barrier

Research on cognitive load has long emphasized that problem-solving burden is shaped by the relationship between task demands and the cognitive resources available to the person performing the task [Swe88]. Research on the expertise-reversal effect goes further: information and support that help novices can become redundant or even counterproductive for experts, demonstrating that the effective burden of a task cannot be specified independently of prior knowledge and expertise [KACS03]. Rasmussen’s distinction among skill-, rule-, and knowledge-based behavior similarly shows that the same work can be encountered through very different modes of human performance depending on familiarity, experience, and the availability of established patterns [Ras83].

This suggests a refinement.

Encountered complexity should not be understood solely as the amount of architectural structure that becomes relevant to an action. It should also account for the capability of the encountering agent, or distributed agent system, to absorb, interpret, and act upon that structure.

We can express the encountered complexity C_{enc} in a provisional way as

    \begin{equation*}   C_{enc} = \kappa(a, \ell, \tau) C_{req}(\ell, \tau) \end{equation*}

where:

  • C_{req} is the complexity that must be encountered from locality \ell in order to perform task or action \tau responsibly
  • a is the encountering agent, which may be an individual or a distributed cognitive system
  • \kappa is a provisional competence-sensitive encounter factor reflecting expertise, familiarity, prior knowledge, tool support, representation quality, organizational access, and other forms of cognitive scaffolding.

I am not proposing this as a final CCC equation. The causal formulation of CCC will almost certainly require richer structure.

However, the notation exposes an important point.

For an agent well-matched to the encountered structure, \kappa may be relatively small: the agent compresses patterns, recognizes familiar relationships, accesses appropriate tools, and avoids unnecessary search.

For an agent poorly matched to the encountered structure, \kappa may be large: relationships that are obvious to an expert must be reconstructed laboriously, irrelevant possibilities cannot be discarded confidently, hidden assumptions are harder to identify, and the risk of error increases.

The same idea can be expressed from the opposite direction by introducing an effectiveness term \eta a:

    \begin{equation*}    C_{enc} = C_{req} \eta a, \quad 0 < \eta a \le 1 \end{equation*}

where lower effectiveness increases the burden imposed by the same required architectural encounter.

The two formulations are conceptually dual. One scales the complexity. The other reduces the effectiveness of the agent.

The more important point is not which notation survives. It is that

Encountered complexity is bidirectionally relational. It depends on the architecture encountered and on the lived architecture of the agent doing the encountering.

This also guards against a dangerous interpretation of CCC.

A high CCC value should not automatically be read as evidence of a bad architecture. It may indicate a poorly prepared agent, inadequate tooling, missing decision memory, weak representations, organizational barriers, or a mismatch between competence and assigned responsibility.

Conversely, a highly competent agent can sometimes make a badly structured architecture appear manageable, at least temporarily. That does not mean the architecture is healthy. It may mean that scarce expertise is compensating for architectural deficiencies.

This distinction is operationally important.

When an expert retires, leaves, or simply becomes unavailable, the architecture may appear to become suddenly more complex even though its structural form has barely changed. What has changed is the lived architecture available to meet it.

The system has lost a cognitive capability. That loss should be visible in any mature theory of encountered complexity.

Expertise Is Not Fungible Headcount

This competence-sensitive view raises an uncomfortable organizational question.

Why do companies so often behave as though an experienced senior engineer were simply an expensive version of a recent, inexperienced graduate?

A salary comparison makes the substitution appear straightforward as one expensive engineer being equivalent to several less expensive junior engineers. However, that comparison assumes that engineering capability scales approximately with headcount and labor cost.

For many forms of knowledge-intensive work, that assumption is too weak.

Research on developer productivity does not support a simple one-dimensional model in which output is explained by salary, activity counts, or years of experience alone. A recent systematic review of 218 peer-reviewed studies found developer productivity to be shaped by a broad set of technical, cognitive, environmental, and organizational factors [RBL+24].

The implication is not that every senior engineer outperforms every junior engineer. That would be equally simplistic. The implication is that experience changes how work is encountered, what must be made explicit, how quickly patterns are recognized, which errors are avoided, and how much support the surrounding organization must provide.

The economically relevant comparison is therefore not

How many junior salaries equal one senior salary?

It is closer to

What cognitive and architectural functions disappear when this experienced agent leaves, and what new burdens appear elsewhere when less experienced agents must compensate?

An experienced engineer may contribute through direct production, but also through pattern recognition, anomaly detection, cross-layer interpretation, mentoring, decision-memory recovery, trusted relationships, avoidance of dead ends, and rapid discrimination among plausible and implausible futures.

Those contributions are nonlinear.

An expert does not necessarily solve the same problem three times faster than a novice

  • The expert may recognize that two-thirds of the apparent problem should not be pursued at all
  • The expert may know that an apparently attractive solution violates an assumption made years earlier
  • The expert may recognize that a test result is formally valid but operationally misleading
  • The expert may know which interface is fragile, which document is stale, which dependency is historical rather than necessary, and which person elsewhere in the organization carries the missing part of the decision memory.

This leads to an important principle

Expert Complexity Suppression Principle. A sufficiently competent agent can suppress the effective encountered complexity of an architectural locality through pattern recognition, internalized decision memory, selective attention, trusted relationships, tool fluency, and accumulated knowledge of causal history.

Because successful suppression often appears as the absence of delay, failure, or visible effort, organizations may systematically undervalue the capability until it is removed.

This creates a paradox.

The better an expert is at preventing consequences, the fewer visible consequences exist as evidence that the expert was necessary.

Successful expertise can destroy much of the evidence of its own necessity.

The senior engineer who quietly prevents bad decisions, redirects teams away from dead ends, catches weak assumptions, and preserves architectural invariants may produce less visible activity than someone generating large volumes of code, documents, tickets, or presentations.

Yet the absence of visible failure may itself be the product.

Research on transactive memory systems reinforces this point. Groups do not merely contain individual knowledge. They can develop shared knowledge of who knows what and how expertise can be located and applied. Such systems affect group learning, learning transfer, and the ability to form more abstract understandings of a problem domain [Lew05]. Removing an experienced person may therefore damage not only individual capability but the cognitive routing structure of the group.

Similarly, models of organizational learning show that disruption to collective learning can be harmful in both the short and long term [AL14]. Empirical and review literature on turnover and knowledge loss likewise shows that departures can reduce performance and destroy organizational knowledge, especially where work depends on accumulated, non-standardized experience [TH08, Gal23].

This does not imply that senior expertise is always irreplaceable. It does imply that replacement cannot be evaluated by salary arithmetic alone.

The central question becomes architectural

What lived cognitive structure was this person carrying for the organization?

That may include decision history, causal shortcuts, exception knowledge, cross-layer translation, knowledge of hidden coupling, and the ability to make encountered complexity manageable for others. When such capability is removed without being preserved or regenerated, the organization has not merely reduced labor capacity. It has changed its own lived architecture.

Cognitive Architecture Destruction Principle. When an organization removes experienced agents without preserving the cognitive capabilities, decision memory, cross-layer relationships, and complexity-suppression functions they provide, it is not merely reducing labor capacity. It is altering its own lived architecture. The resulting increase in encountered complexity may remain latent until future decisions expose the missing capability.

This also explains why a senior-to-junior tradeoff cannot be reduced to a universal conversion factor. There may be routine, highly standardized settings in which turnover can be buffered through strong process conformance and repeatable procedures [TH08]. But the more the work depends on tacit knowledge, unusual exceptions, cross-layer reasoning, historical context, and recovery of architectural rationale, the less defensible simple headcount substitution becomes.

One senior engineer is not necessarily worth two juniors, five juniors, or ten. The ratio is the wrong abstraction.

The real issue is whether the cognitive architecture required for responsible action survives the substitution.

Agent-Relative Does Not Mean Subjective

At this point, an understandable objection arises.

If encountered complexity depends on who is acting, where they are acting, what they are trying to do, and what competence they bring, does the concept become merely subjective?

I don’t think so.

Agent-relative is not the same as arbitrary. With agent-relative encountered complexity

  • The locality can be declared
  • The action can be identified
  • The relevant dependencies can be examined
  • The constraints that must be preserved can be stated
  • The representations available to the agent can be inspected
  • The decisions within reach can be identified
  • The organizational and technical boundaries that must be crossed can be observed
  • The evidence required to justify action can be established.
  • The competence assumptions can be made explicit.

Two agents acting from different localities, or with different expertise and support, may therefore encounter different complexity without either assessment being incorrect.

This is analogous to saying that two travelers can face different routes through the same landscape. Their paths may differ because their starting points, destinations, capabilities, and admissible routes differ. That does not make the landscape imaginary, nor does it make every claimed route equally valid.

The encounter is relational. It arises from the interaction among

agent \leftrightarrow agent-lived architecture \leftrightarrow locality \leftrightarrow system architecture \leftrightarrow action


This relation is where CCC becomes especially interesting in the causal framework.

The original mathematical formulation will almost certainly need to change. A static measure of localized coupling is not sufficient to represent agents moving through architectures whose future possibilities are themselves being changed by decisions.

But my original intuition survives

The meaningful complexity is the complexity that must be encountered in order to act.

Locality Is Not Fixed

There is another complication related to the architecture as a causal sequence of decisions

An agent does not remain at a fixed point while observing a changing architecture.

Action changes both the locality of the agent and the future cone of the architecture.

  • A decision is made
  • An option is eliminated
  • An interface is frozen
  • A trade study selects one branch and prunes another
  • A verification result exposes a dependency that had previously been hidden
  • A governance authority imposes a new constraint
  • An integration event forces previously independent decisions into a common future.

The architecture encountered next is therefore partly a consequence of what was done before.

This is where the causal view becomes essential. At any given moment, an agent acts from a causal present. Behind that present lies a history of decisions, commitments, evidence, assumptions, deferrals, and unresolved alternatives. Ahead lies a causal frontier containing futures that remain possible but are not equally accessible.

An action taken now can reshape that frontier.

  • It can widen future options
  • It can narrow them
  • It can make certain dependencies irrelevant
  • It can create new ones
  • It can preserve a decision for later
  • It can make reversal prohibitively difficult
  • It can transfer complexity into another locality
  • It can defer complexity into the future

So encountered complexity cannot be understood only as a property of a fixed graph neighborhood. The encounter locality is causally mobile.

An agent does not simply move through an architecture. The agent’s decisions help determine the architecture that will be encountered next.

This has significant consequences.

Encountered Complexity Changes Behavior

Human beings do not process unlimited complexity.

When the architecture encountered from a particular locality becomes difficult to comprehend agents adapt

  • They simplify
  • They defer
  • They create abstractions
  • They freeze decisions
  • They rely on precedent
  • They introduce workarounds
  • They reduce scope
  • They postpone verification
  • They preserve an imperfect interface because changing it would expose too many dependencies
  • They avoid parts of the system that appear too dangerous or too poorly understood to disturb

These actions are not necessarily irrational. In fact, from the local position of the person acting, they may be entirely reasonable.

Suppose an engineer discovers that making a seemingly desirable change would require understanding five unfamiliar subsystems, negotiating with three organizations, reconstructing undocumented rationale, repeating several expensive verification activities, and risking an operational capability that currently works.

Deferring the change may be the rational choice.

But the consequences of that deferral do not vanish. They enter the causal future.

A locally rational decision can therefore create a future constraint. Repeated across many decisions and many actors, those constraints can accumulate into recognizable architectural formations. This gives us an important possible sequence

encountered complexity \rightarrow agent adaptation \rightarrow deferrral or constraint \rightarrow future burden \rightarrow technical debt accumulation

This is not the only mechanism through which technical debt forms. Debt can result from schedule pressure, economic choices, technical mistakes, uncertainty, changing missions, external disruption, or deliberate investment decisions.

However, encountered complexity provides an agent-based mechanism for explaining at least some of the sources of technical debt.

People do not defer only because they are careless. Sometimes they defer because the architecture has made responsible action too difficult from the locality in which action must occur.

And now we can sharpen that further

  • Sometimes the architecture is objectively difficult to encounter
  • Sometimes the available agent is insufficiently prepared to encounter it
  • Sometimes the organization has failed to provide the representations, tools, decision memory, access, or distributed expertise needed to make the encounter manageable

Often, all three are true at once.

The Call Does Not Belong Only to Those with Authority

The discussion so far could be read as though the obligation to surface adverse technical consequences belongs only to people already recognized as technical leaders.

That would be too narrow.

Leadership does not begin with a title. Formal authority determines who is empowered to make certain decisions. Management determines who is responsible for resources, execution, staffing, schedules, or organizational performance. Administrators sustain processes, policies, and continuity.

Leadership is something else, entirely.

Leadership is enacted when a person accepts responsibility for consequences that others may prefer not to see and this can happen at any level of an organization.

  • A non-managerial engineer may recognize that a proposed change destroys an assumption on which several downstream activities depend
  • A technician may know that a formal procedure does not match operational reality
  • A junior employee may notice that an interface, model, or test result is being misrepresented
  • A systems engineer may see that a decision made in one layer will create hidden burden in another
  • A senior individual contributor may realize that a layoff will remove decision memory or scarce cross-layer expertise that management has mistaken for replaceable headcount

None of these people needs managerial authority in order to exercise leadership.

They do, however, need the willingness to make the consequence visible. This suggests a broader principle

Distributed Leadership Emergence Principle. Leadership can emerge at any level of an organization, including among non-managerial employees. Formal authority is neither necessary nor sufficient for leadership. A person may exercise leadership by surfacing hidden consequences, protecting people or principles, coordinating action, challenging harmful decisions, preserving technical integrity, or carrying responsibility that others avoid.

A simpler and more compact form is

Leadership can emerge anywhere responsibility is accepted before authority is granted.

This matters because organizations often use the word leadership as a status label.

They speak of executive leadership, senior leadership, technical leadership, and leadership teams. But seniority, authority, management, administration, and leadership are not the same thing

authority \ne management \ne adminstration \ne leadership

A person may possess several of these at once. None should be assumed from title alone.

An organization can therefore preserve the language of leadership while losing the practice.

Leadership Substitution Principle. Organizations may preserve the language of leadership while substituting administrative authority, managerial compliance, political alignment, or hierarchical seniority for actual leadership practice.

When this occurs, the institution retains the title but loses the function.

This distinction changes the call made by this post.

The obligation to make consequences visible should not be addressed only to people with assigned technical authority. It should reach the person who can see the consequence.

Leadership Beyond Assigned Authority Principle. The obligation to surface important consequences does not belong only to people with formal titles, managerial responsibility, or assigned technical authority. Anyone who can see a material consequence that others may miss can exercise leadership by making it visible, preserving it in decision memory, and carrying it as far into the decision process as their position allows.

The compact formulation is

The call to leadership reaches the person who can see the consequence, not merely the person who owns the title.

This does not make authority irrelevant.

A junior engineer who sees a consequence may have little power to alter the decision. A senior executive may have direct access to the decision authority. The obligations are therefore not identical.

Formal authority increases responsibility.

Authority-Weighted Responsibility Principle. Leadership can emerge anywhere, but formal authority increases responsibility. Those with greater decision power, organizational access, or protection have a stronger obligation to ensure that material technical, human, operational, or architectural consequences are not suppressed or ignored.

The person without authority may only be able to raise the issue, document it, seek allies, or preserve it in decision memory. The person with authority may be able to stop the decision.

Those are not equivalent positions but both require leadership.

This distinction also clarifies an important boundary.

  • Not every objection is leadership
  • Not every act of resistance is principled
  • Not every technical disagreement deserves escalation

Leadership requires judgment.

The obligation is not to oppose everything. It is to act when a consequence is material enough that silence would allow others to make a decision without seeing what should reasonably have been made visible.

A useful test could be

If I remain silent, will the organization be able to claim later that nobody saw this coming?

Sometimes the answer will be no.

Sometimes the issue is minor, speculative, or already adequately represented.

But sometimes one person can see a consequence that has not entered the formal decision process at all. At that moment, leadership may begin before authority does.

Hierarchy determines who is authorized to decide. It does not determine who is capable of leading.

When Authority and Consequence Occupy Different Localities

The competence question also exposes a governance problem.

The people who authorize a decision and the people who later encounter its architectural consequences may occupy entirely different localities.

A financially oriented executive decision locality may make visible labor cost, margin, headcount, cash flow, near-term financial targets.

A technical locality may make visible something else, such as decision memory, cross-layer knowledge, hidden dependencies, integration risk, CCC suppression, future TTD.

Both localities may be real. The problem arises when one has authority over the other without carrying the other’s constraints forward.

The financial locality may observe

headcount reduced \rightarrow cost target achieved

The technical locality may later encounter

expert capability removed \rightarrow decision memory lost \rightarrow \quad \kappa \uparrow \quad \rightarrow \quad C_{enc} \uparrow \quad \rightarrow decision latency and deferral increase

Both observations can be locally correct which is precisely the danger.

An organization can declare success at the same moment it is degrading its future architectural viability.

This suggests another principle

Executive–Technical Locality Mismatch Principle. Strategic decisions may be made from an executive locality whose dominant observables differ fundamentally from those of the technical locality in which the consequences will be encountered.

When financial measures are visible and architectural consequences are latent, the decision process can systematically favor local financial optimization while exporting complexity, debt, and risk into the technical future.

The mismatch can persist even when people inside the technical locality understand the consequences, whether they hold formal authority or not.

An engineer, architect, technician, specialist, or technical manager may know that a decision will destroy important expertise, increase integration risk, or remove decision memory. Yet that knowledge may not change the outcome because the person lacks authority, expects resistance, faces personal or political risk, or believes the decision has already become irreversible.

In such a case, the organization is not ignorant. The knowledge exists. It simply has no effective causal path to the decision authority.

Suppressed Technical Knowledge Principle. An organization may possess accurate technical knowledge of the consequences of a strategic decision while lacking a governance path through which that knowledge can alter the decision.

In such cases, ignorance is not the problem, blocked causal transmission is. This is a vertical transmission problem as much as a knowledge problem.

A technically meaningful signal may begin as

This decision will remove expertise that currently suppresses substantial architectural complexity.

As the signal moves upward, it may be attenuated, reframed, compressed, softened, or converted into more familiar managerial language

There may be some transition risk.

The factual content has not necessarily disappeared. Its causal impact has.

Sometimes technical leadership itself participates in this attenuation through silence, self-protection, political calculation, or learned powerlessness. This leads to a broader asymmetry

Asymmetric Consequence Locality Principle. Those with authority to make an architectural or organizational decision may not inhabit the locality in which its consequences are later encountered. This separation allows locally rational decisions to export complexity, risk, debt, and cognitive burden into other parts of the organization or into the future.

A more direct and compact form is

Organizations often separate the authority to create future complexity from the obligation to encounter it.

The claim here is not that a leader’s professional background mechanically determines every decision. It is that leadership locality can influence which variables become most visible, most credible, and most actionable.

Complexity Can Be Pushed Around

This suggests a deeper connection between CCC and what I have called Total Technical Debt, or TTD.

Architectural decisions can move encountered complexity.

  • A new service interface may reduce CCC for application developers while increasing verification burden elsewhere
  • A new layer of abstraction may simplify local reasoning while making failures more difficult to trace
  • An organizational restructuring may give one team clearer ownership while increasing the number of boundaries an integration engineer must cross.
  • A decision to postpone redesign may preserve immediate stability while narrowing future options and increasing the cost of eventual change

In each case, local complexity may decrease while future burden accumulates elsewhere. This is why local improvement cannot automatically be equated with global improvement.

The central architectural question is not merely whether complexity was reduced here. It is

  • Where did the complexity go?
  • Was it genuinely eliminated?
  • Was it absorbed by a better abstraction?
  • Was it transferred to a locality better equipped to manage it?
  • Was it hidden behind a representation?
  • Was it pushed into verification?
  • Was it moved across an organizational boundary?
  • Was it deferred into the causal future?

This is also why CCC and TTD appear increasingly coupled in the causal framework. High encountered complexity can encourage deferral. Deferral can accumulate debt. Accumulated debt can make certain regions of the architecture more difficult to enter or change. Those regions can then increase future encountered complexity, encouraging further avoidance and deferral.

A reinforcing cycle can emerge

CCC \rightarrow TTD \rightarrow future constraint \rightarrow higher CCC

Eventually, the architecture may develop what looks like a basin, i.e., a region of causal consequence which is easy to enter and difficult to exit.

Certain decisions become easier because they follow established structure. Other decisions become increasingly difficult because escaping the accumulated architecture would require confronting too much debt, recovering too much lost rationale, crossing too many boundaries, or reopening too many coupled commitments.

The architecture begins to shape not only what is possible, but what feels locally survivable.

Architecture as Cognitive Constraint

This leads me to a broader claim.

Architecture is often described in structural terms such as components, relationships, interfaces, principles, patterns, views, and models.

While those descriptions matter, architecture also operates as a cognitive constraint on the space of possible action.

  • It determines what an agent must know
  • It determines what can safely remain hidden
  • It shapes which dependencies become visible
  • It influences which actions appear easy, difficult, risky, or impossible
  • It can preserve rationale or force its rediscovery
  • It can localize consequence or allow it to propagate unexpectedly
  • It can protect agents from irrelevant detail or conceal the very structure they need to act responsibly

In this sense, architecture is not merely something an agent sees. Rather, It helps determine what the agent is capable of seeing from where the agent stands. And because decisions change architecture, today’s actions help construct the cognitive environment in which tomorrow’s decisions must be made.

The agent, however, is not a neutral observer. The agent arrives with a lived architecture of competence, memory, practice, tools, representations, and relationships. Architecture and agent therefore meet as two histories in the causal present or the accumulated history of the system and the accumulated history of the one trying to act within it.

This is why encountered complexity matters. The architecture that affects action is not the total architecture considered from nowhere. It is the architecture that must be encountered from somewhere, by someone, with some actual capacity to meet it.

From Encountered Complexity to Architectural Futures

CCC began, for me, as an attempt to answer a practical question about integration in robotic systems.

How could I demonstrate that one architectural approach made integration less difficult than another?

The answer led to the CCC metric in its original form.

Years later, I think the deeper question was already hiding inside that form

What must an agent encounter in order to act within an architecture?

The causal framework makes that question richer. The agent acts from a locality shaped by prior decisions. The agent also brings a lived architecture shaped by prior experience, competence, tools, representations, and relationships. The act changes the causal future.

  • Complexity can be reduced, transferred, hidden, amplified by mismatch, mitigated by expertise, or deferred
  • Organizations can also remove the very expertise that had been suppressing encountered complexity, while decision-makers remain distant from the localities in which the resulting burden will later appear
  • Local decisions can preserve options or destroy them
  • High encountered complexity can make deferral locally rational
  • Repeated deferral can accumulate technical debt
  • Accumulated debt can reshape the future landscape so that some paths become easier and others increasingly difficult to reach.

The metric has to evolve to represent this. However, the underlying intuition remains remarkably stable

Complexity matters when it must be encountered.

And once complexity becomes difficult enough to encounter, whether because of the architecture, the locality, the task, the agent, or the support available to that agent, then architecture begins to influence not only the cost of action, but the actions people are willing and able to take at all.

That is where encountered complexity stops being merely a metric. It becomes part of the dynamics of architecture itself. And because those dynamics are encountered by people at every level of an organization, the corresponding call to leadership cannot be reserved for those who already possess formal authority.

The person who can see the consequence may be the only person in a position to make it visible.

That does not guarantee power.

It does create responsibility.

References

[AL14] Jr. Anderson, Edward G. and Kyle Lewis. A dynamic model of individual and collective learning amid disruption. Organization Science, 25(2):356–376, 2014.

[Gal23] Nataliya Galan. Knowledge loss induced by organizational member turnover: A review of empirical literature, synthesis and future research directions (part i). The Learning Organization, 2023.

[Gib79] James J. Gibson. The Ecological Approach to Visual Perception. Houghton Mifflin, Boston, 1979.

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

[Hut95] Edwin Hutchins. Cognition in the Wild. MIT Press, Cambridge, Massachusetts, 1995.

[KACS03] Slava Kalyuga, Paul Ayres, Paul Chandler, and John Sweller. The expertise reversal effect. Educational Psychologist, 38(1):23–31, 2003.

[Lew05] Kyle Lewis. Transactive memory systems, learning, and learning transfer. Organization Science, 16(6):581–598, 2005.

[RA09] Philip Robbins and Murat Aydede, editors. The Cambridge Handbook of Situated Cognition. Cambridge University Press, Cambridge, 2009.

[Ras83] Jens Rasmussen. Skills, rules, and knowledge; signals, signs, and symbols, and other distinctions in human performance models. IEEE Transactions on Systems, Man, and Cybernetics, SMC-13(3):257–266, 1983.

[RBL+24] Abdul Razzaq, Jim Buckley, Qin Lai, Tingting Yu, and Goetz Botterweck. A systematic literature review on the influence of enhanced developer experience on developers’ productivity: Factors, practices, and recommendations. ACM Computing Surveys, 57(1):1–46, 2024.

[Swe88] John Sweller. Cognitive load during problem solving: Effects on learning. Cognitive Science, 12(2):257–285, 1988.

[TH08] Zeynep Ton and Robert S. Huckman. Managing the impact of employee turnover on performance: The role of process conformance. Organization Science, 19(1):56–68, 2008.

Leave a Reply