How We Do
- Status
- Review
- Version
- 0.2.0
- Authority
- UASK standard
- Applies to
- Core
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, 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.
- Define once. Every rule, fact and decision has one home; everything else links to it (rules 1, 8, 121).
- The owner decides. What cannot be undone, or is public, is the owner’s decision; agents propose (rules 7, 14).
- No harm. There is always a way back, and security and privacy are never lowered, whatever the tier (rules 26, 28, 76, 101).
- 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.
- We define each rule once, borrow proven methods, prove what we claim and keep it simple. (Define once, Evidence)
- The owner decides what cannot be undone or is public; everyone else decides the rest and writes down why. (The owner decides)
- Every project goes Idea → Blueprint → Spec → Build → Release → Support, through four gates, with as much process as its risk needs. (The owner decides)
- 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)
- We record every hard-to-reverse choice, draw the system so anyone can read it, and turn its rules into checks. (Define once)
- Each release has a written plan, a fixed time budget and a way back, before any code. (No harm)
- Small changes, checks written first, someone else verifies, and “done” means proved. (Evidence)
- No release without a backup, a rehearsed way back and a named person’s approval. (No harm, The owner decides)
- A system we look after has a runbook, tested backups, service levels measured from outside and honest incident reports. (No harm, Evidence)
- Every job leaves a lesson where the next job will find it, and facts live in files, not in memory. (Define once)
- Agents work from one rule file, a written brief and a short report, inside limits the owner sets. (Define once, The owner decides)
- No secrets or personal data where they do not belong; public material is safe to read and to reuse. (No harm)
- We measure how the system is delivered, never the people, and change one thing at a time. (Evidence)
- 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; 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, 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 (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; 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
Rule 7
Agents propose; the owner approves what is the owner’s.
Approved · Home: mgmt.project-foundation#R9, mgmt.roles-and-decision-rights#R15
Rule 8
Everything has a version and a stable id that is never reused.
Approved · Home: mgmt.project-foundation#R5; 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
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
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
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, #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, #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, #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
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, #R17
Rule 18
A client works through the owner.
Approved · Home: mgmt.roles-and-decision-rights#R7
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, #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 (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 (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 (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, #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 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, #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, #R4;
process.project-lifecycle#R3
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
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, #R12
Rule 29
A change merges only when done; a system enters support only after a readiness review.
Approved · Home: process.project-lifecycle#R7, #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 (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
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
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
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 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
Rule 36
A product has a one-page vision: who, what need, which outcomes, what it will not do.
Approved · Home: req.product-vision
Rule 37
Requirements live in one specification: one need each, verifiable, traced, reviewed by someone else.
Approved · Home: req.requirements-specification
Rule 38
Data that cannot be recreated gets loss and recovery targets in the requirements.
Approved · Home: mgmt.project-foundation#R13
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 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, #R6, #R8
Rule 41
Replacing a system starts with a list of everything that depends on it.
Approved · Home: mgmt.project-foundation#R12
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; mgmt.project-foundation#R14
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
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 to #R8, #R13 to #R15;
mgmt.project-foundation#R6
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 to #R12
Rule 46
We draw systems with C4 diagrams kept as text.
Approved · Home: arch.c4-model; mgmt.project-foundation#R7
Rule 47
The Blueprint describes the architecture in fixed sections, as much as the tier needs.
Not yet approved · Home: arch.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
Rule 49
Every external interface is listed with its contract; breaking changes are versioned or announced.
Not yet approved · Home: arch.context-and-interfaces
Rule 50
Quality goals are measurable scenarios, set by what people can bear.
Not yet approved · Home: arch.quality-attributes
Rule 51
Architecture rules become checks that prove themselves and are never loosened to pass.
Not yet approved · Home: arch.fitness-functions
Rule 52
Risks and technical debt are kept in two short registers.
Not yet approved · Home: arch.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
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 (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
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
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; process.deliver-a-release#R5
Rule 58
Every open question carries a default.
Not yet approved · Home: process.release-spec#R13
Rule 59
Build starts only when the Definition of Ready holds.
Not yet approved · Home: process.definition-of-ready; quality.quality-release#R2
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
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 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 to #R12
Rule 65
“Done” means proved, by the Definition of Done.
Not yet approved · Home: process.definition-of-done; quality.quality-release#R1
Rule 66
Every defect fixed after a release comes with a test that reproduces it.
Approved · Home: quality.quality-release#R8
Rule 67
Commit messages follow Conventional Commits.
Approved · Home: config.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, #R5 to #R7
Rule 69
We log the same day, above all what broke.
Not yet approved · Home: mgmt.how-we-work#R15
Rule 70
Changes are scripted so they can be repeated, with snapshots before and after.
Not yet approved · Home: mgmt.how-we-work#R16
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
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
Rule 73
A site under construction is closed and hidden from search engines until launch.
Not yet approved · Home: mgmt.how-we-work#R19 (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; quality.quality-release#R4, #R10
Rule 75
A release is built by a script from a tagged commit that passed the checks.
Approved · Home: quality.quality-release#R9, #R11
Rule 76
No deployment without a written way back; going live rests on a rehearsed one.
Approved · Home: quality.quality-release#R12, #R13; mgmt.governance-tiers#R10
Rule 77
A named person approves each release; a green pipeline is not an approval.
Approved · Home: quality.quality-release#R14
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, #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, #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 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 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 (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
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
Rule 86
Before support takes a system over, someone else reviews its readiness.
Not yet approved · Home: ops.production-readiness-and-handover
Rule 87
A supported system has written service levels measured from outside.
Not yet approved · Home: ops.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 to #R7
Rule 89
Serious incidents get a blameless postmortem with owned actions.
Not yet approved · Home: ops.incidents-and-postmortems#R8 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
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
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, #R14;
mgmt.project-foundation#R16
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
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 to #R12; mgmt.how-we-work#R23 (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 (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
Rule 97
Long procedures live in playbooks; agent skills stay short and point to them.
Not yet approved · Home: mgmt.how-we-work#R26
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 (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 (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 (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
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 (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
Rule 109
Public examples are made up or from a UK project without client data.
Not yet approved · Home: mgmt.how-we-work#R31
Rule 110
Our public material stays out of markets the owner excludes.
Not yet approved · Home: mgmt.how-we-work#R32 (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 (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 (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
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) |
| 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) |
| 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 |
| 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) |
| 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) |
| requirements specification | the one document that lists what a product must do and how well (page) |
| 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) |
| 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) |
| 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 — Open Government Licence v3.0. The two layers: short numbered points over detailed guidance. Accessed 2026-11-22.
- Basecamp, Shape Up — 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 — 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 — all rights reserved. One rules file that every AI agent reads. Accessed 2026-11-22.
- The /llms.txt file — all rights reserved. A small index of pages for AI agents, with Markdown copies. Accessed 2026-11-22.