---
id: process.how-we-do
domain: process
title: How We Do
kind: concept
description: "How we take any software work through its whole life — idea, build, release and support: who decides, how a project runs, and the rules we keep, in plain words for clients, owners and AI agents."
version: 0.2.0
status: review
authority: uask
applies_to: [core]
sources:
  - title: GOV.UK Service Standard
    url: https://www.gov.uk/service-manual/service-standard
    license: OGL-UK-3.0
    accessed: 2026-11-22
  - title: Basecamp, Shape Up
    url: https://basecamp.com/shapeup
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-22
  - title: thoughtbot Playbook
    url: https://thoughtbot.com/playbook
    license: CC-BY-NC-3.0
    accessed: 2026-11-22
  - title: AGENTS.md
    url: https://agents.md
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-22
  - title: The /llms.txt file
    url: https://llmstxt.org
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-22
standards: []
requires: []
related:
  - mgmt.roles-and-decision-rights
  - mgmt.project-foundation
  - process.project-lifecycle
templates: []
skills: []
last_reviewed: 2026-11-22
review_every: 6
supersedes: ~
superseded_by: ~
tableOfContents:
  maxHeadingLevel: 2
---

*How we take any software work through its whole life: idea, build, release and support.*

This is how we work, on our own products and on yours. It is short on purpose. Each rule here is one plain sentence.
The detail behind it lives in the [Hub](/knowledge/), our public library of rules and methods. Each part of the Hub is
an *item* with an id such as `mgmt.project-foundation`, and each rule here links to the item that holds it.

This draft is written in parts. This is a draft for the owner to accept. What changed, and when, is in annex C.

## What working with us looks like

A page for clients, written from the rules below. A sentence marked † rests on a rule that is not yet approved.

**You agree the what; we do the how and show our working.** You agree with us what we build, how much time it is
worth and what counts as finished. Going live, and anything that cannot be undone, is decided by our owner together
with you — never by an agent. You talk to us, not to our agents. We decide the technical details and write down every
decision and why. We ask you only what we cannot decide for you, and each question comes with a default.†

**We start by listening.** We keep your request exactly as you sent it. Before we promise a date we read it all, look
at what you already have without changing anything, and tell you about any gap.†

**We agree "done" before we start.** Together we write what is in, what is out and what waits for later, and how each
part will be checked — as plain pass-or-fail statements that you can check yourself. A change of scope is written down
and agreed, never slipped in.

**Work comes in small releases with a fixed time budget.**† Each release has a short written plan, a way back if
something goes wrong, and a budget. If the budget runs out, we stop and give you the options instead of quietly
running over.

**Nothing reaches your live system untested.** Before we change a live system there is a backup that we have restored
at least once. We try every change that touches code or data on a closed copy first, choose a quiet time to release
it, check the result straight away, and keep someone ready to roll back.

**Someone else checks our work.** Every change is checked by someone who did not make it, and by automatic checks that
nobody may switch off to get a green light. "Done" means proved: we show the check and its result.†

**When we look after your system,**† you get a runbook, tested backups, service levels measured from outside, and an
honest report if something fails: what happened, what we know and do not yet know, and what we change so it does not
happen again.

**Every job leaves something behind**† — notes, a check or a better procedure — so the next job is faster and safer.

**We work with AI agents under human direction.** Agents work from written rules and briefs and report what they did;
people approve what matters.

**Your data stays yours.** We never put passwords in reports or chats, and each system we run lists the personal data
it holds and how long it is kept.†

† *Not yet approved by our owner: this sentence or paragraph rests on rules still in review or on our practice. The
mark goes when they are approved.*

## The core

Four principles sit under everything else on this page. Each one is a rule we already keep; the rules it rests on are
named.

1. **Define once.** Every rule, fact and decision has one home; everything else links to it (rules 1, 8, 121).
2. **The owner decides.** What cannot be undone, or is public, is the owner's decision; agents propose (rules 7, 14).
3. **No harm.** There is always a way back, and security and privacy are never lowered, whatever the tier (rules 26,
   28, 76, 101).
4. **Evidence.** A claim, and every "done", comes with its proof (rules 4, 65).

The 14 points below carry, in brackets, the principles they apply.

## In short: 14 points

Words in the points — gate, Blueprint, Spec, runbook, service level, pinning a release — are explained in the
chapters and in annex A.

1. We define each rule once, borrow proven methods, prove what we claim and keep it simple. *(Define once, Evidence)*
2. The owner decides what cannot be undone or is public; everyone else decides the rest and writes down why. *(The owner decides)*
3. Every project goes Idea → Blueprint → Spec → Build → Release → Support, through four gates, with as much process
   as its risk needs. *(The owner decides)*
4. We keep your request as you gave it, agree what success looks like, and write down what is in and out before we
   build. *(The owner decides)*
5. We record every hard-to-reverse choice, draw the system so anyone can read it, and turn its rules into checks. *(Define once)*
6. Each release has a written plan, a fixed time budget and a way back, before any code. *(No harm)*
7. Small changes, checks written first, someone else verifies, and "done" means proved. *(Evidence)*
8. No release without a backup, a rehearsed way back and a named person's approval. *(No harm, The owner decides)*
9. A system we look after has a runbook, tested backups, service levels measured from outside and honest incident
   reports. *(No harm, Evidence)*
10. Every job leaves a lesson where the next job will find it, and facts live in files, not in memory. *(Define once)*
11. Agents work from one rule file, a written brief and a short report, inside limits the owner sets. *(Define once, The owner decides)*
12. No secrets or personal data where they do not belong; public material is safe to read and to reuse. *(No harm)*
13. We measure how the system is delivered, never the people, and change one thing at a time. *(Evidence)*
14. Every rule has an id, a version and a status; drafts are marked; projects pin an exact release. *(Define once)*

## 0. About this document

**Who it is for.** Three readers, and each has a part:

- **A client** reads the 14 points, then the chapters on who decides, how a project runs, releases and support.
- **The owner** reads the points and the badges: the badges show at a glance what is already approved.
- **An AI agent** reads the numbered rules. Each rule has a number, a badge and a home, so an agent can cite it and
  look up the detail.

**Who "the owner" is.** We use a small set of role names, defined once in `mgmt.roles-and-decision-rights`. The
**owner** is the person at our side who decides the time budget, the scope and what is accepted, and takes every
decision that cannot be undone (chapter 2). On our own products the owner is
also the client. On your project you are the **client**: you work with us through the owner, and never with our AI
agents directly. An **agent** is an AI program that does work for us under written rules.

**How to read a rule.** Every chapter opens with its point, says why it matters and what it looks like, then lists
its rules. Each rule carries one badge:

- **Approved** — the owner has approved the Hub item the rule comes from, or accepted the decision record it rests on.
- **Owner's rule** — a written instruction of the owner in our rules file `AGENTS.md`. That file changes only with
  the owner's approval (`mgmt.roles-and-decision-rights#R15`); each such rule names its section.
