architecting-systems
Guides clean, scalable system architecture during the build phase. Use when designing modules, defining boundaries, structuring…
Defines product features from a PM perspective (JTBD, competitive research, scope negotiation) before technical planning. Use when scoping features, writing product specs, defining user problems, or choosing what to build.
$ npx -y skills add rileyhilliard/claude-essentials --skill planning-products --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
/planning-productsContext preview
The summary Claude sees to decide when to auto-load this skill.
Defines product features from a PM perspective (JTBD, competitive research, scope negotiation) before technical planning. Use when scoping features, writing product specs, defining user problems, or choosing what to build.
name: planning-products description: Defines product features from a PM perspective (JTBD, competitive research, scope negotiation) before technical planning. Use when scoping features, writing product specs, defining user problems, or choosing what to build.
**Core principle:** Define the problem worth solving and the experience worth building before deciding how to build it. Research what exists, understand who needs it, scope what matters.
Load the relevant reference based on where you are in the planning process:
| Phase | Load | File | |-------|------|------| | Researching market, competitors, existing patterns | **Discovery** | `references/discovery.md` | | Framing the problem, users, and jobs to be done | **Definition** | `references/definition.md` | | Defining how the feature should feel (UX or DX) | **Experience** | `references/experience.md` | | Drawing scope boundaries, MVP, phasing | **Scoping** | `references/scoping.md` | | Writing the actual product spec document | **Template** | `references/feature-spec-template.md` |
Start with **Discovery** when beginning from scratch. Start with **Definition** when the problem is already understood. Load **Experience** alongside either when the feature has significant interaction design. Load **Scoping** when you need to cut.
---
Discovery → Definition → Experience → Scoping → [Hand off]
↓ ↓ ↓ ↓
Research Problem How it What's in
& patterns & users feels & what's outNot always linear. Discovery can reframe the problem. Experience constraints can force scope changes. Scoping can send you back to discovery. But this is the default order.
---
Different products need different emphasis. Adjust the planning weight:
| Product type | Heavy on | Light on | Key question | |-------------|----------|----------|--------------| | Consumer (B2C) | Experience, discovery | Formal definition | "Would I use this?" | | B2B / Enterprise | Definition, scoping | Visual polish | "Does this solve a workflow?" | | Developer tools | DX experience, API ergonomics | Marketing polish | "Is this the obvious API?" | | Internal tools | Scoping, definition | Discovery | "Does this save time?" | | Platform / API | Definition, experience (DX) | Consumer UX | "Is this composable?" |
---
You are not designing features. You are solving problems for specific people. If you can't name the person and their frustration, you're not ready to plan.
Before designing something new, find out what already exists. Users have expectations shaped by other products. Meeting those expectations is usually better than surprising people with novelty. Novelty costs learning; familiarity is free.
Frame decisions as hypotheses that could be wrong. "We believe [user] will [behavior] because [evidence]." If you can't state the evidence, it's a guess. Guesses are fine as long as you know they're guesses.
| Decision type | Characteristics | Planning rigor | |---------------|-----------------|----------------| | Type 1 (one-way door) | Hard to reverse, high switching cost | Full discovery + definition | | Type 2 (two-way door) | Easy to change, low cost to undo | Lightweight spec, ship and learn |
Most product decisions are Type 2. Don't over-plan reversible choices.
Every feature needs measurable success criteria before work begins. Not vanity metrics. Outcomes tied to the user problem you're solving.
| Bad metric | Good metric | |-----------|-------------| | "Page views" | "% of users who complete the core task" | | "API calls" | "Time to first successful integration" | | "DAU" | "Users who return within 7 days" |
---
| Pattern | Problem | |---------|---------| | Solution-first planning ("Let's build X") | Skips problem validation, builds the wrong thing | | Feature lists without user stories | No context for why, impossible to prioritize | | Copying competitors without understanding why | Imports their problems along with their solutions | | "Users" as a monolith (no persona distinction) | Different users need different things | | Scope that only grows, never shrinks | Ship date slides, value dilutes | | Planning without research | Invents patterns users already know differently | | Perfecting the spec before testing assumptions | Spec fiction, not product planning | | DX as afterthought ("devs will figure it out") | Developers are users too, bad DX kills adoption |
---
This skill's output feeds into other skills:
**Writing tone for specs and product docs:** Use `Skill(writer)` with The PM persona.
A unified development plugin for Claude Code with essential skills and specialized agents, all accessible under the ce namespace.
Guides clean, scalable system architecture during the build phase. Use when designing modules, defining boundaries, structuring…
Enforces precise, minimal design for dashboards and admin interfaces. Use when building SaaS UIs, data-heavy interfaces, or any…
Executes implementation plans directly with a verification gate and conditional code review. Use when carrying out a written plan…
Diagnose and fix tests that pass in isolation but fail when run concurrently. Covers shared state isolation, resource conflicts,…
Prevents silent failures and context loss in error handling. Use when writing try-catch blocks, designing error propagation,…
Guides database architecture for PostgreSQL, DuckDB, Parquet, PGVector, and Neo4j. Use when designing schemas, choosing storage…