Compositional Assembly

batch: First Iteration/Batch 02

source_primes: composition modularity relation

related_primes: boundary set_and_membership hierarchy order representation constraint

Composition

slug: composition

role: Arranges components into a cohesive whole and supplies the central part-whole logic.

Modularity

slug: modularity

role: Provides bounded components that can be selected, connected, and coordinated.

Relation

role: Defines the connections, dependencies, handoffs, compatibility constraints, and interactions among parts.

Boundary

slug: boundary

role: Marks where one component ends and another begins, including interface surfaces.

Set and Membership

role: Helps determine which components belong in the assembly and which role-slots they can fill.

Hierarchy

slug: hierarchy

role: Appears when assemblies are nested into subsystems, levels, or parent-child structures.

Order

role: Appears when sequence or prerequisite structure is necessary for the whole to function.

Representation

role: Makes the assembly visible through diagrams, maps, specifications, plans, or narratives.

Constraint

slug: constraint

role: Limits which components can be combined and how they can interact.

components:
Intended Whole Function
Component Selection
Role Definition
Interface Contract
Interaction Map
Sequencing Rule
Integration Policy
Compatibility Check
System-Level Validation
Component Catalog
Dependency Constraint
Coherence Invariant
Assembly Owner

mechanisms:
System Integration Workflow
Bill of Materials and Configuration
Architecture Blueprint
Integration Test Plan
Curriculum Map
Team Composition Matrix
Policy Package Design
Research Synthesis Protocol

essence_one_line: Assemble selected components into a coherent whole by defining roles, interfaces, sequence, and interaction logic.

compression_statement: When useful parts do not automatically produce a viable whole, deliberately select, arrange, connect, and validate components so their interactions generate the intended system-level function, accepting integration complexity, coordination overhead, and the risk that locally good parts may conflict in combination.

core_intuition: Composition is not addition. A pile of good parts is still only a pile until each part has a role, the relations among parts are shaped, incompatibilities are resolved, and the result is tested against a whole-level purpose. Compositional Assembly turns fragmented capability into coherent function.

canonical_formula: available_parts + intended_whole_function + role_definition + interfaces + interaction_map + compatibility_check + integration_policy → coherent_system_level_function

structural_problem: Available parts, modules, actors, ideas, policies, procedures, or materials exist, but they do not yet form a coherent functioning whole because their roles, relations, interfaces, order, or compatibility have not been deliberately designed.

condition: Useful components exist but their combined effect is weak, incoherent, duplicative, or self-defeating.

why_it_matters: The limiting problem is not the absence of parts; it is the absence of whole-level composition logic.

condition: Multiple teams, disciplines, modules, policy instruments, lessons, or tools must contribute to one outcome.

why_it_matters: Each contribution needs a role and relation to the rest or the system will fragment.

condition: A design has many good local decisions but no visible account of how they interact.

why_it_matters: Local optimization can create incompatibility, gaps, overload, or conflicting incentives.

condition: The system requires dependencies, handoffs, sequence, or compatibility constraints that cannot be assumed.

why_it_matters: The same parts can work or fail depending on arrangement.

condition: Repeated assembly decisions are being made ad hoc.

why_it_matters: Without an integration policy or validation method, each assembly becomes fragile, hard to revise, and difficult to audit.

symptom: Parts are individually acceptable but the whole does not work.

interpretation: System-level function is being assumed from local quality rather than designed.

symptom: Handoffs fail, interfaces are unclear, or components make incompatible assumptions.

interpretation: The assembly lacks explicit interaction and compatibility rules.

symptom: Some functions are duplicated while other necessary functions are missing.

interpretation: Role definition and coverage are weak.

symptom: Changing one part unexpectedly breaks another.

interpretation: Dependencies are hidden and the integration policy is under-specified.

symptom: A plan reads like a list of parts rather than an operating whole.

interpretation: The design has cataloged components but has not composed them.

symptom: The system cannot be tested meaningfully until too late.

interpretation: Whole-level validation was not designed as part of the assembly.

root_tension: The assembly must preserve the useful identity of parts while making them subordinate enough to a whole-level function. Too little integration leaves fragmentation; too much integration can erase modular flexibility, create brittle coupling, or make every change a system-wide negotiation.

case: The main problem is breaking a complex whole into manageable parts.

why_not: Modular Decomposition is the better fit; Compositional Assembly works in the opposite direction by turning parts into a whole.

case: The main problem is stabilizing an interaction boundary between two already-defined units.

why_not: Decoupling via Interface or interface design may be more precise; interfaces are components of assembly, not always the archetype itself.

case: The parts are merely grouped for reporting or cognitive tractability.

why_not: Aggregation to Manage Complexity or Canonical Classification may be closer if the group does not produce a new whole-level function.

case: The design is only a catalog, checklist, or bill of materials.

why_not: Those artifacts support assembly but do not specify roles, relations, compatibility, and validation.

case: A single homogeneous part is replicated many times without distinct roles or interaction logic.

why_not: Scaling, replication, or redundancy patterns may be more relevant than compositional assembly.

structural_intervention: Select, arrange, connect, sequence, and coordinate components so their interactions produce a coherent whole-level function that none of the parts can produce alone.

action: State what the assembled whole must do, decide, express, deliver, withstand, teach, explain, or enable.

rationale: The whole-level function is the criterion that distinguishes useful composition from arbitrary accumulation.

action: Inventory available parts and missing capabilities, including modules, actors, information, roles, materials, policies, tools, or procedures.

rationale: Assembly begins with possible components, but component availability should not dictate the design without regard to purpose.

action: Choose components that cover necessary functions while avoiding unnecessary duplication, unresolved gaps, and excessive complexity.

rationale: A good assembly includes enough parts to create the whole and no more parts than the whole can meaningfully coordinate.

action: Give each component a clear contribution, boundary, authority, input, output, and relationship to the intended whole.

rationale: Parts become components only when their function within the assembly is explicit.

action: Represent how components exchange inputs, outputs, information, authority, resources, meaning, timing, and constraints.

rationale: The structure of relations determines whether the whole is coherent, brittle, redundant, or unstable.

action: Define the interaction surfaces, protocols, translation points, handoff conditions, and shared assumptions needed for components to connect.

rationale: Interfaces let separately meaningful parts cooperate without forcing every part to know every detail of every other part.

action: Arrange components spatially, logically, temporally, hierarchically, or procedurally according to dependency and interaction needs.

rationale: The same parts can yield different wholes depending on their arrangement.

action: Check for mismatched assumptions, version conflicts, incentive conflicts, capacity limits, physical fit, semantic mismatch, governance conflict, or value conflict.

rationale: Compatibility failures are often relational rather than visible in any individual component.

action: Decide how components are connected, changed, owned, revised, tested, and coordinated over time.

rationale: Assemblies decay when local changes are not governed at the level of the whole.

action: Test whether the assembly produces the intended whole-level outcome under realistic conditions and revise the composition accordingly.

rationale: Successful parts do not guarantee a successful whole; the whole must be tested as a whole.

guidance: Let the intended whole determine which components belong, which roles matter, and what must be validated.

guidance: Design handoffs, interfaces, dependencies, feedback, and conflict resolution explicitly instead of assuming parts will coordinate themselves.

guidance: A locally superior component may be a poor choice if it duplicates another role, violates constraints, or destabilizes the whole.

guidance: An assembly plan should reveal absent capabilities, unsupported dependencies, missing owners, and untested interfaces.

guidance: Do not infer whole-level performance from component-level performance; test the integrated behavior.

guidance: Avoid making integration so bespoke that future substitution, repair, scaling, or learning becomes impossible.

description: Every selected component has a reason to exist in relation to the intended whole.

description: Each component has a clear contribution, scope, input, output, and boundary.

description: Dependencies, handoffs, and interactions among components are explicit enough to inspect and revise.

description: Components can interact without hidden contradiction, overload, semantic mismatch, or destructive interference.

description: The assembly is judged by whole-level performance rather than component-level completeness alone.

description: Local component changes have a defined path for assessing and maintaining whole-level coherence.

description: The assembled whole does something useful that isolated components could not do alone.

description: Separate parts, teams, instruments, or ideas are coordinated into one usable structure.

description: Participants can explain why each part exists and how it contributes to the whole.

description: Interfaces, handoffs, dependencies, and compatibility constraints are handled before they become failures.