- **Not yet approved** — the rule comes from an item still in review, from our own practice, or from the owner's
  words not yet written into the Hub. We work by it, but the owner has not approved it as a rule.

Each rule also names its **home**: the one place where the rule is written in full. A Hub item is shown by its id
and links to its page, for example [`mgmt.project-foundation`](/knowledge/playbooks/project-foundation/); a rule inside it by its number, for example
`mgmt.project-foundation#R8`. Our rules file `AGENTS.md` and our decision records are kept in our repository, which is
not public yet, so those homes are named, not linked. Rules that have no other home live in one Hub item of their
own, [`mgmt.how-we-work`](/knowledge/core/management/how-we-work/), written with this document and still in review.

**How to cite a rule.** Say "Rule 12", or link to `/how-we-do/#rule-12`. An agent cites it as `process.how-we-do#rule-12`.
A rule keeps its number for good. If we drop a rule, its number stays, marked "withdrawn".

**How it changes.** The document has a version and a status, like every Hub item. While the owner has not accepted
it, every page carries the mark "Draft — not approved". When a rule's home changes, the rule here is re-read and
changed in the same step. The document is in English.

## 1. What we believe

**Point 1.** We define each rule once, borrow proven methods, prove what we claim and keep it simple.

**Why it matters.** Rules that live in two places drift apart, and then nobody knows which one holds. Methods we
invent ourselves are untested; methods many teams use have already met the hard cases. A claim without evidence is
an opinion, and a design bigger than the need is a cost someone pays later.

**What it looks like.** Each rule has one home, and every other page links to it. When we choose a method, we say
whose method it is and where we differ. A technical claim comes with a source, a measurement or a command anyone can
run again. We build what a real need asks for, and we check by machine whatever a machine can check. We work on our
own products the same way we work on yours.

### Rule 1

Each rule has exactly one home; every other place links to it or is generated from it.
**Owner's rule** · Home: our rules file (`AGENTS.md` §3)

### Rule 2

We borrow proven methods before inventing our own, and name the source we follow.
**Not yet approved** · Home: [`mgmt.how-we-work#R1`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-22)

### Rule 3

We use mature open-source tools first, and we are tied to no single vendor or AI tool.
**Owner's rule** · Home: our rules file (`AGENTS.md` §3)

### Rule 4

A technical claim comes with a source and its date, a measurement or a check anyone can repeat, or is marked as an
assumption.
**Approved** · Home: [`mgmt.project-foundation#R8`](/knowledge/playbooks/project-foundation/); our rules file (`AGENTS.md` §3)

### Rule 5

We build only what a real need asks for.
**Owner's rule** · Home: our rules file (`AGENTS.md` §3)

### Rule 6

A rule we can check automatically, we check automatically.
**Not yet approved** · Home: [`mgmt.how-we-work#R2`](/knowledge/core/management/how-we-work/)

### Rule 7

Agents propose; the owner approves what is the owner's.
**Approved** · Home: [`mgmt.project-foundation#R9`](/knowledge/playbooks/project-foundation/), [`mgmt.roles-and-decision-rights#R15`](/knowledge/core/management/roles-and-decision-rights/)

### Rule 8

Everything has a version and a stable id that is never reused.
**Approved** · Home: [`mgmt.project-foundation#R5`](/knowledge/playbooks/project-foundation/); our rules file (`AGENTS.md` §3, "Versioning & Traceability")

### Rule 9

Every job leaves an asset: a case, a better procedure or a new check.
**Not yet approved** · Home: [`mgmt.how-we-work#R3`](/knowledge/core/management/how-we-work/)

### Rule 10

We use our method on our own work, one reviewed step at a time.
**Not yet approved** · Home: [`mgmt.how-we-work#R4`](/knowledge/core/management/how-we-work/)

### Rule 11

The method stands on its own: each piece belongs to one phase and to one document or record we produce, and none
needs our interface and system frameworks.
**Not yet approved** · Home: [`mgmt.how-we-work#R5`](/knowledge/core/management/how-we-work/)

### Rule 12

We quote briefly, link and credit; our code and texts carry open licences.
**Approved** · Home: our decision record on licences, ADR-0005. A decision record (ADR) is a short, numbered note of
one decision, the options we weighed and why we chose.

## 2. Who decides

**Point 2.** The owner decides what cannot be undone or is public; everyone else decides the rest and writes down why.

**Why it matters.** When nobody knows who decides, two things go wrong. Either the owner is asked about every small
step and the work stops, or someone takes a step that cannot be undone and nobody agreed to it. A short, written list
of who decides what prevents both.

**What it looks like.** Every project names its roles: the **owner**, the **lead** who runs the work day to day, the
**builders** who make each change, the **verifiers** who check it, the **client**, and the **automated gate** — the
checks that run on every change. The owner's list is short: the bet (whether the work is worth doing) and the time budget, the scope, how much process
the project needs, hard-to-reverse choices, acceptance, serious risks, and every step that is public or cannot be
undone. Everything else is decided by whoever holds the work, who writes down the decision and why. An agent stops
and asks only in three cases. A **standing rule** — a written, dated instruction of the owner with its limits — lets
agents act without asking each time. A **technical adviser** may brief the team, but only through the owner.

### Rule 13

Each project names who is owner, lead, builder, verifier and client; nobody verifies their own work.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R1`](/knowledge/core/management/roles-and-decision-rights/), `#R2`, `#R6`

### Rule 14

The owner decides the bet and budget, scope, tier, hard-to-reverse architecture, acceptance, serious risks and every
irreversible or public step.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R9`](/knowledge/core/management/roles-and-decision-rights/), `#R16`

### Rule 15

Every other decision is taken by whoever holds the work and written down with its reason; settled questions are not
asked again, except an owner's action, which always needs the owner's yes.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R3`](/knowledge/core/management/roles-and-decision-rights/), `#R10`, `#R11`

### Rule 16

An agent stops and asks only before an owner's action, at a hard-to-reverse fork, or when the work drifts from its
goal.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R12`](/knowledge/core/management/roles-and-decision-rights/)

### Rule 17

Owner decisions are recorded with their date and words; a standing rule lets agents act within written limits.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R13`](/knowledge/core/management/roles-and-decision-rights/), `#R17`

### Rule 18

A client works through the owner.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R7`](/knowledge/core/management/roles-and-decision-rights/)

### Rule 19

Builders stay inside the scope and the decisions; the automated gate is never bypassed; each gate is taken by its
decider; the adviser decides nothing alone.
**Approved** · Home: [`mgmt.roles-and-decision-rights#R4`](/knowledge/core/management/roles-and-decision-rights/), `#R5`, `#R8`, `#R14`

### Rule 20

Questions reach the owner only in the three cases of rule 16, each with a default; other requests are parked for
later.
**Not yet approved** · Home: [`mgmt.how-we-work#R6`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-20 and 2026-11-21)

### Rule 21

