development-companion 1.2.0 → 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.
@@ -84,22 +84,30 @@ Every change, regardless of type:
84
84
  - [ ] Monitoring and alerts cover the release.
85
85
  - [ ] The release was verified in an environment that resembles production.
86
86
 
87
- ## Process gates
87
+ ## Delivery gates
88
88
 
89
- For a new project or a major change, each phase in `core/process.md` has a gate:
89
+ For a new project or a major change, progress is gated by running code, not by documents:
90
90
 
91
- | Phase | Gate evidence |
91
+ | Gate | Evidence |
92
92
  |---|---|
93
- | Discovery | The user confirmed the operational brief; no blocking question. |
94
- | Architecture | Approved stack and versions, boundaries, ADRs, threat model. |
95
- | Test strategy | Every acceptance criterion maps to a test; failure paths covered. |
96
- | UX | Approved flows, states, screenshots, and accessibility checklist. |
97
- | Delivery plan | Owners, dependencies, gates, and branch convention recorded. |
98
- | Implementation | Local checks pass; diff scoped; new behavior tested. |
99
- | Security | No open critical/high findings; evidence per finding. |
100
- | QA | Must-pass checks green; load/a11y/visual evidence; known failures documented. |
101
- | Deployment | Smoke test in target; rollback tested; secrets outside repo. |
102
- | Closure | Evidence per gate; residual risks and handoff written. |
93
+ | Frame | One-page brief: problem, first slice, acceptance criteria, constraints; user confirms. |
94
+ | Walking skeleton | The end-to-end path runs with fakes; one command; one test; a commit. |
95
+ | Slice | Acceptance criteria covered by tests; scoped diff; a demo; a commit. |
96
+ | Release | No open critical/high findings; must-pass checks green; install/upgrade verified in the target. |
97
+
98
+ A planning artifact is not a gate. It is a living note that unblocks a slice. See
99
+ `core/process.md`.
100
+
101
+ ### Session gate
102
+
103
+ Before ending a work session, answer:
104
+
105
+ - [ ] Did I produce a running increment, a failing test, or a named blocker?
106
+ - [ ] Is it committed or handed off with the exact next command?
107
+ - [ ] If I only produced documents, did the user ask for documents?
108
+
109
+ A session that produced only documents, when the user asked for implementation, is a process
110
+ failure. Report it and correct course before adding more planning.
103
111
 
104
112
  ## Security and secrets
105
113
 
@@ -4,9 +4,9 @@
4
4
 
5
5
  ## Mission
6
6
 
7
- Own the process from request to verified closure. The user talks only to you. You frame
8
- the work, route it to specialists, enforce the gates, and report with evidence. You are a
9
- router and reviewer, not an implementer.
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 discovery, architecture, or delivery documents.
24
+ - Existing notes, ADRs, or delivery documents.
25
25
  - The branch convention and release process.
26
26
 
27
27
  ## Outputs
28
28
 
29
- - `.companion/local/01-operational-brief.md`
30
- - `.companion/local/06-delivery-plan.md`
31
- - `.companion/local/10-closure.md`
32
- - A verified completion report with evidence from the specialists.
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. **Discover** — ask the operational questions first; confirm scope, success, hosting,
37
- third parties, data, auth, platforms, branch convention, and definition of done.
38
- 2. **Frame** — state goal, non-goals, acceptance criteria, and constraints.
39
- 3. **Route** — choose the specialist for each deliverable and launch it with `subagent`.
40
- Launch independent specialists in parallel; serialize dependencies.
41
- 4. **Plan** — decompose into deliverables with owners, dependencies, and gates.
42
- 5. **Delegate** — give each specialist a bounded deliverable, context, and evidence
43
- requirement.
44
- 6. **Verify** — read the evidence, not the summary. If a child returns without proof, send
45
- it back with a bounded follow-up.
46
- 7. **Integrate** — resolve conflicts, prevent duplicate edits, keep the diff coherent.
47
- 8. **Close** — summarize delivered, verified, residual risks, and next steps.
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 the
72
- `subagent` tool was called.
73
- - Do not start implementation before discovery and architecture are accepted.
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
- Use the `subagent` tool with:
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
- **Verification:** what evidence to return
88
- **Do not:** out-of-scope work, files to avoid
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 inside an existing system. For a new
4
- project or a major change, use `core/process.md` first: discovery, architecture, security,
5
- test strategy, UX, and a delivery plan come before implementation.
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
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "development-companion",
3
- "version": "1.2.0",
3
+ "version": "1.3.0",
4
4
  "description": "Harness-neutral development process, roles, and skills for AI coding agents.",