description: The logic of selection, arrangement, and validation can be inspected and improved.

description: Components can be updated or substituted without losing sight of whole-level coherence.

prose_essence:
Compositional Assembly is the intervention of turning useful parts into a coherent functioning whole. The problem is not that nothing exists; the problem is that existing components, actors, policies, modules, lessons, procedures, or ideas do not automatically combine into a viable system. The archetype asks: what whole-level function is needed, which components should participate, what role does each part play, how do the parts connect, and how will the whole be validated?

The central distinction is that composition is not mere addition. A list of components can look complete while still failing at handoffs, assumptions, timing, authority, incentives, or meaning. Compositional Assembly therefore treats relations among parts as first-class design objects.

prose_when_to_use:
Use Compositional Assembly when the available pieces are promising but the system-level result is missing, unreliable, or incoherent. It is especially useful when success depends on complementarity among unlike parts: a curriculum needs lessons, practice, feedback, and assessment; a policy package needs incentives, rules, enforcement, services, and communication; a software system needs modules, interfaces, data flows, permissions, and operations; a team needs roles, skills, decision rights, and collaboration routines.

The archetype is also appropriate when local excellence is not enough. A component can be strong in isolation and still be wrong for the assembly if it duplicates another role, makes incompatible assumptions, overloads a handoff, or undermines the intended whole.

Do not use this archetype merely to collect items into a list, group them into categories, or document them in a catalog. Those may be mechanisms or preparatory components, but the assembly intervention begins only when the parts are arranged to produce a whole-level function.

prose_structural_problem:
The structural problem is fragmentation without coherent integration. Parts exist, but their roles, boundaries, dependencies, interfaces, order, or compatibility are not explicit enough to produce the desired whole. The result may look organized on paper while failing in use: handoffs break, responsibilities collide, duplicate functions consume capacity, needed roles are missing, or local improvements create system-wide disruption.

A useful diagnostic is to ask whether the failure appears inside a component or between components. If the parts are individually acceptable but the combined system fails, the problem is likely compositional.

prose_intervention_logic:
The intervention starts by defining the intended whole function. This prevents available parts from dictating the design by accident. Once the whole-level purpose is explicit, the designer identifies candidate components, selects for coverage and complementarity, assigns roles, maps interactions, designs interfaces and handoffs, sets sequence or topology where needed, checks compatibility, defines integration governance, and validates the assembled whole under realistic conditions.

The logic can be summarized as:

```text
available parts + intended whole function + role definition + interaction map + interfaces + compatibility checks + integration policy → coherent system-level function
```

The important move is to validate the whole rather than merely inspect the parts. A component-level review can confirm that every part is present while missing the relational failures that determine whether the system works.

prose_key_components:
### Intended Whole Function

The intended whole function states what the assembly must produce: a service, product, decision, learning outcome, program effect, explanation, operating capability, or coordinated response. It is the standard against which component choice and arrangement are judged. Without it, assembly becomes accumulation.

### Component Selection

Component selection chooses which parts, modules, actors, ideas, policies, procedures, or materials belong in the whole. The question is not simply whether a part is good, but whether it fills a needed role, fits the constraints, and contributes to the whole without adding avoidable coordination burden.

### Role Definition

Role definition explains what each component contributes. In strong assemblies, every part has a job: an input it consumes, an output it provides, a decision it supports, a constraint it enforces, a service it performs, or a meaning it carries. Role definition prevents gaps and collisions.

### Interface Contract

An interface contract defines how components connect. In software it may be an API; in policy it may be an agency handoff; in education it may be a prerequisite relation; in a team it may be a communication protocol or decision right. The interface is a component of assembly, not automatically the whole archetype.

### Interaction Map

An interaction map shows dependencies, flows, feedback loops, handoffs, constraints, and conflict points. It turns invisible relations into inspectable structure. This is often where assembly failures become visible before they become operational failures.

### Sequencing Rule

A sequencing rule specifies order, prerequisite structure, cadence, or activation conditions. Some assemblies are not merely sets of parts; they are progressions. A curriculum, manufacturing process, onboarding sequence, diagnostic pathway, or staged policy rollout can fail if correct components occur in the wrong order.

### Integration Policy

An integration policy governs how the parts are connected and maintained over time. It answers who owns whole-level coherence, how changes are reviewed, how conflicts are resolved, how versions are coordinated, and how the assembly adapts after deployment.

### Compatibility Check

A compatibility check tests whether components can coexist. Compatibility can be technical, semantic, procedural, physical, legal, cultural, financial, temporal, or ethical. Many failures arise because components are locally plausible but relationally incompatible.

### System-Level Validation

System-level validation tests whether the assembled whole produces the intended result. It protects against the common failure of declaring success because every part is present. The right question is whether the composition works under realistic use.

prose_common_mechanisms:
### System Integration Workflow

A system integration workflow implements the archetype by coordinating subsystem connection, interface work, release decisions, and end-to-end testing. It is common in engineering and enterprise systems. The workflow is not the archetype itself; it is one way to operationalize assembly when subsystems must function together.

### Bill of Materials and Configuration

A bill of materials records the parts, versions, variants, and quantities required for an assembly. It supports component selection and configuration, but it becomes part of Compositional Assembly only when connected to roles, compatibility constraints, assembly instructions, and whole-level validation.

### Architecture Blueprint

An architecture blueprint makes components, boundaries, interfaces, flows, and dependencies visible. It is a representation mechanism that supports reasoning about composition. A diagram alone is not enough; it must guide actual selection, connection, compatibility checking, and validation.

### Integration Test Plan

An integration test plan tests the behavior of the whole after parts are connected. It implements the validation side of the archetype by checking cross-component behavior, workflow continuity, failure interactions, and outcome performance.

### Curriculum Map

A curriculum map arranges lessons, practice, feedback, assessment, and prerequisites into a learning whole. It is compositional when its purpose is not just to list topics, but to make components build toward integrated capability.

### Team Composition Matrix

A team composition matrix maps roles, skills, authority, collaboration paths, and gaps. It implements assembly when the components are people or role-holders and the desired whole is a team capability.

### Policy Package Design

Policy package design combines instruments such as mandates, incentives, services, communication, reporting, enforcement, and transition support. It implements the archetype when the combined effect matters more than any single instrument.

### Research Synthesis Protocol

A research synthesis protocol selects and relates findings, claims, models, cases, and uncertainties into a coherent knowledge product. It is compositional when it reconciles parts into a usable whole rather than merely summarizing sources.

prose_failure_modes:
A common failure mode is mistaking a component pile for a functioning whole. The design contains many impressive parts, but no role logic, interaction map, compatibility check, or whole-level validation. Another failure mode is hidden interface mismatch: components use different terms, data formats, authority assumptions, timelines, or resource expectations. Role gaps and role collisions occur when critical functions are unowned or multiply owned without coordination.

Integration overload occurs when the assembly contains more components or interactions than the system can govern. Emergent negative interactions occur when locally sensible parts combine into unsafe behavior, perverse incentives, bottlenecks, or incoherent meaning. Brittle bespoke coupling occurs when parts are wired together so tightly that future changes become dangerous. Finally, interface conformance without coherence occurs when components satisfy a formal standard but the assembled whole still fails its purpose.

prose_neighbor_distinctions:
**Modular Decomposition** moves from whole to parts. It breaks a complex whole into bounded modules for local reasoning, ownership, or change. Compositional Assembly moves from parts to whole. It connects selected components into coherent function.

**Decoupling via Interface** stabilizes interaction across boundaries. Compositional Assembly may use interfaces, but its target is broader: roles, interactions, sequence, compatibility, and whole-level validation.

**Standard Interface Composition** is merge-sensitive. It focuses on making components compose through shared interface standards. In this draft it is captured as a variant under review, because the Batch 002 roadmap holds it as defer/component while reconciliation controls also mark it as a distinct architecture-family boundary.

**Canonical Classification** defines stable categories and membership criteria. Compositional Assembly defines how selected components work together. Classification may help choose components, but it does not by itself create a functioning whole.

**Aggregation to Manage Complexity** groups elements so reasoning becomes tractable. Compositional Assembly combines components so their interactions produce new function.

**Reintegration After Decomposition** is a close second-wave neighbor. It specifically handles the problem created when prior decomposition improves local work but threatens global coherence. Compositional Assembly is broader and can occur without a prior decomposition step.