Whether work is development or support is the owner's call.
**Not yet approved** · Home: [`mgmt.how-we-work#R7`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-27)

### Rule 22

We build with AI agents under human direction, and choose designs that keep agents consistent.
**Not yet approved** · Home: [`mgmt.how-we-work#R8`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-20)

## 3. How a project runs

**Point 3.** Every project goes Idea → Blueprint → Spec → Build → Release → Support, through four gates, with as much
process as its risk needs.

**Why it matters.** One fixed path means everyone knows what comes next and what must exist before it. Gates stop a
costly mistake while it is still cheap to stop. And process should fit the risk: a one-page script does not need the
paperwork of a system that holds people's money.

**What it looks like.** Every project runs through six phases:

- **Idea** — why, for whom, and is it worth the time? It ends at gate **G0 Bet**: the owner says go or no-go and sets
  the time budget.
- **Blueprint** — what the product must do and how it is built: the requirements and the architecture. It ends at
  **G1**, when the owner approves the scope and the hard-to-reverse choices.
- **Spec** — the short written plan of one release. It ends at **G2 Ready**, the lead's gate.
- **Build** — small changes, each checked before it merges.
- **Release** — the change goes out safely. Going live with a live or client system is gate **G3**, the owner's.
- **Support** — we look after the running system. It starts only after a readiness review: a checklist the system
  passes before we take over its support.

Spec, Build and Release repeat for every release. Each project also picks one of three **tiers** — lightweight,
standard or high-assurance — by its risk; the tier sets how much is written, never which decisions are made. Work on
a live system is sorted into a **fix**, a **change** or a **system change**, and the class sets its route. Before the
first change to a live system there is a backup that we have restored at least once, and changes are tried on a
closed copy first. Building a new site and looking after a live one are different work, run in different ways. The Hub itself runs at
the standard tier, as the owner confirmed on 2026-11-22.

### Rule 23

Every project runs Idea, Blueprint, Spec, Build, Release, Support, in that order; any other stage list maps onto them.
**Approved** · Home: [`process.project-lifecycle#R1`](/knowledge/core/process/project-lifecycle/), `#R2`, `#R15`

### Rule 24

