development-companion 1.2.1 → 1.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +39 -19
- package/RELEASE.md +7 -7
- package/adapters/README.md +7 -1
- package/adapters/opencode/README.md +7 -2
- package/core/principles.md +21 -0
- package/core/process.md +122 -158
- package/core/quality-gates.md +21 -13
- package/core/roles/team-lead.md +46 -29
- package/core/workflow.md +16 -3
- package/package.json +1 -1
- package/skills/architecture-design/SKILL.md +7 -0
- package/skills/delivery-orchestration/SKILL.md +65 -67
- package/skills/development-workflow/SKILL.md +2 -0
- package/skills/incremental-delivery/SKILL.md +116 -0
- package/skills/project-discovery/SKILL.md +23 -3
- package/skills/test-strategy/SKILL.md +7 -2
- package/skills/ux-design/SKILL.md +7 -2
- package/src/cli.mjs +57 -16
- package/src/content.mjs +1 -0
- package/src/install.mjs +30 -7
- package/src/rules.mjs +3 -1
- package/templates/artifacts/01-operational-brief.md +17 -3
- package/templates/artifacts/06-delivery-plan.md +26 -5
- package/templates/rules/AGENTS.block.md +34 -18
package/core/roles/team-lead.md
CHANGED
|
@@ -4,9 +4,9 @@
|
|
|
4
4
|
|
|
5
5
|
## Mission
|
|
6
6
|
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
7
|
+
Ship working increments. The user talks to you; you frame the smallest valuable slice, route
|
|
8
|
+
it to specialists, enforce the delivery gates, and report with evidence. You are accountable
|
|
9
|
+
for **code that lands**, not for the volume of documents produced.
|
|
10
10
|
|
|
11
11
|
## Use when
|
|
12
12
|
|
|
@@ -21,30 +21,38 @@ Do not use for a one-file fix or a routine review; handle those directly.
|
|
|
21
21
|
|
|
22
22
|
- The user's request and constraints.
|
|
23
23
|
- The repository and its conventions.
|
|
24
|
-
- Existing
|
|
24
|
+
- Existing notes, ADRs, or delivery documents.
|
|
25
25
|
- The branch convention and release process.
|
|
26
26
|
|
|
27
27
|
## Outputs
|
|
28
28
|
|
|
29
|
-
-
|
|
30
|
-
- `.companion/local/
|
|
31
|
-
- `.companion/local/
|
|
32
|
-
-
|
|
29
|
+
- A **running increment** in the repository (commit + tests + evidence).
|
|
30
|
+
- `.companion/local/01-operational-brief.md` — one page, first slice only.
|
|
31
|
+
- `.companion/local/06-delivery-plan.md` — first slice and next three, one page.
|
|
32
|
+
- `.companion/local/10-closure.md` — what shipped, what was deferred, evidence.
|
|
33
33
|
|
|
34
34
|
## Operating checklist
|
|
35
35
|
|
|
36
|
-
1. **
|
|
37
|
-
|
|
38
|
-
2. **
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
6. **
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
36
|
+
1. **Frame (≤ 1 work block)** — five questions: problem, first end-to-end slice, constraints,
|
|
37
|
+
non-goals, irreversible decisions. Write one page. Stop.
|
|
38
|
+
2. **Prove the path** — delegate a walking skeleton with fakes where needed. It must run with
|
|
39
|
+
one command and have one test. Commit.
|
|
40
|
+
3. **Slice loop** — pick the highest-risk or highest-value slice; one writer per slice; require
|
|
41
|
+
implementation, tests, and a demo.
|
|
42
|
+
4. **Verify** — security and QA review the slice, not a document. Read evidence, not summaries.
|
|
43
|
+
5. **Next slice** — only after the previous one is green and committed.
|
|
44
|
+
6. **Close** — what shipped, what was deferred, residual risk, next slice.
|
|
45
|
+
|
|
46
|
+
## Definition of progress
|
|
47
|
+
|
|
48
|
+
Progress is one of:
|
|
49
|
+
|
|
50
|
+
- a green build with a new end-to-end path;
|
|
51
|
+
- a merged slice with tests and a demo;
|
|
52
|
+
- a release artifact verified in the target.
|
|
53
|
+
|
|
54
|
+
A document is progress only when it unblocks a slice that is about to be built. Otherwise it
|
|
55
|
+
is inventory.
|
|
48
56
|
|
|
49
57
|
## Routing
|
|
50
58
|
|
|
@@ -68,25 +76,34 @@ Do not use for a one-file fix or a routine review; handle those directly.
|
|
|
68
76
|
- Do not design the architecture, implement features, run tests, or run shell commands.
|
|
69
77
|
- Do not edit code. Your only writable paths are `.companion/local/**` and
|
|
70
78
|
`docs/companion/**`.
|
|
71
|
-
- Do not claim a delegation you did not perform. A delegation is real only if
|
|
72
|
-
|
|
73
|
-
|
|
79
|
+
- Do not claim a delegation you did not perform. A delegation is real only if a native
|
|
80
|
+
delegation tool launched another agent; otherwise describe the work as a single-agent role
|
|
81
|
+
switch or manual handoff.
|
|
82
|
+
- **Do not spend more than one work block producing planning artifacts before the first
|
|
83
|
+
commit.**
|
|
84
|
+
- **Do not accept a child that returns only a document when code was requested.** Send it back
|
|
85
|
+
with a bounded instruction to implement.
|
|
86
|
+
- **Stop the line:** if two consecutive delegations produce no running code, stop and tell the
|
|
87
|
+
user what is blocking, with options.
|
|
74
88
|
- Do not expand scope silently; surface the trade-off.
|
|
75
89
|
- Do not accept a high-risk change without independent security and QA verification.
|
|
76
90
|
- Do not let two writers own the same files.
|
|
77
91
|
|
|
78
92
|
## Handoff
|
|
79
93
|
|
|
80
|
-
|
|
94
|
+
Where the harness supports native subagents, launch one with:
|
|
81
95
|
|
|
82
96
|
```markdown
|
|
83
97
|
**Role:** architect | cybersecurity | qa | frontend | backend | mobile | platform | sre
|
|
84
|
-
**Goal:**
|
|
98
|
+
**Goal:** the smallest shippable outcome
|
|
85
99
|
**Context:** files, decisions, constraints
|
|
86
|
-
**Deliverable:**
|
|
87
|
-
**
|
|
88
|
-
**
|
|
100
|
+
**Deliverable:** code + tests + evidence (not a document, unless explicitly requested)
|
|
101
|
+
**Slice:** what must work end-to-end when this returns
|
|
102
|
+
**Verification:** command to run and output to return
|
|
103
|
+
**Do not:** out-of-scope work, files to avoid, planning expansion
|
|
89
104
|
```
|
|
90
105
|
|
|
91
|
-
After the child returns, verify the evidence and either accept it or send a follow-up.
|
|
106
|
+
After the child returns, verify the evidence and either accept it or send a follow-up. Reject
|
|
107
|
+
"done" without a commit, a test, or a reproducible demo.
|
|
108
|
+
|
|
92
109
|
Close with the completion format in the `development-workflow` skill.
|
package/core/workflow.md
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# Development Workflow
|
|
2
2
|
|
|
3
|
-
This is the default path for an individual change
|
|
4
|
-
|
|
5
|
-
|
|
3
|
+
This is the default path for an individual change. For a new project, do **not** run the full
|
|
4
|
+
planning sequence first: frame the first slice in one page, build a walking skeleton, then use
|
|
5
|
+
this workflow per slice. See `core/process.md` and the `incremental-delivery` skill.
|
|
6
6
|
|
|
7
7
|
It scales with risk: a typo fix needs a short version; a cross-layer feature needs the full
|
|
8
8
|
version.
|
|
@@ -23,6 +23,19 @@ Identify the task type and the minimum rigor it needs.
|
|
|
23
23
|
If the task mixes types, split it. Do not ship a refactor and a behavior change in
|
|
24
24
|
the same unreviewable diff.
|
|
25
25
|
|
|
26
|
+
**First-commit rule:** for a new feature or project, create the thinnest runnable path before
|
|
27
|
+
expanding the design. A plan that does not produce a commit is not progress.
|
|
28
|
+
|
|
29
|
+
## Phase 0.5 — First commit
|
|
30
|
+
|
|
31
|
+
Before deep recon or a full plan, ask: *what is the smallest end-to-end path that can run?*
|
|
32
|
+
|
|
33
|
+
- Wire the real entry point to a fake or minimal implementation.
|
|
34
|
+
- Get one command and one test working.
|
|
35
|
+
- Commit.
|
|
36
|
+
|
|
37
|
+
Then use the rest of this workflow to deepen that path slice by slice.
|
|
38
|
+
|
|
26
39
|
## Phase 1 — Recon
|
|
27
40
|
|
|
28
41
|
Understand the system before proposing changes.
|
package/package.json
CHANGED
|
@@ -21,6 +21,13 @@ keep the domain independent, and record why.
|
|
|
21
21
|
|
|
22
22
|
Do not use for a local refactor that preserves boundaries.
|
|
23
23
|
|
|
24
|
+
## Minimum viable architecture
|
|
25
|
+
|
|
26
|
+
Architecture is validated by running code, not by review volume. Decide only what blocks the
|
|
27
|
+
next slice; defer reversible choices until a second adapter or a real constraint appears. Write
|
|
28
|
+
one-page ADRs. A second architecture cycle before the first commit is a red flag: build the
|
|
29
|
+
skeleton and let it falsify the design.
|
|
30
|
+
|
|
24
31
|
## Inputs
|
|
25
32
|
|
|
26
33
|
- The operational brief and success criteria.
|
|
@@ -1,119 +1,117 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: delivery-orchestration
|
|
3
|
-
description: Turn
|
|
3
|
+
description: Turn a goal into a sequence of working vertical slices with owners, WIP limits, and evidence. Use when coordinating multiple specialists, planning a milestone, or when a plan is growing faster than the code.
|
|
4
4
|
license: MIT
|
|
5
5
|
metadata:
|
|
6
|
-
version: "
|
|
6
|
+
version: "2.0.0"
|
|
7
7
|
author: development-companion
|
|
8
8
|
---
|
|
9
9
|
|
|
10
10
|
# Delivery Orchestration
|
|
11
11
|
|
|
12
|
-
The team lead routes work; specialists
|
|
13
|
-
|
|
12
|
+
The team lead routes work; specialists ship slices. A plan is useful only if every item produces
|
|
13
|
+
something that runs and can be verified.
|
|
14
|
+
|
|
15
|
+
**Planning is not progress.** A plan that keeps growing without a commit is a risk, not an asset.
|
|
14
16
|
|
|
15
17
|
## When to use
|
|
16
18
|
|
|
17
19
|
- A project or milestone has more than one workstream.
|
|
18
20
|
- Several agents or people will edit the repository.
|
|
19
21
|
- There are dependencies between frontend, backend, security, QA, and deployment.
|
|
20
|
-
- The
|
|
22
|
+
- The plan is longer than the code.
|
|
21
23
|
|
|
22
24
|
## Inputs
|
|
23
25
|
|
|
24
|
-
-
|
|
25
|
-
-
|
|
26
|
-
- Test plan and threat model.
|
|
26
|
+
- One-page operational brief with the first slice and acceptance criteria.
|
|
27
|
+
- The decisions that actually block the first slice.
|
|
27
28
|
- Branch convention and release process.
|
|
28
29
|
- Team capacity and deadlines.
|
|
29
30
|
|
|
30
31
|
## Procedure
|
|
31
32
|
|
|
32
|
-
### 1.
|
|
33
|
+
### 1. Define the first vertical slice
|
|
33
34
|
|
|
34
|
-
|
|
35
|
+
A slice goes from the user's entry point to an observable result:
|
|
35
36
|
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
- migration;
|
|
40
|
-
- test suite;
|
|
41
|
-
- security report;
|
|
42
|
-
- deployment recipe.
|
|
37
|
+
```text
|
|
38
|
+
input → process → output
|
|
39
|
+
```
|
|
43
40
|
|
|
44
|
-
|
|
41
|
+
It touches every layer needed for that result. "Finish the domain first" is not a slice.
|
|
45
42
|
|
|
46
|
-
|
|
43
|
+
For the first slice, prefer a fake or fixture over a real dependency. The goal is to prove the
|
|
44
|
+
path, not the integration.
|
|
47
45
|
|
|
48
|
-
|
|
49
|
-
- Read-only work can run in parallel.
|
|
50
|
-
- Write-heavy work is serialized unless the boundaries are explicit.
|
|
51
|
-
- The reviewer or QA does not edit the code they verify.
|
|
46
|
+
### 2. Set the WIP limit
|
|
52
47
|
|
|
53
|
-
|
|
48
|
+
- **One slice per writer.**
|
|
49
|
+
- Parallel work only for read-only tasks or slices that touch disjoint files.
|
|
50
|
+
- Do not start the second slice until the first is green, committed, and demoed.
|
|
54
51
|
|
|
55
|
-
|
|
52
|
+
### 3. Order by risk, not by layer
|
|
56
53
|
|
|
57
|
-
1.
|
|
58
|
-
2.
|
|
59
|
-
3.
|
|
60
|
-
4.
|
|
61
|
-
5. security and QA verification;
|
|
62
|
-
6. deployment and smoke tests.
|
|
54
|
+
1. The assumption most likely to kill the product.
|
|
55
|
+
2. The integration most likely to break.
|
|
56
|
+
3. The user-visible path that unlocks feedback.
|
|
57
|
+
4. Polish and edge cases.
|
|
63
58
|
|
|
64
|
-
|
|
59
|
+
### 4. Write a one-page plan
|
|
65
60
|
|
|
66
|
-
|
|
61
|
+
Only what the next three slices need:
|
|
67
62
|
|
|
68
|
-
|
|
69
|
-
|
|
63
|
+
| Slice | Owner | Observable result | Verification | Depends on |
|
|
64
|
+
|---|---|---|---|---|
|
|
70
65
|
|
|
71
|
-
|
|
66
|
+
No task without an observable result. No owner without a file boundary. No gate without evidence.
|
|
72
67
|
|
|
73
|
-
|
|
68
|
+
### 5. Delegate for code, not documents
|
|
74
69
|
|
|
75
|
-
|
|
76
|
-
- artifact;
|
|
77
|
-
- evidence required;
|
|
78
|
-
- who accepts it.
|
|
70
|
+
Every handoff asks for:
|
|
79
71
|
|
|
80
|
-
|
|
72
|
+
- the smallest shippable outcome;
|
|
73
|
+
- code + tests + a command to reproduce it;
|
|
74
|
+
- files the child owns and files it must not touch;
|
|
75
|
+
- the evidence to return.
|
|
81
76
|
|
|
82
|
-
|
|
77
|
+
Reject a child that returns only a document when code was requested.
|
|
83
78
|
|
|
84
|
-
|
|
79
|
+
### 6. Verify and close the slice
|
|
85
80
|
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
**Deliverable:** ...
|
|
91
|
-
**Verification:** ...
|
|
92
|
-
**Do not:** ...
|
|
93
|
-
```
|
|
81
|
+
- Run the command yourself or read its output.
|
|
82
|
+
- Confirm the acceptance criteria are covered.
|
|
83
|
+
- Commit.
|
|
84
|
+
- Record one line in the delivery log: slice, commit, tests, next.
|
|
94
85
|
|
|
95
|
-
### 7.
|
|
86
|
+
### 7. Re-plan only when reality changes
|
|
96
87
|
|
|
97
|
-
- Update the plan when
|
|
88
|
+
- Update the plan when a slice reveals a wrong assumption.
|
|
89
|
+
- Do not re-plan to avoid a hard decision.
|
|
98
90
|
- Surface scope growth before implementing it.
|
|
99
|
-
- Keep a short status: done, in progress, blocked, next.
|
|
100
91
|
|
|
101
92
|
## Output
|
|
102
93
|
|
|
103
|
-
`.companion/local/06-delivery-plan.md
|
|
94
|
+
`.companion/local/06-delivery-plan.md`, maximum one page for the first three slices:
|
|
104
95
|
|
|
105
|
-
-
|
|
106
|
-
- owners;
|
|
107
|
-
-
|
|
108
|
-
-
|
|
109
|
-
-
|
|
110
|
-
-
|
|
111
|
-
- status and next checkpoint.
|
|
96
|
+
- first slice and acceptance criteria;
|
|
97
|
+
- owners and file boundaries;
|
|
98
|
+
- WIP limit and parallel tracks;
|
|
99
|
+
- verification per slice;
|
|
100
|
+
- risks and blocked decisions;
|
|
101
|
+
- status: last commit, tests, next slice.
|
|
112
102
|
|
|
113
103
|
## Verification
|
|
114
104
|
|
|
115
|
-
- Every
|
|
105
|
+
- Every slice has an observable result and a verification.
|
|
106
|
+
- The first slice is end-to-end, not a layer.
|
|
107
|
+
- The WIP limit is explicit.
|
|
116
108
|
- No two writers own the same files.
|
|
117
|
-
- The
|
|
118
|
-
|
|
119
|
-
-
|
|
109
|
+
- The plan fits on one page; if it does not, the scope is too broad.
|
|
110
|
+
|
|
111
|
+
## Anti-patterns
|
|
112
|
+
|
|
113
|
+
- **Horizontal plan:** domain, then API, then UI, then integration.
|
|
114
|
+
- **Planning loop:** a second plan before the first commit.
|
|
115
|
+
- **Ownerless work:** "the team" owns it, so nobody does.
|
|
116
|
+
- **Gate theater:** a phase marked done because its document exists.
|
|
117
|
+
- **Silent parallelism:** two writers on the same files.
|
|
@@ -146,6 +146,7 @@ Do not continue past these without clarification:
|
|
|
146
146
|
- Security, accessibility, and performance considered from the start.
|
|
147
147
|
- No secrets, debug output, or unrelated changes.
|
|
148
148
|
- Honest reporting of residual risk.
|
|
149
|
+
- A running increment or a named blocker. Documents alone are not delivery.
|
|
149
150
|
|
|
150
151
|
## Anti-patterns
|
|
151
152
|
|
|
@@ -156,3 +157,4 @@ Do not continue past these without clarification:
|
|
|
156
157
|
- Running tests but not reading the failures.
|
|
157
158
|
- Claiming completion from memory instead of evidence.
|
|
158
159
|
- Expanding scope without telling the user.
|
|
160
|
+
- Producing documents when the user asked for implementation.
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
---
|
|
2
|
+
name: incremental-delivery
|
|
3
|
+
description: Ship a working vertical slice instead of expanding the plan. Use when planning is growing faster than the code, when a project has documents but no running increment, or when a milestone needs to be cut into end-to-end slices.
|
|
4
|
+
license: MIT
|
|
5
|
+
metadata:
|
|
6
|
+
version: "1.0.0"
|
|
7
|
+
author: development-companion
|
|
8
|
+
---
|
|
9
|
+
|
|
10
|
+
# Incremental Delivery
|
|
11
|
+
|
|
12
|
+
The failure mode this skill prevents: a project that has produced a stack of design documents
|
|
13
|
+
and still cannot be run. Planning feels like progress because it is easy to produce and hard
|
|
14
|
+
to falsify. Code is the opposite. Prefer the thing that can be falsified.
|
|
15
|
+
|
|
16
|
+
## When to use
|
|
17
|
+
|
|
18
|
+
- The plan is longer than the code.
|
|
19
|
+
- A milestone has many artifacts and no demo.
|
|
20
|
+
- Two consecutive sessions produced documents but no commit.
|
|
21
|
+
- A new feature is described as "the whole module" instead of one visible path.
|
|
22
|
+
- The user says "stop planning, start building".
|
|
23
|
+
|
|
24
|
+
## The rule
|
|
25
|
+
|
|
26
|
+
> **One slice at a time, end-to-end, running, tested, committed.**
|
|
27
|
+
|
|
28
|
+
A slice is vertical: it touches every layer needed to produce one visible result. It is not
|
|
29
|
+
"the domain layer" or "the API".
|
|
30
|
+
|
|
31
|
+
## Procedure
|
|
32
|
+
|
|
33
|
+
### 1. Cut the thinnest end-to-end slice
|
|
34
|
+
|
|
35
|
+
Start from the user's entry point and stop at the first observable result:
|
|
36
|
+
|
|
37
|
+
```text
|
|
38
|
+
input → process → output
|
|
39
|
+
```
|
|
40
|
+
|
|
41
|
+
Examples:
|
|
42
|
+
|
|
43
|
+
- "Create a meeting from a fixture WAV and see a fake summary."
|
|
44
|
+
- "Record 10 seconds on the watch and see the file on the phone."
|
|
45
|
+
- "Load the meeting list from the database and open a detail screen."
|
|
46
|
+
|
|
47
|
+
If the slice needs a real model, a real service, or a full schema to be visible, replace it
|
|
48
|
+
with a fake or a fixture. Fakes are allowed in the skeleton; they are not allowed to become
|
|
49
|
+
the product.
|
|
50
|
+
|
|
51
|
+
### 2. Freeze the contract for the slice
|
|
52
|
+
|
|
53
|
+
Write only the interfaces and types the slice needs. Defer the rest. A contract that is not
|
|
54
|
+
used by running code is a guess.
|
|
55
|
+
|
|
56
|
+
### 3. Build in one pass
|
|
57
|
+
|
|
58
|
+
- Implement the smallest path.
|
|
59
|
+
- Add one test that proves it.
|
|
60
|
+
- Run it with one command.
|
|
61
|
+
- Commit.
|
|
62
|
+
|
|
63
|
+
No design system, no exhaustive error matrix, no performance tuning yet.
|
|
64
|
+
|
|
65
|
+
### 4. Demo and decide
|
|
66
|
+
|
|
67
|
+
Record the command and output. Then choose the next slice by risk:
|
|
68
|
+
|
|
69
|
+
1. The assumption most likely to kill the product.
|
|
70
|
+
2. The integration most likely to break.
|
|
71
|
+
3. The user-visible path that unlocks feedback.
|
|
72
|
+
|
|
73
|
+
### 5. Expand just in time
|
|
74
|
+
|
|
75
|
+
Add depth only when the slice demands it:
|
|
76
|
+
|
|
77
|
+
- error states when a failure is observed;
|
|
78
|
+
- architecture when a second adapter appears;
|
|
79
|
+
- abstractions when the third duplication appears;
|
|
80
|
+
- documentation when a decision becomes non-obvious.
|
|
81
|
+
|
|
82
|
+
## Planning budget
|
|
83
|
+
|
|
84
|
+
- Frame: 30–60 minutes, one page.
|
|
85
|
+
- Before the first running slice: ≤ 10–15 % of total effort.
|
|
86
|
+
- Any document that does not unblock the next slice is deferred.
|
|
87
|
+
- If a planning artifact exceeds two pages before the first commit, cut it.
|
|
88
|
+
|
|
89
|
+
## Definition of done for a slice
|
|
90
|
+
|
|
91
|
+
- [ ] It runs end-to-end.
|
|
92
|
+
- [ ] One command reproduces it.
|
|
93
|
+
- [ ] At least one automated test covers the path.
|
|
94
|
+
- [ ] It is committed.
|
|
95
|
+
- [ ] The demo is recorded (command output, screenshot, or request/response).
|
|
96
|
+
- [ ] Deferred work is written down, not silently dropped.
|
|
97
|
+
|
|
98
|
+
## Anti-patterns
|
|
99
|
+
|
|
100
|
+
- **Planning loop:** another discovery/architecture/UX cycle before the first commit.
|
|
101
|
+
- **Horizontal slicing:** "finish the domain first", "finish the schema first".
|
|
102
|
+
- **Fake as product:** the skeleton's fake survives into release without a decision.
|
|
103
|
+
- **Hidden integration:** every layer is "done" but nothing runs together.
|
|
104
|
+
- **Scope creep disguised as quality:** polishing a slice before proving the next one.
|
|
105
|
+
- **Documentation theater:** a 40-page spec for a 2-day slice.
|
|
106
|
+
|
|
107
|
+
## Escalation
|
|
108
|
+
|
|
109
|
+
If the slice cannot be cut small enough, say so with options:
|
|
110
|
+
|
|
111
|
+
- reduce scope;
|
|
112
|
+
- accept a fake for one dependency;
|
|
113
|
+
- split into two slices;
|
|
114
|
+
- stop and ask the user for a decision.
|
|
115
|
+
|
|
116
|
+
Do not respond to a blocked slice by writing more plan.
|
|
@@ -22,6 +22,15 @@ right problem with the right constraints. Ask before building.
|
|
|
22
22
|
For a small change inside a known system, use the short brief in
|
|
23
23
|
`development-workflow` instead.
|
|
24
24
|
|
|
25
|
+
## Timebox and stop rule
|
|
26
|
+
|
|
27
|
+
Discovery has a budget: **30–60 minutes and one page** in the first pass. Stop asking when the
|
|
28
|
+
first end-to-end slice and its acceptance criteria are defined and no blocking constraint is
|
|
29
|
+
open. Defer everything else to the slice that needs it.
|
|
30
|
+
|
|
31
|
+
Do not write a 500-line brief before the first commit. If the brief keeps growing, the slice is
|
|
32
|
+
too broad: cut it.
|
|
33
|
+
|
|
25
34
|
## Inputs
|
|
26
35
|
|
|
27
36
|
- The user's idea, goals, and constraints.
|
|
@@ -93,14 +102,25 @@ Write `.companion/local/01-operational-brief.md` with:
|
|
|
93
102
|
|
|
94
103
|
## Problem and users
|
|
95
104
|
## Goals and success metrics
|
|
96
|
-
##
|
|
97
|
-
|
|
105
|
+
## First end-to-end slice
|
|
106
|
+
- Input:
|
|
107
|
+
- Process:
|
|
108
|
+
- Observable output:
|
|
109
|
+
- Acceptance criteria:
|
|
110
|
+
## Scope
|
|
111
|
+
### In scope
|
|
112
|
+
### Out of scope
|
|
98
113
|
## Constraints
|
|
114
|
+
## Existing artifacts
|
|
99
115
|
## Hosting and third parties
|
|
100
|
-
## Data and
|
|
116
|
+
## Data and privacy
|
|
117
|
+
## Authentication and authorization
|
|
101
118
|
## Platforms
|
|
102
119
|
## Branch convention
|
|
103
120
|
## Definition of done
|
|
121
|
+
## Planning budget
|
|
122
|
+
- Time spent:
|
|
123
|
+
- Deferred decisions and the slice that will unblock them:
|
|
104
124
|
## Open questions
|
|
105
125
|
```
|
|
106
126
|
|
|
@@ -9,8 +9,13 @@ metadata:
|
|
|
9
9
|
|
|
10
10
|
# Test Strategy
|
|
11
11
|
|
|
12
|
-
QA enters
|
|
13
|
-
how it will be proven.
|
|
12
|
+
QA enters with the first slice, not after the whole plan. The test plan is a living contract for
|
|
13
|
+
what "working" means and how it will be proven.
|
|
14
|
+
|
|
15
|
+
## First tests before the full plan
|
|
16
|
+
|
|
17
|
+
Do not write a 300-line test plan before the first commit. Define the **first five tests** that
|
|
18
|
+
prove the walking skeleton and the riskiest failure path. Expand the plan as slices land.
|
|
14
19
|
|
|
15
20
|
## When to use
|
|
16
21
|
|
|
@@ -9,8 +9,13 @@ metadata:
|
|
|
9
9
|
|
|
10
10
|
# UX Design
|
|
11
11
|
|
|
12
|
-
The user approves the experience
|
|
13
|
-
|
|
12
|
+
The user approves the experience per slice. Design is validated with flows, states, and
|
|
13
|
+
screenshots, not with adjectives.
|
|
14
|
+
|
|
15
|
+
## Design the next screen, not the whole app
|
|
16
|
+
|
|
17
|
+
Design only the surfaces needed for the next slice. Reuse patterns; defer the design system until
|
|
18
|
+
the third repetition. Approval is per slice, not a one-time gate for every future screen.
|
|
14
19
|
|
|
15
20
|
## When to use
|
|
16
21
|
|