jettypod 4.4.115 → 4.4.118

package/skills-templates/project-discovery/SKILL.md

@@ -1,372 +0,0 @@
----
-name: project-discovery
-description: "Guide new project planning from blank slate to epics. Auto-activates when project has no implementation code. Walks user through journey exploration, UX approach selection, optional prototyping, epic breakdown, and tech stack selection."
----
-
-# Project Discovery Skill
-
-Guides users through planning a new project from blank slate to epics. Auto-activates when a blank project (no implementation code) is detected.
-
-## Instructions
-
-When this skill is activated, you are guiding a user through planning a brand new project. Follow this structured approach:
-
-### Step 1: Check for Resume (Checkpoint)
-
-**First, check if there's an existing checkpoint** from a previous session:
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  const data = checkpoint.getCheckpoint();
-  if (data && data.step > 1) {
-    // Resume from checkpoint - display resume message
-    const resumeMessage = checkpoint.generateResumeMessage(data);
-    console.log(resumeMessage);
-    // Then skip to appropriate step based on data.step
-  }
-} catch (e) {
-  // No checkpoint - start fresh
-}
-```
-
-**If resuming from checkpoint:**
-
-Use `generateResumeMessage(checkpoint)` from `lib/discovery-checkpoint.js` to display:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔄 RESUMING PROJECT DISCOVERY
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📍 Resuming from Step [step]: [step description]
-
-📝 User Journey: "[user_journey]"      (if exists)
-🎨 UX Approach: "[ux_approach]"        (if exists)
-✅ Epics: Already created              (if epics_created)
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Continuing where you left off...
-```
-
-Then skip to the appropriate step based on `checkpoint.step`.
-
-**If starting fresh:** Continue to Step 2.
-
----
-
-### Step 2: Greet and Explore User Goal
-
-**Your FIRST words to the user must be:**
-
-> 👋 Hey there. It looks like you're kicking off a new project. I'm going to use JettyPod to guide you through building and shipping high quality code.
->
-> And FYI, JettyPod is fully set up in your project for all future Claude Code sessions.
->
-> **Ready to do this?**
-
-**WAIT FOR USER RESPONSE.**
-
-After they respond affirmatively, continue with:
-
-> Awesome!
->
-> Here is how we are going to kick things off:
->
-> 1. I'll help you explore some prototypes to define what users actually do in your product
-> 2. We'll choose a tech stack that fits
-> 3. I'll break the project into phases so you have a clear plan
->
-> Let's start simple: What do users DO in this product? Walk me through it.
->
-> If that's not clear yet, what are you trying to help them accomplish?
-
-**WAIT FOR USER RESPONSE.**
-
----
-
-### Step 3: Explore User Journey
-
-After user responds with their goal, ask about the user journey:
-
-> Do you have a clear picture of how users will accomplish this? Like, what's the flow from opening your product to getting value from it?
->
-> If yes, walk me through it. If not, I can suggest some user journey ideas based on what you've described.
-
-**If user wants journey suggestions, present exactly 3 journey options:**
-
-```
-Here are 3 different ways users could accomplish [their goal]:
-
-**Journey Option 1: [Simple/Direct approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - fast, familiar, low friction]
-- **Cons**: ❌ [2-3 trade-offs - limitations, constraints]
-
-**Journey Option 2: [Balanced approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - good balance]
-- **Cons**: ❌ [2-3 trade-offs]
-
-**Journey Option 3: [Advanced/Guided approach name]**
-- **Flow**: [Step-by-step user actions]
-- **Pros**: ✅ [2-3 advantages - powerful, guided]
-- **Cons**: ❌ [2-3 trade-offs - complexity, learning curve]
-
-**Additional journey patterns considered:**
-- *Alternative 1*: [Brief] - Not recommended because [reason]
-- *Alternative 2*: [Brief] - Not recommended because [reason]
-
-Which journey resonates with you? Or do you want to describe your own?
-```
-
-**WAIT FOR USER RESPONSE.**
-
-**After user picks/describes journey, save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(2, { user_journey: "[their chosen/described journey]" });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 4: Explore UX Approach
-
-**Present exactly 3 UX approaches** (NOT tech stacks - focus on what it FEELS LIKE to use):
-
-Adapt to their workflow. Example patterns:
-- Command-Line Workflow vs Visual Dashboard vs Conversational AI
-- Template Selection vs Drag-and-Drop Editor vs Code-First
-- Linear Document vs Networked Notes vs Canvas-Based
-
-```
-**Option 1: [Simple approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Option 2: [Balanced approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Option 3: [Advanced approach]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **Experience**: [What it feels like to use]
-
-**Additional approaches considered but not recommended:**
-- *Alternative 1*: [Brief] - Not selected because [reason]
-- *Alternative 2*: [Brief] - Not selected because [reason]
-- *Alternative 3*: [Brief] - Not selected because [reason]
-
-**Would you like me to create working prototypes of these experiences?**
-```
-
-**WAIT FOR USER RESPONSE.**
-
----
-
-### Step 4B: Optional Prototyping
-
-**If user wants prototypes:**
-
-For each prototype approach, run:
-```bash
-jettypod project prototype start <approach-name>
-```
-
-This creates a worktree at `.jettypod-work/project-prototype-<approach>/`. Build the prototype using **absolute paths**:
-- `<worktree_path>/prototypes/<approach>/` for prototype files
-- Focus on demonstrating the FEEL, not production code
-- Use whatever tech is FASTEST to show the experience
-
-After building, commit and merge:
-```bash
-cd <worktree_path>
-git add .
-git commit -m "Add project prototype: <approach>"
-jettypod project prototype merge
-```
-
-Repeat for each approach. Each merge lands the prototype on main in `/prototypes/`.
-
-**After building prototypes, offer to open them:**
-
-> Want me to open these in your browser so you can try them out?
-
-If yes, use: `open prototypes/<approach>/index.html`
-
-**After ANY prototype modifications or tweaks, always ask:**
-
-> Got it - I've updated the prototype.
->
-> Do you feel like you have enough clarity on the basic user journey now? Like, do you know what users will DO to get value from this?
->
-> If yes, let's break this down into phases and start building the real thing.
-> If no, what else do you want to explore with the prototype?
-
-**Important:** Prototypes are for learning and answering questions, not for building production features. Don't let users iterate endlessly - help them move forward once they have clarity on the user journey.
-
----
-
-### Step 5: Epic Breakdown
-
-**After user picks UX approach winner, save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(4, { ux_approach: "[chosen option]" });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
-**Propose epic breakdown:**
-
-> Based on what you described, here's how I'd break this into epics.
->
-> **Quick context:** Epics are phase-level chunks of work that each contain several features. For example, an epic might be "User Authentication" which includes features like "Email/password login", "Password reset", and "Social login".
->
-> Here's what I'm thinking:
->
-> **Epic 1: [Name]** - [What it covers - specific capabilities]
-> **Epic 2: [Name]** - [What it covers]
-> **Epic 3: [Name]** - [What it covers]
->
-> Sound right?
-
-**WAIT FOR USER RESPONSE.**
-
-After user confirms (with any adjustments), create the epics:
-
-```bash
-jettypod work create epic "[Epic Name]" "[Description]"
-```
-
-After creating all epics, display:
-
-> ✅ Epics created and added to your backlog.
-
-**Save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(5, { epics_created: true });
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 6: Tech Stack Selection
-
-**Present exactly 3 tech stack options** appropriate for the UX approach they chose:
-
-```
-Now let's pick the tech stack. Based on [their chosen UX approach], here are 3 options:
-
-**Option 1: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages - why this is good for their use case]
-- **Cons**: ❌ [2-3 trade-offs - limitations or costs]
-- **What you'll get**: [What development will feel like, deployment complexity, learning curve]
-
-**Option 2: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **What you'll get**: [Development experience, deployment, learning curve]
-
-**Option 3: [Tech stack name]**
-- **Pros**: ✅ [2-3 advantages]
-- **Cons**: ❌ [2-3 trade-offs]
-- **What you'll get**: [Development experience, deployment, learning curve]
-
-**Other options considered:**
-- *Alternative 1*: [Brief] - Not recommended because [reason]
-- *Alternative 2*: [Brief] - Not recommended because [reason]
-
-Which tech stack fits best for you?
-```
-
-**Important:** If they're building a web application, use shadcn/ui as the default component library (don't ask - just use it when building UI).
-
-**WAIT FOR USER RESPONSE.**
-
-**Save checkpoint:**
-
-```javascript
-try {
-  const checkpoint = require('./lib/discovery-checkpoint');
-  checkpoint.updateCheckpoint(6, {});
-} catch (e) {
-  // Checkpoint module optional - skip if not available
-}
-```
-
----
-
-### Step 7: Confirm Rationale and Complete Discovery
-
-**Propose the rationale to the user first:**
-
-> I'm going to record this decision:
->
-> Winner: prototypes/[path]
-> Rationale: [experience] with [tech] because [reason]
->
-> Does this capture why you chose this approach? (You can edit the rationale if needed)
-
-**WAIT FOR USER RESPONSE.**
-
-**After user confirms, record the decision:**
-
-```bash
-jettypod project discover complete --winner="prototypes/[path]" --rationale="[user's confirmed/edited rationale]"
-```
-
----
-
-### Step 8: Educational Transition
-
-**After recording decision, provide this educational transition:**
-
-> 🎉 Project discovery complete! You've got your epics defined and we know what we're building.
->
-> **Here's how we'll build this, one piece at a time:**
->
-> We're entering a repeatable workflow that you'll use for the rest of this project. Think of it like Russian nesting dolls:
->
-> 📦 **Epic** = A big capability (like "User Authentication" or "Real-time Collaboration")
->   └─ ✨ **Feature** = Something users actually do (like "Email/password login" or "Live cursor tracking")
->       └─ 🔧 **Chore** = Technical tasks to build that feature (like "Create login form" or "Hash passwords")
->
-> **Two phases for everything you build:**
->
-> 1️⃣ **Discovery Phase** - Figure out what to build
->    - We'll explore 2-3 different approaches
->    - You pick the winner
->    - We write test scenarios
->    - **You only do this once per feature**
->
-> 2️⃣ **Implementation Phase** - Build it in 3 modes
->    - **Speed Mode**: Prove it works (happy path only, ~2 hours)
->    - **Stable Mode**: Make it dependable (error handling, edge cases - this is where features live)
->    - **Production Mode**: Safe for customers (security, scale, compliance - only needed if customers use it)
->
-> **We won't talk about modes yet** - you'll learn those when you start implementing. Right now, focus on discovery.
->
-> **Next step: Plan your first epic**
->
-> Pick one epic to start with (usually the foundational one). Then tell me:
-> "Let's plan [epic name]"
-
-**Discovery is complete.** Wait for user to choose which epic to plan next.