Four gates: the owner takes G0 Bet, G1 Blueprint and G3 Go-live; the lead takes G2 Ready (the owner, when the spec
changes the scope or the budget or needs an owner's decision).
**Approved** · Home: [`process.project-lifecycle#R4`](/knowledge/core/process/project-lifecycle/) to `#R8`

### Rule 25

Each project picks one tier — lightweight, standard or high-assurance — by its risk; the owner decides, and the tier is
reviewed when the risk changes.
**Approved** · Home: [`mgmt.governance-tiers#R1`](/knowledge/core/management/governance-tiers/), `#R2`, `#R5` to `#R9`

### Rule 26

A tier removes paperwork, never a gate, an owner decision, a safety duty or the backup.
**Approved** · Home: [`mgmt.governance-tiers#R3`](/knowledge/core/management/governance-tiers/), `#R4`;
[`process.project-lifecycle#R3`](/knowledge/core/process/project-lifecycle/)

### Rule 27

Work on a live system is a fix, a change or a system change, and the class sets its route.
**Approved** · Home: [`process.project-lifecycle#R10`](/knowledge/core/process/project-lifecycle/)

### Rule 28

A live system gets a backup proved by restore before the first change, and every change that touches code or data
is tried on a closed copy first.
**Approved** · Home: [`process.project-lifecycle#R11`](/knowledge/core/process/project-lifecycle/), `#R12`

### Rule 29

A change merges only when done; a system enters support only after a readiness review.
**Approved** · Home: [`process.project-lifecycle#R7`](/knowledge/core/process/project-lifecycle/), `#R9`

### Rule 30

Development and support are different work; a new site moves to support when it is handed over with a support
service.
**Not yet approved** · Home: [`mgmt.how-we-work#R9`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-26 and 2026-09-27)

### Rule 31

Stages run in order; a step never done for real is marked "not verified"; every job has one visible status and one
folder, and every project a card with what is missing and its risks.
**Not yet approved** · Home: [`mgmt.how-we-work#R10`](/knowledge/core/management/how-we-work/)

## 4. Starting a project

**Point 4.** We keep your request as you gave it, agree what success looks like, and write down what is in and out
before we build.

**Why it matters.** Most failed projects fail at the start: the team builds what it understood, not what was asked,
or nobody wrote down what "finished" means. Writing the request, the goal, the scope and the checks before any code
costs a few hours. Finding the gap after launch costs weeks.

**What it looks like.** We keep your request word for word, in a short **client brief**, and add our reading of it.
Before we promise a date we read all of it and look at what you already have, without changing anything. Our first
time budget is counted in **agent-days** — one AI agent session working through its brief — and rests on the closest
jobs we have done before. A product then gets:

- a one-page **vision**: who it is for, what need it meets, which outcomes show it works, and what it will not do;
- one **requirements specification**: each requirement states one need, can be checked, and traces back to why it
  is there;
- a written **scope**: what is in, what is out, and what waits for later;
- for a first version (an MVP, a minimum viable product), what it must teach us and when we judge it;
- **acceptance criteria**: plain pass-or-fail statements, agreed before work starts, that someone other than their
  author can check.

When we replace a system that already runs, we first list everything outside it that depends on it — old addresses,
links from other systems, scheduled jobs, mail — so nothing breaks quietly.

### Rule 32

We keep your request exactly as you gave it, in a client brief, and every question to you goes through our owner.
**Approved** · Home: [`mgmt.project-foundation#R19`](/knowledge/playbooks/project-foundation/)

### Rule 33

We look before we promise: we read the whole request and snapshot your system without changing it.
**Not yet approved** · Home: [`mgmt.how-we-work#R11`](/knowledge/core/management/how-we-work/)

### Rule 34

A new project starts from the owner's brief, uses current templates, and merges no code before the owner's approval.
**Approved** · Home: [`mgmt.project-foundation#R1`](/knowledge/playbooks/project-foundation/) to `#R4`, `#R10`, `#R11`, `#R15`, `#R17`, `#R18`

### Rule 35

The first time budget is in agent-days, based on our closest past cases.
**Approved** · Home: [`mgmt.project-foundation#R20`](/knowledge/playbooks/project-foundation/)

### Rule 36

A product has a one-page vision: who, what need, which outcomes, what it will not do.
**Approved** · Home: [`req.product-vision`](/knowledge/core/requirements/product-vision/)

### Rule 37

Requirements live in one specification: one need each, verifiable, traced, reviewed by someone else.
**Approved** · Home: [`req.requirements-specification`](/knowledge/core/requirements/requirements-specification/)

### Rule 38

Data that cannot be recreated gets loss and recovery targets in the requirements.
**Approved** · Home: [`mgmt.project-foundation#R13`](/knowledge/playbooks/project-foundation/)

### Rule 39

Scope is written as in, out and later; only the person who owns the product changes it, in writing — on a client
project, the client through our owner.
**Approved** · Home: [`req.scope-and-mvp#R1`](/knowledge/core/requirements/scope-and-mvp/) to `#R4`, `#R7`, `#R9` to `#R11`

### Rule 40

A first version is defined by what it must teach us and judged on a set date.
**Approved** · Home: [`req.scope-and-mvp#R5`](/knowledge/core/requirements/scope-and-mvp/), `#R6`, `#R8`

### Rule 41

Replacing a system starts with a list of everything that depends on it.
**Approved** · Home: [`mgmt.project-foundation#R12`](/knowledge/playbooks/project-foundation/)

### Rule 42

Acceptance criteria are agreed before work, checkable by anyone, never weakened, and accepted by the person who owns
the product or by the customer, never by whoever did the work.
**Approved** · Home: [`req.acceptance-criteria`](/knowledge/core/requirements/acceptance-criteria/); [`mgmt.project-foundation#R14`](/knowledge/playbooks/project-foundation/)

### Rule 43

A big job is cut into stages, each with its own plan and acceptance.
**Not yet approved** · Home: [`mgmt.how-we-work#R12`](/knowledge/core/management/how-we-work/)

## 5. Architecture

**Point 5.** We record every hard-to-reverse choice, draw the system so anyone can read it, and turn its rules into
checks.

**Why it matters.** Architecture is the set of choices that are expensive to change later: how the system is split,
what it talks to, where its data lives. When those choices are only in someone's head, the next person repeats the
debate or breaks the design without knowing it. Written choices, readable diagrams and automatic checks keep the
design true as the code changes.

**What it looks like.** Each hard-to-reverse choice gets a **decision record** (ADR): a short, numbered note with the
options, the choice and the evidence. An accepted record is never rewritten; a new one replaces it. By default the
owner accepts every record; a project's rules may hand records that are not owner-level to the lead, but an
owner-level record is always the owner's. In the Hub itself the owner accepts every record. We draw systems with the **C4 model** — a context diagram of the system and its users,
then its main parts — kept as text beside the code. The **Blueprint** describes the architecture in fixed sections:
the parts of the system and who owns each, every **interface** to the outside world with its contract (what is
exchanged, when and how securely), the quality goals as measurable scenarios, and the risks and the shortcuts we took
(**technical debt**). Each architecture rule becomes an automatic check, a **fitness function**, where it can. (These parts of the
Blueprint are rules 47–52, not yet approved.) When we
review an existing system, we work on copies or with read-only access, say what we could not see, and the owner
decides what to do with each serious finding.

On your project we use the platform as it was designed. A picture you send us is an idea, not a specification: we
reach it with the platform's own settings and parts first, and write our own code last.

### Rule 44

Every hard-to-reverse choice is a short, numbered decision record with options and evidence, replaced but never
rewritten.
**Approved** · Home: [`arch.adr#R1`](/knowledge/core/architecture/adr/) to `#R8`, `#R13` to `#R15`;
[`mgmt.project-foundation#R6`](/knowledge/playbooks/project-foundation/)

### Rule 45

Each decision record says who decides and whether the decision is the owner's; an owner-level record waits for the
owner's dated acceptance.
**Approved** · Home: [`arch.adr#R9`](/knowledge/core/architecture/adr/) to `#R12`

### Rule 46

We draw systems with C4 diagrams kept as text.
**Approved** · Home: [`arch.c4-model`](/knowledge/core/architecture/c4-model/); [`mgmt.project-foundation#R7`](/knowledge/playbooks/project-foundation/)

### Rule 47

The Blueprint describes the architecture in fixed sections, as much as the tier needs.
**Not yet approved** · Home: [`arch.architecture-description`](/knowledge/core/architecture/architecture-description/)

### Rule 48

The system is split into blocks with an owner, a public interface and checked dependency rules.
**Not yet approved** · Home: [`arch.building-blocks-and-dependencies`](/knowledge/core/architecture/building-blocks-and-dependencies/)

### Rule 49

Every external interface is listed with its contract; breaking changes are versioned or announced.
**Not yet approved** · Home: [`arch.context-and-interfaces`](/knowledge/core/architecture/context-and-interfaces/)

### Rule 50

Quality goals are measurable scenarios, set by what people can bear.
**Not yet approved** · Home: [`arch.quality-attributes`](/knowledge/core/architecture/quality-attributes/)

### Rule 51

Architecture rules become checks that prove themselves and are never loosened to pass.
**Not yet approved** · Home: [`arch.fitness-functions`](/knowledge/core/architecture/fitness-functions/)

### Rule 52

Risks and technical debt are kept in two short registers.
**Not yet approved** · Home: [`arch.risks-and-technical-debt`](/knowledge/core/architecture/risks-and-technical-debt/)

### Rule 53

An architecture review has an agreed scope, changes nothing live, says what it did not see, and the owner decides its
findings.
**Approved** · Home: [`arch.architecture-review`](/knowledge/playbooks/architecture-review/)

### Rule 54

We use a platform as designed: a client's picture is an idea; settings first, our own code last.
**Not yet approved** · Home: [`mgmt.how-we-work#R13`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-27)

### Rule 55

Our customisations are packaged, switchable, safe across updates and hold no client values.
**Not yet approved** · Home: [`mgmt.how-we-work#R14`](/knowledge/core/management/how-we-work/)

## 6. Planning one release

**Point 6.** Each release has a written plan, a fixed time budget and a way back, before any code.

**Why it matters.** A release without a plan grows while it is built: one more feature, one more fix, and the date
slips. A fixed time budget turns "how long will it take?" into "what fits in the time we agreed?". And a release with
no way back is a bet nobody chose to make.

**What it looks like.** Each change gets a short **release spec**: why now, which requirements it covers and which it
does not, what changes in the system, which checks we write first, how we roll it out and how we undo it. A small fix
gets at least a plan: the failing check, the backup and the way back. Your own terms of reference feed into our
specification; they never replace it. Each release has an **appetite** — the time the owner agrees to spend on it,
fixed before the design. If the appetite runs out with the work unfinished, we stop and put the options to the owner,
with a default, instead of quietly running over. Build starts only when a short checklist, the **Definition of
Ready**, holds. The work is cut into **work packages**, each small enough for one builder, with a short brief in a file.
All rules of this chapter are not yet approved: their Hub items are still in review.

### Rule 56

Each change has a short release spec approved before Build, with its checks and its way back; a small fix has at
least the plan of the fix. Your terms of reference are an input to it, never a replacement.
**Not yet approved** · Home: [`process.release-spec`](/knowledge/core/process/release-spec/)

### Rule 57

Each release has a fixed time budget; when it runs out we stop and give the owner options.
**Not yet approved** · Home: [`process.release-spec#R12`](/knowledge/core/process/release-spec/); [`process.deliver-a-release#R5`](/knowledge/playbooks/deliver-a-release/)

### Rule 58

Every open question carries a default.
**Not yet approved** · Home: [`process.release-spec#R13`](/knowledge/core/process/release-spec/)

### Rule 59

Build starts only when the Definition of Ready holds.
**Not yet approved** · Home: [`process.definition-of-ready`](/knowledge/core/process/definition-of-ready/); [`quality.quality-release#R2`](/knowledge/playbooks/quality-release/)

### Rule 60

A release runs five stages in order, a fix a shorter route, and whoever builds it never approves it.
**Not yet approved** · Home: [`process.deliver-a-release`](/knowledge/playbooks/deliver-a-release/)

### Rule 61

Each work package has a brief in a file and fits one builder, one branch and one pull request.
**Not yet approved** · Home: [`process.work-packages#R1`](/knowledge/core/process/work-packages/) to `#R3`

## 7. Building and checking

**Point 7.** Small changes, checks written first, someone else verifies, and "done" means proved.

**Why it matters.** Big changes hide their mistakes, and a check written after the code tends to prove only what the
code already does. A person checking their own work sees what they meant, not what they wrote. "Done" without proof
is only a hope.

**What it looks like.** In our repositories, each change starts from an issue, is built on its own branch and comes
back as a small pull request; the main line can be released at any time. The builder first writes the checks that
will prove the change and sees them fail, then makes them pass. A **verifier** who did not build the change re-runs
the checks. One check script runs the same on the builder's machine and in the shared pipeline, and nobody switches a
check off to get a green light. The **Definition of Done** says what "done" means: the goal met, with the command and
its output to show it. Every defect that reaches a release comes back as a test.

On client sites we keep a log the same day, above all of what broke. We script our changes so they can be repeated,
look at the result the way users do — on a desktop and a phone — and test anything with real effects, such as an
order or an email, only together with the owner. Until launch, a site under construction is closed by a password and
hidden from search engines. Rules 64, 65 and 69–73 below are not yet approved.

### Rule 62

In our repositories, work flows from an issue through a branch and a reviewed pull request; the main line is always
releasable.
**Owner's rule** · Home: our rules file (`AGENTS.md` §5)

### Rule 63

In our repositories, an agent merges its own pull request on green checks inside an approved task; the owner reviews
after.
**Owner's rule** · Home: our rules file (`AGENTS.md` §5; the owner's instruction of 2026-11-20, confirmed 2026-11-21)

