On this page
A proposed implementation can be plausible, syntactically correct and still wrong for the product. That has always been true of software engineering. AI-assisted implementation makes it especially important because a coherent-looking solution can be produced with little of the delay that once gave an architect time to question the approach.
My working response is to bring the evidence closer to the development decision. Rather than treating a generated change as complete, I want to see how it behaves, what it affects, and whether it leaves the system more coherent than before.
The running system has the final say
For this website, a change has not been adequately examined merely because the PHP passes a syntax check. The relevant WordPress functionality has to load. An article must render in the intended editorial layout. A draft importer should behave correctly when run more than once. A diagram must remain legible in the different appearance modes and at narrower widths.
These checks answer different questions. Syntax validation catches one class of errors, not an architectural misunderstanding. A successful import confirms an operation, not necessarily that every relationship is editorially justified. A favourable Lighthouse result is useful evidence about a particular page in a particular test environment, not a general certification of the website or proof of how the engineering was performed.
The distinction is easy to lose when a result looks finished. It is also the reason I find short inspection-and-correction cycles more useful than accepting a large change solely on the strength of its description.
Observe before changing
The first step is understanding the actual condition of the system. That means inspecting the current code and, where behaviour matters, the running application. An older account of the architecture can be helpful context, but it is not a substitute for examining what is installed now.
This is especially important during incremental development. WordPress can load a theme successfully while a separate must-use plugin is incomplete. An apparently missing feature might be a packaging fault, not a reason to write another implementation. The responsible change is the one that addresses the actual fault.
The same principle applies to content. A relationship can be absent because the linked article is still a draft. Adding another link to bypass the publishing rules would be a poor correction. Understanding why it is absent comes first.
Trace responsibility, then test the hypothesis
Once a problem is observed, I want to identify the component that owns it and establish why the behaviour occurs. A change can then be bounded and its expected result made explicit. That does not guarantee the hypothesis is right, but it gives the next test something meaningful to examine.
Research figure 01
A recursive engineering check
A working discipline for bounded changes
- OBSERVEInspect the actual conditionSource, rendered behaviour, state or failure
- TRACEFind the responsible boundaryIdentify causes and relevant dependencies
- PROVEEstablish a testable explanationSeparate observation from assumption
- CHANGEMake the smallest coherent correctionPreserve unrelated responsibilities and data
- TESTCheck the outcome and regressionsAccept, revise or return to observation
This is a decision discipline, not a claim that all development follows a fixed linear sequence.
An example of convergence through removal
The research-diagram work provides a straightforward example. We wanted consistent illustrations that could be placed within articles and used at different sizes. The first approach created graphical assets and a separate generation process. It worked as a way of producing pictures, but it also created another layer of files and presentation decisions to manage.
The figures were mostly words, bordered stages and connectors. Once the problem was considered in those terms, we could replace the graphics with semantic HTML and CSS. That made the content selectable and allowed it to inherit the website’s light, dark and high-contrast styling. It also removed the requirement to maintain separate mobile image variants.
The important decision was not to produce a more complicated rendering system. It was to recognise that the original solution did more than the problem needed. A second implementation, tested against the real article layout, was simpler and better integrated.
This does not imply HTML/CSS is suitable for every diagram. Detailed technical drawings may require different methods. It does show why a working implementation should remain open to challenge.
Correction is not a failure of the method
A recursive process assumes that some early decisions will be revised. A screen may reveal crowded typography that was not obvious from the source. A technically correct importer can expose a dependency on how the files were packaged. A research article can become too defensive about its limitations and need a different balance between established outcomes and open questions.
The correction has value only if it is connected to observed evidence. Otherwise iteration becomes an endless series of preferences. The point is to converge: fewer competing paths, clearer boundaries, more predictable interactions and a better account of what the system can actually do.
The decision to remove complexity can be as important as the decision to add capability. In later phases of determinIQ, much work has similarly concerned removing duplicated controls, clarifying state, preserving journeys between workspaces and making the application behave as one coherent product. The systems differ, but the engineering concern is recognisable.
What the evidence can and cannot show
The website has undergone source checks, visual review and local automated performance, accessibility and SEO audits. Those results are useful. They do not demonstrate that the whole site has passed a manual accessibility audit or that every feature has been exercised in production. Nor do they measure a universal productivity improvement caused by AI assistance.
What the project provides is a traceable example of a working method: requirements were revised, implementations were changed, problems were found in the running system, and the design became more coherent through successive decisions.
For me, the deeper research question is not whether AI can generate a plausible first answer. It is whether we can use that assistance while preserving the discipline to inspect, challenge and, when necessary, discard the answer. That is what turns rapid implementation into reliable engineering progress.
Research context
Research programme: From intention to implementation: human-directed AI-assisted engineering
Topic: AI-assisted engineering
Explore further
Further reading is listed below.