prose_cross_domain_examples:
In software architecture, a subscription service may assemble authentication, billing, notifications, analytics, support tooling, and user workflows into a single operating product. The archetype appears in the role definitions, interfaces, data flows, release dependencies, compatibility tests, and end-to-end validation.

In education, a course may assemble readings, lectures, labs, practice, feedback, and assessments into a coherent learning progression. The assembly succeeds only if components build toward the whole-level learning outcome.

In public policy, a city may combine grants, zoning changes, inspection capacity, landlord guidance, tenant communication, and enforcement into a housing safety program. The program depends on instrument complementarity rather than any single instrument.

In team design, an incident response group may combine operations, communications, legal, technical diagnosis, executive authority, and logistics into one response capability. The assembly is about role complementarity and coordination.

In research, a synthesis may combine experiments, field evidence, mechanism models, case studies, and uncertainty analysis into one recommendation. The assembly must reconcile relations among claims, not merely list sources.

prose_non_examples: A list of recommended tools is not Compositional Assembly unless it explains how the tools work together. A taxonomy of parts is not Compositional Assembly unless the categories support a working composition. A single module solving a problem independently is not Compositional Assembly because no cross-component relation is required. A standard API specification with no assembled whole is an interface artifact or standardization mechanism, not the full archetype. An org chart that merely names departments is documentation, not assembly, unless it specifies roles, authority, handoffs, and whole-level coordination.

prose_tradeoffs:
Compositional Assembly creates integration value, but it also introduces integration cost. More components can increase capability, coverage, and resilience, but they also increase dependency management, testing burden, coordination overhead, and failure surface. Tighter integration can improve performance, but it can reduce flexibility and make future substitution difficult. Standardized interfaces can improve reuse, but they can constrain components that need context-specific adaptation.

A recurring tradeoff is local quality versus system fit. The best isolated component is not always the best component for the assembly. A slightly less capable part may be the right choice if it fits better, simplifies interfaces, reduces risk, or preserves coherence.

prose_invariants_to_preserve: The first invariant is whole-function alignment: every component should have a reason to exist in relation to the intended whole. The second is role clarity: components should have identifiable contributions and boundaries. The third is relation visibility: dependencies and handoffs should be explicit enough to inspect. The fourth is compatibility across boundaries: components should not make hidden assumptions that undermine one another. The fifth is system-level validation: the whole should be tested as a whole. The sixth is change governance: the assembly should remain coherent as components evolve.

prose_target_outcomes: The target outcome is coherent system-level function. Depending on the domain, this may be a working product, a reliable service, an integrated policy program, a functioning team, a coherent curriculum, or a defensible synthesis. Secondary outcomes include reduced fragmentation, clearer roles, better handoffs, fewer hidden incompatibilities, more auditable design logic, and improved ability to revise or substitute components without losing sight of the whole.

prose_parameter_dimensions:
Important tuning dimensions include component granularity, interface strictness, role specificity, sequence rigidity, integration centralization, validation depth, substitution tolerance, and acceptable complexity. A fine-grained assembly may be flexible but difficult to coordinate. A tightly integrated assembly may perform well but become brittle. A highly standardized interface may support substitution but constrain component variation.

Another important tuning dimension is whether the assembly is designed once or repeatedly recomposed. A one-time product assembly may emphasize configuration and acceptance testing. A living organizational, software, policy, or curriculum assembly needs change governance so local component updates do not silently break whole-level coherence.

prose_variants_and_near_names:
Recognized variants include system integration assembly, role-based composition, sequenced composition, policy package composition, knowledge synthesis composition, and standard interface composition under merge review. Near names include purposeful assembly, system composition, system integration, curriculum design, team composition, research synthesis, product assembly, and bricolage when improvisational assembly still produces coherent function.

The policy for this draft is conservative: named variants are retained when they help retrieval and boundary-setting, but mechanisms such as bills of materials, architecture diagrams, integration tests, and curriculum maps are not promoted into standalone archetypes.

System Integration Assembly

short_definition: Assembles technical, organizational, or operational subsystems into a functioning integrated system.

distinctive_feature: The assembly target is an operational system whose components must interoperate under load, change, and failure.

distinct_from_parent: The parent applies to any purposeful assembly; this variant emphasizes operational integration and validation of subsystems.

still_same_parent_because: The structural intervention remains selection, arrangement, connection, compatibility checking, and whole-level validation.

Composition

role: Combines parts into a system-level whole.

Relation

role: Defines connections among subsystems.

condition: Subcomponents already exist but do not yet work together under real operating conditions.

condition: Interfaces, dependencies, data flows, ownership, and tests must be coordinated before deployment.

Interface Contract

role: Defines subsystem interaction surfaces.

Integration Policy

role: Coordinates changes and ownership across subsystems.

System-Level Validation

role: Tests integrated behavior.

System Integration Workflow

role: Coordinates integration tasks.

Integration Test Plan

role: Tests cross-component behavior.

example_domains:
engineering
enterprise architecture
operations

domain: enterprise systems

example: A customer-onboarding process composed from CRM, identity checks, billing, support, and notification systems.

domain: engineering

example: A device assembled from sensors, firmware, enclosure, power management, diagnostics, and operating procedures.

failure_mode: Interfaces pass local tests but fail under end-to-end workflow conditions.

failure_mode: No owner is responsible for integrated behavior after components are delivered.

Role-Based Composition

variant_type: subtype

short_definition: Assembles a whole by defining necessary roles and selecting components or actors to fill them.

distinctive_feature: The primary design object is a role structure with filled slots, such as a team, committee, cast, toolkit, or plugin set.

distinct_from_parent: The parent can assemble any kind of component; this variant emphasizes role complementarity and coverage.

still_same_parent_because: Role definition, component selection, compatibility, and whole-level validation remain the same core assembly logic.

Composition

role: Builds a whole from role-bearing parts.

Set and Membership

role: Determines which members can fill each role.

condition: A functioning whole requires complementary roles rather than interchangeable parts.

condition: The specific occupants may vary, but the role set and interaction logic must remain coherent.

Role Definition

role: Defines needed contributions.

Component Selection

role: Selects actors or parts for slots.

Compatibility Check

role: Checks whether roles can work together.

Team Composition Matrix

role: Maps roles, skills, and coordination needs.

example_domains:
teams
software plugins
committees
performing arts

domain: organization design

example: A crisis response cell composed of operations, communications, legal, logistics, and decision authority roles.

failure_mode: Roles cover nominal responsibilities but omit critical coordination or decision rights.

failure_mode: Selected members are individually competent but incompatible as a working composition.

Sequenced Composition

short_definition: Assembles components by arranging them in an order where earlier outputs become useful inputs for later components.

distinctive_feature: The most important relation among parts is temporal or dependency order.

distinct_from_parent: The parent can be non-sequential; this variant emphasizes order as the key assembly relation.

still_same_parent_because: The core intervention is still to compose selected components into a coherent whole, with sequencing acting as a component of that assembly.

Composition

role: Combines parts into a whole.

Order

role: Introduces dependency and progression among components.

condition: The same components succeed or fail depending on order, prerequisites, cadence, or handoff timing.

condition: The whole is a transformation chain, learning progression, procedure, or staged assembly.

Sequencing Rule

role: Determines order and dependency.

Interaction Map

role: Shows handoffs and dependencies.

Curriculum Map

role: Sequences learning components.

Workflow Diagram

role: Represents staged handoffs.

example_domains: education manufacturing procedures onboarding

example: A curriculum sequence where conceptual foundations, practice, integration, and assessment are deliberately ordered.

failure_mode: Correct components are used in an order that causes rework, confusion, or invalid outputs.

Policy Package Composition

short_definition: Assembles multiple policy instruments so their combined effects address a structural problem more coherently than any one instrument could.

distinctive_feature: The components are policy instruments whose interactions can produce complementarity, conflict, leakage, or distributional effects.

distinct_from_parent: The parent is cross-domain; this variant emphasizes instrument mix and governance consequences.

still_same_parent_because: The intervention is still deliberate component selection, role definition, interaction design, compatibility checking, and whole-level validation.

Composition

role: Combines policy instruments.

Relation

role: Defines complementarity, dependency, and conflict among instruments.

condition: A problem requires mutually reinforcing rules, incentives, services, information, enforcement, and transition supports.