### Rule 64

Checks are written first and seen to fail; someone who did not build the change re-runs them.
**Not yet approved** · Home: [`process.work-packages#R4`](/knowledge/core/process/work-packages/) to `#R12`

### Rule 65

"Done" means proved, by the Definition of Done.
**Not yet approved** · Home: [`process.definition-of-done`](/knowledge/core/process/definition-of-done/); [`quality.quality-release#R1`](/knowledge/playbooks/quality-release/)

### Rule 66

Every defect fixed after a release comes with a test that reproduces it.
**Approved** · Home: [`quality.quality-release#R8`](/knowledge/playbooks/quality-release/)

### Rule 67

Commit messages follow Conventional Commits.
**Approved** · Home: [`config.conventional-commits`](/knowledge/core/configuration-management/conventional-commits/)

### Rule 68

One check script runs the same on our machines and in the shared pipeline (CI); a check is switched off only in its
own reviewed change.
**Approved** · Home: [`quality.quality-release#R3`](/knowledge/playbooks/quality-release/), `#R5` to `#R7`

### Rule 69

We log the same day, above all what broke.
**Not yet approved** · Home: [`mgmt.how-we-work#R15`](/knowledge/core/management/how-we-work/)

### Rule 70

Changes are scripted so they can be repeated, with snapshots before and after.
**Not yet approved** · Home: [`mgmt.how-we-work#R16`](/knowledge/core/management/how-we-work/)

### Rule 71

We look at the result as users do — on desktop and phone, every link — and a fresh reviewer looks before hand-over.
**Not yet approved** · Home: [`mgmt.how-we-work#R17`](/knowledge/core/management/how-we-work/)

### Rule 72

Tests with real side effects run only with the owner; machine-made content is a draft until checked.
**Not yet approved** · Home: [`mgmt.how-we-work#R18`](/knowledge/core/management/how-we-work/)

### Rule 73

A site under construction is closed and hidden from search engines until launch.
**Not yet approved** · Home: [`mgmt.how-we-work#R19`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-27)

## 8. Releasing safely

**Point 8.** No release without a backup, a rehearsed way back and a named person's approval.

**Why it matters.** Most of the damage a release does happens in the first hour, and most of it can be undone — if
there is a recent backup and a way back that someone has tried. A green test run says the code passed its checks; it
does not say a person has looked and agreed.

**What it looks like.** Each release has a version number that tells users whether it can break them (**SemVer**:
MAJOR.MINOR.PATCH) and a changelog written for them. It is built by a script from a marked commit that passed the
checks. Before it goes out there is a checklist with the deployment plan and the way back — what makes us roll back,
the steps, how long it takes and who decides. A named person approves the release against that checklist. We try it
on a copy first, take a fresh backup of the live system, choose a quiet time from real traffic or order data, and keep
someone ready to roll back. Right after the release we check the main paths, the error logs and the monitoring, and
we keep a record of what went out. An urgent fix (a **hotfix**) is the smallest change that removes the fault and goes
through the same checks. For a new site we take a backup right after the platform is installed and again before the
first deployment; acceptance follows the written criteria, and launch follows a checklist. Rules 82 and 83 below are
not yet approved.

### Rule 74

Versions follow SemVer, and every release has a changelog for its users.
**Approved** · Home: [`config.semantic-versioning`](/knowledge/core/configuration-management/semantic-versioning/); [`quality.quality-release#R4`](/knowledge/playbooks/quality-release/), `#R10`

### Rule 75

A release is built by a script from a tagged commit that passed the checks.
**Approved** · Home: [`quality.quality-release#R9`](/knowledge/playbooks/quality-release/), `#R11`

### Rule 76

No deployment without a written way back; going live rests on a rehearsed one.
**Approved** · Home: [`quality.quality-release#R12`](/knowledge/playbooks/quality-release/), `#R13`; [`mgmt.governance-tiers#R10`](/knowledge/core/management/governance-tiers/)

### Rule 77

A named person approves each release; a green pipeline is not an approval.
**Approved** · Home: [`quality.quality-release#R14`](/knowledge/playbooks/quality-release/)

### Rule 78

A release is tried on a copy first, or the missing copy is recorded as an accepted risk; it ships no known-exploited
weakness unless a named person accepts it.
**Approved** · Home: [`quality.quality-release#R15`](/knowledge/playbooks/quality-release/), `#R16`

### Rule 79

A fresh backup comes before deploying to a live system, at a quiet time chosen from data, with someone ready to roll
back.
**Approved** · Home: [`quality.quality-release#R17`](/knowledge/playbooks/quality-release/), `#R18`

### Rule 80

