tech-planning
/tech-planning
Planuje budowę produktu: plan techniczny z decyzjami, ryzykami i kamieniami milowymi, a potem zgłasza epic w Linear.
- Autor
- cdeweyx ↗
- Repozytorium
- conor-os ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 12.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 8
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Planuje budowę produktu: plan techniczny z decyzjami, ryzykami i kamieniami milowymi, a potem zgłasza epic w Linear.
Wyzwalacze z opisu
Oryginalny opis (EN)
Plans how a designed product gets built: a tech plan with decisions, risks and milestones, then the epic filed in Linear. Use when the design step is closed and the user says "tech plan", "tech planning", "how would we build this", "plan the build", "what's the stack", "architecture", "sequence the build", or "write the epic". Do NOT use for the product doc (product-shaping, product-doc), to design surfaces (design-shaping), or to run the build (build).
Jak działa
- Inputs
- The steps
- Rules that hold throughout
- Working with the user
- Checklist
Podgląd SKILL.md
---
name: tech-planning
description: >
Plans how a designed product gets built: a tech plan with decisions,
risks and milestones, then the epic filed in Linear. Use when the
design step is closed and the user says "tech plan", "tech planning",
"how would we build this", "plan the build", "what's the stack",
"architecture", "sequence the build", or "write the epic". Do NOT use
for the product doc (product-shaping, product-doc), to design
surfaces (design-shaping), or to run the build (build).
---
# Tech planning
The plan for a solo, agent-built product with a fixed design (greenfield in zero-to-one's Personal mode, on the running v1 in Go live) is two lists and an order: the one-way doors with the reasoning attached, and the checks the build agent can run, sequenced so milestone 0 puts the whole loop in front of the user rough before anything gets polished. Code is cheap now; what's expensive is a wrong one-way door and a milestone with no runnable check. The plan is read twice: once by the user, in one sitting, for the decisions, the open forks, the risks, and the milestones; then by a build session with no memory, which needs names and checks. Those two readers get two artifacts at two altitudes. The tech plan is the decision record and carries no file names. The epic is the build's input, a Linear project written only after the user's review, so it never carries an open decision.
Read `references/preferences.md` before the first question, `references/plan-template.md` before drafting, `references/spike.md` before proposing lanes, and `references/panel.md` before the lint and the critic rounds. Apply writing-style to anything the user reads.
## Inputs
The product doc end to end: goals, non-goals, overall shape, Solution Details per surface, both open-question lists (resolved and open), every appendix toggle, and the "for tech planning" toggle the design step left. The designs: DESIGN.md with its Brand section, the final artboards and their states, the motion spec, and the design skills' preferences and constraints files. Prior research, especially any stack or data lane. Read all of it before the first question; a plan that re-decides something the design settled costs a round.
## The steps
1. Read, then list the givens and the gaps. Open with a progress map. Givens are what the plan honors and can't re-decide: the surfaces and their states, the tokens, the metric order, every product call recorded as resolved. Gaps are what the plan has to decide and nobody wrote down: the open questions, the "for tech planning" items, and what neither doc says because the user can't see it from the UI (where history comes from, what a refresh runs, what a scheduled job needs). Show both lists in chat. A gap that isn't already a numbered open question gets proposed as one, with a proposed answer where there is one, and goes into the product doc's Open Questions on the user's yes, so the record shows what tech planning had to work out. Tag each gap as an interview question (the user can answer it) or a lane (nobody can yet). Any stack pick made before the design (a research lane's recommendation, a seed from the design step) is a candidate, never a given; a one-session prototype can overturn one. The product doc is too big to fetch per read, so dump it once per session to a file and slice it by heading. Skip test, for smaller work: if the diff fits in a sentence, say so and stop.
2. Constraints interview. Five questions only the user can answer, one at a time, each one a criterion the approaches get scored on later: where it has to run (does the scheduled job fire while the laptop is closed), the cost line (is $0 hard, or is $20 a month fine if it removes a risk), what must survive, asked as a capability rather than as data ("the ability to research and save recipes" reordered the milestones more than any data answer would have), the build and review loop (one feature per session, reviewed by clicking the app or by comments on the UI), and any dependency they'd rather pay for than trust. Don't ask about appetite: an agent build isn't budgeted in days, the plan builds the whole design and orders the milestones by risk, and effort is reported per milestone instead. Confirm back the goals and non-goals the plan honors in a few lines. Don't ask what the doc already says. An answer here is a criterion, not a vow: the review can reopen it once the risks are in front of the user (capture on demand became scheduled capture at review), and the plan should make that cheap.
3. Research spike. Generate the lanes from the givens and gaps with the walk in `references/spike.md`: walk the shape, walk the design, grade the stack (every frontend job on `references/libraries.md` starts from its pick), run the cross-cutting checklist, merge, add the three "why this fails in a month" questions. Four to seven lanes, each with the decision it feeds, that decision's reversibility, the verification rung it needs (doc, repo, probe, prototype), and a time budget. Preview the list and get a yes before spawning. One `researcher` agent per lane, in parallel (Model: researcher role). Probe first for anything runnable; a twenty-minute script retires a lane. Raw reports go to the project's research page the same day as numbered sub-pages, no yes needed. Stop when every decision has its rung and the top risk has a probe result; anything still unverified becomes an open question tagged with the rung it needs. Probes produce tests: every verified table is fixture material, and a probe can retire a constraint, not just a lane (data recoverable after the fact removed the cron). The lanes read one shared brief file rather than a long prompt each. Reports cite paths in backticks, never as links, and the numbering continues the project's one research sequence across pages.
4. Frame the decisions. Write the criteria before the options, weighted by what the product needs (engine correctness, fidelity to the design, solo iteration speed, the cost line, the checks each choice gives the agent), and show them. List every decision point, tag each one-way or two-way, and name the open question or surface it serves. One-way doors in a data product, hardest to reverse first: the ID scheme, the core table's grain, the format of what users create, what each computed number means, the storage layout. Two-way: the UI framework, the host, the notifier, the cron runner. Only one-way doors and forks with product or design implications get the full treatment; two-way doors get a line and a swap note.
5. Approaches. Three `planner` agents, each with a bias from `references/panel.md`, draft a whole-system approach from the same inputs and the same criteria (Model: planner role, bias set in the prompt). One agent asked for options produces one option and two straw men; three biased authors produce a real disagreement. The lead compares on the criteria, picks, writes the reasoning next to each decision, and records each loser as a rejected option (`references/plan-template.md`, Decision records). Design it twice at every one-way door even when the answer looks obvious. Keep the three runs: on the first plan they agreed on about 80% of the shape and disagreed on ten real forks, two of which no single planner would have raised. A planner reading every lane also catches what two lanes assumed differently (one lane said paths aren't drawn; the motion spec draws them), so the step doubles as a consistency check across the spike. The comparison record becomes an appendix toggle in the plan.
6. Draft. The `planner` writes the plan to the template (Model: planner role). Sections, in order: problem and link, constraints, scenarios, system context and data flow, components and what each requires, data model, decisions, risks, open questions, milestones, Public later (Personal mode), deliberately left out, how we'll know, appendix. Body under 2,500 words; the appendix is unbounded. One-way doors get full records in the body; two-way doors get one line each, with their full records in an appendix toggle (the first draft put all 27 records in the body and ran 6,300 words). Reasoning sits next to the decision it belongs to, never in a trailing alternatives section. Effort per milestone is S, M, L, or Spike, sized by sessions and the user's review minutes, tagged with its risk driver, and marked as the agent's read. No file names anywhere; files belong to the epic.
7. Lint. Before any critic, the mechanical pass in `references/panel.md`, which owns the list. Fix what fails; a critic scores what's there and can't see what's missing. Then the paraphrase gate in `references/panel.md`: one fresh critic restates the plan cold, and a wrong restatement means the plan gets fixed before any seat scores it.
8. Critic panel. Five seats with partitioned inputs (Model: critic role, so the critics run on a different model from the author). `references/panel.md` owns the seats, the critic prompt, the author verdicts, the rounds and the debate on forks. Critics never see prior scores, prior findings, or the author's reasoning. The lead, not the planner, writes a verdict per finding, then the planner applies them. Cap three rounds. Stop early when no blocking finding is unanswered and the median is 8 or better, or when a round moves the median under a point without producing a blocker; a round that holds the median but finds new blockers isn't done. A round-two critic re-flagging a round-one rejection is the stop signal, not a reopen. One toggle per round in the appendix, never edited after it closes.
9. The user's review. The plan in chat in the user's voice, scoped to the decisions, the open forks, the risks, and the milestones. Lead with the top risks, one plain sentence each, before the forks; a risk the user understands can change a constraint, and that's the point. Every change the user weighs comes with its blast radius: what it touches and what it doesn't. Forks as numbered questions, one at a time, each with the recommendation and the runner-up. Each answer is the push for that item. New open questions arrive with a proposed answer. Don't reopen a call the rounds already settled unless the user does.
10. Push and propagate. The plan as its own page, linked from the product doc's tech planning section, which carries a decisions toggle of one-line statements linked to the plan's records and a milestones toggle with the check per milestone. Open Questions refreshed from the freshly fetched doc: each one resolved with a dated answer, parked with the surviving goal and a revisit condition, or named in a milestone. The "for tech planning" toggle emptied into decision records. Synced copies swept (overall shape, the appendix, any spec line an answer touched). Notion toggles need their opening tag and summary on separate lines with a blank line after the summary, and every toggle closed; a page with no children can be replaced whole, which beats four inserts. Run the close checklist in `references/plan-template.md`.
11. The epic. After the review, draft the epic as a Linear project to "The epic" in `references/plan-template.md`, which holds the format: milestones, waves, each issue's brief, labels, how to file, and what stays in the repo. Linear becomes the build's only todo list. Plan milestones become project milestones in order; milestone 0 (`references/plan-template.md`, Milestones) runs alone before anything fans out; each issue is one PR and its body is its brief. A Large implementation issue can stay as the parent, but it's broken out into sub-issues as necessary, each one PR, so it never reaches the build as one piece of work; a Large design issue gets the same split once its design locks, before its build (build's Approach review). Before filing, one `critic` reads the plan and the epic draft together for the seams between issues (the seam read in `references/panel.md`; Model: critic role): mismatched interfaces, missing failure contracts, two issues in a wave owning one file. One pass, no score; the lead rules on each finding and fixes the briefs. Every milestone of an earlier build needed close issues for bugs where issues met, and a brief that names its seams is cheaper than a close issue. Then file it, and snapshot the milestones and issue titles into a toggle at the bottom of the tech plan as "what we thought the epic would be"; Linear is live and the snapshot isn't kept in sync.
12. Checkpoint (the procedure is authoring-skills' "Closing a skill update"). Keep a learnings log in memory from step 1 and append at every step; fold it after the user's review, not before. What the rounds changed about the process goes into this skill's body; a rejected finding that recurs across plans becomes a rule in `references/panel.md`; a prompt that produced a bad first pass goes into `references/failed-prompts.md`; the user's picks (a stack, a host, a scale) go into `references/preferences.md` so the next plan starts from them.
## Rules that hold throughout
- Reversibility sorts everything. Critic time, research rungs, and the user's attention go to one-way doors. Two-way doors get a line.
- The design is a spec, not a risk. Stack choices are judged by whether they render the surfaces and the motion at the cost line and by the checks they hand the agent (a type checker, a test runner, a browser). Well-represented ecosystems win; the agent builds worse in what it's read less of.
- The walking skeleton is the whole product loop, rough, not the scariest computation alone (`references/plan-template.md`, Milestones, defines milestone 0), so the user can iterate on the product before the polish and the forward ledger starts recording. The first run put the engine alone in milestone 0 and the loop seven milestones later, and at review the user asked to feel the loop first. Order the rest by risk after that.
- **Public later.** A plan for zero-to-one's Personal mode carries a Public later section: the seams that keep Go live from being a rewrite (an owner ID on every row a user owns, one auth boundary the lock sits behind, nothing hardcoded to the user, per-account limits in config rather than constants). Name the seams and build them in, with the value the owner ID holds before accounts exist; build none of Go live's features. **Go live's plan** starts from this section and the code on `main`, not a greenfield read. Its first milestone, its walking skeleton, is the user signing in with a real account and seeing their own data, lock still on. Its one-way doors are the data move (which account claims the user's rows, a backup and a rehearsed migration first, any move off single-instance storage), the account check replacing the lock's check on the same boundary, and billing. The lock comes off in its epic's last issue (zero-to-one, Go live's Build step). Its project numbers its own milestones from the start again, like any epic; its ledgers go under `docs/build/go-live/` so they don't collide with Personal's, and a lead names the project with the milestone ("run Go live M1").
- Statistical code fails silently. Any milestone with a numeric-correctness driver gets golden fixtures written before it, not after.
- Scale is rarely the risk on a single-user product; unattended operation is. Cron timing guarantees and free-tier cliffs are always a lane; performance is a lane only near a boundary, and a probe usually retires it.
- Self-review is worthless. Every vantage point on the plan is a fresh context with inputs the author didn't use.
- One home per question. The product doc gives a question its number and status; the plan quotes by number and topic and never renumbers. Answers flow spike to plan to doc, the doc's copy wins, and the user's yes is the push.
- The words are the user's: milestones and epic, not slices and execution plan. When a term doesn't land, rename it in the skill the same day.
- No process language. No owners, deadlines, approvers, or review meetings. The panel can't block; it can only make the user's read shorter.
- Issues cite each other by the tracker's keys once filed, never the plan's draft keys (S-4.3); a brief that points at a renamed key sends its implementer hunting. Every issue that builds a surface with no Final design gets the Design Needed label at filing.
- Real IDs (database, account, deploy URLs) are redacted from any live response quoted in research or plan docs before they're committed; the repo may go public, and history keeps them.
## Working with the user
- Preview lanes before they run. Show the criteria before the approaches. Show the plan before pushing it. Ask before the doc changes; push research the same day.
- Every recommendation comes with a runner-up and the reason each is where it is.
- Questions one at a time, numbered, in the user's words. Name calls by topic in chat, not by doc number; numbers move.
- When the user asks whether the skill ran, answer per step: which ran, which were skipped or reused, what closes the gap.
## Checklist
Only the things that have gone wrong.
- A stack pick from before the design was scored as a candidate, not carried in as a given.
- The body is under 2,500 words, two-way records sit in the appendix, and there are no file names.
- The first milestones put the whole loop in front of the user rough, not the engine alone.
- The lint and the paraphrase gate ran before round one, and the lead, not the planner, wrote the verdicts.
- The close checklist in `references/plan-template.md` ran before the epic.
- The seam read ran on the epic draft and every finding was ruled on before filing.
- Every issue has an effort label and a runnable check, and no surface that spans milestones leaves a dead control in the earlier one.
Pliki w paczce (8)
- SKILL.md 17 KB
- references/failed-prompts.md 1 KB
- references/learnings.md 1 KB
- references/libraries.md 6 KB
- references/panel.md 9 KB
- references/plan-template.md 15 KB
- references/preferences.md 1 KB
- references/spike.md 5 KB
Wersje
W bazie nie ma innych skilli o nazwie tech-planning.
Migawka bazy z 13.11.2026 · wersja paczki 7222cc472a5f (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100shape-epic
Kształtuje pomysł produktu w gotowy do budowy epic: problem, projekt, plasterki, testy, przewodnik i prompt dla tech leada. - 87build-epic
Buduje epik od briefu technicznego do testów wydania, prowadząc sesje w każdym repozytorium: plan do zatwierdzenia, historie po kolei i przegląd. - 100run
Prowadzi Epic Flow przez funkcje i etapy: od burzy mózgów po budowę i weryfikację, z jedną sesją pytań na początku i resztą bez nadzoru. - 100cds-linear-issue-shaping
Zamienia zatwierdzony plan w gotowe do Linear zgłoszenia z zależnościami, kryteriami akceptacji i kolejnością, aby plan stał się wykonywalną pracą w Linear. - 100product-shaping
Kształtuje produkt w trzech fazach: rama problemu, research i zwalidowana specyfikacja, a potem przekazuje opis do product-doc. - 100zero-to-one
Prowadzi produkt od badań po budowę i start, pilnując bramek między etapami w trybie osobistym i publicznym.