condition: Single-instrument interventions produce gaps, perverse incentives, or implementation failure.

Intended Whole Function

role: Defines target policy outcome.

Interaction Map

role: Maps complementarity and conflict among instruments.

Integration Policy

role: Coordinates agencies and update paths.

Policy Package Design

role: Creates the instrument package.

example_domains:
public policy
organizational policy
regulatory design

example: Combining standards, subsidies, enforcement, outreach, and reporting into one implementation package.

failure_mode: One instrument undermines another, or the package omits an enabling support needed for adoption.

Knowledge Synthesis Composition

short_definition: Assembles claims, evidence, models, examples, and interpretations into a coherent knowledge product.

distinctive_feature: The components are knowledge elements whose relations include support, contradiction, scope, mechanism, and uncertainty.

distinct_from_parent: The parent covers all assembly; this variant focuses on epistemic coherence and evidential fit.

still_same_parent_because: The intervention still selects, relates, reconciles, and validates parts against whole-level purpose.

Composition

role: Combines evidence, claims, and concepts.

Representation

role: Makes the assembled synthesis communicable.

condition: Separate findings or perspectives are individually useful but fragmented, conflicting, or incomplete.

condition: A decision, explanation, or theory requires the parts to be reconciled into one usable structure.

Component Selection

role: Selects evidence and claims.

Interaction Map

role: Maps support, contradiction, and dependency.

System-Level Validation

role: Checks explanatory adequacy.

Research Synthesis Protocol

role: Coordinates synthesis work.

example_domains:
research
strategy
legal analysis
education

domain: research

example: A synthesis that combines experiments, qualitative findings, models, and boundary conditions into one explanation.

failure_mode: The synthesis creates superficial coherence by hiding incompatible assumptions or weak evidence.

Standard Interface Composition

short_definition: Assembles components by requiring them to expose compatible, standardized interfaces.

distinctive_feature: The core differentiator is standardization of interfaces as the enabling constraint for composition.

distinct_from_parent: The parent can use bespoke interfaces, spatial arrangement, role complementarity, sequence, or synthesis; this variant emphasizes shared interface standards.

still_same_parent_because: When the standard exists only to make a particular assembly coherent, it remains a variant or component of compositional assembly.

Composition

role: Enables parts to form a whole.

Interoperability

slug: interoperability

role: Emphasizes compatible interaction surfaces.

Modularity

role: Enables separately designed units to connect.

condition: Useful components cannot compose because their interaction surfaces are incompatible.

condition: The assembly must support many possible component combinations rather than one bespoke integration.

Interface Contract

role: Specifies the standard interaction surface.

Compatibility Check

role: Validates conformity to the standard.

Integration Policy

role: Maintains standards and versioning.

API Specification

role: Documents software interfaces.

Design Standard

role: Documents shared physical, procedural, or semantic interfaces.

example_domains: software manufacturing procurement infrastructure

example: A plugin ecosystem whose modules compose because each conforms to a common API.

failure_mode: Conformance to the interface standard is mistaken for whole-level coherence.

failure_mode: The standard becomes too restrictive and prevents useful component variation.

near_names:
Purposeful Assembly
System Composition
System Integration
Curriculum Design
Team Composition
Research Synthesis
Product Assembly
Bricolage


Compositional Attention Design

type: archetype

source: generated

batch: First Iteration/Batch 43

aliases:
perceptual composition
attention-oriented composition
compositional guidance
arranged attention design

slug: representation

slug: flow

components:
Element Inventory
Perceptual Hierarchy
Spatial Relation
Reading Path
Interpretation Test
Competing Salience Suppression
Context Preservation
Accessibility Check
Medium Constraint

mechanisms:
Layout Composition
Dashboard Arrangement
Page Design
Exhibit Design
Interface Layout
Architectural Arrangement
Slide Composition
Information Design

essence_one_line: Arrange elements so attention, interpretation, and action follow the intended structure.

compression_statement: When people misread, overlook, or mis-sequence important elements, compose the available elements deliberately so the whole arrangement guides perception toward the intended priority, relation, meaning, or action.

core_intuition: People rarely encounter elements one by one in neutral order. They scan fields, infer relationships from placement, and treat salience as meaning. By arranging parts as a designed perceptual structure, the solution changes what is noticed first, what is seen as related, and what action feels natural.

canonical_formula: elements + intended relation + perceptual hierarchy + reading path + interpretation test -> guided attention and meaning

structural_problem: The elements needed for understanding or action are present, but their arrangement fails to communicate priority, relation, sequence, or meaning. People therefore attend to the wrong thing, miss the intended structure, or act on an accidental reading of the field.

trigger_conditions: The audience sees the right parts but misses the intended whole.

trigger_conditions: Important relationships are implied by the content but not legible from the arrangement.

trigger_conditions: Users, readers, visitors, or decision-makers look in the wrong place first or cannot tell where to go next.

trigger_conditions: A display, space, page, interface, or presentation contains all necessary information but produces inconsistent interpretation.

trigger_conditions: Competing elements create false emphasis or make secondary material appear primary.

symptoms: People ask for explanations that the arrangement should have made obvious.

symptoms: The wrong element attracts first attention during testing or observation.

symptoms: Users skip critical context, warnings, comparisons, or next actions.

symptoms: Viewers describe the parts correctly but misunderstand their relation.

symptoms: A design is aesthetically acceptable but does not guide the intended behavior.

root_tension: The designer knows the intended priority and relationship among elements, but the audience encounters a perceptual field whose salience, spacing, grouping, and sequence create a different structure.

anti_signatures: The problem is missing content rather than misarranged content.

anti_signatures: The main issue is choosing the right representation type, not arranging elements within a chosen representation.

anti_signatures: The desired result is aesthetic novelty without a clear interpretation or action consequence.

anti_signatures: The audience already perceives the intended priority and relation reliably.

anti_signatures: The problem requires reducing total cognitive load rather than changing the reading structure.

structural_intervention: Inventory the relevant elements, define the intended priority and relation among them, arrange them into a legible perceptual hierarchy and reading path, suppress accidental salience, preserve necessary context, and test whether real viewers infer the intended meaning or action.

action_logic: Clarify what the audience should notice first, understand next, and do or infer after that.

action_logic: List the elements that compete for attention, including background, decorative, contextual, and environmental cues.

action_logic: Assign each element a compositional role: focal, supporting, contextual, sequential, comparative, or suppressible.

action_logic: Use placement, grouping, spacing, scale, contrast, alignment, containment, and ordering to express the intended structure.

action_logic: Remove or quiet elements whose salience contradicts the intended reading.

action_logic: Test the arrangement with representative viewers and revise based on actual attention, interpretation, and action.

decision_rules: Promote an element visually only when its priority in the composition matches its priority in the task or meaning structure.

decision_rules: Place related elements so their relation is perceptually easier to infer than competing accidental relations.

decision_rules: Use contrast and isolation sparingly; too many focal signals destroy hierarchy.

decision_rules: Preserve enough context that the focal reading remains accurate, not merely attention-grabbing.

decision_rules: Treat a composition as successful only when viewers can explain the intended relation or take the intended action without excessive prompting.

target_invariants: The intended focal priority remains perceptually dominant without erasing necessary context.

target_invariants: Spatial relations communicate real or intended semantic relations rather than accidental adjacency.

target_invariants: The arrangement supports the task, message, or experience rather than decorative preference alone.

target_invariants: The composition remains legible for the actual audience, medium, environment, and time available.

target_invariants: The design does not use salience to mislead, hide risk, or exaggerate importance.

expected_outcomes: Viewers notice the intended element or relation first.

expected_outcomes: Interpretation becomes more consistent across users or audiences.

expected_outcomes: Navigation, reading, or decision sequence becomes easier to follow.

expected_outcomes: The design communicates priority and relationship without requiring extra explanation.

expected_outcomes: Action becomes more aligned with the intended structure of the situation.

prose_essence:
Compositional Attention Design uses arrangement as an intervention. It starts from a simple observation: people do not perceive a field of elements neutrally. They notice some things first, infer relationships from placement, treat spacing and grouping as meaningful, and often act on the structure the arrangement implies. The archetype deliberately shapes that structure so attention, interpretation, and action follow the intended design rather than an accidental reading.

This is not the same as “making a layout look good.” A composition can be attractive and still fail if viewers miss the intended priority or misunderstand the relation among parts. The test is whether the audience can perceive what matters, how the parts relate, and what to do or infer next.

