Skip to content
How it works

From work item to merge request.

Eleven stages, four automated gates and two human checkpoints. Here is what happens at each one, and where the pipeline deliberately stops.

order 4f2c · delivery pipeline
  1. OrderA work item from your tracker, or a plain-language request typed straight in.
  2. SpecificationAcceptance criteria, interfaces and scope, written before anything is built.
  3. Spec approvalHuman checkpointAn engineer signs off the specification. Nothing is written until someone says yes.
  4. DecompositionThe order is split into stories, each with its own branch and its own gates.
  5. BuildCode is written story by story, on branches in your own repository.
  6. Code reviewGateAn automated review pass before a human is ever asked to look.
  7. QAGateTests are generated and the change is exercised against the acceptance criteria.
  8. Security reviewGateThe diff is examined for the things that should never reach a merge request.
  9. Spec completenessGateThe endpoints and behaviour the specification promised are checked against what was actually built. A gate that can see an absence.
  10. Merge requestOpened in your repository, against your branch rules, for your reviewers.
  11. Your pipelineYour CI/CD runs the change. Intelli-Dev reports the result and stops there.
The unit of work

An order, not a prompt

Most AI development tools are built around a conversation. You ask, it answers, and the context lives and dies inside a chat window. That works for a single change and falls apart the moment the work spans a week, a team or a failure.

Intelli-Dev is built around an order. An order is a durable record that carries the original request, the approved specification, the stories it was split into, every gate result, every approval and the merge request it produced. It survives a restart. It can be picked up again after a failed stage rather than being started from the beginning.

That is also what makes the work explainable afterwards. When an engineering lead asks what the agent did and who agreed to it, the order is the answer.

Before any code

The specification comes first, and a person approves it

The first thing the pipeline produces is not code. It is a specification: acceptance criteria, the interfaces the change is expected to expose, and an explicit statement of what is in and out of scope.

This is where most of the risk gets removed. A misunderstanding caught in a specification costs a minute to fix. The same misunderstanding caught in review costs an afternoon, and caught in production it costs considerably more.

The specification then waits. An engineer reads it and approves it, and only then does the build begin. This checkpoint is not a setting we expect you to turn off. It is the point of the design.

Splitting the work

Stories, each on their own branch

An approved specification is decomposed into stories. Each story is built independently, on its own branch, and runs the full set of gates on its own.

The practical benefit is blast radius. A story that fails a gate does not drag the rest of the order down with it, and a story that needs a second attempt does not force a rebuild of the work that already passed.

It also keeps merge requests reviewable. A single change that touches forty files is not a review, it is a rubber stamp. Stories keep the diffs at a size a human can actually hold in their head.

The checks

Nothing reaches a reviewer unchecked

Four gates run before a merge request is opened. A code review pass, a QA pass that generates and exercises tests against the acceptance criteria, a security review of the diff, and a spec completeness check.

That last one exists because of a failure we hit ourselves. An application once passed review, QA and security while being functionally empty. The logic had been written, but nothing ever mounted the routes, so every gate looked at correct code and reported that it was correct. None of them could see what was missing.

The spec completeness gate closes that hole. It extracts the endpoints and behaviour the specification promised, compares them against what the built application actually serves, and blocks when something promised is not there. It is a gate designed to detect an absence rather than judge a presence.

Read the full account: Every gate passed. The app did nothing.

The handoff

It stops at your merge request on purpose

When the gates pass, Intelli-Dev opens a merge request in your repository. Not a copy of your repository, and not a repository we host. Yours, against your branch protection rules, assigned to your reviewers.

From there your CI/CD does what it already does. Intelli-Dev watches the pipeline and reports the result back against the order, and that is where its authority ends.

This is a deliberate limit. A tool that insists on owning your build and your hosting in order to be useful is a tool that most engineering organisations cannot adopt without a migration. We would rather be adoptable.

Want to point this at your backlog?

We are opening a small early access group. Tell us where your work lives and what is stuck.