On this page
Questions you could ask me
Software projects usually begin well before the first line of code. Somebody recognises a problem, develops a possible answer and tries to make that answer sufficiently precise for other people — and eventually a computer — to act upon it. Much of my working life has involved making that transition, from an idea that is still difficult to explain to a system that people can actually use.
The availability of increasingly capable AI assistants has changed how much practical implementation can happen during that transition. It has not removed the questions that matter most: what are we trying to achieve, which assumptions are we making, what responsibilities belong where, and what would demonstrate that the result is right?
This research programme examines that combination. It is concerned with human-directed engineering, not a claim that software can simply be ordered into existence by writing an impressive instruction.
The question behind the work
Can natural-language collaboration make the journey from a product idea to a working implementation substantially more direct, without surrendering architectural judgement, verification or responsibility for the outcome?
I have been exploring that question while developing determinIQ, a governed data intelligence application, and more recently while creating this website. The two projects are very different in scale and purpose. Together they offer opportunities to examine the working method in more than one setting.
This is not a controlled comparison between development teams or a universal estimate of how much faster software engineering has become. It is a record of decisions, implementations and observed results, with the limitations of that evidence made clear.
The human role does not disappear
An AI assistant can propose components, translate an intended behaviour into code, identify relevant dependencies and suggest ways to test a change. Those contributions can be valuable. They do not establish that the proposed solution belongs in the product.
A product owner still needs to decide what problem is worth solving. An architect must understand the consequences of an authority boundary. Someone has to recognise when an interface has become more complicated than the task deserves. And the acceptance decision must be based on what the implementation actually does, not how persuasively its description has been written.
In my own work I have retained those responsibilities. AI has expanded the implementation options I can investigate within a working session. It has not become the authority that decides what should be built or whether the result is acceptable.
Intention becomes something testable
Natural language is useful precisely because it allows someone to describe an outcome without first translating every detail into a programming syntax. But an intention is not yet a complete specification. Ambiguity, inherited assumptions and constraints hidden elsewhere in a system still need to be surfaced.
For that reason, the productive unit of work is not the initial description alone. It is the sequence in which the intended outcome is examined against the existing architecture, a bounded change is implemented, the running result is inspected and defects or unexpected behaviour are corrected.
Research figure 01
Human direction, observable results
A conceptual view of engineering responsibilities and verification
- HUMAN INTENTDefine the outcomeProblem, purpose and acceptance criteria
- AI-ASSISTED WORKExplore an implementationSuggestions and code within known boundaries
- ARCHITECTURAL RESPONSIBILITYCheck the fitExisting responsibilities and constraints remain authoritative
- REAL-WORLD VERIFICATIONInspect the resultCode, running behaviour and appropriate tests
- HUMAN JUDGEMENTAccept, revise or removeThe next iteration follows evidence, not plausibility
Illustrative architecture, not a complete implementation trace.
This process depends on continuity. A correction to a page should not unknowingly change its publishing rules. A new research article should not overwrite an earlier edit. A revised diagram should inherit the website’s design system rather than introduce a competing visual identity. The work becomes more reliable when those boundaries are maintained across successive changes.
The importance of an observable result
I have found that a convincing explanation of a proposed change is not enough. Code can be syntactically valid and still behave incorrectly. A page can be visually attractive but fail a keyboard interaction. An import can run successfully once and create duplicates on the second attempt.
The practical test is therefore outside the conversation. It lives in the codebase, the running application, the tests, the logs, the rendered pages and the behaviour someone can reproduce.
The website project has provided a compact example. Rather than stopping at an editorial design, the work reached a functioning WordPress theme, a separate content and publishing Core, related research publications, first-party draft importers, accessible conceptual diagrams and local browser checks. The companion project study records that implementation in greater detail.
Convergence matters more than accumulation
When implementation becomes easier, it is tempting to add something whenever a problem appears. Another control, another rendering tool, another subsystem. The danger is that an application can accumulate features faster than it acquires coherence.
A useful development method must therefore permit removal. An approach can be technically workable and still be unnecessarily complicated. During work on this website we explored generating research diagrams as separate graphical assets. The diagrams consisted mostly of text, bordered panels and connectors. Once that became obvious, the better route was to render them directly as semantic HTML with CSS supplied by the existing theme.
That decision removed a separate rendering and image-management step while improving reflow, appearance-mode consistency and the editability of the labels. It was not evidence that every technical diagram belongs in CSS. It was evidence that this class of figure did not need a graphical production pipeline.
Two implementations, a common principle
The analytical architecture of determinIQ separates language assistance from authority over numerical results. The engineering approach considered here makes a related separation: AI can assist with implementation, but decisions about the product and acceptance of its behaviour remain human responsibilities.
These are not identical problems. A deterministic analytical calculation and an architectural design decision require different forms of verification. The common principle is narrower: use AI where it provides leverage, retain explicit responsibility, and verify the outcome in the system that must actually perform the work.
This connection is a reason to study the two projects together, not an assertion that either proves the other correct.
What this programme will examine
The initial publications distinguish the general research question from a specific implementation and an individual engineering decision. The professional project study documents the website’s architecture, publishing mechanisms and local test evidence. A linked journal entry examines the moment when a complicated diagram workflow was replaced with a simpler web-native solution.
Later studies can investigate how conversation becomes bounded engineering work, how architectural authority is maintained, and how a recursive observe-and-test process affects the result. Those subjects should develop from documented examples rather than from an invented methodology presented as settled science.
Current position and open questions
The working examples show that a human-directed approach can produce substantial functioning software with AI assistance. They also show why review and correction remain necessary. What they do not establish is how the approach scales across teams, how its effects vary with experience, or which benefits persist over years of maintenance.
Those are worthwhile questions. For now, the stronger contribution is a closely observed account of what was built, the decisions that shaped it, and the difference between a plausible implementation and a verified one.
The point is not that judgement has become unnecessary. It is that the distance between judgement and something testable has changed.
Research context
Topic: AI-assisted engineering
Explore further
Supporting material is listed below.
Further reading is listed below.