prose_when_to_use:
Use this archetype when the necessary elements are present but people are reading them incorrectly. It is especially useful for pages, slides, dashboards, interfaces, exhibits, built spaces, diagrams, educational materials, and service environments where meaning emerges from the arrangement of parts.

It applies when users look in the wrong place first, miss a warning, fail to compare related items, misunderstand sequence, or treat unrelated elements as connected. It is weaker when the real problem is missing content, wrong representation choice, or lack of agreement about the intended message.

prose_structural_problem:
The structural problem is a mismatch between intended meaning and perceived arrangement. Designers, educators, architects, analysts, or communicators may know which elements matter and how they relate, but the audience encounters a field whose salience, spacing, grouping, and order imply something else.

A common symptom is the phrase “but it’s all there.” The information, control, object, or instruction may indeed be present, yet its placement makes it secondary, disconnected, ambiguous, or invisible. The composition fails not because the parts are absent, but because the whole does not speak.

prose_intervention_logic:
The intervention begins by identifying what the audience should notice first, understand next, and do or infer afterward. The designer then inventories the available elements and assigns each one a role: focal, supporting, contextual, sequential, comparative, or suppressible.

The arrangement is tuned through placement, grouping, spacing, scale, contrast, alignment, containment, and ordering. Elements that accidentally pull attention are quieted or moved. Elements that belong together are made perceptually close or otherwise connected. Elements that require sequence are placed into a readable path. Finally, the design is tested against actual interpretation, not just designer intent.

prose_key_components:
### Element Inventory

The element inventory names everything that can participate in the composition: text, images, controls, data, objects, labels, empty space, decorative material, environmental cues, and sometimes people or movement paths. Without an inventory, the designer cannot distinguish necessary elements from accidental noise.

### Perceptual Hierarchy

The perceptual hierarchy states what should be noticed first, second, and third. This is broader than typography or size. It defines the intended order of attention across the whole field and checks whether visual dominance matches actual importance.

### Spatial Relation

Spatial relation uses placement, distance, alignment, grouping, containment, and adjacency to communicate how elements relate. If two things are near each other, viewers often assume they belong together. If they are separated, viewers may assume contrast or independence. The archetype uses those assumptions deliberately.

### Reading Path

The reading path describes how attention should move through the arrangement. Some compositions need a clear sequence; others need a loose path from overview to detail. The key is that the design does not leave critical sequence to chance.

### Interpretation Test

The interpretation test checks whether real viewers perceive the intended focal point, relation, sequence, and action. It protects the archetype from becoming a purely aesthetic exercise. The design works when the intended reading happens without excessive explanation.

### Competing Salience Suppression

Competing salience suppression reduces false focal points. A bright decoration, large logo, central image, or high-contrast aside can accidentally become the most important thing. This component quiets elements whose perceptual force exceeds their structural role.

### Context Preservation

Context preservation keeps enough surrounding information available for accurate interpretation. A design can make one element unmistakable while stripping away the evidence, caveat, or comparison needed to understand it truthfully.

### Accessibility Check

The accessibility check asks whether the arrangement remains legible across different viewers, devices, distances, abilities, languages, and environmental conditions. A composition that works only for one viewing condition is not robust.

### Medium Constraint

Medium constraint accounts for the affordances and limits of the surface or space. A phone screen, printed page, museum gallery, control room, hallway, and presentation slide all shape attention differently.

prose_common_mechanisms:
### Layout Composition

Layout composition is a common mechanism for placing elements on a surface. It implements the archetype when placement, grouping, spacing, and sequence are chosen to guide attention and interpretation. A layout grid may help, but the grid is not the archetype.

### Dashboard Arrangement

Dashboard arrangement implements the archetype in operational displays. It makes status, anomaly, cause, and next action readable in a time-constrained environment. The mechanism succeeds when operators can diagnose and act without hunting through equal-weight widgets.

### Page Design

Page design uses headings, margins, callouts, blocks, and order to guide readers through a document. It implements the archetype when the page structure makes the main claim, evidence, caveat, and action legible.

### Exhibit Design

Exhibit design arranges objects, labels, lighting, sightlines, and visitor sequence so a space communicates an interpretive story. It is an implementation of the archetype when visitor attention moves through context, artifact, comparison, and reflection in a deliberate structure.

### Interface Layout

Interface layout places content, controls, feedback, and warnings so users can understand state and act. It implements the archetype only when arrangement supports task interpretation, not merely when the interface looks balanced.

### Architectural Arrangement

Architectural arrangement uses entry, sightline, adjacency, void, mass, and circulation to guide embodied attention. Visitors read a building or space compositionally before they read signs.

### Slide Composition

Slide composition arranges visuals, text, emphasis, and progression to make the intended point clear. A slide can be visually polished but compositionally weak if the audience’s first read is not the intended argument.

### Information Design

Information design uses labels, grouping, visual encoding, spacing, and explanatory context to make relationships interpretable. It implements the archetype when the arrangement helps people infer the intended comparison, sequence, or causal relation.

prose_failure_modes:
A false focal point occurs when decoration, central placement, size, color, or emotional force makes the wrong element dominant. Relation misread occurs when placement implies the wrong connection. Overcomposed path occurs when users are forced through a brittle sequence and cannot recover or compare. Aesthetic drift occurs when beauty replaces interpretive function. Context erasure occurs when focus is gained by hiding necessary evidence. Audience mismatch occurs when the composition assumes scan habits or perceptual conditions that the real audience does not share.

Each failure mode should be mitigated through salience mapping, context checks, accessibility review, and interpretation testing with representative users or viewers.

prose_neighbor_distinctions:
Compositional Attention Design is broader than Gestalt Grouping Design. Gestalt grouping focuses on perceptual grouping principles; this archetype uses grouping only as one tool in a larger arrangement of priority, relation, sequence, and action.

It is distinct from Cognitive Load Reduction because it does not always simplify. Sometimes it preserves complexity but arranges it so the right structure can be read.

It is distinct from Representation Fit Selection because it does not primarily choose the representation. It arranges elements within a chosen representation, medium, or environment.

It is close to Visual Hierarchy Design, but hierarchy alone is narrower. This archetype includes context, relation, sequence, and whole-field meaning.

It is distinct from Visual Flow Guidance, Negative Space Design, Focal Emphasis Design, Visual Metaphor Design, and Iconographic Meaning System when those patterns have their own active intervention: path, absence, salience, metaphor mapping, or symbolic convention.

prose_cross_domain_examples: In interface design, a checkout page can place error feedback next to the blocked action so the user understands what to fix before retrying. In data visualization, a dashboard can place the anomalous signal near causal context and comparison data. In architecture, an entrance sequence can make orientation, service priority, and public/private boundaries legible. In education, a handout can arrange model, worked example, and practice prompt so learners see the conceptual relation before acting. In exhibit design, object placement and visitor path can change the meaning of an artifact before the label is even read.

prose_non_examples: A layout grid used only for tidy margins is not the archetype. A fashionable color palette is not the archetype. A beautiful poster whose main message is still missed is not a successful instance. A chart type change made because the data requires a different representation is primarily representation fit selection. An art style label is not an archetype unless it explains a transferable intervention for attention, interpretation, or action.

prose_tradeoffs:
Strong guidance can reduce exploration. Clear hierarchy can make secondary context feel less important. Dense context can weaken focal clarity. A medium-specific composition may transfer poorly when copied into another format. Visual polish can also create unwarranted trust if the underlying content is weak.

The right tradeoff depends on the task. A warning display may need strict hierarchy; a museum gallery may need more exploratory room; a technical report may need both a focal claim and visible caveats.

prose_invariants_to_preserve: The focal priority must remain aligned with actual importance. Spatial relations should communicate true or intended semantic relations, not accidental adjacency. Necessary context must remain available. Accessibility and audience fit must be preserved. In high-stakes contexts, the arrangement must not hide risks, alternatives, uncertainty, or exit options.

prose_target_outcomes: Successful use of this archetype produces faster first recognition, more consistent interpretation, clearer relationship-reading, smoother navigation, and more appropriate action. It should reduce the need for explanatory repair because the arrangement itself carries more of the intended structure.

