The flow

The factory has one way in. Each piece of work starts as an input to intake.

When each change task of an exploration is done, the exploration is consumed.

#Two queues

A change task changes the product. Its work is on a branch in each repository, and the branch is merged.

An exploration builds something to answer a question. Its work is in its folder in the hub. It does not change the repositories, and its artifacts stay, because they are progress.

#Shaping the work

intake and probe run with you. intake finds what is missing before the work can be built, and it uses one of these:

• For a decision that only you can make, it asks you now.
• For knowledge that only building can give, such as how it looks, if it works, or how much work it is, it writes an exploration.
• When nothing is missing, it writes a change task.

When you say that the work is not for now, it adds one line to the inbox.

probe then settles each thing that a change task leaves open. When the code or the docs settle it, probe reads them. It asks you about the rest. A task is ready when nothing is unsettled.

#Building the work

build runs with no person, so it does not ask questions. It works on the branch task/<id>, and opens one pull request in each repository of the task. It pushes only that branch, never the default branch.

When the work needs a decision that the task does not give, build looks at what the decision changes:

• If it changes what the product does for its users or for other systems, or changes stored data, build writes the question and sets the status to blocked.
• If it changes only how the code is written, build makes the decision, and writes the reason.

#Reviewing the work

You review the pull request as a reviewer. When a pull request changes, triage reads it and chooses a way out: rework, an answer, new work, a decision for you, or nothing to do. A rework goes back to ready, and build does it on the same branch.

The default branch changes only when you merge. A merge accepts the task and the items in the body of the pull request. accept then writes what future tasks must know to context/.

#Which task is next

build takes the ready task with a ## Rework section first. Then it takes the ready task with the lowest number, with each task in its depends_on at done. When no change task is ready, it takes the ready exploration with the lowest number.