Your AI writes code fast. It doesn't know your customers. Evermuse plugs Cursor straight into your customer knowledge base: every interview, sales call, and piece of feedback, processed into a structured model of your product. Ask what customers are saying about onboarding friction and get cited quotes, not guesses. Generate PRDs, feature specs, and user stories grounded in what customers actually asked for, then build against them without leaving your editor. Grounded tools cover customer voice search, expert product workflows, competitor analysis, and roadmap shaping. Stop describing your users to your AI. Let it understand them.
Build evidence-based personas and segments from real people and conversations in the corpus
# /evermuse:research-users
Chain **user-personas** → **segmentation** for `$ARGUMENTS`. Personas built only from real people (get_meetings by attendee_domain) with verbatim quote blocks; segments by evidence-based need differences.Run sentiment and theme analysis over a period of customer feedback, with quotes carrying real sentiment signals
# /evermuse:analyze-feedback
Invoke the **sentiment-analysis** skill with `$ARGUMENTS`. Use get_notes(date_from/to) plus evidence searches; surface themes, sentiment split, and cited quotes. Save to Evermuse (nature=evidence).Create a sales battlecard whose objection-handling rows are real customer objections and competitor mentions from the corpus
# /evermuse:battlecard
Invoke the **competitive-battlecard** skill with `$ARGUMENTS`. They-say/we-say rows come from evidence (objections, competitor mentions) plus capabilities. Save to Evermuse (nature=context).Brainstorm feature or product ideas seeded by real unmet customer needs, from PM, designer, and engineer perspectives, each idea mapped to the evidence behind it
# /evermuse:brainstorm
Invoke the **brainstorm-ideas** skill with `$ARGUMENTS` (existing-product mode leans on evidence of unmet needs; new-product mode leans on market context). Output an idea → evidencing-quote table.Explore a business model with evidence-backed problem and segment assumptions — Business Model Canvas, Lean Canvas, or Startup Canvas
# /evermuse:business-model
Invoke the **business-model** skill with `$ARGUMENTS` (pick the canvas variant from references/). Problem/segment boxes cite customer evidence; channels/competition cite market context.Analyze the competitive landscape, cross-checking competitor capabilities against what customers actually say about rivals in real conversations
# /evermuse:competitive-analysis
Invoke the **competitor-analysis** skill with `$ARGUMENTS`. Cross-check list_competitors/get_competitor_capabilities (secondary) against evidence (competitor mentions, win/loss quotes). Save to Evermuse (nature=context).Create a development plan that starts from what customers actually requested — quotes and demand evidence in the plan, plus spec-driven phasing and a dependency-ordered task list
# /evermuse:dev-plan — Development plan (customer-grounded)
If `$ARGUMENTS` points to (or the repo already has) a `specs/<feature>/spec.md` or a matching Evermuse shaping note, inherit its evidence. Otherwise, first run a light grounding pass (or offer `/evermuse:spec`).
Then invoke the **development-plan** skill: open with "Why we're building this" (quotes) → technical context from the actual repo → spec-driven phases → evidence-weighted, MVP-first task list → save `plan.md` + `tasks.md` and to Evermuse (nature=guidance). Honor the prime directive: enrich, never override the user's stated approach.Run a discovery cycle grounded in customer evidence — map an opportunity-solution tree from real needs, then surface and prioritize the riskiest assumptions
# /evermuse:discover
Ground in customer evidence, then chain **opportunity-solution-tree** → **assumptions** for `$ARGUMENTS`. Every opportunity node is quote-backed; assumptions already answered by evidence become cited findings, the rest are scored and matched to cheap experiments.Find gaps across three lenses — spec-vs-spec consistency, spec-vs-code implementation, and spec-vs-customer demand coverage — each finding backed by evidence
# /evermuse:gap-analysis — Three-lens gap audit
Invoke the **gap-analysis** skill with `$ARGUMENTS`. Gather the spec/plan (local or shaping notes), read the code read-only, and search customer evidence per need theme. Output a severity-ranked gap table (each row badged with a quote, file:line, or spec ref) and a prioritized fix list. Save to Evermuse (nature=guidance).Design a growth strategy — define a customer-value-grounded North Star and the GTM motions to move it
# /evermuse:growth-strategy
Chain **north-star-metric** → **gtm-strategy** for `$ARGUMENTS`. North Star tied to evidenced customer value.Prepare a Mom-Test interview script targeting what evidence cannot yet answer, or summarize an interview transcript into needs, quotes, and action items
# /evermuse:interview
- **prep** → invoke **interview-script** for `$ARGUMENTS`: use evidence searches plus research questions to find what is already known vs. open, and target the script at the gaps.
- **summarize** → invoke **summarize-conversation**: locate the meeting (get_meetings) → get_meeting_transcript → extract needs/quotes/decisions. Save to Evermuse (nature=evidence).Generate positioning options and campaign ideas written in mined customer vocabulary, each message mapped to a quote that proves it resonates
# /evermuse:market-product
Invoke the **positioning-and-messaging** skill with `$ARGUMENTS`. Every message maps to a resonance-proving customer quote.Run a market or environment analysis (SWOT, PESTLE, Porters Five Forces, or Ansoff) where each cell cites a real evidence or market-context result
# /evermuse:market-scan
Invoke the **strategy-frameworks** skill with `$ARGUMENTS`. Pick the framework; fill each cell from evidence or context searches rather than generic filler. Save to Evermuse (nature=context).Summarize a customer meeting or interview transcript into decisions, needs, verbatim quotes, and action items
# /evermuse:meeting-notes
Invoke the **summarize-conversation** skill with `$ARGUMENTS`. Locate via get_meetings → get_meeting_transcript, extract with timestamps, save to Evermuse (nature=evidence).Define a North Star Metric and its input-metric tree, tied to the customer value evidenced in real conversations
# /evermuse:north-star
Invoke the **north-star-metric** skill with `$ARGUMENTS`. Tie the NSM and inputs to evidenced customer value.Plan a go-to-market: pick a beachhead by demand density, profile the ideal customer, and build the GTM strategy — all grounded in customer evidence
# /evermuse:plan-launch
Chain **beachhead-segment** → **ideal-customer-profile** → **gtm-strategy** for `$ARGUMENTS`. Beachhead chosen by demand density in the corpus; ICP from real won-and-happy customers.Brainstorm team OKRs whose objectives map to evidenced customer outcomes and whose key results measure real pain reduction
# /evermuse:plan-okrs
Invoke the **brainstorm-okrs** skill with `$ARGUMENTS`. Ground objectives in guidance (company goals) plus evidence (customer outcomes).Run a pre-mortem on a strategy, PRD, or roadmap — imagine it failed and trace why, citing counter-evidence where customers already signal risk
# /evermuse:pre-mortem
Invoke the **strategy-red-team** skill in pre-mortem mode with `$ARGUMENTS`. Attacks cite counter-evidence from the corpus where it exists.Design a pricing and packaging strategy grounded in willingness-to-pay signals, pricing objections, and value language from real customer conversations
# /evermuse:pricing
Invoke the **pricing-strategy** skill with `$ARGUMENTS`. Ground in evidence (WTP signals, objections, value language) and competitor pricing via context plus get_competitor_capabilities (labeled secondary).Adversarially stress-test a PRD, roadmap, or strategy by attacking its load-bearing assumptions with customer counter-evidence
# /evermuse:red-team-prd
Invoke the **strategy-red-team** skill with `$ARGUMENTS`. Run evidence searches designed to falsify the claims; rank assumptions by impact and cheapest test.Write "you asked, we built" release notes — for each shipped item, surface the customers who requested it (quoted internally, counted externally) and flag follow-ups
# /evermuse:release-notes
Invoke the **release-notes** skill with `$ARGUMENTS`. For each shipped item, find the customers who asked (find_supporting_quotes / get_notes), tie the note to their voice, and flag follow-up opportunities (optionally notify via the Intercom/email bridge if available). Save to Evermuse (nature=guidance).Answer a question about what customers think, need, ask for, or complain about — a quote-rich, source-linked brief drawn from real customer conversations in Evermuse
# /evermuse:research — Voice-of-customer brief
Invoke the **customer-research** skill with `$ARGUMENTS`. Scope the question → run 3–4 varied evidence searches + find_supporting_quotes (+ get_notes filters as needed) → synthesize into themes with sentiment, demand strength, and dissent → deliver a quote-rich brief with a Sources footer → offer to save (nature=evidence) and to spin into a spec.Review a PR against code quality, the spec it should satisfy, and the actual customer asks behind it — flagging where the diff diverges from what customers requested
# /evermuse:review-pr — Customer-aware PR review
Invoke the **review-pr** skill with `$ARGUMENTS`. Fetch the PR/diff (`gh` CLI or the Evermuse GitHub bridge, degrade gracefully), find the intent (shaping note by branch/PR number, or local spec), ground in the feature's customer asks, and review in three passes: code quality / spec conformance / customer-voice conformance. Lead with a clear verdict.Save the current research, spec, plan, or analysis back into Evermuse so the knowledge base compounds
# /evermuse:save — Persist to Evermuse
Read `${CLAUDE_PLUGIN_ROOT}/skills/using-evermuse/references/saving-to-evermuse.md`. Determine what to save (the most recent substantial deliverable, or `$ARGUMENTS`), pick the `nature` (customer-voice synthesis → evidence; market/competitor → context; company direction like specs/plans/strategy → guidance), resolve the project (get_projects → ask if several), then `add_source(source_type: "document", tags: ["evermuse-plugin", …])`. Confirm what was saved and where.Connect and verify Evermuse — confirm the MCP is authorized, pick the right Product (and Project if needed), and run a smoke-test search
# /evermuse:setup — Get grounded
Prepare the session so every later skill is grounded in the right customer data.
## Workflow
1. **Check the MCP.** Confirm the `mcp__evermuse__*` tools are present. If not, tell the user to authorize the Evermuse connector (via `/mcp` in an interactive session, or their claude.ai connector settings) and stop — nothing else works until it's connected.
2. **Pick the Product.** Call `get_products`. If `$ARGUMENTS` names one, match and `switch_product`. If one product exists, select it. If several, show the list and ask which one. (Read `${CLAUDE_PLUGIN_ROOT}/skills/using-evermuse/SKILL.md` Rule 1.)
3. **Offer a Project.** Call `get_projects`. Mention the projects (Discovery/Support/Sales/…) and note that most tasks stay at product scope; `switch_project` only if the user is focused on one research effort.
4. **Smoke-test.** Run one `find_supporting_quotes` or `search` (nature=evidence) on the product's core area and show 1–2 real quotes, so the user sees grounding working.
5. Report which product/project is active and suggest a next step (`/evermuse:research`, `/evermuse:spec`).Turn a built feature into a reviewer-ready packet — generate shipping artifacts, then run a customer-grounded gap analysis
# /evermuse:ship-check
Chain **shipping-artifacts** → **gap-analysis** for `$ARGUMENTS`. Reconstruct intent from shaping notes plus spec plus evidence, then audit spec-vs-spec, spec-vs-code, and spec-vs-customer.Write a feature specification grounded in real customer evidence — prioritized user stories, acceptance scenarios, and requirements with verbatim customer quotes and source links
# /evermuse:spec — Feature spec (customer-grounded)
Invoke the **write-feature-spec** skill with `$ARGUMENTS`.
Follow its flow: verify product → ground (evidence searches + quotes + guidance) → clarify (evidence-attached, ≤3 markers) → draft the spec (Customer Evidence section, per-story evidence, cited FRs, measurable SCs) → quality gate → save to `specs/<slug>/spec.md` and to Evermuse (nature=guidance). Then offer `/evermuse:dev-plan`.Build a product strategy where every pillar is grounded in customer pains (evidence) and market shifts (context), aligned to stated company objectives
# /evermuse:strategy
Invoke the **product-strategy** skill with `$ARGUMENTS`. Ground with a guidance search (existing objectives) first, then evidence (pains) and context (market). Save to Evermuse (nature=guidance).Generate Given/When/Then test scenarios from a spec plus the edge cases customers actually hit in real conversations
# /evermuse:test-scenarios
Invoke the **test-scenarios** skill with `$ARGUMENTS`. Derive scenarios from acceptance criteria AND from evidenced failure stories/complaints in the feature area.Transform a feature-based roadmap into an outcome-focused one where each outcome lane cites the customer demand behind it
# /evermuse:transform-roadmap
Invoke the **outcome-roadmap** skill with `$ARGUMENTS`. Each outcome lane cites demand evidence; see_updated_roadmap is a labeled AI-generated cross-check only.Triage a batch of customer feature requests into themes, duplicates, and the underlying needs behind them, prioritized by real demand
# /evermuse:triage-requests
Invoke the **analyze-feature-requests** skill with `$ARGUMENTS`. Pull requests via get_notes(note_types:[need,feedback]) plus evidence searches, cluster into themes, distinguish requests from underlying needs, and rank by demand strength.Design a value proposition in the customers own words — pains and gains pulled verbatim from real conversations — plus ready-to-use value-prop statements
# /evermuse:value-proposition
Invoke the **value-proposition** skill with `$ARGUMENTS`. Pains/gains come from find_supporting_quotes verbatim; statements reuse customer phrasing.Create a business PRD (8-section) grounded in customer evidence — the lighter sibling of a full spec-driven feature spec
# /evermuse:write-prd
Invoke the **create-prd** skill with `$ARGUMENTS`. For a rigorous spec-driven spec (prioritized user stories, acceptance scenarios), use `/evermuse:spec` instead — the skill will help you choose.Break a feature into user stories or job stories, each citing the customer quote that motivated it and acceptance criteria reflecting stated expectations
# /evermuse:write-stories
Invoke the **user-stories** skill with `$ARGUMENTS` (user-story or job-story format). Each story cites its motivating quote.