prose_parameter_dimensions:
Important tuning dimensions include focal strength, number of competing elements, density, spacing, grouping strength, contrast, scale, symmetry or asymmetry, reading-path strictness, contextual richness, and medium distance. These parameters should be tuned against the intended interpretation rather than abstract taste.

The most important tuning question is: “What does the audience perceive first, and what relation do they infer from that first perception?” If the answer differs from the intended structure, the composition needs revision.

prose_variants_and_near_names:
Useful variants include interface attention composition, information display composition, and environmental attention composition. These variants apply the same arrangement logic to screens, information artifacts, and physical spaces.

Visual balance calibration and proportion/scale calibration are recorded as merge-review variants. They may become standalone archetypes if balance, tension, ratio, observer scale, and proportional fit produce distinct components and failure modes. For now they are best treated as composition-sensitive tuning families unless review finds stronger separation.

Near names include perceptual composition, attention-oriented composition, compositional guidance, layout composition, dashboard arrangement, and visual hierarchy design. Mechanism names such as layout grid, page template, dashboard layout, and decorative border should not be drafted as archetypes.

Interface Attention Composition

short_definition: Applies compositional attention design to screens, controls, feedback, warnings, and task flows.

distinctive_feature: The composition must support interactive action, not only viewing or reading.

distinct_from_parent: The parent can apply to any perceptual field; this variant adds task state, control affordances, and interaction timing.

still_same_parent_because: The core intervention is still deliberate arrangement of elements so attention and interpretation follow the intended structure.

use_when: Users must notice status, next action, affordances, or risk signals in an interface.

use_when: Important controls or feedback are present but visually lost among competing interface elements.

Element Inventory

role: defines the material available for composition

Perceptual Hierarchy

role: sets priority within the arrangement

Reading Path

role: routes attention through the composition

Interpretation Test

role: checks whether the intended reading occurs

Interface Layout

mechanism_type: interface

role: places controls and feedback for action

Dashboard Arrangement

role: routes operational attention

domain: interface design

example: A checkout screen places error feedback, payment action, and order summary so the user sees the blocking issue before retrying.

failure_modes: The interface becomes visually polished but hides task-critical state or error feedback.

Information Display Composition

short_definition: Arranges informational elements so viewers infer the intended priority, comparison, sequence, or relation.

distinctive_feature: The variant emphasizes relation-reading in information artifacts.

distinct_from_parent: The parent includes physical and symbolic environments; this variant focuses on information surfaces and explanatory artifacts.

still_same_parent_because: It still relies on composition to guide attention and interpretation, not on changing the underlying data or representation type alone.

use_when: A report, dashboard, chart, poster, slide, or exhibit includes the right facts but makes the wrong relation salient.

use_when: Viewers need to compare, diagnose, or interpret rather than merely read isolated labels.

Spatial Relation

role: expresses relation through placement and adjacency

Slide Composition

mechanism_type: artifact

role: guides audience attention on a slide

Layout Composition

mechanism_type: method

role: arranges elements on a field

domain: data visualization

example: A monitoring display places anomalous readings near causal context rather than burying them in a uniform table.

failure_modes: The display optimizes for symmetry or density while obscuring the relation users must understand.

Environmental Attention Composition

short_definition: Arranges physical space, objects, sightlines, voids, and approach paths so people perceive purpose and movement in an environment.

distinctive_feature: The attention field is embodied and spatial; people read it while moving through it.

distinct_from_parent: The parent includes any medium; this variant emphasizes sightline, distance, entry sequence, and bodily orientation.

still_same_parent_because: The intervention remains a compositional arrangement that changes what people notice and how they interpret relations.

use_when: People enter or move through a built or exhibit space and need to understand where to look, gather, pause, or proceed.

use_when: The physical arrangement sends unintended signals about importance, access, or sequence.

Architectural Arrangement

role: shapes embodied attention through space

Exhibit Design

role: arranges objects and path through a space

domain: museum design

example: A gallery uses entry angle, object spacing, and label placement so visitors encounter context before a central artifact.

failure_modes: The intended reading path conflicts with actual movement patterns, crowding, or accessibility needs.

Visual Balance Calibration

short_definition: Tunes visual weight, symmetry, asymmetry, and spacing so the arrangement feels stable, intentionally tense, or meaningfully uneven.

distinctive_feature: It focuses on perceived weight and equilibrium rather than the whole reading structure.

distinct_from_parent: The parent routes attention and interpretation broadly; this subtype emphasizes stability, tension, and weight distribution.

still_same_parent_because: Balance calibration still changes attention and meaning by rearranging elements within a composition.

use_when: The composition feels accidentally heavy, unstable, dull, or skewed.

use_when: The meaning depends on perceived equilibrium, tension, or asymmetry.

Visual Weight Map

role: estimates the attention pull of each visible element

domain: presentation design

example: A slide balances a strong image with concise text so neither dominates the intended message accidentally.

failure_modes: Balance becomes decorative symmetry that weakens priority or hides the true focal relation.

Proportion/Scale Calibration

short_definition: Tunes relative size relationships so importance, usability, fit, and emotional force are perceived correctly.

distinctive_feature: The subtype centers on ratio, scale cue, and observer relation.

distinct_from_parent: The parent includes all arrangement relations; this subtype isolates size and proportion as the controlling relation.

still_same_parent_because: Scale and proportion work here as compositional signals that shape attention and interpretation.

use_when: Relative size makes an element look too important, too weak, too distant, or misfit for the observer.

use_when: The relation between parts matters more than the absolute size of any one part.

Size Ratio

role: sets perceived relative importance through proportion

example: A chart scales labels and annotations so the deciding comparison is legible without exaggerating the data.

failure_modes: Scale becomes emphasis theater: size implies importance or magnitude that the evidence does not justify.

near_names:
Perceptual Composition
Attention-Oriented Composition
Compositional Guidance
Layout Composition
Dashboard Arrangement
Visual Hierarchy Design


Compositional Meaning Design

batch: First Iteration/Batch 47

source_primes: compositionality composition order

related_primes: modularity relation function constraint schema pattern_design interoperability abstraction representation chunking well_foundedness

slug: compositionality

slug: order

slug: relation

slug: function

slug: schema

slug: abstraction

slug: chunking

components:
Meaning Component
Combination Rule
Scope Rule
Exception Rule
Composed Meaning Test
Miscomposition Risk
Invalid Combination Check
Interpretation Context
Component Catalog
Sequence or Precedence Rule
Worked Example Set
Versioned Rule Record

mechanisms:
Grammar Rule Set
Design System Component Rules
Semantic Schema Validation
Modular Documentation Template
Legal Clause Composition Review
Composable Icon System
Sentence Frame or Message Template
Invalid Combination Linter
Interpretation Walkthrough

essence_one_line: Design parts and combination rules so complex meanings can be built predictably.

compression_statement: When complex messages, symbols, interfaces, clauses, schemas, or procedures are assembled from meaningful parts, define component meanings, combination rules, scope rules, exception rules, invalid-combination checks, and whole-meaning tests so the assembled result says and does what it is intended to say and do.

core_intuition: A part can be clear by itself and still create confusion when combined with other parts. Meaning emerges from both components and the rules that bind them, so the intervention works by making the assembly logic explicit and testable rather than relying on local clarity alone.

canonical_formula: meaning_components + combination_rules + scope/exception_rules → composed_meaning → interpretation_test + invalid_combination_check → governed_assembly

structural_problem: Parts of a message, symbol system, interface, legal text, template, or schema are meaningful in isolation, but their combination produces ambiguity, contradiction, unintended scope, invalid affordance, or a whole meaning that no part individually signaled.

trigger_conditions: Teams assemble messages, screens, clauses, templates, icons, fields, or procedures from reusable modules.

trigger_conditions: A modifier, exception, condition, label, operator, color, badge, or sequence changes more of the whole than intended.

trigger_conditions: Local review approves individual parts but users, readers, or systems misinterpret the assembled result.

trigger_conditions: Different teams combine the same parts differently and produce inconsistent meanings.

trigger_conditions: The system has slots, sequences, or rule-governed assemblies whose validity cannot be inferred from part validity alone.

trigger_conditions: A design system, document system, schema, icon language, or policy library grows faster than its composition rules.

symptoms: A sentence, clause, or interface appears correct locally but is interpreted differently when read as a whole.

symptoms: People disagree about which component a condition, exception, label, or modifier applies to.

symptoms: Reusable modules create contradictory or redundant assembled outputs.

