Mores and the Machine
The Latin word mores carries a weight that its English derivatives only approximate. Where "morals" suggests codified rules and "morality" implies a system of judgment, mores points to something more fundamental: the customs, conventions, and deeply held values that shape a community's sense of right conduct. In the context of software development, this distinction matters profoundly.
Every line of code embodies a decision about how the world should work. The question is whether we make those decisions consciously or inherit them by default.
We build systems that allocate resources, mediate relationships, filter information, and structure attention. Each architectural choice carries implicit values: who is centered, who is marginalized, what is measured, what is ignored. The mores of software development are not abstract philosophical puzzles but lived practices with tangible consequences.
This space exists to explore that intersection with care and intellectual honesty, drawing from traditions of philosophical inquiry to ask better questions about the systems we create.†
Ethics in the Architecture
The relationship between ethics and code is not metaphorical. When we design a database schema, we decide what categories of human experience deserve to be recorded. When we write an algorithm, we encode a theory of fairness, however implicit. When we choose a framework, we inherit its assumptions about how humans interact with machines.
Consider the simple act of designing a form. Every field represents a claim about what information matters. Every validation rule embodies an assumption about what constitutes a legitimate answer. The dropdown menu that offers only "Male" or "Female" is not a neutral technical choice but a philosophical position about human identity.‡
The ethical developer is not one who avoids all harm but one who develops the habit of asking: whose interests does this design serve, and whose does it neglect?
This inquiry demands more than adding an ethics review to the sprint cycle. It requires cultivating what Aristotle called phronesis practical wisdom: the capacity to perceive the morally salient features of a situation and respond with appropriate care. In software development, practical wisdom manifests as the ability to see past the technical requirements to the human realities they shape.
The challenge is that software systems operate at scales that overwhelm individual moral intuition. A decision that seems innocuous when applied to one user takes on entirely different significance when applied to millions. This is where the rigorous traditions of moral philosophy become not luxuries but necessities.
The Shape of Reasoned Argument
Discourse, in its philosophical sense, is not merely conversation but a structured practice of reasoning together. It requires patience, intellectual honesty, and a willingness to follow arguments where they lead, even when the destination is uncomfortable. In an industry dominated by hot takes and tribal affiliations, this kind of sustained, careful reasoning is both rare and necessary.
The traditions of philosophical discourse offer models for how technical communities might engage with difficult questions. The Socratic method reminds us that good inquiry begins not with answers but with a recognition of what we do not know. The dialectical tradition teaches that opposing positions often contain partial truths that, when synthesized, yield deeper understanding.
Good discourse requires the intellectual humility to treat one's own positions as hypotheses rather than certainties, and the generosity to extend the same courtesy to others.
In the context of software development, discourse takes on particular urgency when we consider that technical decisions are never purely technical. The choice between centralization and decentralization is a political question. The design of a recommendation algorithm is an epistemological question. The implementation of a content moderation system is a question of justice.†
What we need are not more opinions delivered with confidence, but more questions asked with genuine curiosity and a commitment to working through the complexity rather than around it.
Building with Values
Architecture, in both its physical and software senses, is the art of creating structures that shape human experience. The architect Christopher Alexander argued that certain spatial patterns naturally support human well-being, that the arrangement of doors, windows, and walls is never neutral but always either supports or undermines the life that unfolds within them. The same principle applies to software architecture.
A well-designed API is not merely one that is efficient and well-documented; it is one that makes the right things easy and the wrong things hard. A thoughtful database schema does not just store data correctly; it represents the domain in a way that illuminates rather than obscures the relationships that matter. Good software architecture, like good physical architecture, creates spaces where good things are likely to happen.
Architecture is the practice of giving form to values. Every system we build is an argument, rendered in code, about how some part of the world should work.
This perspective transforms the practice of software development from a purely technical exercise into a moral one. Not in the sense that every commit requires an ethical review, but in the deeper sense that the habits of mind we bring to our work determine the character of what we produce.‡
The question is not whether our architectures embody values but whether we are conscious of the values they embody, whether we have chosen them deliberately or merely inherited them from convention, convenience, or inertia.
From Principle to Practice
Philosophy without practice is mere speculation; practice without philosophy is mere habit. The challenge and the opportunity of mores.dev is to hold these two modes of inquiry in productive tension, allowing each to inform and challenge the other.
In practical terms, this means developing frameworks for ethical reflection that are grounded in the actual conditions of software development: the pressures of deadlines, the complexity of legacy systems, the uncertainty of emerging technologies, the competing demands of stakeholders with different interests and different power.
The goal is not moral perfection but moral attention: the cultivated habit of noticing the ethical dimensions of technical work and taking them seriously.
It also means engaging seriously with the philosophical traditions that have grappled with these questions for millennia. The virtue ethics of Aristotle, the deontological frameworks of Kant, the consequentialism of Mill, the care ethics of Noddings, the justice theories of Rawls, each offers distinct and valuable perspectives on the questions that confront us as builders of digital systems.
What distinguishes mores.dev is the conviction that these traditions are not academic curiosities but practical resources, tools for thinking more clearly about the work we do and the world we are making through that work.†