We check right after release, roll back when the trigger fires unless the approver decides to fix forward, and keep a
release record.
**Approved** · Home: [`quality.quality-release#R19`](/knowledge/playbooks/quality-release/) to `#R21`

### Rule 81

A hotfix is the smallest change through the same checks; we do not change a live system directly, and an emergency
change is recorded and brought back within one working day.
**Approved** · Home: [`quality.quality-release#R22`](/knowledge/playbooks/quality-release/) to `#R24`

### Rule 82

A new site is backed up when the platform is installed and before its first deployment.
**Not yet approved** · Home: [`mgmt.how-we-work#R20`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-27)

### Rule 83

Acceptance follows the written criteria; launch follows a checklist.
**Not yet approved** · Home: [`mgmt.how-we-work#R21`](/knowledge/core/management/how-we-work/)

### Rule 84

Our own site is deployed by our own scripts, with a way back, and only on the owner's word.
**Owner's rule** · Home: our rules file (`AGENTS.md` §4)

## 9. Running and supporting

**Point 9.** A system we look after has a runbook, tested backups, service levels measured from outside and honest
incident reports.

**Why it matters.** A live system is only as safe as the day it is needed most: the day it breaks. Backups that were
never restored, a support team that has to call the builder, or a client who learns about a failure from their own
customers — each turns a small fault into a large one.

**What it looks like.** Data that cannot be recreated is backed up by the **3-2-1** rule — three copies, on two kinds of
storage, one of them off-site — with one copy that the live system cannot delete, and we prove the backups by
restoring them at least every quarter. On client sites our practice is a backup in three parts: the files, the database and the
configuration. Before we take over a system's support, someone who did not build it checks its readiness: who looks
after it, a **runbook** (a written guide to start, stop, check and restore it), backups, access, monitoring and known
limits. We write down its **service levels** — two to four targets for what its users feel, such as "the order page
answers", measured from outside the system. When something fails we report it at once, bring the service back first,
and tell the client the truth through our owner: what we know and what we do not know yet. A serious failure gets a
**postmortem** that looks for causes, not for someone to blame, and each action from it has an owner and a date.
Support has a named person and a stand-in, a calendar of routine duties, one place where all requests arrive, and a
one-page review each month. Rules 86–91 below are not yet approved.

### Rule 85

Data that cannot be recreated has 3-2-1 backups, one copy the live system cannot delete, proved by restore at least
every quarter.
**Approved** · Home: [`ops.backups`](/knowledge/core/operations/backups/)

### Rule 86

Before support takes a system over, someone else reviews its readiness.
**Not yet approved** · Home: [`ops.production-readiness-and-handover`](/knowledge/core/operations/production-readiness-and-handover/)

### Rule 87

A supported system has written service levels measured from outside.
**Not yet approved** · Home: [`ops.service-levels`](/knowledge/core/operations/service-levels/)

### Rule 88

Incidents are reported at once, service comes back first, and the client hears the truth through the owner.
**Not yet approved** · Home: [`ops.incidents-and-postmortems#R1`](/knowledge/core/operations/incidents-and-postmortems/) to `#R7`

### Rule 89

Serious incidents get a blameless postmortem with owned actions.
**Not yet approved** · Home: [`ops.incidents-and-postmortems#R8`](/knowledge/core/operations/incidents-and-postmortems/) to `#R13`

### Rule 90

Support has a named supporter, a calendar of duties, one intake and a monthly one-page review.
**Not yet approved** · Home: [`ops.operate-and-support`](/knowledge/playbooks/operate-and-support/)

### Rule 91

Nothing downloadable is left in a web root, the public folder of a site: no copies of code, database dumps or old
backups.
**Not yet approved** · Home: [`mgmt.how-we-work#R22`](/knowledge/core/management/how-we-work/)

## 10. Keeping what we learn

**Point 10.** Every job leaves a lesson where the next job will find it, and facts live in files, not in memory.

**Why it matters.** A lesson that stays in one person's head, or in one chat, is lost by the next job. AI agents
forget everything between sessions unless it is written down. So what we learn has to land in a place the next person
— or the next agent — will look, and what we depend on has to live in files that anyone can read and check.

**What it looks like.** Every phase opens by **recalling** earlier work — have we done something like this before? —
and closes by **recording** what it decided and learned. Recall only informs a decision; anything we depend on goes
into a file in the project's repository. We keep memory in four layers: files in Git, which hold the rules and facts;
search over those files; short notes of what was tried and what happened; and the agents' own session notes, which
never hold a project fact or anyone's personal data. A lesson climbs step by step: a note, then an entry in our
**knowledge base** (our collection of pitfalls, each with the project and date it came from), then, if it is general,
a Hub item or an automatic check. Every closed job leaves a short **case** — what was there before, what is there
after, how long it took — and past cases are how we estimate the next job. Long procedures live in **playbooks**;
an agent **skill** stays short and points to them. Rules 93–98 below are not yet approved.

### Rule 92

Each phase starts by recalling earlier work and ends by recording; what we depend on lives in files.
**Approved** · Home: [`process.project-lifecycle#R13`](/knowledge/core/process/project-lifecycle/), `#R14`;
[`mgmt.project-foundation#R16`](/knowledge/playbooks/project-foundation/)

### Rule 93

Memory has four layers; only files hold rules; recalled notes are checked and cleaned of other clients' data.
**Not yet approved** · Home: [`process.knowledge-and-memory`](/knowledge/core/process/knowledge-and-memory/)

### Rule 94

A lesson climbs from a note to the knowledge base to a rule or a check, and has a real case behind it.
**Not yet approved** · Home: [`process.knowledge-and-memory#R10`](/knowledge/core/process/knowledge-and-memory/) to `#R12`; [`mgmt.how-we-work#R23`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-26)

### Rule 95

Before work starts we look for where we did something similar.
**Not yet approved** · Home: [`mgmt.how-we-work#R24`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-26)

### Rule 96

A closed job leaves a case with numbers before and after; past cases are the basis of estimates.
**Not yet approved** · Home: [`mgmt.how-we-work#R25`](/knowledge/core/management/how-we-work/)

### Rule 97

Long procedures live in playbooks; agent skills stay short and point to them.
**Not yet approved** · Home: [`mgmt.how-we-work#R26`](/knowledge/core/management/how-we-work/)

### Rule 98

A site worked on by several teams keeps one shared, private notes file; a client sees a private project page.
**Not yet approved** · Home: [`mgmt.how-we-work#R27`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-09-27)

## 11. Working with AI agents

**Point 11.** Agents work from one rule file, a written brief and a short report, inside limits the owner sets.

**Why it matters.** AI agents are fast and tireless, but they follow what they are given. Scattered rules give
scattered results; a vague task gives a confident wrong answer; a long report hides what matters. Clear rules, a
written brief and a short report make an agent's work checkable by a person.