symptoms: Users can identify individual icons, fields, or labels but misread their combined state or action.

symptoms: Templates allow technically valid combinations that produce nonsensical, unsafe, or misleading outcomes.

symptoms: Reviewers keep fixing cases one by one because there is no explicit composition rule to generalize from.

root_tension: Reusable components increase speed and consistency, but meaning is not preserved automatically when parts are combined. The system must preserve component reuse while preventing the assembly from creating unintended whole meaning.

anti_signatures: The problem is only that one sign, label, or symbol means the wrong thing. Use Sign–Meaning Alignment instead.

anti_signatures: The problem is choosing whether to use an icon, index, or arbitrary symbol. Use Sign-Type Selection instead.

anti_signatures: The problem is a term changing meaning over time. Use Semantic Drift Monitoring instead.

anti_signatures: The problem is a multi-meaning term in a particular context rather than part/whole assembly. Use Polysemy Disambiguation instead.

anti_signatures: The problem is updating a schema or convention over time rather than composing meaning from current parts. Use Schema Update Protocol or Symbolic Convention Governance instead.

anti_signatures: The requested artifact is only a grammar rule, template, style guide, legal clause, schema, or icon set without a transferable assembly intervention.

structural_intervention: Define the parts, the permissible ways they combine, the scope and exception logic, the invalid combinations, and the tests that confirm the intended composed meaning across representative contexts.

action_logic: Inventory the meaning-bearing parts and identify what each contributes in isolation.

action_logic: Define the intended whole meanings or functions that assembled outputs are allowed to produce.

action_logic: Specify combination rules: order, grouping, nesting, adjacency, connector logic, inheritance, overrides, and allowed substitutions.

action_logic: Specify scope rules so modifiers, exceptions, constraints, permissions, labels, and conditions apply to the correct parts.

action_logic: Define exception rules and invalid-combination checks for cases where ordinary composition fails.

action_logic: Create examples and nonexamples that illustrate valid and invalid assemblies.

action_logic: Test representative assembled outputs with users, readers, reviewers, or validators who must interpret the whole.

action_logic: Revise components or rules and govern changes so future compositions remain predictable.

decision_rules: Use the archetype only when whole meaning depends on how parts combine, not merely on choosing better individual labels.

decision_rules: Treat local clarity as insufficient until the assembled whole has been tested.

decision_rules: When a modifier or exception could apply to multiple parts, require an explicit scope rule.

decision_rules: When a part can occupy multiple roles or slots, require role-specific interpretation rules.

decision_rules: When invalid combinations are predictable, encode them as rules, linters, tests, or review checks rather than relying on expert memory.

decision_rules: When the same parts must support multiple domains or audiences, document context-specific composition differences rather than pretending the rule is universal.

decision_rules: Do not make every exception ad hoc; exceptions should preserve governability of the overall composition system.

target_invariants: Each reusable part has a known contribution to the whole.

target_invariants: Combination rules are explicit enough for independent users to apply consistently.

target_invariants: Scope and exception boundaries are inspectable and testable.

target_invariants: The composed whole does not contradict component meanings unless an explicit rule explains the override.

target_invariants: Invalid combinations are detectable before they cause interpretation or operational failure.

target_invariants: The system remains flexible enough to build new meanings without making every assembly bespoke.

target_invariants: Mechanisms such as templates, schemas, and style guides remain governed by the archetype rather than replacing it.

expected_outcomes: Complex messages, interfaces, symbols, documents, and records become easier to assemble without unintended meaning.

expected_outcomes: Teams can reuse parts while preserving whole-level interpretability.

expected_outcomes: Readers and users infer scope, exceptions, and combined effects more reliably.

expected_outcomes: Review shifts from case-by-case correction to reusable composition governance.

expected_outcomes: Templates, schemas, design systems, and icon systems become more consistent and maintainable.

expected_outcomes: Misinterpretation from accidental combinations, misplaced modifiers, invalid slots, or untested assemblies decreases.

prose_essence:
Compositional Meaning Design is the intervention pattern for situations where the meaning of a whole depends on how meaningful parts are assembled. It is not just modular reuse and not just grammar. It asks: what does each part contribute, what rules control how parts combine, how far do modifiers and exceptions reach, what combinations are invalid, and how do we test the meaning of the finished whole?

The archetype is useful because local clarity does not guarantee global clarity. A label, clause, icon, template module, or data field can be individually understandable while its combination with other parts creates ambiguity, contradiction, overbroad scope, or unintended affordance.

prose_when_to_use:
Use this archetype when a message, interface, policy, visual language, schema, or modular content system is assembled from reusable components and the assembly itself affects interpretation. It is especially relevant when teams reuse parts across many contexts, when exceptions or modifiers apply only to part of a whole, or when templates allow combinations that are technically valid but semantically wrong.

Do not use it for a single misunderstood sign, a general style guide, or a linguistic theory explanation. The roadmap specifically warns that compositionality should not be promoted as a term alone; it should become an intervention only when parts, combination rules, emergent meaning/function, and miscomposition risk are explicit.

prose_structural_problem:
The structural problem is miscomposition. Parts that look clear in isolation combine into an unclear, contradictory, misleading, or invalid whole. This can happen through ambiguous scope, invalid slot substitution, bad sequence, untested exceptions, conflicting visual modifiers, or schemas that validate syntax but not meaning.

The root tension is between reuse and interpretation. Reusable components make systems scalable, but they also create more possible assemblies than any reviewer can inspect manually unless the composition rules are explicit.

prose_intervention_logic:
The intervention begins by inventorying meaning-bearing parts and defining their intended contribution. It then specifies combination rules: order, grouping, nesting, adjacency, connector logic, override rules, slot substitutions, and scope boundaries. Next, it defines exceptions and invalid combinations so the system can block or review assemblies that would create unintended meaning. Finally, it tests representative composed outputs with readers, users, reviewers, or validators who must interpret the whole.

In practical terms, this turns composition from an implicit habit into a governable design surface. The outcome is not merely a template or rule list; it is a repeatable way to preserve whole-level meaning while still allowing modular assembly.

prose_key_components:
- **Meaning Component (`meaning_component`)**: Each reusable part must have a known local contribution. This may be a word, clause, icon element, interface module, field, or content block.
- **Combination Rule (`combination_rule`)**: The rule explains how components combine through order, grouping, nesting, adjacency, hierarchy, or override logic.
- **Scope Rule (`scope_rule`)**: Scope rules define how far a modifier, exception, condition, label, or visual marker applies.
- **Exception Rule (`exception_rule`)**: Exceptions document where ordinary composition stops working and how the system should treat the boundary.
- **Composed Meaning Test (`composed_meaning_test`)**: The whole assembly must be tested, not only its parts.
- **Miscomposition Risk (`miscomposition_risk`)**: This identifies ambiguity, contradiction, overbreadth, exclusion, unsafe affordance, or operational failure caused by the assembly.
- **Invalid Combination Check (`invalid_combination_check`)**: This prevents individually valid parts from becoming invalid when combined.
- **Interpretation Context (`interpretation_context`)**: The expected audience, domain, convention, and setting must be named because composition rules can differ by context.

prose_common_mechanisms:
Grammar rule sets implement this archetype for language by documenting valid combinations and scope conventions. Design-system component rules implement it for interfaces by defining how modules, states, labels, and actions can be combined. Semantic schema validation implements it for data systems by checking whether fields and relationships compose into valid records.

Other mechanisms include modular documentation templates, legal clause composition reviews, composable icon systems, sentence frames, invalid-combination linters, and interpretation walkthroughs. These are implementation families. They should not be confused with the archetype itself. A template or schema only implements Compositional Meaning Design when it governs part contribution, combination logic, scope/exception behavior, invalid combinations, and whole-level interpretation.

prose_failure_modes: The most common failure mode is local clarity with global ambiguity: every component passes review, but the assembled whole fails. Another is scope leakage, where a modifier or exception applies farther than intended. Invalid substitution happens when a part works in one slot but not another. Exception sprawl occurs when ad hoc exceptions accumulate until the composition rule is no longer teachable. Mechanism capture occurs when a team mistakes a template, grammar rule, or schema for the archetype.

prose_neighbor_distinctions:
This is distinct from **Sign–Meaning Alignment**, which fixes mismatch between a sign form and intended interpretation. Compositional Meaning Design addresses meaning that emerges from multiple parts and their assembly rules.

