Back to the blog

 · Development AX · about 12 min read

AX Field Notes: sixteen weeks of rearranging the order of work

Everyone has an AI account, and there's a chatbot in the company messenger. Yet approvals, reviews and reporting happen in exactly the same order as before. This piece follows one project from the start: building a large system for a global automotive parts maker with AI doing the work. How we applied it, what changed, and where your company could begin.

AI on top, same work underneath

When we meet companies that have adopted AI, we keep seeing the same picture.

AI was added as a tool while the order of work stayed the same. A tool makes one step a bit faster; it doesn't change who does what, or in what order.

AX isn't bringing AI in. It's rearranging the order of work on the premise that AI does it.

How it differs from DX

Put it next to digital transformation (DX) and the difference is clear.

AspectDXAX
GoalMoves analogue work into digitalRedesigns digital work so AI performs it
Who does the workPeople operate the systemAI executes; people judge and approve
System integrationPeople use systems through screensAI agents call systems directly through interfaces such as APIs, CLIs and MCP
SuccessAsks 'did the system go live?'Asks 'did lead time, throughput and quality change?'

Three questions to tell if it's AX

You can check whether your AI adoption is really AX with three questions.


Why requirement changes are really so expensive

It was a program management and profitability analysis system. Twelve business areas — orders, cost, profitability, quality and schedules among them — had to come together in one system, with business teams, the PMO and developers working side by side. We had sixteen weeks to build 225 features, and the requirements changed every day. In a system shared by many departments, requirements arrive every day, and what was decided yesterday changes today.

On large projects, changes are feared not because of the time it takes to change code. Each change brings a chain of work behind it.

  1. One change
  2. Analyse the requirement and check its impact
  3. Update the design documents
  4. Rewrite the test scenarios
  5. Release it and update the progress report
Changes aren't expensive because of code, but because of the analysis, documents, tests and reporting that follow them.

When people do all of this by hand, change is slow and expensive. So requirements get frozen early or blocked with change-request forms — and months later, on launch day, the business says, 'This isn't what we needed.'

Block changes and you pay on launch day. Lower the cost of a single change and you can afford to accept them.

Changing the question

We changed the question from 'How do we stop changes?' to 'How do we lower the cost of handling one change?'

The answer wasn't more people. We redivided the work: AI agents took on the analysis, documents, tests, code and records that follow a change, and people approved scope and checked results.


One requirement, start to finish

Plenty of teams write code with AI now. But when only the code gets faster, the slow part just moves to before and after the code. So we gave an AI agent a whole requirement, from start to finish, instead of a line of code. A single requirement flowed through five steps.

StepWhat AI doesWhat people do
RequirementAnalyses it and drafts a PRDRegister the requirement and approve the scope
DesignWrites the development spec and test scenarios and breaks them into work itemsReview the spec
BuildWrites code and tests, verifies locally and opens a merge requestReview and approve the merge
ReleaseWrites release notes for each release—
RecordLogs the start and end of every step in the requirements management systemCheck the records on screen and approve completion

Merged changes ship at fixed times. Up to the reference date (October 8, 2026), releases ran three times a day on a schedule. Progress is calculated from the records.

What changed most wasn't speed but where people sit in the process. They moved from writing things themselves to requesting, approving and checking. Because a step can't start until the previous one is done, and scope grows only through approval, decisions stay with people even as the pace picks up. Hand AI a whole requirement instead of a line of code, and people move from authors to decision-makers.


Integrating business systems with AI agents

If an AI agent carried a requirement from start to finish, a question follows: where did it read the requirement, and where did it record progress?

Requirements and work items lived in a separate requirements management system, built for people to use through a web interface. Left as it was, people would have to copy AI's output back in by hand, and progress reporting would become yet another manual job.

So we wrapped the requirements management system's API in a CLI (command-line tool) and integrated it with the AI agent. Because the AI agent doing development worked in the terminal, a thin CLI over the API became the official integration, and we didn't build a separate MCP server. The CLI lives in the same repository as the API, so when the API changes, the CLI changes in the same commit.

People
Web UI
AI agent
CLIcommand-line tool
API
Requirements management system
People use the web UI; the AI agent uses the CLI; both work on the same data.

Once integrated, the AI agent's job changed.

The AI agent became not just a tool that produces output but a participant that leaves a record of the work.

API, CLI or MCP — choose the integration that fits your situation. What matters is not the form but whether your business systems are integrated with AI agents at all.


Sixteen weeks in numbers

Here are the results in numbers, as of October 8, 2026.

What we built · As of October 8, 2026
ItemValue
Business areas12
Features225
Screens700+
APIsAbout 3,000
Lines of code1.35 million
Test files1,100+
How we built it · As of October 8, 2026
ItemValue
DurationAbout sixteen weeks
Requirements delivered500+
Merge requests2,800+
Merges37 a day on average
Scheduled releasesThree a day
Commits10,000+
AI skills that capture the development process16

The development was end-to-end vibe coding.

What matters to us in these numbers is not their size but their source. None of them is a figure someone wrote into a report; each was counted from repository records, and anyone can measure it again the same way at any time. That's possible because we built a way of working that leaves a record every time a piece of work is finished.

What we haven't measured yet

To be honest, these numbers show how much the work of building the system has changed. We haven't yet measured how much faster or more accurate the business teams' work has become with it. Producing that number is our next task. We cover the plan under 'Next' below.


Rules, not tools, made us fast

Integrate a requirements management system with an AI agent and the worry comes right after: 'What if the AI deletes something by mistake, or expands the scope on its own?'

Our answer wasn't to trust the AI, but to build boundaries into the system that it can't cross. Looking back on sixteen weeks, what made us fast wasn't any particular AI tool either, but rules we ran into and refined as we worked.

