Millwright-Inspector logoMillwright-Inspector
V1.2.0

Software Engineering, Evolved for What Comes Next

The Millwright-Inspector methodology is a structured approach to modern software development, centered on collaboration between execution and oversight.

CHAPTER 01

The Actors

Manage operations through parallel oversight structures, ensuring strict separation of concerns.

Millwright — AI coding agent illustration

Millwright

  • Builds the machines. An AI coding agent that treats the codebase as a factory and each feature as a machine to build, maintain, and repair.
  • Works end-to-end. Plans, designs, diagrams, implements, and documents, owning every generated artifact.
  • Delegates heavy lifting. Spawns bounded sub-agents for context-heavy work.
  • Never self-approves. Fills the payload and waits for the Inspector's go-ahead.

CHAPTER 02

What it is

The Millwright-Inspector methodology augments the current software development approach by adding a human-agent collaboration mechanism to each step of the workflow. By defining new roles for the actors in software development, this methodology mainly focuses on the adaptation of the AI to the current software development workflows.

Context Artifact

What it is

A document the project actually produces and keeps: a requirements file, a design note, a code review, a test plan. Anything the work depends on next.

Why we call it that

“Artifact” because it is durable — it outlives the conversation that produced it. “Context” because it is what both the human and the agent read to know where the project stands.

Why it matters

Each artifact is written in plain prose or markdown — readable by a person at review time, and parseable by an agent at the next step. The same file serves both audiences, so nothing is lost in translation.

Inside one relay

A relay is one unit of work. It takes a task and any relevant artifacts, the Millwright drafts a new artifact, the Inspector reviews it, and only an approved artifact moves on.

INPUTSContext ArtifactsTaskCONTEXT ARTIFACT RELAYMillwrightdrafts the artifactInspectorapproves or rejectsSwitchNext RelayCONTEXT ARTIFACT REPOSITORYContext Artifactan inputNew ContextArtifactthe output

Two relays from a real project

The same relay shape, with the inputs and outputs replaced by concrete files. One produces a requirements document; one produces a review.

Generating a requirements file

Context ArtifactsTask: GenerateRequirementsRELAYMillwrightInspectorSwitchNext RelayREPOSITORYTODO-list.mdRequirements.md

Reviewing a pull request

Context ArtifactsCodebaseTask: ReviewCodeRELAYMillwrightInspectorSwitchTask: Write CommentsREPOSITORYlessons-learned.mdUMLDiagramsFindings.md

The same four stages, redrawn

The software lifecycle keeps its familiar shape — analysis, design, implementation, test. The difference is that each stage is a relay, and every relay reads from and writes to one shared repository.

TraditionalAnalysisDesignImplementationTest
Millwright-InspectorCA Relay #1AnalysisCA Relay #2DesignCA Relay #3ImplementationCA Relay #4TestContextArtifactRepository

BEFORE YOU GO FURTHER

Engine of the Methodology

Context artifacts, where they live, and the relay that drives every step: the mechanism behind the two roles you just met.

CHAPTER 03

Every step, reassigned

Every project runs the same five steps, from customer demand to tested software. The conventional pipeline passes that work across four specialised human roles. Millwright-Inspector runs it through one AI agent and one human inspector.

Traditional Approach
Millwright-Inspector
1.Customer demands transformed into tasks.
Business Analyst
Millwright-Inspector
1.Customer demands transformed into quests.
Millwright
2.Tasks created by business analysts are assigned to developers.
Business AnalystDeveloper
Millwright-Inspector
2.Quests are broken into tasks, and inspectors pick tasks.
MillwrightInspector
3.Developer creates software designs and blueprints.
Developer
Millwright-Inspector
3.Millwright generates blueprints. Inspector reviews.
MillwrightInspector
4.Developer writes code.
Developer
Millwright-Inspector
4.Millwright generates code. Inspector reviews.
MillwrightInspector
5.QA Engineers test the output.
QA Engineer
Millwright-Inspector
5.Millwright generates test plans and runs tests. Inspector reviews and performs tests.
MillwrightInspector

CHAPTER 04

The work stays visible

Millwright-Inspector turns AI-assisted work into artifacts the whole team can see, review, and shape, long before anything ships.

Context artifacts: every plan, task, and test the workflow produces, saved as readable files. Like git history, but for the team's thinking.

01

Review plans before coding

Every feature starts as a blueprint artifact. Teammates read, question, and refine the approach before a line is implemented.

02

Track issues your way

Tasks live as todo context artifacts, so any AI agent can build the view you want: status reports, live boards, burndown charts.

03

See progress live

Each workflow records its own progression as artifacts. Managers, reviewers, even customers see where a task stands. No status meetings.

04

Review test plans too

Testing plans exist as artifacts before a feature is verified, so anyone can add cases, flag gaps, or discuss coverage.

05

Never wait on review

Every workflow is fully self-contained. Hand one task off for review and pick up another. No blocking, no idle time.

THE MAIN ADVANTAGE

What Millwright-Inspector brings

  • Reliable, secure, well-documented code, without letting an AI run unchecked.
  • Inspectors who understand the system, not just the latest diff.
  • Delivery that stays fast, because review never blocks — speed is the by-product, not the pitch.
  • Easier parallel work — writing code demands sustained focus, but reviewing doesn’t, so an inspector can move between Millwright-Inspector workflows without the usual context-switch cost.
  • Shared knowledge across the whole team, and quality you can trust.
Vibe-coding: speed, until it breaksvsMillwright-Inspector: speed that holds up