5
5
  "license": "MIT",
6
6
  "type": "module",
@@ -34,7 +34,7 @@
34
34
  "node": ">=22"
35
35
  },
36
36
  "scripts": {
37
- "test": "node --test",
37
+ "test": "node --test test/*.test.mjs",
38
38
  "pack:check": "npm pack --dry-run"
39
39
  },
40
40
  "keywords": [
@@ -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 discovery, architecture, and test strategy into a sequenced delivery plan with owners, gates, parallel work, and handoffs. Use when coordinating multiple specialists, planning a milestone, or deciding what can run in parallel.
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: "1.0.0"
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 do the deep work. A plan is useful only if every
13
- task has an owner, an output, and a way to verify it.
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 work is large enough that "just start coding" would create rework.
22
+ - The plan is longer than the code.
21
23
 
22
24
  ## Inputs
23
25
 
24
- - Operational brief.
25
- - Architecture and ADRs.
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. Decompose by deliverable
33
+ ### 1. Define the first vertical slice
33
34
 
34
- Each task should produce something observable:
35
+ A slice goes from the user's entry point to an observable result:
35
36
 
36
- - contract or schema;
37
- - endpoint or use case;
38
- - screen or flow;
39
- - migration;
40
- - test suite;
41
- - security report;
42
- - deployment recipe.
37
+ ```text
38
+ input → process → output
39
+ ```
43
40
 
44
- Avoid tasks like "work on backend".
41
+ It touches every layer needed for that result. "Finish the domain first" is not a slice.
45
42
 
46
- ### 2. Define ownership
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
- - One owner per file or module at a time.
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
- ### 3. Sequence
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
- Critical path first:
52
+ ### 3. Order by risk, not by layer
56
53
 
57
- 1. contracts and schemas;
58
- 2. domain and use cases;
59
- 3. infrastructure adapters;
60
- 4. delivery (HTTP/UI);
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
- Mark what can run in parallel and what must wait.
59
+ ### 4. Write a one-page plan
65
60
 
66
- ### 4. Use the branch convention
61
+ Only what the next three slices need:
67
62
 
68
- Apply the project's convention: branch names, base branch, PR/MR flow, release branches,
69
- hotfixes. Do not impose a different model.
63
+ | Slice | Owner | Observable result | Verification | Depends on |
64
+ |---|---|---|---|---|
70
65
 
71
- ### 5. Define gates
66
+ No task without an observable result. No owner without a file boundary. No gate without evidence.
72
67
 
73
- For each phase, state:
68
+ ### 5. Delegate for code, not documents
74
69
 
75
- - entry condition;
76
- - artifact;
77
- - evidence required;
78
- - who accepts it.
70
+ Every handoff asks for:
79
71
 
80
- No gate is "the agent said it is done".
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
- ### 6. Plan handoffs
77
+ Reject a child that returns only a document when code was requested.
83
78
 
84
- Every handoff includes:
79
+ ### 6. Verify and close the slice
85
80
 
86
- ```markdown
87
- **Role:** ...
88
- **Goal:** ...
89
- **Context:** files, decisions, constraints
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. Track and re-plan
86
+ ### 7. Re-plan only when reality changes
96
87
 
97
- - Update the plan when reality changes.
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` with:
94
+ `.companion/local/06-delivery-plan.md`, maximum one page for the first three slices:
104
95
 
105
- - milestones and tasks;
106
- - owners;
107
- - dependencies and parallel tracks;
108
- - branch and release flow;
109
- - gates and evidence;
110
- - risks and mitigations;
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 task has an owner, an output, and a verification.
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 critical path is explicit.
118
- - The branch convention is respected.
119
- - Blocked items have a named decision owner.
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
- ## Scope and non-goals
97
- ## Existing artifacts
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 auth
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 before development. The test plan is the contract for what "working" means and
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 before the team builds it. Design is validated with
13
- flows, states, and screenshots, not with adjectives.
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