RuleHow it was enforced
Hard-to-undo actions stay closedDeleting requirements or work items and rolling back completion simply don't exist in the CLI the AI uses. People do them in the web UI
AI moves only within the owner's permissionsAI works with a token a person issued, and the server checks that person's permissions as-is. A developer can only edit items they registered or were assigned
The server enforces the orderA step can't start until the previous one is finished
Scope grows only through approvalApproving a requirement is approving its scope, and only people with review rights can approve. Items added directly without a requirement also need separate scope approval from an approver
People approve mergesAI writes the code, but it can't review its own work. Passing automated checks is the minimum bar, not approval
Progress isn't written by handA record is left when a step actually finishes, and the progress rate is calculated from those records. Nobody writes a separate progress report
Procedures are fixed in AI skillsFrom starting a task through pre-checks, merge requests, merges and release records, we built the development procedure into 16 AI skills. The work follows the same order whoever does it

Credentials stayed with people too. People issue and configure tokens themselves, and AI never receives password or token values. Credentials don't appear on the command line or in command history either.

We accept change, but scope never grows without anyone noticing. With clear boundaries, we could hand over the work inside them with confidence. Releasing three times a day at fixed times over those sixteen weeks rested on those boundaries (as of October 8, 2026).

It didn't work from day one

At first, people entered progress rates by hand. When we checked in early August, all 185 work items still showed a progress rate of 0. So instead of entering it, we switched to calculating it from step records. That's how the rule 'progress isn't written by hand' was born.

We also had a step where a second AI reviewed the code the first AI wrote. But it added a lot of time and cost, and its results changed from run to run, so we couldn't use it as a standard. In September we dropped it and made people's merge approval and post-release checks the final check.

AI tools change every few months. Rules stay when the tools change. That's why we think the lasting outcome of AX is a way of working more than a system.

Tools change every few months; the rules stay and keep you fast.


AX is ultimately about people

What changes most in AX isn't the system but people's working day. On this project, business teams, the PMO and developers moved together, and the work of all three roles changed.

RoleWhat they stopped doingWhat they did instead
Business teamsTesting everything at once right before go-liveChecked the development environment every day and gave feedback right away
PMOGathering progress in spreadsheets for reportsProgress was calculated from records, so they focused on approving scope and setting priorities
DevelopersWriting the code (AI agents wrote it)Reviewed the results and decided on merges

Because we released three times a day at fixed times, business teams could sometimes see on screen today what they had asked for yesterday. For developers, asking precisely for what to build became more important.

We made the change through distribution and training

This change didn't happen on its own. We bundled the AI skills that capture the development process into a single plugin and distributed it with an installation guide, skill descriptions, training materials and an operations manual, so any developer could work through the same procedure. We also ran separate training for the system's users.

When only a few people use a good way of working, only they get faster. The organization gets faster when everyone works the same way.

When adopting AX, what takes time is less the technology than people getting used to a new way of working. That's why re:boot leaves behind the way of working and the training along with the system.


Next: beyond the system, into the business workflow

So far, AX meant changing how we build the system. Next is changing how people use it. Even with the system finished, business teams are still left moving between screens and copying the same information over. AX isn't done until that work changes too.

The principles are the same ones we used in development.

We built a demo so anyone can see these principles at work. It takes a single contract at a fictional company and prepares the activation request and the first month's invoice draft. Done the usual way, the same contract details are entered into forms 12 times across 3 systems. In the demo, it takes one natural-language request and one plan approval.

The usual way

  • The same contract details entered into forms 12 times
  • 3 systems

The demo

  • One natural-language request
  • One plan approval
This is a fictional company demo and uses no real customer data.

We're now preparing to apply the same principles to business work on a real project. This time, before we start, we plan to measure today's numbers, such as the number of entries and the time each task takes. That way we can show the 'numbers we haven't measured yet' from above as a before-and-after comparison.


Where should our company start?

'Sounds good, but where should our company start?' re:boot runs AX in five stages. Let's place what we've covered back in that order.

  1. Diagnose
  2. Design
  3. Pilot
  4. Scale
  5. Embed
  1. Diagnose — pick one workflow and measure today's numbers. Good candidates are repetitive, move across several screens and copy the same information more than once. One team's workflow beats a company-wide program. Then measure today's numbers first, such as processing time and the number of entries.
  2. Design — draw out the business rules and split AI's work from people's. Business rules are scattered across documents, system code and people's heads. We turn them into procedures AI can follow (skills) and set the points where people approve. Hard-to-undo actions stay with people from the start.
  3. Pilot — run it for real in a small scope. Connect the business systems to AI agents through APIs and CLIs, run real work through them, and compare against the numbers from the diagnosis.
  4. Scale — widen only what has proven its effect. Only the ways of working the numbers confirm become skills and rules and spread to other teams.
  5. Embed — keep measuring and refining. So that the way of working outlasts the tools, measuring and improving become part of everyday work.

The business rules matter most

Of all this, the business rules in the design stage matter most. That's why re:boot organizes and builds up the business knowledge from its projects by industry and by workflow. With experience of similar work, you start out knowing what to check first.

You can take the first step with us

You can also do the diagnosis with re:boot. Pick one workflow, and we'll run a free two-week on-site assessment and hand you an assessment report and a pilot proposal. You're under no obligation to move on to a pilot.

Takeaway

AX starts not with a company-wide program but with one team's workflow. Measure today's numbers first, draw out the business rules, and widen only what has proven its effect.

Related: Global automotive parts case

Would this work for us? Find out with a free two-week on-site diagnosis

Pick one workflow and we'll diagnose it on site for two weeks, then hand you a report and a build proposal. No obligation to go further.

Explore consulting