- The paper introduces a systematic framework that operationalizes meaningful software design by formalizing a four-part ontology of individuals, actions, facts, and values.
- The paper demonstrates that aligning explicit semantic representations with domain phenomena reduces conceptual misalignment and improves user engagement.
- The paper advocates for practical implementations using minimal DSLs and agentic codes of conduct to ensure transparent, auditable, and modular software behavior.
Explicit Semantics and the Foundation of Meaningful Software
Introduction
"Making Software Meaningful" (2606.11051) presents a systematic approach to defining and operationalizing meaning in software systems. The core thesis is that committing to explicit, shared representations of software behavior—grounded in domain-relevant phenomena—substantively improves usability, modularity, and accountability. The authors synthesize ideas from language semantics, formal methods, conceptual modeling, and HCI to propose a discipline of software design centered on making behavioral meaning explicit and ubiquitous across all artifacts and stakeholder interactions.
Historical Context of Meaning in Software
Efforts to clarify the semantics of software trace back to early programming languages, where denotational, operational, and axiomatic semantics linked program meaning to observable behavior. However, as software’s role developed, practitioners observed that users and stakeholders interpreted meaning primarily within specific application domains. Philosophical critiques (e.g., Cantwell Smith) and practical arguments (e.g., Michael Jackson's problem frames) highlighted the insufficiency of seeing software as mere symbolic manipulation disconnected from the domain.
While formal methods advanced models for behavioral specification, a persistent disconnect remained between specifications and code, and between developer models and user-facing concepts. Conceptual modeling and HCI traditions emphasized the importance of conceptual models, yet lacked concrete, actionable frameworks for encoding and operationalizing such models within development. The paper positions concept design—a discipline extracting phenomena (actions, facts, individuals) and partitioning them into meaningful modules—as the technical basis for realizing ubiquitous, actionable meaning.
The Role of Meaning in Usability, Modularity, and Accountability
The authors argue that usability is fundamentally a property of shared and explicit meaning. User confusion, misinterpretation, and interaction failures often derive from misaligned or opaque mappings between user-facing actions and system-internal events. Similarly, modularity is not merely architectural separation, but must be grounded in meaningful partitions—modules should encapsulate cohesive, interpretable units of behavior, not arbitrary code.
Accountability is framed as being achievable only to the extent that software actions are meaningful, explicit, and inspectable—for both traditional software and increasingly for agentic systems. The GDPR and related regulatory regimes highlight emergent risks where meaning is ambiguous or inaccessible, particularly in agent-mediated action.
A shared language—transcending role and artifact—is proposed as the linchpin for cross-functional communication, participatory design, and regulatory transparency. The concept framework, organized around well-scoped actions and facts, operationalizes Eric Evans’ notion of “ubiquitous language,” but with formal semantics and clear behavioral grounding.
Ontology of Phenomena: Individuals, Actions, Facts, and Values
The formal system underlying this approach is a four-way ontology:
- Individuals: Unique entities with unstructured identity, orthogonal to values and not characterized by methods or attributes as in object-orientation.
- Values: Structured, interpretable data.
- Actions: Atomic, domain-relevant behavioral events, characterized by input/output participants and explicit conditions/effects on facts.
- Facts: Relations among individuals and values, representing system state.
Modularity is achieved by partitioning actions—and the facts they manipulate—into concepts, each representing a well-scoped functional concern (e.g., Posting, Authenticating). Cross-concept coordination is captured declaratively via synchronizations (reactions), which link action patterns and their effects across concepts without introducing inter-module coupling at the code level.
Practical Implications in UX, Code Generation, and Agent Design
Diagnosing Conceptual Misalignment
The framework provides diagnostic tools for analyzing mismatched or misleading meaning. It enables designers and users to precisely identify when user intentions are not matched by system-implemented actions, facilitating rigorous critique of “dark patterns” and dynamic subversion of interface semantics (enshittification). It offers a mechanism for users to articulate actionable bug reports and feature requests grounded in the explicit conceptual model, bridging the persistent gap between user experience and implementation.
End-User Programming and Participatory Design
By introducing explicit units of meaning, the approach seeks to render end-user programming tractable at the semantic level users actually operate. Unlike low-code or LLM-based approaches, which prioritize syntactic accessibility but retain semantic opacity, concept design enables reasoning about software at the level of domain phenomena. Participatory design processes benefit from a shared conceptual vocabulary, promoting meaningful user involvement and reducing misinterpretation.
Building Meaningful Code Structures
Applying concept design to implementation, the authors propose mapping individuals to UUIDs, actions to simple functions over maps, facts to relations, and organizing code into singleton classes (one per concept) with rigorous isolation. Synchronizations are realized via a minimal DSL interpreted by a lightweight TypeScript framework. This facilitates highly regular, context-light LLM code generation: concept classes and synchronizations can be generated in isolation, with minimal risk of accidental coupling or accidental complexity, as evidenced by student project experiences.
Crucially, action logs become the canonical record: every action and its provenance are logged, supporting strong auditability, systemic replay for analysis or recovery, and offering a direct mapping between user-observable actions and internal state transitions.
Agentic Systems Governed by Explicit Codes of Conduct
The framework extends naturally to autonomous agents. With the proliferation of agentic systems that act on users’ behalf, the lack of transparent, inspectable meaning in agent behavior logs introduces novel risks. The paper advocates for agentic “codes of conduct,” explicitly enumerating authorized actions and their enabling conditions as synchronizations among domain concepts. Action traces generated under such codes are inherently legible—every action is attributable to a clause in the code of conduct, supporting both ex post auditing and regulatory evaluation.
The trace structure organizes agent memory and evaluation, enabling querying by intent rather than by raw text similarity, and supports replay and counterfactual evaluation. Multi-agent coordination is handled by structuring inter-agent communication as actions in shared concepts, not as ad hoc message passing.
The empirical evidence provided (in educational and early domain applications) suggests that meaningful constraints do not impede, and may in fact facilitate, effective agentic work—legibility is achieved without loss of functional capability.
Prospects for the Discipline of Meaningful Software
The approach outlined is intentionally discipline-agnostic, meant to bridge silos between engineers, UX designers, product management, and regulatory stakeholders. It reimagines the principal responsibility of programmers from code construction to meaning construction, aligning with ongoing industry transitions toward microservice architectures, event-driven systems, and LLM-driven code generation.
Explicit, shared meaning is posited as the only tractable route to closing institutional gaps between user intent and delivered software, or between policy and system behavior. Future production and governance of complex autonomous software may depend on the adoption of frameworks that render meaning, not only code, as the primary artifact of design and review.
Conclusion
"Making Software Meaningful" (2606.11051) provides a rigorous articulation of a conceptual foundation for software systems where meaning—grounded, explicit, and shared across developer, user, and agent—is a first-class concern. By formalizing the ontology of phenomena, encoding modularity as a partition of explicit actions and facts, and operationalizing agent accountability through codes of conduct, the authors lay groundwork for practical, inspectable, and robust software aligned with human needs and institutional norms. Adoption of these principles has significant implications for the legibility, evolvability, and trustworthiness of future software, especially in the context of increasingly agentic and autonomous systems.