elliot-stack 1.0.6 → 1.0.8

package/bin/install.cjs

@@ -350,7 +350,7 @@ async function main() {
   for (const name of skillNames) {
     if (modifiedSkills.includes(name)) {
       if (modifiedAction === 'skip') {
-        console.log('  Skipped estack-' + name + ' (local modifications preserved)');
+        console.log('  Skipped ' + name + ' (local modifications preserved)');
         const currentHash = computeSkillHash(path.join(SKILLS_DIR, name));
         if (currentHash) newChecksums[name] = currentHash;
         continue;
@@ -358,7 +358,7 @@ async function main() {
       if (modifiedAction === 'merge') {
         backupSkill(name);
         mergedSkills.push(name);
-        console.log('  Backed up estack-' + name + ' → ~/.claude/.estack-backup/' + name);
+        console.log('  Backed up ' + name + ' → ~/.claude/.estack-backup/' + name);
       }
       // overwrite or merge — fall through to install
     } else if (!needsUpdate.includes(name) && fs.existsSync(path.join(SKILLS_DIR, name))) {
@@ -368,7 +368,7 @@ async function main() {
     copyDir(path.join(PACKAGE_SKILLS_DIR, name), path.join(SKILLS_DIR, name));
     newChecksums[name] = packageHashes[name];
     installedCount++;
-    console.log('  Installed estack-' + name);
+    console.log('  Installed ' + name);
   }
 
   // 9. Write checksums
@@ -384,7 +384,7 @@ async function main() {
 
   for (const name of skillNames) {
     const desc = getSkillDescription(path.join(PACKAGE_SKILLS_DIR, name));
-    console.log('  /estack-' + name + (desc ? ' — ' + desc : ''));
+    console.log('  /' + name + (desc ? ' — ' + desc : ''));
   }
 
   if (mergedSkills.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elliot-stack",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Elliot's skill stack for Claude Code — install via npx elliot-stack@latest",
   "bin": {
     "elliot-stack": "bin/install.cjs"

package/skills/estack-better-title/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: better-title
+name: estack-better-title
 description: Suggest better chat session titles and rename the session
 disable-model-invocation: true
 allowed-tools: Bash, AskUserQuestion

package/skills/estack-chris-voss/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: chris-voss
+name: estack-chris-voss
 description: >
   Applies Chris Voss negotiation principles from *Never Split the Difference* to any situation
   where understanding human psychology, persuasion, or influence would improve the output. Use

package/skills/estack-customer-discovery/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: customer-discovery
+description: Guide users through customer discovery — validating business ideas, identifying target customers, crafting outreach, preparing interview questions, and analyzing interview results. Use this skill whenever the user mentions customer discovery, customer interviews, validating an idea, market research, finding product-market fit, talking to customers, outreach messages, interview guides, or analyzing customer feedback. Also use when someone says they have a business idea and want to test it, or when they're preparing to talk to potential customers.
+---
+
+# Customer Discovery
+
+This skill guides users through the full customer discovery process, or any specific part of it. Customer discovery is a detective exercise — you're confirming or denying assumptions, not selling or pitching.
+
+## The flow
+
+There are 4 steps. Each builds on the last, but the user can jump to any step directly.
+
+1. **Strategy & Targeting** — Define who you're talking to, what you're testing, and why. Map assumptions, define customer segments, frame the job-to-be-done.
+2. **Outreach** — Craft messages that get people to say yes to a conversation. Warm intros first, then cold outreach using proven formulas.
+3. **Interview Execution** — Build a tailored interview guide with the right questions (behavioral, story-eliciting) and avoid the wrong ones (speculative, leading). Prepare to run great interviews.
+4. **Analysis & Signals** — Make sense of what you heard. Spot patterns, rank problems, identify progression signals, and decide what to do next.
+
+## How to use this skill
+
+### Step 1: Figure out what the user needs
+
+Ask the user: do they want to go through the full flow, or do they need help with a specific step?
+
+If they describe their situation without picking a step, route them based on where they are:
+- Have an idea but haven't talked to anyone yet → Start at **Step 1: Strategy & Targeting**
+- Know who to talk to but need help reaching out → **Step 2: Outreach**
+- Have interviews scheduled but need questions → **Step 3: Interview Execution**
+- Have done interviews and need to make sense of them → **Step 4: Analysis & Signals**
+
+### Step 2: Read the right step file
+
+Each step has its own workflow file with detailed instructions. Read the one you need:
+
+- **Step 1: Strategy & Targeting** → Read `steps/step-1-strategy.md`
+- **Step 2: Outreach** → Read `steps/step-2-outreach.md`
+- **Step 3: Interview Execution** → Read `steps/step-3-interviews.md`
+- **Step 4: Analysis & Signals** → Read `steps/step-4-analysis.md`
+
+The step file will tell you to also read the corresponding reference document. The reference docs are the source of truth — they contain the principles and frameworks. The step files tell you how to work through them with the user.
+
+### Step 3: Be adaptive
+
+Read the room. If the user clearly knows what they're doing, don't over-explain. If they're new to this, coach them. Adjust your depth and pacing based on how they talk about their idea.
+
+### Step 4: Offer deliverables
+
+At the end of each step, offer to produce a written summary the user can reference later. Don't force it — some users just want the conversation.
+
+### Step 5: Continue the flow
+
+After completing a step, offer to continue to the next one by name (e.g., "Would you like to continue to **Step 3: Interview Execution**?"). Never reference a step by number alone — always include the name so the user knows what it covers. If the user jumped into a specific step, still offer the next step — they might want to keep going.

package/skills/estack-customer-discovery/references/01-strategy-and-targeting.md

@@ -0,0 +1,125 @@
+# Customer Discovery: Strategy & Targeting
+
+## The mindset
+
+Customer discovery is a detective exercise. You're confirming or denying your assumptions. You're not selling, not pitching, not asking customers to design your product. You're there to learn.
+
+Fall in love with the problem, not the solution.
+
+Every business is a stack of assumptions. Your job is to test the high-impact, high-uncertainty ones before investing heavily.
+
+You're an intelligent filter, not an order-taker. Discovery informs decisions, it doesn't make them. Vision still leads.
+
+Don't talk to anyone with a pulse. Target the specific customer you think has the problem.
+
+Everyone on the team should talk to customers. Not just the designer or the founder.
+
+## The 4 reasons companies buy
+
+Every B2B purchase maps to one of these:
+- Make money
+- Save money
+- Gain competitive advantage
+- Avoid compliance or risk
+
+Map every pain point you hear to one of these. If it doesn't tie to one, the purchase is unlikely.
+
+## Map your assumptions first
+
+Answer these before you interview anyone:
+- Who is my target customer?
+- What problem do they want to solve?
+- Why can't they solve it today?
+- What measurable outcome do they want?
+- Who is my earliest adopter?
+- How will I acquire customers?
+- How will I make money?
+- Who is my primary competition and why will I beat them?
+- What assumption, if proven wrong, would kill this?
+
+Mark the ones that are both high-impact and highly uncertain. Those are your interview priorities.
+
+## Define your customer segment
+
+"Everyone" is not a customer. Get specific: job, role, mindset, context.
+
+Not "marketing managers." Try "marketing managers at 50–200 person B2B SaaS companies who own the content pipeline and report to the VP of Marketing."
+
+Pick one narrow segment and one specific job to solve first.
+
+Define three audiences:
+1. Typical customer at scale (who you'll serve once you're big)
+2. Early adopter (feels the pain acutely, loves trying new things, interview first)
+3. Critical distribution or fulfillment partners
+
+## B2B buyer landscape
+
+Map every role involved in the purchase:
+- **User**: who actually uses the product
+- **Buyer**: who signs the contract
+- **Payer**: who controls the budget
+- **Technical buyer**: who evaluates fit
+- **Economic buyer**: who approves the spend
+- **Strategic buyer**: who owns the outcome
+- **Influencer / recommender**: who shapes the decision
+
+Start with mid-level managers, not C-suite. Easier access, more conversations, and you'll be better educated before going up the chain. Influencers and recommenders are especially valuable because they connect you to more customers.
+
+## Jobs-to-be-done framing
+
+Define the job as the specific problem they're trying to solve in a specific situation.
+
+Include three layers:
+- Functional needs (what they need to get done)
+- Emotional needs (how they want to feel)
+- Social needs (how they want to be seen)
+
+Describe the problem in the customer's own words, not founder language. Pull phrasing from forums, Reddit, and actual conversations.
+
+## Validating the problem
+
+The problem needs to be:
+- **Important** to the customer
+- **Unsatisfied** by current options
+- **High-value** enough that they'd pay for a better solution
+
+If any of the three fails, it's not worth solving first.
+
+Identify what they do today instead of your solution. Existing alternatives matter. DIY workarounds are strong signals of real need.
+
+Distinguish primary from secondary problems. Solve the pain that matters most.
+
+## Finding interview subjects
+
+Three rules:
+1. One degree of separation. Don't interview close friends or family.
+2. Be creative. Don't expect people to come to you.
+3. Fish where the fish are. If a tactic isn't working, switch immediately.
+
+Tactics:
+- End every interview with a goal of 2–3 new referrals
+- LinkedIn search by title, reach out via referral or cold
+- Call the CEO's office, ask the EA for "the person who handles X." They route you. Then name-drop the CEO's office in follow-up.
+- Find people at their moment of pain (conferences, relevant forums, events)
+- At conferences: ask for time after, not during. Follow up while memory is fresh.
+- You're a student. Say so. It's an advantage. Offer to share research results.
+- Start with warm intros before cold outreach. Always exhaust that first.
+
+Default to asking for advice early on. "I'm not selling anything, I just want 20 minutes." People like being asked. It makes them feel important.
+
+## No surveys. Period.
+
+Don't use surveys. Not for discovery, not for recruiting, not for screening.
+
+Why:
+- You need the customer's exact words, context, workflow, and emotions
+- Early-stage discovery is about uncovering the real problem, not confirming your assumptions
+- Conversations let you probe, clarify, and discover unexpected needs
+- Surveys flatten nuance and kill follow-up
+- They're noisy and usually poorly designed
+- Stronger proof points come from hearing pain, dissatisfaction with current alternatives, and actual purchase intent directly
+
+The right path:
+- Use quick research or LLMs to learn the space
+- Do primary research through live customer conversations
+- Document pain points and proof points in their own words

package/skills/estack-customer-discovery/references/02-outreach.md

@@ -0,0 +1,71 @@
+# Customer Discovery: Outreach
+
+Cold outreach fails because it reads like outreach. Yours needs to feel like a human asking a human for a small favor.
+
+One rule above all: be completely honest about who you are and why you're reaching out. Nothing here is about tricking anyone. It's about removing friction so the right people say yes.
+
+## Warm intros first. Always.
+
+A mutual connection asking on your behalf will always outperform cold. Exhaust warm intros before sending a single cold message.
+
+If you're not finding people, it's rarely "I don't know how." It's usually fear of rejection in disguise. Send more messages. Faster.
+
+## The 2-sentence formula
+
+Two sentences. That's it.
+
+**Sentence 1: Their job to be done.**
+Lead with a specific problem they likely deal with. Not your idea. Not your product. Make it relatable enough that they instantly recognize it. Hint at the problem, don't explain your solution.
+
+**Sentence 2: The honest ask.**
+Say exactly who you are and what you want. Ask for a specific time, not "sometime next week."
+
+No-oriented close: "Would it be crazy to ask for 15 minutes tomorrow at 3pm?"
+
+On LinkedIn you have 300 characters. Use every technique that fits.
+
+## Example outreach
+
+**Simple version:**
+
+> I'm working to better understand how software sales leaders handle pricing when customer value varies so much across deals. Could you do a 15-minute call tomorrow at 6pm to share how you approach it?
+
+**Stacked version (LinkedIn note, 300 chars):**
+
+> Hi Kendall. I'm a student at Purdue researching marketing workflows at B2B companies for a concept competition. Exploring AI's impact on team workflows.
+>
+> I ONLY need 10 interviews by Friday to move on to the next phase!
+>
+> Would it be crazy to ask for 15 minutes of your time?
+>
+> \- Elliot
+
+This converted at 10%. 1 in 10 cold strangers agreed to a call.
+
+## The 12 tricks that make it work
+
+1. **Lead with their world.** Open with a problem they recognize, not a pitch they have to decode.
+2. **Zero threat.** "Student" + "concept competition" signals nothing is for sale. Guard drops immediately.
+3. **Complete honesty.** Be upfront about who you are and what you want. People respond to realness.
+4. **Tiny ask.** 15 minutes doesn't feel like a decision.
+5. **Specific time.** "Tomorrow at 6pm" creates urgency. "Sometime next week" gets ignored.
+6. **Scarcity.** A cap + deadline makes them feel like a limited slot, not one of a thousand targets.
+7. **Hard deadline.** "By Friday" forces action now. Later always becomes never.
+8. **Visual interrupt.** Capitalizing ONLY pulls the eye straight to the scarcity line.
+9. **No-oriented close.** Saying no means agreeing it's crazy. Path of least resistance is yes.
+10. **Curiosity gap.** Specific enough to be relevant, vague enough that they want to know more.
+11. **Human format.** First-name opener, personal sign-off. No links, no title.
+12. **No pitch.** No ask to buy, no demo, no product link. Pure curiosity.
+
+## What to avoid
+
+- Long paragraphs
+- Leading with features or your product concept
+- Multiple value props crammed in
+- Vague asks like "sometime next week"
+- Anything misleading about who you are
+- Framing that looks like sales
+
+## Keep testing
+
+Test lots of versions. Tone, opening line, specific time, deadline. Small tweaks move conversion more than you'd expect.

package/skills/estack-customer-discovery/references/03-interview-execution.md

@@ -0,0 +1,98 @@
+# Customer Discovery: Interview Execution
+
+## Prepare an interview guide
+
+Always write one. It's a guide, not a script. Veer off when something interesting comes up.
+
+Structure:
+- Brief intro explaining purpose
+- 1–2 warm-up questions
+- Story-eliciting behavioral questions
+- Drill-down follow-ups
+- Close: "What should I have asked you that I didn't?"
+
+Set pass/fail metric targets before you start. Know what you're hoping to see. Write it down.
+
+Don't wing it. No prepared, prioritized questions = wasted conversation.
+
+Don't try to learn everything in one session. Go deep on a few areas instead.
+
+## Format priorities
+
+In-person is best. Video is second. Phone is last resort. Never text or email.
+
+One person at a time. No focus groups. Group think contaminates answers.
+
+Bring a note taker if possible. Stay present during the conversation. If you're solo, write notes immediately after. Detail fades fast.
+
+## The most important rule: stories, not speculation
+
+Humans are terrible at predicting their own behavior. "Would you use this?" and "Would you buy this?" answers are weak on their own.
+
+Ask about the past instead:
+- "Tell me about the last time you..."
+- "Walk me through how you..."
+- "What triggered your search for a solution?"
+- "What happened after you tried it?"
+
+Past behavior is the strongest predictor of future behavior.
+
+## Ask open-ended questions
+
+Start with: who, what, why, how.
+
+Avoid: is, are, would, do you.
+
+Don't rush to fill silence. Let them sit. Gold comes out in the pause.
+
+## Drill down relentlessly
+
+Whenever something tweaks your antenna, go deeper. Multiple layers of "why."
+
+Parrot back what they said. They'll either correct your misinterpretation or refine their own thinking.
+
+## Look for solution hacks
+
+If someone has DIY-solved the problem or cobbled together a workaround, that's one of the strongest market-need signals you can get. Nobody builds workarounds for problems they don't feel.
+
+## Test for priority
+
+Even if the problem exists, it needs to be acute enough to change behavior and justify payment.
+
+Ask where it ranks in their list of problems. Ask what they're spending time on this week vs. this. If the pain isn't top-5, it's probably not getting solved.
+
+## Pricing questions
+
+Speculative pricing is unreliable. "Would you pay $X?" answers mean almost nothing on their own.
+
+Better:
+- Ask what they currently spend to address this problem
+- Ask what budget exists and who controls it
+- Create situations where they think they're actually buying. People only honestly consider willingness to pay when it feels like a real transaction.
+
+## Handling prototypes
+
+If you're showing something:
+- Behavior questions first, product feedback second. People love talking features and it'll contaminate their stories.
+- Explicitly ask for brutal honesty upfront
+- Don't trust verbal "I like it." Watch behavior. Try to get them to open their wallet.
+
+## Disarm your own bias
+
+Go in ready to hear things you don't want to hear.
+
+Adopt a "try to kill the idea" mindset for interviews. It works.
+
+A dedicated note-taker helps. Interviewers filter for what they believe. Note-takers catch what you miss.
+
+Don't lead the witness. Don't embed the answer in how you ask.
+
+Don't pitch. Don't hear only what you want to hear. Don't treat one conversation as truth.
+
+## Close every interview with this
+
+"What should I have asked you that I didn't?"
+
+Then: "Who else should I talk to?"
+
+Goal: 2–3 referrals per conversation.

package/skills/estack-customer-discovery/references/04-analysis-and-signals.md

@@ -0,0 +1,143 @@
+# Customer Discovery: Analysis & Signals
+
+## How to take notes
+
+Top of every note doc:
+- Subject name
+- Date
+- Interviewer(s)
+- Format (in-person, video, phone)
+- Photo if possible
+- Brief descriptive info about the subject
+
+Capture direct quotes and the story. Not your interpretations.
+
+## Convert notes to metrics
+
+Calculate percentages across interviews. Numbers fight cognitive bias.
+
+Don't obsess over single numbers. Don't treat qualitative results as statistical fact. Keep questioning what's behind the numbers.
+
+## Dump and sort exercise
+
+Team exercise, 10 minutes:
+1. Everyone writes patterns they noticed on sticky notes
+2. Put them on a wall
+3. Sort into groups
+4. Discuss what clusters and what doesn't
+5. Re-review assumptions. See what needs to change.
+
+Do this every 5–10 interviews.
+
+## Pattern recognition thresholds
+
+A clear pattern across 5–10 people is a signal.
+
+Even 5 consistent responses can reveal a valid pattern if the responses are tight.
+
+Don't overreact to one conversation. Don't wait for statistical significance either. Move fast from credible patterns. Analysis paralysis is the enemy.
+
+## Stickiness as a signal
+
+The strongest signal isn't "they liked it." It's whether they'd be genuinely upset if the product disappeared.
+
+If you could yank it away and they wouldn't care, you don't have stickiness yet. Keep digging for what would actually hurt them to lose.
+
+Don't stop at "they liked it." Identify the specific value they got and why they care.
+
+## Progression signals to watch for
+
+Signal gets stronger at each step:
+1. They describe the pain clearly and unprompted
+2. They say they'd buy a solution
+3. They ask how to buy it now
+
+Level 3 is gold. Level 2 counts. Level 1 alone isn't enough.
+
+Also strong:
+- They've DIY-hacked their own solution
+- They're currently paying for a partial workaround
+- They can tell you their existing budget and who controls it
+
+## The Truth Curve
+
+Each level yields more reliable truth, at higher cost:
+1. Conversations
+2. Paper test (landing page, deck, concept test)
+3. Prototype
+4. Live product (real behavior, real money)
+
+Start at the cheap end. Build confidence iteratively. Concierge or Wizard-of-Oz experiments (manually faking the product) beat interviews because you watch actual behavior.
+
+## Interview count target
+
+**Goal: 10–20 interviews.**
+
+Patterns often show up fast. Even 5 consistent responses can reveal a signal. Top student teams typically talk to 20–30.
+
+If you hit 20 without patterns emerging, your segment or hypothesis is probably off. Rethink before interviewing more.
+
+## Primary vs secondary problems
+
+Not every problem you hear is the one you should solve.
+
+After interviews, force-rank the problems by:
+- How often they came up
+- How intense the emotion was
+- How willing people were to act on them
+- How much money or time they were already spending
+
+Solve the #1 problem. Don't get distracted by #3.
+
+## Before vs after lens
+
+For each problem you might solve, sketch:
+- What does the customer's world look like today?
+- What does it look like after your solution exists?
+- What specifically changes: cost, revenue, time, trust, peace of mind, compliance risk?
+
+Quantify wherever possible. Is your solution 1% better, 50% better, 3x better, 10x better? Aim for multiples, not percentages.
+
+## Real user vs real decision-maker
+
+These are often different people.
+
+The user feels the pain. The decision-maker signs off.
+
+Map both. Interview both if you can. A product users love but economic buyers won't approve doesn't ship.
+
+## Confidence vs impact framework
+
+After patterns emerge, list every assumption left.
+
+Rank them on two axes:
+- How confident are you? (low to high)
+- How badly does the business hurt if you're wrong? (low to high)
+
+Test low-confidence, high-impact first. Those are your biggest risks.
+
+Apply this across the whole model: customer segment, value prop, channels, revenue, costs, differentiation, success metrics.
+
+## False positives
+
+People want to be nice. Weight positive reactions with skepticism.
+
+"I love it" means nothing without behavior to back it up.
+
+Watch what they do, not what they say.
+
+## When to transition from discovery to selling
+
+**Trigger: you start hearing the exact same thing, interview after interview.**
+
+That's pattern saturation. Shift from discovery to offering a solution. Start testing whether it's burning pain they'll pay to solve or mild discomfort they'll live with.
+
+Don't wait for a perfect sample size. Hit the trigger, move.
+
+## You're never fully done
+
+Customer discovery is ongoing. Qualitative research is permanent in good companies.
+
+When patterns flatten, evolve what you're exploring. The questions change. The cadence shouldn't stop.
+
+Worst thing you can do: stop talking to customers after week one.

package/skills/estack-customer-discovery/steps/step-1-strategy.md

@@ -0,0 +1,78 @@
+# Step 1: Strategy & Targeting
+
+## Before anything else
+
+Read `references/01-strategy-and-targeting.md` in the skill directory. That's your source of truth for this step. Internalize it before working with the user.
+
+## What this step accomplishes
+
+Help the user get clear on who they're talking to, what they're testing, and what assumptions carry the most risk. By the end, they should have a sharp customer segment, a clear job-to-be-done, and a prioritized list of assumptions to test in interviews.
+
+## How to work through this with the user
+
+### Understand their idea
+
+Start by asking the user to describe their business idea or problem in plain language. Don't let them pitch you — ask them to tell you who has the problem and why it matters. Listen for whether they're talking about a real person or a vague abstraction.
+
+If they say something like "everyone could use this" or "any business would want this," that's your signal to push for specificity. Help them narrow down.
+
+### Map assumptions
+
+Walk the user through the assumption-mapping questions from the reference doc. These are the big ones:
+
+- Who is your target customer?
+- What problem do they want to solve?
+- Why can't they solve it today?
+- What measurable outcome do they want?
+- Who is your earliest adopter?
+- How will you acquire customers?
+- How will you make money?
+- Who is your primary competition and why will you beat them?
+- What assumption, if proven wrong, would kill this?
+
+Help them answer each one. When they're done, flag which assumptions are both high-impact AND highly uncertain — those become interview priorities.
+
+### Define the customer segment
+
+Push them to get specific. Not "marketing managers" — try "marketing managers at 50-200 person B2B SaaS companies who own the content pipeline and report to the VP of Marketing."
+
+Help them define three audiences:
+1. Typical customer at scale
+2. Early adopter (feels the pain acutely, interview first)
+3. Critical distribution or fulfillment partners
+
+### Frame the job-to-be-done
+
+Help them articulate the specific problem their customer is trying to solve, in a specific situation. Include:
+- Functional needs (what they need to get done)
+- Emotional needs (how they want to feel)
+- Social needs (how they want to be seen)
+
+Use the customer's language, not founder language. If the user is using jargon their customer wouldn't use, flag it.
+
+### Check problem validity
+
+Run the problem through the three-part test:
+- Is it important to the customer?
+- Is it unsatisfied by current options?
+- Is it high-value enough that they'd pay for a better solution?
+
+If any of these fail, flag it honestly. Also identify what the customer does today instead — existing alternatives and DIY workarounds are strong signals.
+
+## Deliverable
+
+Offer to produce a **Discovery Strategy Brief** — a single document the user can reference throughout their entire discovery process. This is the foundation everything else builds on.
+
+The brief should include:
+- **Assumption map:** All 9 questions answered, with each marked as confirmed / uncertain / high-risk. Highlight the high-impact + high-uncertainty ones — these drive the interviews.
+- **Customer segment definition:** The specific person they're targeting (not generic). Include typical customer, early adopter, and distribution partners if applicable.
+- **Job-to-be-done statement:** The specific problem, in the customer's language, covering functional, emotional, and social needs.
+- **Buyer landscape:** Who's involved in the purchase decision (if B2B) — user, buyer, payer, influencer, etc.
+- **Interview priorities:** The top 3-5 assumptions to test first, ranked by risk.
+- **Current alternatives:** What customers do today instead, including DIY workarounds.
+
+Write this as a clean, scannable document the user can share with teammates or refer back to before every interview.
+
+## Next step
+
+When this step is done, offer to continue to **Step 2: Outreach** — crafting messages to reach the people they've just identified.

package/skills/estack-customer-discovery/steps/step-2-outreach.md

@@ -0,0 +1,69 @@
+# Step 2: Outreach
+
+## Before anything else
+
+Read `references/02-outreach.md` in the skill directory. That's your source of truth for this step.
+
+## What this step accomplishes
+
+Help the user craft outreach messages that actually get responses. By the end, they should have ready-to-send messages — warm intro asks, cold outreach, and LinkedIn variants if needed.
+
+## How to work through this with the user
+
+### Start with warm intros
+
+Before touching cold outreach, ask: who do they already know that could introduce them to their target customer? A mutual connection asking on their behalf will always outperform cold. Help them think through their network — friends, classmates, coworkers, LinkedIn connections, advisors.
+
+If they're hesitant, name it: hesitation to reach out is usually fear of rejection in disguise. The fix is sending more messages, faster.
+
+### Understand their context
+
+Before writing messages, ask:
+- Who specifically are they reaching out to? (title, company type, context)
+- What's the problem they want to discuss? (from **Step 1: Strategy & Targeting** if they did it)
+- What's their angle? (student, founder, researcher — this shapes how they position themselves)
+- What platform? (LinkedIn, email, Twitter DM, etc.)
+
+### Craft outreach using the 2-sentence formula
+
+Build messages using the formula from the reference:
+- **Sentence 1:** Their job to be done. Lead with a problem they recognize.
+- **Sentence 2:** The honest ask. Say who you are and what you want. Ask for a specific time.
+
+Apply the relevant tricks from the reference (no-oriented close, scarcity, specific time, tiny ask, etc.) — but don't force all 12 into every message. Pick what fits naturally.
+
+Generate 2-3 variants so the user can pick and test.
+
+### LinkedIn version
+
+If they're using LinkedIn, create a version under 300 characters. Every word counts.
+
+### Review together
+
+Show the messages and briefly explain which techniques are at play and why. Let the user adjust tone, details, and anything that doesn't sound like them. The message has to feel authentic — if it reads like outreach, it won't work.
+
+### Flag what to avoid
+
+If the user's draft or instinct includes any of these, flag it:
+- Long paragraphs
+- Leading with features or their product concept
+- Vague asks like "sometime next week"
+- Anything that looks like sales
+- Multiple value props crammed in
+
+## Deliverable
+
+Offer to produce an **Outreach Playbook** — a ready-to-use document with every message the user needs to start booking interviews.
+
+The playbook should include:
+- **Warm intro request template:** A message the user can send to mutual connections asking for an introduction. Should explain who they want to talk to and why, making it easy for the connector to forward.
+- **Cold outreach messages:** 2-3 variants using the 2-sentence formula, each with a slightly different angle or tone so the user can A/B test.
+- **LinkedIn connection note:** A sub-300-character version optimized for the LinkedIn character limit (if applicable).
+- **Follow-up message:** A short, non-pushy follow-up for people who don't respond to the first message.
+- **Technique annotations:** Brief notes on which of the 12 tricks are at play in each message, so the user understands why they work and can adapt them for future outreach.
+
+Write the messages ready to copy-paste — the user should be able to send them within minutes of reading the playbook.
+
+## Next step
+
+When this step is done, offer to continue to **Step 3: Interview Execution** — building a tailored interview guide with the right questions.

package/skills/estack-customer-discovery/steps/step-3-interviews.md

@@ -0,0 +1,87 @@
+# Step 3: Interview Execution
+
+## Before anything else
+
+Read `references/03-interview-execution.md` in the skill directory. That's your source of truth for this step.
+
+## What this step accomplishes
+
+Help the user build a tailored interview guide with the right questions and protect them from the wrong ones. By the end, they should have a guide they can walk into an interview with — structured, behavioral, and bias-aware.
+
+## How to work through this with the user
+
+### Clarify what they're testing
+
+Ask what assumptions or questions they want to answer through these interviews. If they did **Step 1: Strategy & Targeting**, pull from their high-priority assumptions. If they didn't, help them articulate what they need to learn before building anything.
+
+Remind them: don't try to learn everything in one interview. Pick 2-3 areas to go deep on.
+
+### Build the interview guide
+
+Generate a structured guide with these sections:
+
+1. **Brief intro** — who you are, why you're here, how long it'll take. Set the tone: "I'm not selling anything, I just want to learn."
+2. **1-2 warm-up questions** — easy, low-stakes questions to get them talking.
+3. **Story-eliciting behavioral questions** — the core. These should start with "Tell me about the last time you..." or "Walk me through how you..." or "What happened when..."
+4. **Drill-down follow-ups** — ready-made probes for when something interesting comes up. "Why was that?" "What happened next?" "How did that make you feel?"
+5. **Closing** — "What should I have asked you that I didn't?" Then: "Who else should I talk to?" Goal: 2-3 referrals.
+
+### The right questions vs. the wrong questions
+
+This is the core value of this step. Actively protect the user from bad questions.
+
+**Wrong questions (flag and replace these):**
+- "Would you use this?" — speculative, unreliable
+- "Do you think this is a good idea?" — people are polite, they'll say yes
+- "Would you pay $X for this?" — hypothetical pricing is meaningless
+- "Do you like [feature]?" — feature feedback before behavior questions contaminates everything
+- Any yes/no question — kills conversation depth
+- Any question that starts with "Is," "Are," "Would," or "Do you" — usually closed-ended
+
+**Right questions (use these patterns):**
+- "Tell me about the last time you [dealt with this problem]..."
+- "Walk me through how you [handle this today]..."
+- "What triggered your search for a solution?"
+- "What happened after you tried [current solution]?"
+- "Where does this rank in your list of problems this week?"
+- "What are you spending (time/money) on this today?"
+
+When the user suggests a question, check it against this list. If it's speculative or leading, explain why and offer a behavioral alternative.
+
+### Pricing (if relevant)
+
+If the user needs to explore pricing, guide them away from "Would you pay $X?" and toward:
+- What are you currently spending to address this?
+- What budget exists for this kind of thing?
+- Who controls that budget?
+
+The reference doc explains why: people only honestly consider willingness to pay when it feels like a real transaction.
+
+### Bias reminders
+
+Before they go into interviews, remind them:
+- Go in ready to hear things you don't want to hear
+- Adopt a "try to kill the idea" mindset — it actually works
+- Don't pitch. Don't lead the witness. Don't embed the answer in the question.
+- If possible, bring a note-taker. Interviewers filter for what they believe.
+- In-person is best, video is second, phone is last resort. Never text or email.
+
+## Deliverable
+
+Offer to produce an **Interview Guide** — a document the user can print or pull up on their phone during interviews.
+
+The guide should include:
+- **Bias checklist at the top:** A short list of reminders to read before every interview — don't pitch, don't lead, try to kill the idea, listen more than you talk.
+- **Intro script:** Exactly what to say in the first 30 seconds — who you are, why you're here, how long it'll take, that you're not selling anything.
+- **Warm-up questions:** 1-2 easy, low-stakes questions to get the conversation flowing.
+- **Core behavioral questions:** 5-8 story-eliciting questions tailored to the specific assumptions they're testing. Each one should start with "Tell me about...", "Walk me through...", or "What happened when..."
+- **Drill-down prompts:** A sidebar of ready-made follow-ups for when something interesting comes up — "Why was that?", "What happened next?", "How did that make you feel?", "Can you give me a specific example?"
+- **Pricing questions (if relevant):** Questions about current spend, budget, and who controls it — not hypothetical "would you pay" questions.
+- **Closing script:** "What should I have asked you that I didn't?" followed by the referral ask — "Who else should I talk to?" with a goal of 2-3 names.
+- **Post-interview checklist:** Reminders to write notes immediately after, capture direct quotes, and note emotional intensity while it's fresh.
+
+Format it so it's scannable at a glance — the user shouldn't have to read paragraphs mid-interview.
+
+## Next step
+
+When this step is done, offer to continue to **Step 4: Analysis & Signals** — making sense of what they hear in the interviews.

package/skills/estack-customer-discovery/steps/step-4-analysis.md

@@ -0,0 +1,95 @@
+# Step 4: Analysis & Signals
+
+## Before anything else
+
+Read `references/04-analysis-and-signals.md` in the skill directory. That's your source of truth for this step.
+
+## What this step accomplishes
+
+Help the user make sense of their interviews. By the end, they should know what patterns emerged, which problems matter most, how strong their signals are, and what to do next.
+
+## How to work through this with the user
+
+### Get the raw material
+
+Ask the user to share their interview transcripts or notes — or both. They can paste them in, describe what they heard, or point to files. Raw transcripts are ideal (more detail, less filtering), but messy notes work too. Work with whatever they have.
+
+If their material is thin, help them reconstruct what they remember. Prompt with: "What surprised you?" "What did you hear more than once?" "Did anyone describe a workaround they built?"
+
+### Structure the notes
+
+For each interview, capture:
+- Who they talked to (name, role, context)
+- Key quotes — their exact words, not the user's interpretation
+- Pain points mentioned
+- Current solutions or workarounds
+- Emotional intensity (mild annoyance vs. genuine frustration)
+- Any progression signals (see below)
+
+### Spot patterns
+
+Look across all interviews for recurring themes. Help the user see what clusters:
+- What problems came up repeatedly?
+- What language do customers use to describe the pain?
+- What workarounds or DIY solutions are they using?
+- Where did emotions run highest?
+
+Calculate rough percentages where possible. "7 out of 10 mentioned X" fights cognitive bias better than "a lot of people said X."
+
+### Check progression signals
+
+The reference doc defines a signal ladder. Help the user assess where their interviewees fall:
+
+1. **They describe the pain clearly and unprompted** — a signal, but not enough alone
+2. **They say they'd buy a solution** — counts, but weight it with skepticism (people are polite)
+3. **They ask how to buy it now** — gold
+
+Also strong signals:
+- They've DIY-hacked their own solution
+- They're currently paying for a partial workaround
+- They can tell you their existing budget and who controls it
+
+### Force-rank problems
+
+After patterns emerge, help the user rank the problems by:
+- How often they came up
+- How intense the emotion was
+- How willing people were to act on them
+- How much money or time they were already spending
+
+The #1 problem is the one to solve. Don't let them get distracted by #3.
+
+### Watch for false positives
+
+Remind them: people want to be nice. "I love it" means nothing without behavior to back it up. Watch what they did, not what they said. Weight positive reactions with skepticism.
+
+### Assess where they are
+
+Help them figure out their next move:
+- **Hearing the same thing over and over?** That's pattern saturation. Time to shift from discovery to testing solutions.
+- **Patterns aren't emerging after 15-20 interviews?** The segment or hypothesis is probably off. Rethink before doing more interviews.
+- **Strong signals but only from a few people?** Might need more interviews to confirm, or might have found a very specific niche.
+
+## Deliverable
+
+Offer to produce a **Discovery Findings Report** — a document that captures everything learned so the insights don't live only in the user's head. This is the document they'd share with co-founders, advisors, or investors to show what they learned.
+
+The report should include:
+- **Interview summary table:** Who was interviewed (name/role, date, format), one-line takeaway per interview.
+- **Top patterns:** The 3-5 themes that came up most often, with rough percentages (e.g., "8 out of 12 mentioned X"). Use the customer's language, not the founder's.
+- **Force-ranked problem list:** Problems ranked by frequency, emotional intensity, willingness to act, and current spend. The #1 problem is clearly called out.
+- **Key quotes:** 5-10 direct quotes that capture the pain in the customer's own words. These are gold for pitch decks, landing pages, and internal alignment.
+- **Progression signals:** Where interviewees fall on the signal ladder — pain described, would buy, asking to buy. Note any who've built DIY workarounds or are already paying for partial solutions.
+- **Assumption scorecard:** Revisit the assumptions from **Step 1: Strategy & Targeting** (if they did it). Mark each as confirmed, denied, or still uncertain based on what they heard.
+- **Before vs. after sketch:** What the customer's world looks like today vs. after the solution exists. Quantify the difference where possible.
+- **Recommended next steps:** Based on the strength of the signals — more interviews, pivot the segment, or start testing solutions (landing page, prototype, concierge experiment).
+
+Write this so it stands on its own — someone who wasn't in the interviews should be able to read it and understand what was learned.
+
+## What's next
+
+Based on the analysis, suggest what makes sense:
+- If patterns are clear and signals are strong → start testing solutions (landing page, prototype, concierge experiment)
+- If patterns are emerging but thin → do more interviews with the same segment
+- If nothing is clicking → revisit **Step 1: Strategy & Targeting** and rethink the customer segment or problem hypothesis
+- Customer discovery is never fully done — when patterns flatten, evolve what you're exploring

package/skills/estack-github-issue-tracker/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: github-issue-tracker
+name: estack-github-issue-tracker
 description: >
   GitHub issue tracker management. Checks all open issues the user is involved in,
   finds related/duplicate issues, reports what changed, and recommends next steps.

package/skills/estack-repo-search/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: repo-search
+name: estack-repo-search
 description: >-
   Clone and search external GitHub repositories to answer questions about their
   code. Use this skill whenever the user references a repo you don't have local