**What it looks like.** Each repository has one rules file, `AGENTS.md`, that every agent reads, whatever tool it runs
in. Agent **skills** — small packaged procedures — apply the Hub's rules by their ids and hold no rules of their own.
When two instructions conflict, safety and the law win, then our core rules, then the platform's profile, then the
project's own decisions, then the task; a lower level relaxes a rule only by a recorded decision, a task never relaxes
one, and an agent that meets a conflict it cannot settle stops and reports it. Agents never ask for a password or a
token and never print one. Each task is a written **brief** in a file; each report says what is now true, the
evidence, what was not done and why, and what waits for the owner. No work starts without an item in the plan, and the
owner gets short, regular summaries. Rules 100 and 103 below are not yet approved.

### Rule 99

In each repository one rules file serves every agent; agent skills apply rules and hold none.
**Approved** · Home: our decision record on agent integration, ADR-0003; our rules file (`AGENTS.md`)

### Rule 100

When instructions conflict, safety wins, then our rules, then the platform's profile, then the project, then the task;
a lower level relaxes a rule only by a recorded decision, and a conflict is reported, not guessed.
**Not yet approved** · Home: the Hub's Blueprint, §3.2 (in our repository, not yet public); the same order is in
`tools/AGENTS.hub.md`, "Instruction precedence", which ships with every release of the Hub

### Rule 101

Agents never ask for or print a secret.
**Owner's rule** · Home: our rules file (`AGENTS.md` §2)

### Rule 102

A task is a written brief; a report says the result, the evidence, what is not done and what waits for the owner.
**Owner's rule** · Home: our rules file (`AGENTS.md` §8)

### Rule 103

No work starts without a plan item, and the owner gets short regular summaries.
**Not yet approved** · Home: [`mgmt.how-we-work#R28`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-21)

### Rule 104

The Hub's repository files are written in English.
**Owner's rule** · Home: our rules file (`AGENTS.md` §9)

## 12. Safety, privacy and public material

**Point 12.** No secrets or personal data where they do not belong; public material is safe to read and to reuse.

**Why it matters.** A password pasted into a chat or a log can be read by anyone who later reads that chat or log.
Personal data kept longer than needed is a risk with no benefit. And what we publish is read by clients, by other
teams and by AI agents, so it has to be true, safe to copy, and clear about whose words it is.

**What it looks like.** Secrets stay in protected files; documents and logs name only where a secret is kept. A
password someone sends us in a chat is moved to safe storage at once and changed. Each system lists the personal data
it holds, where, and for how long; requests sent through our own site's form are deleted after one month at most. Our
public examples are made up, or come from a UK project with no client data in them. Our public material leaves out the
markets the owner has excluded. Our brand is a single mark, and our texts say "we". English is the source language;
the owner decides which sections also appear in other languages. Our portal aims to be usable by everyone (WCAG 2.2
level AA), to build the same way every time, and to give automation no more access than it needs. Rules 106–113 below
are not yet approved.

### Rule 105

No secret goes into a report, a log or a chat; a review copies no secret or personal data either.
**Owner's rule** · Home: our rules file (`AGENTS.md` §2); [`arch.architecture-review#R11`](/knowledge/playbooks/architecture-review/) (approved, for reviews)

### Rule 106

Credentials sent in a chat are moved to safe storage and changed.
**Not yet approved** · Home: [`mgmt.how-we-work#R29`](/knowledge/core/management/how-we-work/)

### Rule 107

Requests sent through our site's form are kept at most one month, then deleted.
**Not yet approved** · Home: [`mgmt.how-we-work#R30`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-22)

### Rule 108

A system lists the personal data it holds, where and for how long.
**Not yet approved** · Home: [`ops.production-readiness-and-handover#R10`](/knowledge/core/operations/production-readiness-and-handover/)

### Rule 109

Public examples are made up or from a UK project without client data.
**Not yet approved** · Home: [`mgmt.how-we-work#R31`](/knowledge/core/management/how-we-work/)

### Rule 110

Our public material stays out of markets the owner excludes.
**Not yet approved** · Home: [`mgmt.how-we-work#R32`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-20)

### Rule 111

Our brand is the mark alone; we write "we".
**Not yet approved** · Home: [`mgmt.how-we-work#R33`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-20)

### Rule 112

