On this page
Questions you could ask me
Questions you could ask me
Where does architectural responsibility belong?
Or describe your own challengeWhen an implementation tool becomes more capable, an old architectural problem becomes easier to overlook: who is authorised to decide what? A system may contain several components able to perform similar tasks, but that does not mean each should be responsible for the same decision. Overlapping authority is a reliable way to create behaviour that works in one place and fails in another.
I have spent much of my working life dealing with that problem in different forms. It has reappeared in AI-assisted development, where a convincing proposal may arrive before the boundaries of the existing system have been examined.
Capability is different from authority
An AI assistant may be able to write a database query, design a page, add a PHP function or construct a diagram. The ability to propose those changes does not grant authority to decide whether they belong in the product or how they should interact with everything already there.
That distinction can sound philosophical until a system has to be maintained. If a theme starts owning editorial data, a publishing plugin begins implementing layout rules, and an importer is allowed to rewrite published content, we have made the system harder to reason about. Each addition might appear convenient in isolation; together they undermine the architecture.
The productive question is therefore not only "Can this be implemented?" It is "Which part of the system should be responsible for it, and what must remain unchanged?"
A practical boundary in the website
The John Stutely website provides a relatively small but concrete example. The WordPress theme is responsible for its editorial visual language, article templates, responsive behaviour and native HTML/CSS diagram presentation. The John Stutely Core must-use plugin is responsible for publication types, taxonomy, evidence metadata, internal relationships and first-party import workflows.
That division allows a presentation change to be made without changing a publication’s identity or evidence. Conversely, adding a capability study need not involve modifying the theme. A content importer creates the appropriate WordPress record and associated metadata; the theme decides how that record is presented.
Those are decisions made in the architecture, not conventions to be rediscovered by every new feature. They provide a basis for reviewing AI-generated changes. If a proposed solution moves responsibility across the boundary, it needs a compelling reason rather than merely being quicker to write.
Ownership continues into the lifecycle
Authority is also visible in what a system is permitted to change after its initial installation. The research importer creates drafts. It does not publish on behalf of the author. Stable source identifiers let it recognise material it has already introduced. Editorial revisions made later in WordPress must not be erased simply because a new release includes updated source files.
The distinction is important because the same record can pass through several states: generated draft, edited draft, reviewed publication and published work. Those states are not interchangeable. An implementation tool should not acquire editorial authority merely because it can produce text or submit a database update.
It follows that some useful actions should remain explicit. Retrospective cross-links can be proposed, with reasons, and then applied to eligible drafts after review. Published material should not be silently rewritten by an automated content update. This is not a limitation of what can be programmed. It is a deliberate control over what the system is allowed to do.
Why this matters for AI-assisted work
An assistant can help inspect the current source, trace dependencies and generate implementation alternatives. It can also overlook an earlier design decision, make an assumption about a directory structure or offer a feature that creates a competing path. That is why I prefer to assess proposals against the current codebase rather than rely on a convincing description of how the code is supposed to be organised.
One useful consequence of that discipline is that errors become easier to locate. If a diagram’s colouring is wrong, the answer belongs in the theme’s design rules. If a research article has the wrong relationship metadata, the investigation belongs in the editorial Core. If content is absent because the must-use plugin is incomplete, correcting the installation takes precedence over changing either subsystem.
Clear responsibility does not prevent collaboration. It makes collaboration safer by defining which decisions must be made or reviewed at each boundary.
Two related applications of the same principle
The determinIQ research programme concerns a different system, but its central architectural question is closely related. In its analytical model, AI can assist with language interpretation and explanation, but it does not become the authority over numerical results or their underlying evidence. In the engineering work described here, AI can assist with implementation, but does not become the owner of architectural or product decisions.
The symmetry is useful, but it should not be exaggerated. Analytical truth can often be tested through deterministic operations and recorded evidence. An architectural decision may involve several defensible trade-offs that no calculation alone resolves. Its acceptance therefore depends on a broader assessment of fit, consequences, usability and maintainability.
In both settings, responsibility should be explicit and outcomes should be inspectable. That is the shared lesson, not a claim that the two systems use identical methods.
A boundary worth keeping
The greater the implementation assistance available, the more important it becomes to know which decisions should not be delegated. The value of rapid software development is reduced if each quick addition introduces hidden dependencies or competing sources of authority.
I am not arguing for frozen architecture. Boundaries can change when the evidence warrants it. But they should change knowingly, with their consequences examined, rather than as an accidental side effect of whichever solution was easiest to generate.
The result I am looking for is practical: a system whose parts have clear responsibilities, whose evolution can be reasoned about, and whose acceptance remains accountable to the people responsible for it.
Research context
Research programme: From intention to implementation: human-directed AI-assisted engineering
Topic: AI-assisted engineering
Explore further
Further reading is listed below.