The Ceremony and the Code

A field report from inside the guild

What It Looks Like From Outside

At some point in the last two decades, a significant portion of software engineering stopped being about software and became about software engineering. The distinction matters, and nobody inside the system is especially motivated to draw it.

The artifact — working software that solves a problem — got steadily buried under a growing apparatus of process, tooling, framework adoption, architectural philosophy, and meeting culture. Sprint planning. Retrospectives. Refinement sessions. Architecture reviews. RFC processes. RFCs for the RFC process. Standups that exist to schedule the real conversation. A practitioner who skips all of this and goes for a walk tends to produce more. They also tend to have political problems. The walk is not the ceremony. The ceremony is the work, in the specific sense that being seen performing it is what the organization is actually measuring.

This is not unique behavior. It is, in fact, extremely precedented. Software just did it faster and with more enthusiasm, possibly because the underlying work is invisible and ritual fills the status vacuum that invisible work creates. You cannot point at a function and explain to your parents what you do. You can point at the Jira board.

Other Guilds Got Here First

Medicine codified this most thoroughly. The AMA spent decades restricting the supply of licensed physicians — limiting medical school seats, standardizing on a single educational model, lobbying to define the practice of medicine broadly enough to exclude competitors. The quality arguments were real. The supply restriction arguments were economic. Both were advanced simultaneously using the same sentences, which is efficient.

Law built the same structure. The bar exam tests recall under pressure. What lawyers actually do is navigate ambiguous situations using prior decisions and judgment accumulated over practice. The exam measures something. The thing it measures correlates weakly with legal competence and strongly with willingness to invest in passing the bar, which is not coincidentally also a supply restriction mechanism.

Architecture, accounting, finance — the pattern repeats. Each profession, at sufficient economic scale, builds a complexity apparatus that raises barriers to entry, creates internal status hierarchies around mastery of the complexity, generates consulting and maintenance work for the complexity itself, and defends against simplification by explaining that simplification is naive. The complexity is the product. The stated purpose is the cover story, in the same way a fee is a cover story for a tax.

This serves two populations simultaneously, which is why the structure is stable. For the elite, the complexity creates a moat — mastery of it is genuinely difficult and genuinely differentiating. For the median practitioner, it provides something more valuable: a script. Follow the ceremonies correctly, adopt the current framework, speak the prevailing architectural dialect, and you are, by the guild's own definition, good enough. The script doesn't require excellence. It requires compliance. This is not a flaw in the system. It is load-bearing. A guild that only served the elite would be a much smaller and more fragile thing.

Software’s version has one distinctive feature: the complexity layer is technical, which makes it harder to audit than a billing code. A microservices architecture with twelve independently deployed services for an application used by three hundred people is obviously over-engineered — but the person who built it can explain, with complete technical fluency, why each service boundary was load-bearing. The explanation is not wrong, exactly. It is the correct answer to a question that perhaps should not have been asked.

The Wheel

Every generation of the profession produces a framework, a methodology, or a paradigm that will finally solve software.

Structured programming. Object orientation. Design patterns. Agile. Microservices. Serverless. AI agents.

Each one arrives with genuine converts, a canon, a conference circuit, and the implicit promise that early adopters will be vindicated and resisters will be embarrassed. Each one solves real problems and creates new ones. The new problems require the next paradigm to solve. The wheel turns. The remarkable thing is not that this happens. The remarkable thing is that each revolution of the wheel is experienced as a departure from all previous wheels rather than as the wheel.

The eschatology — some future state that justifies current sacrifice — is structurally identical across iterations. We are building toward the architecture that will finally be maintainable, the process that will finally produce reliable estimates, the tooling that will finally make onboarding fast. We have always been building toward this. The arrival date is not discussed.

The Sacraments

Frameworks and abstraction layers function as tribal markers in the way that guild credentials function in other professions. Knowing the current framework, using the right terminology, being fluent in the prevailing architectural philosophy — these signal membership. They are also, functionally, a barrier. Someone who doesn’t know the framework needs to learn it before contributing. The framework generates its own upgrade cycles and expertise that has no value outside itself. This is a feature, not a bug, from the perspective of those already credentialed.

The conference talk is the highest sacrament. It is the moment the guild member transcends from practitioner to priest. The content is almost secondary — what matters is the selection, the stage, the slides. People have given conference talks about systems that were quietly decommissioned before the talk was delivered. The talk outlives the system. The talk is the system, in the sense that it is what’s remembered. The decommissioned system had users. The talk has citations.

The cargo cult dynamic follows naturally. Google’s design docs, Amazon’s six-pagers, Netflix’s culture deck, Spotify’s squad model: each was an organic response to a specific organizational problem at a specific scale. Each gets adopted as ritual by organizations with none of the relevant preconditions, because the practice signals sophistication rather than because it solves the same problem. A thirty-person startup doing quarterly OKR calibration sessions is performing Google. The performance is the point. Google, for its part, has moved on.

The Archaeology

A sufficiently old codebase is a stratigraphic column of past ideology. You can date the layers.

Here is where someone read the Gang of Four. Here is the XML configuration enthusiasm of 2008. Here is where someone returned from a microservices conference in 2016 with vision. Here is a framework that was deprecated eighteen months after adoption, preserved in amber because migration was never prioritized. Here is the test suite that tests the mocks rather than the behavior, written by someone who understood that test coverage metrics were being tracked.

The people are gone. The geology remains. Future engineers curse the dead, who were, at the time, following best practices.

The honest definition of a senior engineer is someone who has survived enough of these layers to be privately cynical about the next one, but has learned to perform enthusiasm for it anyway. The cynicism is the competence. The performance is the job.

The Cost Calculation

Every framework adoption, every architectural pattern, every tooling choice carries a cost. The cost is enumerable. It is rarely enumerated.

This is not irrational. The person adopting the framework is frequently not the person who will pay the maintenance cost. The person proposing an architectural pattern is evaluated on the proposal, not the three-year outcome. The incentive structure does not reward accurate cost accounting. It rewards visible technical sophistication, which is different and more legible in a sprint review.

The organizations that would benefit most from running the calculation — the ones paying the accumulated maintenance tax, the upgrade cycles, the incident costs from dependency surfaces they don’t fully understand — frequently cannot see the structural cause because the complexity was presented as inherent to the problem rather than as a choice made about how to approach it.

You cannot easily audit a cost you were told was unavoidable. You can attend the retrospective about it.

The Observation

None of this requires bad faith. It is emergent structure in any community organized around shared practice and status. The question is not whether the apparatus exists. It is whether the ratio of ceremony to output is being honestly tracked.

In most cases it isn’t. The ceremony is the output, in the sense that it is what gets measured and rewarded. The walk produces more but doesn’t show up in the velocity chart.

We built systems that can write production code. We have not reached consensus on the character that was invented for indentation. This is consistent with everything above and requires no further comment.

The economic pressure will do what it does. The ceremony usually continues for some time after the underlying economics have already shifted. The guild members are, after all, still in the room, and the next framework has already been announced.

The wheel, for those just joining, has been turning since approximately 1968. Current estimated arrival at destination: next conference season.