It is distinct from **Sign-Type Selection**, which chooses whether meaning is conveyed through resemblance, causal indication, or convention. It is distinct from **Symbolic Convention Governance**, which maintains shared conventions over time. It is distinct from **Semantic Drift Monitoring**, which tracks changing meanings over time. It is distinct from **Polysemy Disambiguation**, which clarifies the active sense of a multi-meaning term.

For this batch, **Slot / Sequence Meaning Design** is captured as a collapsed subtype: it focuses on allowed substitutions, roles, and order-dependent meaning inside the broader compositional problem.

prose_cross_domain_examples:
In interface design, severity color, icon, title, action button, and dismissal state may combine to signal whether user action is optional, urgent, or blocked. In legal drafting, definitions, exceptions, and cross-references may combine into a legal effect that differs from any single clause. In icon systems, a base icon plus slash, lock badge, arrow, or warning triangle may produce a compound state that users must parse quickly.

In modular documentation, reusable symptom, diagnosis, and resolution modules need allowed-sequence rules to avoid contradictory pages. In data governance, a schema can prevent syntactically valid but semantically impossible records. In education, lesson components can be composed so objective, activity, assessment, and feedback all point to the same capability.

prose_non_examples: A single vague warning label is not this archetype; use Sign–Meaning Alignment or Polysemy Disambiguation. A style guide that merely lists preferred punctuation is a mechanism, not the archetype. A glossary is not this archetype unless it governs how definitions compose into whole documents. A schema migration is not this archetype unless the main problem is current part/relationship composition rather than temporal update.

prose_tradeoffs: More explicit rules increase consistency but can reduce flexibility. Invalid-combination checks prevent errors but may block novel valid assemblies. Whole-meaning tests improve reliability but add review cost. Rule systems can also become brittle if they pretend that all context-sensitive interpretation can be mechanized.

prose_invariants_to_preserve: The archetype should preserve these invariants: each part has a known contribution; combination rules are explicit enough to apply consistently; scope and exceptions are inspectable; the whole does not contradict its parts unless an explicit override rule says so; invalid combinations are detectable; and the system remains flexible enough to support new legitimate compositions.

prose_target_outcomes: Successful use produces assembled messages, interfaces, symbols, clauses, records, or content pages whose whole meaning is predictable. Teams can reuse parts without creating accidental contradiction. Readers and users infer scope and exceptions more reliably. Review shifts from endless local patching to reusable composition governance.

prose_parameter_dimensions:
Important tuning dimensions include rule strictness, allowable variation, exception breadth, scope granularity, test burden, interpretive audience, domain specificity, and automation level. A highly regulated legal or safety system may need strict composition rules and formal review. A creative communication system may need looser rules and examples that preserve room for nuance.

The key calibration question is: how much predictability is required before the composed output can be trusted?

prose_variants_and_near_names:
Recognized variants include Slot / Sequence Meaning Design, Legal Meaning Composition, Composable Icon or Visual-Language Design, and Semantic Schema Composition. Near names include semantic composition design, combinatorial meaning design, grammar design, modular message design, and syntax rule design.

The policy is to keep these as variants or mechanism names unless future reconciliation shows that one has a separate problem signature and intervention logic that is not reducible to part/rule/whole composition.

Slot / Sequence Meaning Design

short_definition: Separate which elements can substitute into roles from how their ordered arrangement changes meaning.

distinctive_feature: It focuses on slot choice and sequence constraints as a specific kind of compositional rule.

distinct_from_parent: The parent handles all part/whole meaning assembly; this variant narrows attention to slot substitution and order-dependent meaning.

still_same_parent_because: Slot and sequence rules are one way to define combination rules and invalid-combination checks inside a compositional system.

use_when: A system has slots, roles, or positions that accept multiple possible values.

use_when: Order, adjacency, grouping, or sequence changes interpretation or validity.

use_when: The main risk is allowing individually valid parts to appear in invalid positions or sequences.

Functional Slot

role: Identifies a position or role into which alternative parts may be placed.

Allowed Substitution

role: Defines which parts may fill a slot without breaking meaning.

Sequence Rule

role: Defines how order changes interpretation.

Invalid Combination Check

role: Prevents individually valid parts from creating invalid assemblies.

Form Template

role: Constrains slots and order in a reusable artifact.

Sentence Frame

role: Shows how substitutions affect message meaning.

Workflow Slot Rule

role: Defines how role assignment and sequence combine in a process.

domain: forms

example: A benefits form separates applicant, dependent, and reviewer slots so substitutions do not change legal responsibility.

example: A notification template defines which status token can precede which action label.

domain: workflow

example: A triage workflow defines which handoff roles can appear before approval steps.

failure_modes: Treating slot filling as free variation when order or role changes meaning.

failure_modes: Overfitting a template so legitimate compositions become impossible.

Legal Meaning Composition

short_definition: Control how definitions, clauses, exceptions, references, and remedies combine into legal effect.

distinctive_feature: The composed meaning carries rights, duties, eligibility, liability, or enforceability consequences.

distinct_from_parent: It is the legal domain version of the same part/rule/test structure.

still_same_parent_because: It uses the same composition logic: components, scope, exception handling, and whole-meaning validation.

source_primes: compositionality composition

use_when: Definitions and clauses are individually clear but interact in unexpected ways.

use_when: An exception may apply to too much or too little of a rule.

use_when: Cross-references or nested conditions create scope ambiguity.

Defined Term

role: Constrains how a term contributes throughout a document.

Cross Reference

role: Connects one clause to another in the composition.

Exception Scope

role: Defines where exceptions begin and end.

Clause Interaction Matrix

role: Maps how clauses and exceptions interact.

Legal Drafting Review

role: Checks composed legal effect.

example_domains: law policy compliance contracting

domain: contracts

example: A limitation-of-liability clause is tested against indemnity and carve-out language.

failure_modes: Local clarity masks global contradiction.

failure_modes: Exceptions unintentionally swallow the rule.

name: Composable Icon or Visual-Language Design

short_definition: Combine visual signs, modifiers, overlays, colors, and positions so a compound icon or visual message is interpreted predictably.

distinctive_feature: Visual composition may be read spatially rather than linearly, so grouping and position rules carry meaning.

distinct_from_parent: It is a visual-language implementation of compositional meaning design.

still_same_parent_because: It still depends on defined components, combination rules, scope, exceptions, and interpretation tests.

use_when: A visual system builds compound messages from reusable marks.

use_when: Modifiers such as color, badge, slash, arrow, or placement alter the base meaning.

use_when: Users must infer both base concept and modifier effect quickly.

Base Icon

role: Carries the primary referent.

Visual Modifier

role: Changes action, status, constraint, or urgency.

Spatial Grouping Rule

role: Defines how position and grouping change interpretation.

Icon Grammar

role: Documents valid visual combinations.

Visual Interpretation Test

role: Checks whether users infer the compound meaning.

example: A cloud icon plus slash plus lock badge is tested so users do not confuse offline, private, and unavailable states.

failure_modes: Visual modifiers conflict with cultural conventions.

failure_modes: Compound icons become too dense to parse.

Semantic Schema Composition

short_definition: Define how fields, relations, constraints, and labels compose into a coherent data or knowledge schema.

distinctive_feature: The composed meaning is encoded in structured records rather than ordinary prose or visual signs.

distinct_from_parent: It is a structured-data version of the parent archetype.

still_same_parent_because: It still uses parts, combination rules, invalid-combination checks, and composed-meaning tests.

source_primes: schema composition compositionality

use_when: Individually valid fields or categories create contradictions when combined.

use_when: A model needs composable labels, relationships, or constraints.

use_when: Schema users need predictable meaning across records, reports, or systems.

Field Meaning

role: Defines what each field contributes.

Relationship Rule

role: Defines how fields and entities combine.

Constraint Check

role: Prevents invalid composed records.

Schema Validator

role: Checks whether combined fields remain valid.

Data Dictionary

role: Documents component meanings and relation rules.

example: A patient-status schema prevents a record from combining deceased status with active appointment reminders.

failure_modes: The schema enforces syntactic validity without checking semantic validity.

failure_modes: Hidden assumptions make cross-system composition brittle.

near_names:
Semantic Composition Design
Combinatorial Meaning Design
Grammar Design
Modular Message Design
Syntax Rule Design