The owner chooses each section's languages; English is the source.
**Not yet approved** · Home: [`mgmt.how-we-work#R34`](/knowledge/core/management/how-we-work/) (the owner's words of 2026-11-22); our rules file
(`AGENTS.md` §9)

### Rule 113

Our portal aims to be accessible (WCAG 2.2 AA), reproducible and least-privileged.
**Not yet approved** · Home: the Hub's requirements (PRD), NFR-9 to NFR-11 (in our repository, not yet public)

## 13. Measuring and improving

**Point 13.** We measure how the system is delivered, never the people, and change one thing at a time.

**Why it matters.** Without numbers, "we are getting faster" is a feeling. With the wrong numbers, people chase the
number instead of the work. Measuring the delivery of a system — not the people who do it — tells us where the process
hurts, without turning the number into a target.

**What it looks like.** From the standard tier we track the five **DORA** delivery measures: how often we release, how
long a change takes to reach users, how often a release fails, how often it needs rework, and how fast we
recover. We read them
together, never one alone; we take them from records the method already writes; with few releases we give counts, not
percentages. We review them at each release and every quarter, and each review ends in at most one change to how we
work. Rule 114 below is not yet approved.

### Rule 114

We measure delivery with the DORA metrics read together — never people, never as targets.
**Not yet approved** · Home: [`mgmt.delivery-metrics`](/knowledge/core/management/delivery-metrics/)

## 14. How our rules are published

**Point 14.** Every rule has an id, a version and a status; drafts are marked; projects pin an exact release.

**Why it matters.** A rule that changes without notice breaks the projects that rely on it. A draft that looks final
misleads. People and agents both need to know which version of a rule they follow and whether it is settled.

**What it looks like.** The Hub is one static site on one stack, changed only through reviewed commits in Git. Each rule
lives in an item with an id, a version, a status, its sources and the template it follows, and each item says who
stands behind it: an outside standard, our own standard, a recommended practice or a project's own rule. Outside
standards are named and linked, never copied. Every page that is not approved carries the mark "Draft — not approved".
A full release of the Hub ships only approved items and lists the rest; a pre-release may carry drafts, marked. A
project pins one exact release, checked by its hash, so no rule changes under it by surprise. The first full release,
`v0.1.0`, holds the 15 items the owner approved on 2026-11-22. Our interface and system frameworks, HIF and SCF, are
kept in the Hub as drafts. Three of our decision records are still proposals, not accepted: how decisions are recorded
(ADR-0001), the HIF rule model (ADR-0009) and the SCF change policy (ADR-0010). Rules 116, 118 and 122 below are not
yet approved.

### Rule 115

Anything not approved carries the mark "Draft — not approved"; a full release ships only approved items.
**Approved** · Home: our decision record on full releases, ADR-0008

### Rule 116

Each rule lives in an item with an id, version, status, sources and template, readable by people and agents.
**Not yet approved** · Home: the Hub's Blueprint §4 and requirements FR-1 to FR-17 (in our repository, not yet public)

### Rule 117

Projects pin an exact release with its hash, so no rule changes under them.
**Approved** · Home: our decision record on versioning, ADR-0004

### Rule 118

Each rule shows who stands behind it; outside standards are linked, not copied.
**Not yet approved** · Home: the Hub's requirements, FR-11 (in our repository, not yet public)

### Rule 119

The portal is one static site on one stack, changed only through reviewed Git commits.
**Approved** · Home: our decision record on the portal, ADR-0006

### Rule 120

Our interface and system frameworks are kept and versioned in the Hub.
**Approved** · Home: our decision record on HIF and SCF, ADR-0007

### Rule 121

In the Hub, each kind of information has one source file.
**Owner's rule** · Home: our rules file (`AGENTS.md` §4)

### Rule 122

The Hub links to bodies of knowledge and does not republish them.
**Not yet approved** · Home: the Hub's vision (in our repository, not yet public)

## Annex A. Words we use

Plain meanings of the words in this document. Where the Hub has a page for the word, it is linked.

**The roles.** The **owner** decides the time budget, the scope, what is accepted and every step that cannot be undone;
on our own products the owner is also the client. The **client** is the person or business we work for; on your
project, that is you, and you work with us through the owner. The **lead** runs the work day to day. A **builder** makes
a change; a **verifier** checks it and never checks its own work. The **automated gate** is the set of checks that runs
on every change. An **agent** is an AI program that works for us under written rules. A **technical adviser** may brief
the team, through the owner, and decides nothing.

| Word | Meaning |
|---|---|
| acceptance criterion | a plain pass-or-fail statement, agreed before work, that shows a requirement is met |
| ADR, decision record | a short, numbered note of one decision, the options weighed and why ([page](/knowledge/glossary/adr/)) |
| agent-day | one AI agent session working through its brief; the unit of our time budgets |
| appetite | the time the owner agrees to spend on a piece of work, fixed before the design |
| bet | the owner's choice, at gate G0, that a piece of work is worth its time budget |
| Blueprint | the architecture and plan of a product: how it is built to meet its requirements ([page](/knowledge/glossary/blueprint/)) |
| C4 model | a way to draw software at four levels of detail, from its context down to its parts |
| case | a short record of one finished job: before, after, time taken; the basis of our estimates |
| change class | how work on a live system is sorted: a **fix**, a **change** or a **system change** |
| client brief | the client's request kept word for word, with our first reading of it |
| Definition of Done | the checklist that says when one change may merge |
| Definition of Ready | the checklist that says when a release may start being built |
| DORA metrics | five measures of software delivery: how often we release, how long a change takes to reach users, how often a release fails, how often it needs rework, how fast we recover |
| fitness function | an automatic check that an architecture rule still holds |
| gate | a point where a named person decides whether the work goes on: G0 Bet, G1 Blueprint, G2 Ready, G3 Go-live |
| hotfix | the smallest change that removes a fault in a release, through the same checks |
| Hub | our public library of rules and methods at [uask.pro/knowledge](/knowledge/) |
| item | one part of the Hub, with an id such as `mgmt.project-foundation`, a version and a status |
| knowledge base | our collection of pitfalls and lessons, each with the project and date it came from |
| MVP | a minimum viable product: the first complete version that teaches us the most ([page](/knowledge/glossary/mvp/)) |
| pin a release | to fix a project to one exact version of the Hub, checked by its hash |
| playbook | a long, step-by-step procedure for one kind of work |
| postmortem | a written look at a serious failure that seeks causes, not someone to blame |
| readiness review | the checklist a system passes before we take over its support |
| recall, record | looking for earlier work at the start of each phase; writing down what was decided and learned at its end |
| release spec | the short written plan of one release ([page](/knowledge/glossary/release-spec/)) |
| requirements specification | the one document that lists what a product must do and how well ([page](/knowledge/glossary/specification/)) |
| runbook | a written guide to start, stop, check and restore a system |
| scope | the written line around what is in, what is out and what waits for later ([page](/knowledge/glossary/scope/)) |
| SemVer | version numbers MAJOR.MINOR.PATCH that tell users whether an upgrade can break them |
| service level | a target for what users of a system feel, such as "the order page answers", measured from outside |
| skill | a small packaged procedure that an agent follows; it applies rules and holds none |
| standing rule | a written, dated instruction of the owner that lets agents act within stated limits |
| technical debt | a shortcut we took, written down with what it costs and when we pay it back |
| 3-2-1 | three copies of a backup, on two kinds of storage, one of them off-site |
| tier | how much process a project needs: lightweight, standard or high-assurance |
| vision | a one-page picture of a product: who it is for, the need, the outcomes, what it will not do ([page](/knowledge/glossary/vision/)) |
| work package | one small piece of a release, for one builder, one branch and one pull request |

## Annex C. Changes

What changed in this document, newest first. A rule keeps its number for good; a withdrawn rule stays, marked
"withdrawn". Each entry gives the date, what changed and why.

| Date | Version | What changed | Why |
|---|---|---|---|
| 2026-11-22 | 0.2.0 | The core of four principles added above the 14 points; each point tagged with its principles; this list of changes added | The owner's word of 2026-11-22: a short core, for now without a name |
| 2026-11-22 | 0.1.0 | Rule 20 reworded: questions reach the owner only in the cases of rule 16 | Its home, `mgmt.how-we-work#R6`, was corrected to match `mgmt.roles-and-decision-rights#R12` |
| 2026-11-22 | 0.1.0 | First draft: the page for clients, the 14 points, chapters 0–14 with rules 1–122, annexes A and B | The owner's gate on the outline: title «How We Do» |

## Annex B. Sources

We borrow structure, not text. The sources of the shape of this document are below. The methods behind the rules —
arc42, the C4 model, MADR, ISO/IEC 25010, the DORA research, Semantic Versioning, Conventional Commits, Diátaxis — are
named and cited, with their addresses and access dates, in the Hub items each rule links to.

- [GOV.UK Service Standard](https://www.gov.uk/service-manual/service-standard) — Open Government Licence v3.0. The two
  layers: short numbered points over detailed guidance. Accessed 2026-11-22.
- [Basecamp, Shape Up](https://basecamp.com/shapeup) — all rights reserved. Chapters in the order of the work, and the
  idea of a fixed time budget (appetite). Accessed 2026-11-22.
- [thoughtbot Playbook](https://thoughtbot.com/playbook) — CC BY-NC 3.0; linked only, no text used. The voice: "we",
  candid, the best we have found so far. Accessed 2026-11-22.
- [AGENTS.md](https://agents.md) — all rights reserved. One rules file that every AI agent reads. Accessed 2026-11-22.
- [The /llms.txt file](https://llmstxt.org) — all rights reserved. A small index of pages for AI agents, with
  Markdown copies. Accessed 2026-11-22.
