Development of Doctrine
An Essay on the Development of Christian Doctrine, published in the year of Newman's conversion to Roman Catholicism, addressed a specific theological problem: how to distinguish legitimate unfolding of an original idea from its betrayal. The seven notes — preservation of type, continuity of principles, power of assimilation, logical sequence, anticipation of the future, conservative action upon the past, and chronic vigour — were diagnostic markers by which genuine development could be distinguished from its counterfeit. The immediate application was to Christian doctrine. The framework, however, has proven remarkably portable: biologists have applied it to evolutionary innovation, historians of science to the growth of scientific theories, and — with careful respect for analogical distance — the Newman volume applies it to the question of how AI-generated code develops or corrupts a software system's architectural integrity over time.
The Material Substrate Problem — Contrarian ^ Opus
There is a parallel reading that begins not with the preservation of ideas but with the material conditions that enable their expression. Software systems don't live in history the way doctrines do — they live in capital allocation decisions, in the quarterly earnings calls that determine whether maintenance gets funded, in the labor markets that price the expertise needed to recognize architectural decay. The developers who might exercise Newman's illative sense are increasingly contract workers cycling through codebases they'll never know deeply enough to perceive corruption. The AI that generates the code is trained on the aggregate of all code, good and bad, elegant and hacky, principled and expedient — a statistical average of every compromise ever committed to a public repository.
The corruption Newman feared in doctrine required centuries; in software, it happens in quarters. Not because the problem is more acute, but because the substrate is different. Doctrine lives in communities of interpretation that span generations; software lives in companies with median lifespans shorter than a developer's career. The steward who might preserve architectural integrity is herself a temporary contractor, incentivized to add features rather than preserve type. The real corruption isn't in the code but in the economic structure that makes corruption invisible until it manifests as technical debt so severe that the only solution is to rewrite from scratch — at which point the cycle begins again, this time with even less institutional memory of why the original principles mattered. Newman's seven notes assume someone is watching, someone with both the authority and the tenure to distinguish development from decay. In the political economy of software production, that person increasingly doesn't exist.
In the AI Story
Newman's seven notes were designed to answer a question the Protestant critique of Catholicism had made urgent: how to tell the difference between an idea that has grown and an idea that has been replaced. Newman's genius was to recognize that this question arises for any idea living through history — that continuity of identity across change requires criteria, and that the criteria cannot be purely formal.
The architectural application illuminates something the purely technical analysis of AI-generated code tends to miss. A software system, like a body of doctrine, has identity — an organizing logic that makes the system this system rather than some other. Code that is individually correct can, in aggregate, corrupt that identity. The corruption is invisible to unit tests, invisible to integration tests, invisible to any metric that operates at the level of functional correctness. It becomes visible only to the architectural judgment of someone who knows the system deeply — who exercises what Newman would have recognized as the illative sense applied to design coherence.
The pattern of corruption by accretion — the gradual alteration of an idea's essential character through the accumulation of individually defensible additions — is what engineers working extensively with AI-generated code report. Each addition extends capability. Each satisfies a real requirement. Each passes the relevant tests. The accumulation, over time, produces a system that no longer embodies the architectural vision that gave it coherence. Newman would recognize this immediately: the type has not been preserved, the principles have been quietly abandoned, and the system's vigour has been replaced by the brittle functionality of a structure that holds together by accident rather than by design.
The steward of a software system in the age of AI thus occupies a position that is, structurally, analogous to the theologian in Newman's account: a person responsible for ensuring that the idea under their care develops genuinely rather than corrupting under the pressure of accumulated additions. The analogy is imperfect — the stakes are different, the material is different — but the cognitive operation is recognizably the same, and the faculty required is the one Newman spent his life defending.
Origin
Newman began the Essay in 1843 while still an Anglican and completed it in 1845 as he was being received into the Catholic Church. The book's form is unusual: Newman broke off its final chapter mid-argument to be received into the Church he had come to believe was the rightful heir of Christian tradition. The text stands as both philosophical argument and autobiographical document.
The seven notes have been the subject of extensive theological commentary and have increasingly crossed over into philosophical and scientific contexts. Stephen Jay Gould cited Newman favorably in his work on punctuated equilibrium; philosophers of biology have used the notes to think about speciation; software architecture scholars in 2024–2025 have begun applying them to the question of what makes a codebase continue to be the same codebase as it evolves.
Key Ideas
Genuine development preserves type and principles. The developed form remains recognizably the same kind of thing, governed by the same fundamental logic.
Corruption accretes invisibly. Each individual addition is defensible; the cumulative effect is transformation without anyone having decided to transform.
Seven notes provide the diagnostic. Together they offer a test more rigorous than any single criterion could supply.
The notes require judgment, not calculation. Their application is not algorithmic; it requires trained perception of design integrity.
AI-generated code is vulnerable to Newman's corruption pattern. Functional additions satisfying specifications can, in aggregate, degrade architectural coherence in ways that only formed judgment can detect.
Debates & Critiques
Whether the seven notes are properly understood as independent tests or as facets of a single underlying criterion of continuity is a long-standing debate in Newman scholarship. For practical application — theological or architectural — the more important question is whether the analogist has earned the right to make the analogy: whether she knows both domains well enough that the transfer illuminates rather than confuses.
Appears in the Orange Pill Cycle
The Judgment-Structure Dialectic — Arbitrator ^ Opus
The right frame depends on which temporal horizon we're examining. At the level of immediate code generation — the next function, the next module — Edo's Newman analogy holds completely (100%). AI-generated code does corrupt architectural integrity through individually defensible additions, and only trained judgment can detect this corruption. The seven notes provide a genuinely useful diagnostic framework that technical metrics miss. This is a real phenomenon that developers report, and Newman's categories illuminate it perfectly.
Shift to the institutional timeline — quarters and years rather than commits and sprints — and the contrarian view gains ground (70%). The economic substrate of software development doesn't support the kind of long-term stewardship Newman's framework requires. The illative sense needs time to develop, continuity to operate, and authority to act. Modern software development often provides none of these. The developers with the judgment to apply Newman's notes are rarely the ones making architectural decisions, and the ones making decisions rarely stay long enough to see corruption unfold.
The synthetic frame recognizes both truths: Newman's framework perfectly diagnoses a corruption pattern that our economic structures make nearly impossible to prevent. This isn't a contradiction but a tragedy in the classical sense — we can see exactly what's happening and why it matters, but the forces driving corruption operate at a different level than the judgment capable of recognizing it. The solution, if there is one, isn't choosing between views but building institutions that can support the kind of sustained architectural attention Newman's framework demands. The question isn't whether the seven notes apply — they do — but whether we can create contexts where someone has both the expertise to apply them and the authority to act on what they reveal.
Further reading
- John Henry Newman, An Essay on the Development of Christian Doctrine (1845, rev. 1878)
- Ian Ker, Newman on Being a Christian (1990)
- Thomas Guarino, The Disputed Teachings of Vatican II (2018), especially chapter on development
- Nicholas Lash, Newman on Development (1975)