diff --git a/docs/research/2026-06-21-marketing-positioning-corpus.json b/docs/research/2026-06-21-marketing-positioning-corpus.json new file mode 100644 index 0000000..2fb48eb --- /dev/null +++ b/docs/research/2026-06-21-marketing-positioning-corpus.json @@ -0,0 +1,351 @@ +{ + "summary": "Deep research harness — fan-out web searches, fetch sources, adversarially verify claims, synthesize a cited report.", + "agentCount": 109, + "logs": [ + "Q: How do the best product marketers and brand strategists do POSITIONING, MESSAGIN…", + "Decomposed into 6 angles: Positioning frameworks (primary source, step-by-step), Messaging & value proposition (StoryBrand SB7, VPC, strategic narrative), Category design & differentiation POV, Evidence-based brand growth laws (Sharp, Binet & Field), Brand archetypes, voice, segmentation & STP templates, Anti-patterns & behavioral positioning (mistakes, Rory Sutherland)", + "Positioning frameworks (primary source, step-by-step): 6 results", + "Category design & differentiation POV: 6 results", + "Evidence-based brand growth laws (Sharp, Binet & Field): 6 results", + "Evidence-based brand growth laws (Sharp, Binet & Field): 4 novel (2 filtered)", + "Messaging & value proposition (StoryBrand SB7, VPC, strategic narrative): 6 results", + "Messaging & value proposition (StoryBrand SB7, VPC, strategic narrative): 4 novel (2 filtered)", + "Anti-patterns & behavioral positioning (mistakes, Rory Sutherland): 6 results", + "Anti-patterns & behavioral positioning (mistakes, Rory Sutherland): 2 novel (4 filtered)", + "Brand archetypes, voice, segmentation & STP templates: 6 results", + "Brand archetypes, voice, segmentation & STP templates: 4 novel (2 filtered)", + "Fetched 26 sources → 122 claims → verifying top 25", + "\"Positioning is defined as making a product a leade…\": 3-0 ✓", + "\"April Dunford's positioning methodology decomposes…\": 3-0 ✓", + "\"The positioning process runs in a specific ordered…\": 3-0 ✓", + "\"April Dunford's positioning framework consists of …\": 3-0 ✓", + "\"Dunford's framework defines three distinct 'styles…\": 3-0 ✓", + "\"Raskin frames the company story as identical to co…\": 3-0 ✓", + "\"The Value Proposition Canvas has two sides: the Cu…\": 3-0 ✓", + "\"Customer Jobs are defined as the functional, socia…\": 3-0 ✓", + "\"Andy Raskin's strategic narrative method leads wit…\": 1-2 ✗", + "\"The book ships 11 named, fill-in-the-blank exercis…\": 3-0 ✓", + "\"Category Design's core thesis is 'different, not b…\": 3-0 ✓", + "\"'Fit' (problem-solution / product-market fit) is a…\": 0-3 ✗", + "\"The book provides a codifiable category-creation m…\": 3-0 ✓", + "\"Play Bigger's category design methodology follows …\": 1-2 ✗", + "\"The central thesis of category design is that a co…\": 3-0 ✓", + "\"The Category Design Scorecard codifies exactly fiv…\": 3-0 ✓", + "\"A defining trait of category designers is having a…\": 3-0 ✓", + "\"Tone of voice can be codified along four measurabl…\": 3-0 ✓", + "\"Maximum profit requires running BOTH brand buildin…\": 3-0 ✓", + "[v1:JTBD directs marketers to align product ] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v2:JTBD directs marketers to align product ] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v2:JTBD prescribes outcome-based segmentati] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v1:JTBD prescribes outcome-based segmentati] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v2:The recommended process for defining bra] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "\"The recommended process for defining brand voice i…\": 2-0 (1 abstain) ✓", + "[v0:JTBD prescribes outcome-based segmentati] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "\"JTBD prescribes outcome-based segmentation (groupi…\": 0-0 (3 abstain) ✗", + "\"The optimal marketing budget split is approximatel…\": 2-1 ✓", + "[v2:JTBD codifies customer needs as measurab] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v0:JTBD directs marketers to align product ] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "\"JTBD directs marketers to align product developmen…\": 0-0 (3 abstain) ✗", + "[v0:JTBD codifies customer needs as measurab] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v0:Emotional advertising campaigns drive la] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "[v2:Emotional advertising campaigns drive la] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "\"Emotional advertising campaigns drive larger long-…\": 1-0 (2 abstain) ✗", + "[v1:JTBD codifies customer needs as measurab] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)", + "\"JTBD codifies customer needs as measurable 'desire…\": 0-0 (3 abstain) ✗", + "Verify done: 25 claims → 18 confirmed, 7 killed", + "[synthesize] failed: You've hit your session limit · resets 1:10am (Asia/Kolkata)" + ], + "result": { + "question": "How do the best product marketers and brand strategists do POSITIONING, MESSAGING, and BRAND STRATEGY? Cover concretely with codifiable frameworks: (1) Positioning - April Dunford's framework from Obviously Awesome (competitive alternatives, unique attributes, value/benefits, target market characteristics, market category, relevant trends) and her 10-step positioning process; Ries & Trout positioning principles; category design (Play Bigger / Category Pirates - the POV, the category narrative). (2) Messaging - Donald Miller StoryBrand SB7 framework (character, problem with 3 levels, guide, plan, call to action, failure, success); value proposition design (Osterwalder/Strategyn value proposition canvas - jobs/pains/gains, pain relievers, gain creators); messaging hierarchy and message pillars; the 'why now' narrative; Andy Raskin strategic narrative. (3) Segmentation & targeting - STP (segmentation-targeting-positioning), ICP definition, jobs-to-be-done applied to marketing. (4) Brand strategy - Mark & Pearson's 12 brand archetypes (the hero, the sage, the outlaw, etc. with traits/voice each); Byron Sharp 'How Brands Grow' evidence-based laws (mental availability, physical availability, distinctive brand assets, light buyers, double jeopardy law); Binet & Field 'The Long and the Short of It' (60/40 brand-vs-activation, emotional vs rational); Rory Sutherland behavioral/psychological positioning; brand voice and personality definition. Emphasize CODIFIABLE: step-by-step templates, fill-in-the-blank structures, named laws/principles, checklists, decision rules, and ANTI-PATTERNS (common positioning/branding mistakes). Prioritize primary sources (named authors' books, blogs, talks). The output will become the ground-truth corpus for a marketing persona/agent in an AI coding-agent system that must position and message ANY brand from scratch, so favor concrete reusable structures over generic advice.", + "summary": "Synthesis step was skipped or failed — returning 18 verified claims unmerged.", + "findings": [], + "confirmed": [ + { + "claim": "April Dunford's positioning framework consists of five named components: (1) Competitive Alternatives, (2) Key Unique Attributes, (3) Value (benefits the attributes enable), (4) Target Customer Segmentation, and (5) Market Category.", + "source": "https://www.aprildunford.com/post/a-quickstart-guide-to-positioning", + "quote": "1. **Competitive Alternatives** - What customers would do if your solution didn't exist\n2. **Key Unique Attributes** - Differentiated features or capabilities your product has that alternatives lack\n3. **Value** - The benefits those capabilities enable for buyers\n4. **Target Customer Segmentation** - Customers that care most about your differentiated value\n5. **Market Category** - The context positioning your product so value is obvious to targets", + "vote": "3-0" + }, + { + "claim": "The positioning process runs in a specific ordered sequence: start with competitive alternatives, then derive unique attributes, then translate attributes into value via 'So what for customers?', then define the target customers who care most about that value, then select the market category last.", + "source": "https://www.aprildunford.com/post/a-quickstart-guide-to-positioning", + "quote": "1. Start with **Competitive Alternatives**\n2. Identify **Key Unique Attributes** (what you have that alternatives lack)\n3. Determine **Value** (ask \"So what for customers?\")\n4. Define **Target Customers** (who cares most about this value?)\n5. Select **Market Category** (\"the context we position our product\")", + "vote": "3-0" + }, + { + "claim": "Positioning is defined as making a product a leader at delivering something a well-defined customer set cares about, and is explicitly distinct from messaging, taglines, and brand story/vision/why.", + "source": "https://www.aprildunford.com/post/a-quickstart-guide-to-positioning", + "quote": "\"Positioning defines how your product is a leader at delivering something that a well-defined set of customers cares a lot about.\"", + "vote": "3-0" + }, + { + "claim": "April Dunford's positioning methodology decomposes positioning into five component pieces, and a core part of the method is understanding how those pieces relate to each other.", + "source": "https://www.aprildunford.com/books", + "quote": "How to break positioning down into five component pieces ... How the component pieces relate to each other and why that matters", + "vote": "3-0" + }, + { + "claim": "Dunford's framework defines three distinct 'styles of positioning' as a decision tool for choosing the best market/category for a product.", + "source": "https://www.aprildunford.com/books", + "quote": "How to choose the best market for your product, including three styles of positioning", + "vote": "3-0" + }, + { + "claim": "Raskin frames the company story as identical to company strategy - the narrative is not decoration but the strategic backbone that aligns sales, marketing, fundraising, product, and recruiting.", + "source": "https://andyraskin.com/", + "quote": "The company story _is_ the company strategy. (Ben Horowitz, Andreessen Horowitz)", + "vote": "3-0" + }, + { + "claim": "The Value Proposition Canvas has two sides: the Customer Profile (Customer Jobs, Customer Pains, Customer Gains) and the Value Map (Products & Services, Pain Relievers, Gain Creators), where Pain Relievers map to pains and Gain Creators map to gains.", + "source": "https://www.strategyzer.com/library/value-proposition-design-book-summary", + "quote": "Pain Relievers — \"how your products and services alleviate specific customer pains\"; Gain Creators — \"how your offerings create positive outcomes customers desire\"", + "vote": "3-0" + }, + { + "claim": "Customer Jobs are defined as the functional, social, and emotional tasks customers try to accomplish, making 'jobs' a three-dimensional construct rather than purely functional.", + "source": "https://www.strategyzer.com/library/value-proposition-design-book-summary", + "quote": "Customer Jobs — \"functional, social, and emotional tasks customers try to accomplish\"", + "vote": "3-0" + }, + { + "claim": "Category Design's core thesis is 'different, not better': success comes from creating and dominating a new/different category rather than competing on incremental improvement. The book codifies this as a named exercise ('Be Different, Not Better') and a discipline that lets a company capture the majority of a category's value (citing Play Bigger research that one company earns 76% of total market-cap value created in tech categories).", + "source": "https://www.amazon.com/Laws-Category-Design-Somewhere-Different/dp/195693457X", + "quote": "Category Design is purpose-built for people who want to make an experiential difference, not an incremental better. Category Design is a business discipline that helps companies earn the majority of the value created in a specific new or different category of products or services. (Primary research on Category Design in Play Bigger... shows that in technology categories, one company earns 76% of the total market cap value created.)", + "vote": "3-0" + }, + { + "claim": "The book provides a codifiable category-creation methodology built on three named levers - a unique POV (point of view), Languaging, and a marketing strategy called a Lightning Strike - which together make a company the 'Category King or Queen' and make it impossible for competitors to copy.", + "source": "https://www.amazon.com/Laws-Category-Design-Somewhere-Different/dp/195693457X", + "quote": "22 Category Design principles that, when combined together, can help you become a Category King or Queen and make it impossible for someone else to \"do what you do\" How to create new categories and redefine existing ones using a unique POV, Languaging, and a powerful marketing strategy called a Lightning Strike", + "vote": "3-0" + }, + { + "claim": "The book ships 11 named, fill-in-the-blank exercises (a reusable template set) including 'Start Rejecting the Premise', 'Put Your Category First, and Your Brand Second', 'How to Frame, Name, and Claim a Category', 'Be Different, Not Better', and 'How to Find Your Superconsumers' - directly codifying the positioning/category-design workflow.", + "source": "https://www.amazon.com/Laws-Category-Design-Somewhere-Different/dp/195693457X", + "quote": "You will start applying these principles through 11 in-book exercises: Start Rejecting the Premise How to Find Your Superconsumers Put Your Category First, and Your Brand Second How to Frame, Name, and Claim a Category Be Different, Not Better Create Net-New Demand For Your Category and Company Build Your DAM the Demand Strategy Create Your Digital Air Offerings Figure Out Your Pricing Innovate Your Business Model Find Your WOM Super-Geos", + "vote": "3-0" + }, + { + "claim": "The central thesis of category design is that a company should design and lead a new category rather than compete in an existing one, because the market does not yet perceive the company's differentiation.", + "source": "https://www.playbigger.com/", + "quote": "DESIGN THE CATEGORY, CREATE THE CONDITIONS TO WIN... design the category they can lead - and build the belief to make it real.", + "vote": "3-0" + }, + { + "claim": "The Category Design Scorecard codifies exactly five named indicators that distinguish category designers/creators from companies merely competing in existing categories: (1) Category POV, (2) Future Category Reimagined and Without Compromise, (3) Radically Different Offer + Business Model, (4) The Data Flywheel, (5) Depth & Degree of Customer Outcomes.", + "source": "https://lochhead.com/category-design-scorecard/", + "quote": "The tool identifies \"five key indicators\" that differentiate category designers from other successful companies.", + "vote": "3-0" + }, + { + "claim": "A defining trait of category designers is having a clear Category Point of View framed around a large problem treated as a noble cause/purpose, not incremental product positioning.", + "source": "https://lochhead.com/category-design-scorecard/", + "quote": "\"Category designers...are going after something that they see as a noble cause, a noble purpose, or a giant problem worth solving.\"", + "vote": "3-0" + }, + { + "claim": "The optimal marketing budget split is approximately 60% brand building and 40% sales activation, identified by maximizing the number of business effects across the IPA case databank.", + "source": "https://www.newisnew.lt/wp-content/uploads/2016/07/1.-Les-Binet.pdf", + "quote": "Budgets must be balanced ... Optimum mix: ~60% brand, ~40% activation", + "vote": "2-1" + }, + { + "claim": "Maximum profit requires running BOTH brand building and sales activation together; the 'Both' campaign objective yields a higher profit effect than either brand building alone or activation alone.", + "source": "https://www.newisnew.lt/wp-content/uploads/2016/07/1.-Les-Binet.pdf", + "quote": "For maximum profit, you need both ... Profit effect ... Brand buiding | Both | Sales activation", + "vote": "3-0" + }, + { + "claim": "Tone of voice can be codified along four measurable dimensions, each defined by two opposing poles: Formal vs. Casual, Serious vs. Funny, Respectful vs. Irreverent, and Matter-of-fact vs. Enthusiastic. This gives a brand a reusable scoring framework for defining and auditing its voice.", + "source": "https://www.nngroup.com/articles/tone-of-voice-dimensions/", + "quote": "Formal vs. Casual: 'Is the writing formal? Informal? Casual?' Serious vs. Funny: 'Is the writer trying to be humorous? Or is the subject approached in a serious way?' Respectful vs. Irreverent: 'Does the writer approach the subject in a respectful way? Or does she take an irreverent approach?' Matter-of-fact vs. Enthusiastic: 'Does the writer seem to be enthusiastic about the subject?... Or is the writing dry and matter-of-fact?'", + "vote": "3-0" + }, + { + "claim": "The recommended process for defining brand voice is to first pick where the brand sits on the four dimensions, then refine with more specific target tone words (e.g. 'playful', 'quirky', 'sarcastic'), and to explicitly choose 'anti-tone' words naming the tones the brand wants to avoid.", + "source": "https://www.nngroup.com/articles/tone-of-voice-dimensions/", + "quote": "Decide what combination of dimensions makes sense best for your company... Refine your tone strategy by choosing more specific tone target words like 'playful,' 'quirky,' or 'sarcastic.'... Consider choosing anti-tone words. These are the tones that you want to avoid creating.", + "vote": "2-0" + } + ], + "refuted": [ + { + "claim": "Andy Raskin's strategic narrative method leads with the customer's future end-state ('the Promised Land') rather than with the product, making the desired customer experience the starting point of the story.", + "vote": "1-2", + "source": "https://andyraskin.com/" + }, + { + "claim": "'Fit' (problem-solution / product-market fit) is achieved when the value proposition addresses the customer's most important pains and gains, with a codifiable target of roughly 50-70% of the most significant pains and gains.", + "vote": "0-3", + "source": "https://www.strategyzer.com/library/value-proposition-design-book-summary" + }, + { + "claim": "Play Bigger's category design methodology follows a named four-stage blueprint: Define the problem, Frame the category, Mobilize the company, Own the market.", + "vote": "1-2", + "source": "https://www.playbigger.com/" + }, + { + "claim": "Emotional advertising campaigns drive larger long-term profit growth than rational campaigns, with the profit gap widening over a 1, 2, and 3+ year horizon; rational and emotional campaigns work differently (rational stronger on short-term activation, emotional stronger on brand effects).", + "vote": "1-0", + "source": "https://www.newisnew.lt/wp-content/uploads/2016/07/1.-Les-Binet.pdf" + }, + { + "claim": "JTBD codifies customer needs as measurable 'desired outcomes' - the metrics customers use to judge success at getting a job done - not vague preferences, which gives marketers concrete, checkable need statements to message against.", + "vote": "0-0", + "source": "https://strategyn.com/jobs-to-be-done/" + }, + { + "claim": "JTBD prescribes outcome-based segmentation (grouping customers by unique sets of unmet needs) as a replacement for demographic, psychographic, or behavioral segmentation, which it claims cannot surface these segments.", + "vote": "0-0", + "source": "https://strategyn.com/jobs-to-be-done/" + }, + { + "claim": "JTBD directs marketers to align product development, messaging, and positioning to the unmet desired outcomes of a target segment, and to align the whole organization around one consistent, problem-focused messaging strategy.", + "vote": "0-0", + "source": "https://strategyn.com/jobs-to-be-done/" + } + ], + "sources": [ + { + "url": "https://www.aprildunford.com/post/a-quickstart-guide-to-positioning", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://www.heinzmarketing.com/blog/10-step-positioning-process-an-obviously-awesome-book-summary-part-3/", + "quality": "secondary", + "claimCount": 5 + }, + { + "url": "https://www.kathirvel.com/guide-april-dunford-positioning-framework/", + "quality": "secondary", + "claimCount": 5 + }, + { + "url": "https://www.aprildunford.com/books", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://readingraphics.com/book-summary-obviously-awesome/", + "quality": "secondary", + "claimCount": 4 + }, + { + "url": "https://userlist.com/blog/positioning-overhaul/", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://medium.com/the-mission/the-greatest-sales-deck-ive-ever-seen-4f4ef3391ba0", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://andyraskin.com/", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://www.strategyzer.com/library/value-proposition-design-book-summary", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://www.creativeo.co/post/storybrand-framework", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.categorypirates.com/post/what-is-category-design", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.amazon.com/Laws-Category-Design-Somewhere-Different/dp/195693457X", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://www.amazon.com/Category-Design-Toolkit-Frameworks-Dominating/dp/195693412X", + "quality": "secondary", + "claimCount": 5 + }, + { + "url": "https://medium.com/firm-narrative/to-create-a-new-category-name-the-new-game-70c2e55edc2e", + "quality": "blog", + "claimCount": 3 + }, + { + "url": "https://www.playbigger.com/", + "quality": "primary", + "claimCount": 4 + }, + { + "url": "https://lochhead.com/category-design-scorecard/", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://marketingscience.info/news-and-insights/summary-on-byron-sharps-laws-of-brand-growth-with-examples", + "quality": "secondary", + "claimCount": 3 + }, + { + "url": "https://www.alexmurrell.co.uk/summaries/byron-sharp-how-brands-grow", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.alexmurrell.co.uk/summaries/les-binet-and-peter-field-the-long-and-the-short-of-it", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.newisnew.lt/wp-content/uploads/2016/07/1.-Les-Binet.pdf", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://iconicfox.com.au/brand-archetypes/", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.nngroup.com/articles/tone-of-voice-dimensions/", + "quality": "primary", + "claimCount": 3 + }, + { + "url": "https://strategyn.com/jobs-to-be-done/", + "quality": "primary", + "claimCount": 5 + }, + { + "url": "https://fullfunnel.io/ideal-customer-profile/", + "quality": "blog", + "claimCount": 5 + }, + { + "url": "https://www.42courses.com/blog/home/rory-sutherlands-11-rules-of-alchemy", + "quality": "secondary", + "claimCount": 5 + }, + { + "url": "https://strategicmarketingtribe.com/marketing-news/b/positioning-ries-trout-summary-small-business", + "quality": "blog", + "claimCount": 5 + } + ], + "stats": { + "angles": 6, + "sources": 26, + "claims": 122, + "verified": 25, + "confirmed": 18, + "killed": 7, + "afterSynthesis": 0 + } + } +} \ No newline at end of file diff --git a/generated/runtime-context/hyperstack.bootstrap.md b/generated/runtime-context/hyperstack.bootstrap.md index a5310a3..787c450 100644 --- a/generated/runtime-context/hyperstack.bootstrap.md +++ b/generated/runtime-context/hyperstack.bootstrap.md @@ -79,8 +79,9 @@ Hyperstack is a **Three-Layer Ecosystem**: - `website-builder` - first specialist for website-facing design and ## Personas -- Personas are internal judgment lenses that own and gate a decision class. +- Personas are internal domain-expert lenses (gate or capability) that hyper auto-engages by domain. - `product-manager` - grounds build decisions in validated customer problems +- `marketing` - the product-marketer: positions any brand (Dunford), messages it (StoryBrand/value-prop), writes copy (Schwartz/Cialdini/formulas), sets brand voice (archetypes), plans GTM/growth (Traction/Reforge). Produces; hands back to `hyper`. ## Routing Summary - Every request enters through `hyper` diff --git a/personas/README.md b/personas/README.md index bc2bb4c..fc10c89 100644 --- a/personas/README.md +++ b/personas/README.md @@ -1,14 +1,19 @@ # Personas (Layer 4) -Personas are judgment lenses that own and gate a class of decision before -execution. Each persona binds an MCP plugin (ground-truth), one or more skills -(process + gate), and a role identity via `persona.json`. The persona registry -(`src/personas/registry.ts`) loads manifests; the bootstrap compiles a Personas -layer so `hyper` knows which personas exist and when they engage. +Personas are domain-expert lenses that `hyper` engages for a domain. Each persona +binds an MCP plugin (ground-truth), one or more skills (process), and a role +identity via `persona.json`. Two modes: -| Persona | Owns | First | +- **gate** - owns a risk and blocks before execution (e.g. `product-manager`). +- **capability** - produces domain output (e.g. `marketing`). + +The persona registry (`src/personas/registry.ts`) loads manifests; the bootstrap +compiles a Personas layer so `hyper` knows which personas exist and when they engage. + +| Persona | Mode | Owns | |---|---|---| -| `product-manager` | value + viability product risk | yes | +| `product-manager` | gate | value + viability product risk | +| `marketing` | capability | positioning, messaging, copy, brand, GTM | ## Anatomy of a persona diff --git a/personas/marketing/LIFECYCLE.md b/personas/marketing/LIFECYCLE.md new file mode 100644 index 0000000..7884f50 --- /dev/null +++ b/personas/marketing/LIFECYCLE.md @@ -0,0 +1,23 @@ +# Product Marketer Persona Lifecycle + +## Engage when +- positioning, messaging, copy, brand voice, GTM/growth, or "marketing words for X" requests + +## Full workflow (new brand, in order) +1. Intake + VoC: gather who/what/alternatives/unique, then `marketing_get_voice_of_customer` - mine the customer's EXACT words from reviews/support/calls (the raw material for everything). +2. Position: `marketing_get_positioning` + `marketing_get_icp` - Dunford's 5 components in sequence, and define who EXACTLY it is for (not everyone). +3. Message: `marketing_get_messaging` - value-proposition canvas (jobs/pains/gains) + StoryBrand SB7 + the strategic narrative; build a message hierarchy. +4. Awareness stage: `marketing_get_awareness_stages` - locate the market on Schwartz's 5 stages; the more aware, the less you need to say. +5. Write: `marketing_get_copywriting_formulas` + `marketing_get_persuasion` - choose a formula (PAS/AIDA/BAB...), write headline + body + CTA, apply Cialdini triggers. +6. Brand voice: `marketing_get_voice` - choose an archetype, set the tone dimensions, apply consistently. +7. GTM: `marketing_get_gtm` (motion), `marketing_get_channels` (19 channels + Bullseye), `marketing_get_growth_model` (AARRR + loop + unit economics), `marketing_get_pricing` (value-based good-better-best packaging). +8. Check: `marketing_get_anti_patterns` - no feature-dump, we-we copy, vague unproven claims. + +## On-demand mode ("give me marketing words for X") +- Skip to: awareness stage -> formula -> voice -> produce. Still grounded in the frameworks, not vibes. + +## Orchestrator +- `marketing_brief(brand, ...)` assembles the relevant frameworks into a structured brief for a specific brand. + +## Handback +- Return to `hyper` for review and delivery. The marketer produces output; it does not ship or gate. diff --git a/personas/marketing/PROFILE.md b/personas/marketing/PROFILE.md new file mode 100644 index 0000000..9689a7a --- /dev/null +++ b/personas/marketing/PROFILE.md @@ -0,0 +1,42 @@ +--- +name: marketing +kind: persona +mode: capability +auto_invoke_when: + - position a product or brand + - write marketing copy or words + - go-to-market or launch + - messaging or brand voice + - growth or channel strategy +owns: + - positioning, messaging, copywriting, GTM, brand +delegates_to: + - hyper +must_not_do: + - write copy before the positioning is decided + - feature-dump (list features instead of customer value) + - ship vague claims with no proof + - copy a template without adapting to the brand's category and audience +--- + +# Product Marketer Persona + +## Mission + +Do product marketing for any brand: position it, find the message, write the words, +choose the go-to-market. Every output traces to a named framework, not vibes. + +## Voice + +A senior product marketer. Customer-language first (their words, mined from how they +actually talk - not the company's jargon). Specific over clever. Differentiated, not +generic. Leads with the customer's problem and the value it unlocks, never a feature +list. Takes a point of view instead of hedging. + +## Authority + +- Produces positioning, messaging, copy, brand voice, and GTM/growth plans. +- Pulls ground-truth frameworks (Dunford, Schwartz, Cialdini, Byron Sharp, Traction, + Reforge, StoryBrand...) via the marketing MCP tools and applies them to the specific + brand - the tools supply the canon, the marketer makes the call. +- Hands back to `hyper` for review and delivery. Generative, not a gate - it does not block. diff --git a/personas/marketing/persona.json b/personas/marketing/persona.json new file mode 100644 index 0000000..924e92c --- /dev/null +++ b/personas/marketing/persona.json @@ -0,0 +1,20 @@ +{ + "id": "marketing", + "name": "Product Marketer", + "version": "0.1.0", + "mode": "capability", + "owns": { + "capabilities": ["positioning", "messaging", "copywriting", "gtm", "brand"], + "plugin": "marketing", + "skills": ["marketing"] + }, + "engaged_by": "hyper", + "engages_when": [ + "position a product or brand", + "write marketing copy or words", + "go-to-market or launch", + "messaging or brand voice", + "growth or channel strategy", + "marketing recommendation for an app or website" + ] +} diff --git a/personas/persona.schema.json b/personas/persona.schema.json index 131916f..b612153 100644 --- a/personas/persona.schema.json +++ b/personas/persona.schema.json @@ -2,23 +2,27 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Hyperstack Persona Manifest", "type": "object", - "required": ["id", "name", "version", "owns", "engages_when", "gate_policy"], + "required": ["id", "name", "version", "owns", "engages_when"], "properties": { "id": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" }, "name": { "type": "string" }, "version": { "type": "string" }, + "mode": { "enum": ["gate", "capability"], "description": "gate owns a risk and blocks; capability produces domain output" }, + "engaged_by": { "type": "string" }, "owns": { "type": "object", - "required": ["risks", "plugin", "skills"], + "required": ["plugin", "skills"], "properties": { - "risks": { "type": "array", "items": { "type": "string" } }, "plugin": { "type": "string" }, - "skills": { "type": "array", "items": { "type": "string" } } + "skills": { "type": "array", "items": { "type": "string" } }, + "risks": { "type": "array", "items": { "type": "string" }, "description": "gate personas only" }, + "capabilities": { "type": "array", "items": { "type": "string" }, "description": "capability personas only" } } }, "engages_when": { "type": "array", "items": { "type": "string" } }, "gate_policy": { "type": "object", + "description": "gate personas only", "required": ["net_new", "tweak", "override"], "properties": { "net_new": { "enum": ["hard", "advisory"] }, diff --git a/personas/product-manager/persona.json b/personas/product-manager/persona.json index a856669..469fc41 100644 --- a/personas/product-manager/persona.json +++ b/personas/product-manager/persona.json @@ -2,6 +2,7 @@ "id": "product-manager", "name": "Product Manager", "version": "0.1.0", + "mode": "gate", "owns": { "risks": ["value", "viability"], "plugin": "product-manager", diff --git a/scripts/audit/sources.ts b/scripts/audit/sources.ts index 97f8e39..bf2e84d 100644 --- a/scripts/audit/sources.ts +++ b/scripts/audit/sources.ts @@ -42,5 +42,6 @@ export const SOURCES: PluginSource[] = [ { plugin: "designer", editorial: true, skip: false, skills: ["designer"], packages: [] }, { plugin: "optimizer", editorial: true, skip: false, skills: ["optimizer"], packages: [] }, { plugin: "product-manager", editorial: true, skip: false, skills: ["pm-gate"], packages: [] }, + { plugin: "marketing", editorial: true, skip: false, skills: ["marketing"], packages: [] }, { plugin: "hyperstack", editorial: false, skip: true, skills: [], packages: [] }, ]; diff --git a/skills/INDEX.md b/skills/INDEX.md index c488852..c75c9b3 100644 --- a/skills/INDEX.md +++ b/skills/INDEX.md @@ -39,6 +39,7 @@ Categories: | `behaviour-analysis` | Systematic UI/UX behaviour analysis for interactive applications. Audits every user action, state transition, view mode, | | `design-patterns-skill` | Apply core programming principles and design patterns from Clean Code, The Pragmatic Programmer, Code Complete, Refactor | | `designer` | | +| `marketing` | Use to do product marketing for any brand - position it, find the message, write the copy ("marketing words"), set brand | | `readme-writer` | Writes or rewrites project README files using repository evidence instead of generic filler. Use when creating a new REA | | `security-review` | Security code review for vulnerabilities. Use when asked to "security review", "find vulnerabilities", "check for securi | | `shadcn-expert` | Advanced shadcn/ui architect specializing in Base UI, Tailwind v4, data-slot patterns, and component composition. Use wh | diff --git a/skills/hyperstack/SKILL.md b/skills/hyperstack/SKILL.md index 7583e0e..175ca77 100644 --- a/skills/hyperstack/SKILL.md +++ b/skills/hyperstack/SKILL.md @@ -248,18 +248,21 @@ The bootstrap and orchestrator (`hyper`) choose the correct role based on the re ## Layer 4: Personas -Personas are judgment lenses that OWN a class of decision and gate it before -execution. They are internal and auto-engaged by `hyper`. +Personas are domain-expert lenses that `hyper` engages for a domain. Two modes: +GATE (owns a risk and blocks, e.g. product-manager) and CAPABILITY (produces +domain output, e.g. marketing). Internal and auto-engaged. -| Persona | Owns | Gate | -|---|---|---| -| `product-manager` | value + viability product risk | hard for net-new builds, advisory for tweaks, user override always | +| Persona | Mode | Owns | Engages on | +|---|---|---|---| +| `product-manager` | gate | value + viability product risk | net-new feature/product/scope (hard gate, advisory tweaks, user override) | +| `marketing` | capability | positioning, messaging, copy, brand, GTM | position/launch/name/write-copy/grow a product, app, or website | ## Persona Registry - `product-manager` - grounds build decisions in validated customer problems (opportunity-vs-solution, four risks, RICE), owns value+viability, hands back to `hyper`. Engaged before design/build on net-new feature/product/scope work. +- `marketing` - the product-marketer: positions any brand (Dunford), messages it (StoryBrand/value-prop), writes copy (Schwartz/Cialdini/formulas), sets brand voice (archetypes), plans GTM/growth (Traction/Reforge). Produces; hands back to `hyper`. --- diff --git a/skills/marketing/SKILL.md b/skills/marketing/SKILL.md new file mode 100644 index 0000000..aaef640 --- /dev/null +++ b/skills/marketing/SKILL.md @@ -0,0 +1,44 @@ +--- +name: marketing +description: Use to do product marketing for any brand - position it, find the message, write the copy ("marketing words"), set brand voice, plan go-to-market and growth. Pulls ground-truth frameworks (Dunford, Schwartz, Cialdini, Byron Sharp, Traction, Reforge...) via the marketing MCP tools and applies them. Trigger when asked to position, launch, name, write copy for, or grow a product, app, or website, or for any marketing recommendation. +category: domain +--- + +# Marketing + +The product-marketer persona's skill. Do real product marketing for any brand, +grounded in named frameworks - the marketing MCP tools supply the canon, you make the calls. + +## Core rule + +``` +POSITION before MESSAGE before COPY. +Never write words before you have decided what it is, who it is for, and why it wins. +``` + +## Workflow (new brand) + +Call `marketing_brief(brand, deliverables?)` first for the ordered plan, then: + +1. **Intake + VoC** - gather who/what/alternatives/unique, then `marketing_get_voice_of_customer` to mine the customer's EXACT words (reviews, support, calls). Write in their language, not yours. +2. **Position** (`marketing_get_positioning` + `marketing_get_icp`) - Dunford's 5 components in order, and define who EXACTLY it is for; write the positioning statement. +3. **Message** (`marketing_get_messaging`) - value-prop canvas (top pains/gains), StoryBrand (customer = hero), strategic narrative ("why now"); build the message hierarchy. +4. **Awareness** (`marketing_get_awareness_stages`) - locate the market on Schwartz's 5 stages; the more aware, the less you say. +5. **Write** (`marketing_get_copywriting_formulas` + `marketing_get_persuasion`) - pick a formula (PAS/AIDA/BAB), write headline + body + CTA; replace adjectives with proof. +6. **Voice** (`marketing_get_voice`) - pick ONE archetype + set the 4 tone dimensions; apply consistently. +7. **GTM** (`marketing_get_gtm`, `marketing_get_channels`, `marketing_get_growth_model`, `marketing_get_pricing`) - choose the motion, Bullseye the channels, design a growth loop, package and price on value. +8. **QA** (`marketing_get_anti_patterns`) - kill feature-dump, we-we copy, vague claims. + +## On-demand mode ("give me marketing words / a tagline / a hero section for X") + +Skip to: awareness stage -> pick a formula -> apply voice -> produce. Always name the framework you used. + +## Output discipline + +- Customer language, not company jargon (mine how they actually talk). +- Lead with the customer outcome/problem, never a feature list (use FAB). +- Every claim earns a proof point (number, named customer, demo) - no "best / seamless / world-class". +- Take a point of view; do not hedge with five safe options. +- Differentiated, not generic - if it could be any competitor's copy, rewrite it. + +## Hand back to `hyper` for review and delivery. The marketer produces; it does not ship or gate. diff --git a/src/index.ts b/src/index.ts index 36cca20..b4ad5fc 100755 --- a/src/index.ts +++ b/src/index.ts @@ -17,6 +17,7 @@ import { shadcnPlugin } from "./plugins/shadcn/index.js"; import { hyperstackPlugin } from "./plugins/hyperstack/index.js"; import { optimizerPlugin } from "./plugins/optimizer/index.js"; import { productManagerPlugin } from "./plugins/product-manager/index.js"; +import { marketingPlugin } from "./plugins/marketing/index.js"; import { readFileSync } from "node:fs"; import { dirname, join } from "node:path"; @@ -46,6 +47,7 @@ export const allPlugins = [ hyperstackPlugin, optimizerPlugin, productManagerPlugin, + marketingPlugin, ]; loadPlugins(server, allPlugins); diff --git a/src/internal/context-compiler.ts b/src/internal/context-compiler.ts index e7eb3e1..562c22d 100644 --- a/src/internal/context-compiler.ts +++ b/src/internal/context-compiler.ts @@ -203,7 +203,7 @@ export function compileUsingHyperstackBootstrap(source: string): { content: stri ...roleRegistry, "", "## Personas", - "- Personas are internal judgment lenses that own and gate a decision class.", + "- Personas are internal domain-expert lenses (gate or capability) that hyper auto-engages by domain.", ...personaRegistry, "", "## Routing Summary", diff --git a/src/personas/registry.ts b/src/personas/registry.ts index 57c3f76..f776a1e 100644 --- a/src/personas/registry.ts +++ b/src/personas/registry.ts @@ -10,10 +10,13 @@ export interface PersonaManifest { id: string; name: string; version: string; - owns: { risks: string[]; plugin: string; skills: string[] }; + // gate = owns a risk and blocks (e.g. product-manager); capability = produces + // domain output (e.g. marketing). Both are domain-expert lenses engaged by hyper. + mode?: "gate" | "capability"; + owns: { plugin: string; skills: string[]; risks?: string[]; capabilities?: string[] }; engaged_by?: string; engages_when: string[]; - gate_policy: { net_new: "hard" | "advisory"; tweak: "hard" | "advisory"; override: string }; + gate_policy?: { net_new: "hard" | "advisory"; tweak: "hard" | "advisory"; override: string }; } function isValid(m: unknown): m is PersonaManifest { @@ -22,8 +25,8 @@ function isValid(m: unknown): m is PersonaManifest { !!p && typeof p.id === "string" && !!p.owns && - Array.isArray(p.owns.risks) && - !!p.gate_policy + typeof p.owns.plugin === "string" && + Array.isArray(p.owns.skills) ); } diff --git a/src/plugins/marketing/data.ts b/src/plugins/marketing/data.ts new file mode 100644 index 0000000..795fbe8 --- /dev/null +++ b/src/plugins/marketing/data.ts @@ -0,0 +1,71 @@ +// Marketing persona (capability) - ground-truth frameworks + a real brief assembler. +// +// PHILOSOPHY (same as the corrected product-manager plugin): tools supply the +// canon (frameworks, formulas-with-templates, swipe structures, playbooks) that +// the agent RECALLS and APPLIES. No regex/classifier "deciders" - the marketer +// makes the call. The only logic here is a deterministic assembler that maps a +// requested deliverable to the ordered set of frameworks to apply. +// +// Corpus prose lives in snippets/*.txt via createSnippetLoader. Sources: Dunford, +// Osterwalder, Miller, Raskin, Schwartz, Ogilvy/Caples, Cialdini, Mark & Pearson, +// Byron Sharp, Binet & Field, Play Bigger, Weinberg/Mares, McClure, Balfour/Reforge. + +import { snippet } from "./loader.js"; + +const join = (...parts: string[]) => parts.join("\n\n---\n\n"); + +export const POSITIONING_DOC: string = join(snippet("positioning/dunford.txt"), snippet("positioning/styles.txt"), snippet("positioning/differentiation.txt")); +export const MESSAGING_DOC: string = join(snippet("messaging/value-prop-canvas.txt"), snippet("messaging/storybrand.txt"), snippet("messaging/narrative.txt")); +export const FORMULAS_DOC: string = snippet("copywriting/formulas.txt"); +export const AWARENESS_DOC: string = snippet("copywriting/awareness-stages.txt"); +export const PERSUASION_DOC: string = join(snippet("copywriting/headlines.txt"), snippet("copywriting/persuasion.txt"), snippet("copywriting/landing-anatomy.txt")); +export const VOICE_DOC: string = join(snippet("brand/archetypes.txt"), snippet("brand/voice-tone.txt")); +export const BRAND_DOC: string = join(snippet("brand/laws.txt"), snippet("brand/category-design.txt")); +export const GTM_DOC: string = join(snippet("gtm/motions.txt"), snippet("gtm/launch.txt")); +export const CHANNELS_DOC: string = snippet("gtm/channels.txt"); +export const GROWTH_DOC: string = snippet("gtm/growth-model.txt"); +export const ANTI_PATTERNS_DOC: string = snippet("anti-patterns/marketing.txt"); +export const VOC_DOC: string = snippet("research/voice-of-customer.txt"); +export const ICP_DOC: string = snippet("positioning/icp.txt"); +export const PRICING_DOC: string = snippet("gtm/pricing.txt"); +export const HOOKS_DOC: string = snippet("copywriting/hooks.txt"); +export const LIFECYCLE_DOC: string = snippet("gtm/lifecycle.txt"); + +// --- The brief assembler: deterministic, real (not a fake verdict). --- +// Given which deliverables the brand needs, return the ordered workflow steps + +// which tools to call. The agent does the actual marketing; this routes it. + +export interface BriefStep { step: string; tools: string; why: string; } + +export const FULL_WORKFLOW: BriefStep[] = [ + { step: "Research", tools: "marketing_get_voice_of_customer", why: "mine the customer's exact words (VoC) - the raw material for all the copy." }, + { step: "Position", tools: "marketing_get_positioning, marketing_get_icp", why: "Dunford's 5 components in order + define the ICP; decide what it is and who exactly it is for." }, + { step: "Message", tools: "marketing_get_messaging", why: "value-prop canvas + StoryBrand + strategic narrative; build the message hierarchy." }, + { step: "Awareness", tools: "marketing_get_awareness_stages", why: "match the copy to how aware the market already is." }, + { step: "Write", tools: "marketing_get_copywriting_formulas, marketing_get_hooks, marketing_get_persuasion", why: "hook the first 3 seconds, pick a formula, write headline + body + CTA with proof - in the customer's words." }, + { step: "Voice", tools: "marketing_get_voice", why: "pick a brand archetype + tone dimensions, apply consistently." }, + { step: "GTM", tools: "marketing_get_gtm, marketing_get_channels, marketing_get_growth_model, marketing_get_lifecycle, marketing_get_pricing", why: "choose the motion, Bullseye the channels, design a growth loop, set up lifecycle flows, package the pricing." }, + { step: "Check", tools: "marketing_get_anti_patterns", why: "no feature-dump, we-we copy, or vague unproven claims." }, +]; + +const DELIVERABLE_STEPS: Record = { + positioning: ["Research", "Position"], + messaging: ["Message", "Awareness"], + copy: ["Research", "Awareness", "Write", "Voice"], + copywriting: ["Research", "Awareness", "Write", "Voice"], + brand: ["Voice"], + gtm: ["GTM"], + growth: ["GTM"], + pricing: ["GTM"], +}; + +export function buildBrief(deliverables?: string[]): BriefStep[] { + if (!deliverables || deliverables.length === 0) return FULL_WORKFLOW; + const wanted = new Set(); + for (const d of deliverables) { + for (const s of DELIVERABLE_STEPS[d.trim().toLowerCase()] ?? []) wanted.add(s); + } + if (wanted.size === 0) return FULL_WORKFLOW; + wanted.add("Check"); + return FULL_WORKFLOW.filter((s) => wanted.has(s.step)); +} diff --git a/src/plugins/marketing/index.ts b/src/plugins/marketing/index.ts new file mode 100644 index 0000000..f15fb14 --- /dev/null +++ b/src/plugins/marketing/index.ts @@ -0,0 +1,44 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import type { Plugin } from "../../registry.js"; +import { register as getPositioning } from "./tools/get-positioning.js"; +import { register as getMessaging } from "./tools/get-messaging.js"; +import { register as getCopywritingFormulas } from "./tools/get-copywriting-formulas.js"; +import { register as getAwarenessStages } from "./tools/get-awareness-stages.js"; +import { register as getPersuasion } from "./tools/get-persuasion.js"; +import { register as getVoice } from "./tools/get-voice.js"; +import { register as getBrandStrategy } from "./tools/get-brand-strategy.js"; +import { register as getGtm } from "./tools/get-gtm.js"; +import { register as getChannels } from "./tools/get-channels.js"; +import { register as getGrowthModel } from "./tools/get-growth-model.js"; +import { register as getAntiPatterns } from "./tools/get-anti-patterns.js"; +import { register as brief } from "./tools/brief.js"; +import { register as getVoiceOfCustomer } from "./tools/get-voice-of-customer.js"; +import { register as getIcp } from "./tools/get-icp.js"; +import { register as getPricing } from "./tools/get-pricing.js"; +import { register as getHooks } from "./tools/get-hooks.js"; +import { register as getLifecycle } from "./tools/get-lifecycle.js"; + +function register(server: McpServer): void { + getPositioning(server); + getMessaging(server); + getCopywritingFormulas(server); + getAwarenessStages(server); + getPersuasion(server); + getVoice(server); + getBrandStrategy(server); + getGtm(server); + getChannels(server); + getGrowthModel(server); + getAntiPatterns(server); + getVoiceOfCustomer(server); + getIcp(server); + getPricing(server); + getHooks(server); + getLifecycle(server); + brief(server); +} + +export const marketingPlugin: Plugin = { + name: "marketing", + register, +}; diff --git a/src/plugins/marketing/loader.ts b/src/plugins/marketing/loader.ts new file mode 100644 index 0000000..ff6a39f --- /dev/null +++ b/src/plugins/marketing/loader.ts @@ -0,0 +1,3 @@ +import { createSnippetLoader } from "../../shared/loader-factory.js"; + +export const snippet = createSnippetLoader("marketing"); diff --git a/src/plugins/marketing/snippets/anti-patterns/marketing.txt b/src/plugins/marketing/snippets/anti-patterns/marketing.txt new file mode 100644 index 0000000..23e1a9a --- /dev/null +++ b/src/plugins/marketing/snippets/anti-patterns/marketing.txt @@ -0,0 +1,12 @@ +# Marketing anti-patterns (red flags - catch these in any output) + +- Feature-dumping - listing features instead of customer value. Fix: FAB, end every line on the benefit. +- "We-we" copy - every sentence starts with we/our/I. Fix: make the customer the hero ("you"); use their words. +- Vague claims - "best-in-class", "world-class", "seamless", "revolutionary" with no proof. Fix: a number, a named customer, a demo. +- Marketing to everyone - targeting "everyone" so it lands with no one. Fix: pick the segment that cares most. +- Better, not different - competing on incremental "better" in a crowded category. Fix: reframe the category or own a sub-segment. +- Copy before positioning - writing words before deciding what you are and who for. Fix: position -> message -> write, in that order. +- Premature scaling - spending on a channel before it is proven, or scaling before retention works. Fix: Bullseye-test first; fix retention before acquisition. +- Vanity metrics - optimizing impressions/signups that do not tie to value or revenue. Fix: North Star + AARRR (activation, retention). +- Jargon over clarity - clever/punny copy the reader must decode. Fix: clarity beats cleverness, always. +- Out-claiming a tired market - a bigger number nobody believes. Fix: out-mechanism (explain HOW) and identify with the reader. diff --git a/src/plugins/marketing/snippets/brand/archetypes.txt b/src/plugins/marketing/snippets/brand/archetypes.txt new file mode 100644 index 0000000..3c0b1e6 --- /dev/null +++ b/src/plugins/marketing/snippets/brand/archetypes.txt @@ -0,0 +1,18 @@ +# The 12 Brand Archetypes (Mark & Pearson) - pick ONE primary (optionally one secondary) for a consistent personality. + +| archetype | core desire | voice | example | +|---|---|---|---| +| Innocent | safety, simplicity | optimistic, honest, pure | Dove | +| Sage | truth, understanding | wise, measured, expert | Google | +| Explorer | freedom, discovery | adventurous, bold, restless | Patagonia | +| Outlaw | revolution, disruption | rebellious, raw, defiant | Harley-Davidson | +| Magician | transformation, wonder | visionary, charismatic | Disney | +| Hero | mastery, courage | bold, confident, motivating | Nike | +| Lover | intimacy, connection | warm, sensual, expressive | Chanel | +| Jester | enjoyment, fun | playful, irreverent, witty | Old Spice | +| Everyman | belonging | down-to-earth, friendly, real | IKEA | +| Caregiver | service, protection | reassuring, nurturing | Johnson & Johnson | +| Ruler | control, order | authoritative, polished, premium | Rolex | +| Creator | innovation, self-expression | imaginative, inventive | Lego, Adobe | + +Rule: ONE primary archetype, applied everywhere. It sets the vocabulary, tone, imagery, and - just as important - what the brand would never say. diff --git a/src/plugins/marketing/snippets/brand/category-design.txt b/src/plugins/marketing/snippets/brand/category-design.txt new file mode 100644 index 0000000..fbad661 --- /dev/null +++ b/src/plugins/marketing/snippets/brand/category-design.txt @@ -0,0 +1,16 @@ +# Category Design (Play Bigger / Category Pirates) - "different, not better" + +Thesis: you win by creating and dominating a NEW/DIFFERENT category, not by being an incremental "better". In tech categories the category king captures ~76% of the total market-cap value created. + +## Three levers +1. POV (point of view) - a distinct world-view that names the problem the old category ignores and frames a new one. Start by REJECTING the premise of the old category. +2. Languaging - name the category and the problem; own the words. Put the CATEGORY first, your brand second. +3. Lightning Strike - a concentrated go-to-market moment (event, launch, campaign) that teaches the market the new category exists. + +## Named moves +- Start rejecting the premise (of the old category). +- Frame, name, and claim the category. +- Put your category first, your brand second. +- Be different, not better. + +Use ONLY when you can credibly create demand for a new category (big bet, multi-year). Otherwise default to big-fish-small-pond positioning. diff --git a/src/plugins/marketing/snippets/brand/laws.txt b/src/plugins/marketing/snippets/brand/laws.txt new file mode 100644 index 0000000..d869184 --- /dev/null +++ b/src/plugins/marketing/snippets/brand/laws.txt @@ -0,0 +1,13 @@ +# Evidence-based brand laws (Byron Sharp, How Brands Grow; Binet & Field) + +## Byron Sharp - how brands actually grow (from data, not theory) +- Growth comes from PENETRATION (more buyers), not loyalty. Acquire light and non-buyers; do not just milk heavy users. +- Mental availability - be easy to BRING TO MIND in a buying moment. Build it with consistent Distinctive Brand Assets (logo, color, character, tagline, sound) used relentlessly over years. +- Physical availability - be easy to FIND and BUY (distribution, presence in every relevant channel/moment). +- Double jeopardy law - smaller brands have fewer buyers AND slightly lower loyalty. The lever is therefore reach/penetration, not loyalty programs. +- Reach broadly and consistently; do not narrow your advertising to a tiny "target" - sell to all the category's buyers. + +## Binet & Field - The Long and the Short of It +- Split budget ~60% brand-building (emotional, broad reach, long-term) / ~40% sales activation (rational, targeted, short-term). +- Brand-building compounds; activation spikes then fades. Activation-only slowly starves growth. +- Emotional campaigns beat rational ones on long-term business effects (and are more efficient at scale). diff --git a/src/plugins/marketing/snippets/brand/voice-tone.txt b/src/plugins/marketing/snippets/brand/voice-tone.txt new file mode 100644 index 0000000..8b23225 --- /dev/null +++ b/src/plugins/marketing/snippets/brand/voice-tone.txt @@ -0,0 +1,18 @@ +# Brand voice & tone + +VOICE = constant (the brand's personality, set by the archetype). TONE = varies by context (a celebration vs an error message). + +## Define voice on 4 tone dimensions (Nielsen Norman Group) +1. Funny <-> serious +2. Formal <-> casual +3. Respectful <-> irreverent +4. Enthusiastic <-> matter-of-fact + +Pick a point on each axis; that is the voice. Then write a "we are / we are not" table and 3-5 example rewrites so anyone can apply it. + +## Apply consistently +- Vocabulary - words we use, words we never use. +- Sentence rhythm and length. +- How we handle errors, empty states, confirmations, and bad news. + +Tone shifts with the user's emotional state (a frustrated user = drop the jokes); voice never changes. diff --git a/src/plugins/marketing/snippets/copywriting/awareness-stages.txt b/src/plugins/marketing/snippets/copywriting/awareness-stages.txt new file mode 100644 index 0000000..871c303 --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/awareness-stages.txt @@ -0,0 +1,12 @@ +# 5 Stages of Market Awareness (Eugene Schwartz, Breakthrough Advertising) +# Rule: the MORE aware the market, the LESS you need to say. Match the message to the stage. + +1. Unaware - does not know they have the problem. Lead with a story or insight that NAMES the problem. Sell the problem first, not the product. +2. Problem-aware - feels the pain, does not know solutions exist. Lead with the problem + agitate, then reveal that a solution exists. +3. Solution-aware - knows solution types exist, is shopping around. Lead with your MECHANISM - why your approach wins over the other approaches. +4. Product-aware - knows your product, on the fence. Lead with proof, differentiation, the offer, and risk reversal. +5. Most-aware - ready, just needs a reason now. Lead with the deal, the CTA, urgency. Shortest copy. + +## Market sophistication (how many claims they have already heard) - escalate accordingly: +- Fresh market: state the claim plainly. +- Tired market: do not out-claim it (no one believes a bigger number) - out-MECHANISM it (explain HOW), then identify with the reader's exact situation. diff --git a/src/plugins/marketing/snippets/copywriting/formulas.txt b/src/plugins/marketing/snippets/copywriting/formulas.txt new file mode 100644 index 0000000..0367074 --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/formulas.txt @@ -0,0 +1,23 @@ +# Copywriting formulas (with fill-in templates). Hybridize freely: PAS hook + FAB body + AIDA close. + +## PAS - Problem, Agitate, Solution (best default for pain-driven copy) +[Problem they feel] -> [Agitate: what it costs them, twist the knife] -> [Solution: your product removes it]. + +## AIDA - Attention, Interest, Desire, Action +[Attention: hook] -> [Interest: relevant detail] -> [Desire: the better future] -> [Action: CTA]. + +## BAB - Before, After, Bridge +[Before: their painful now] -> [After: the better world] -> [Bridge: your product is how they cross over]. + +## FAB - Feature, Advantage, Benefit (kills feature-dumping) +[Feature] which means [Advantage] so you can [Benefit to the customer]. Always land on the benefit. + +## PASTOR - Problem, Amplify, Story/Solution, Transformation, Offer, Response (long-form / sales pages) +Problem -> Amplify the cost of inaction -> Story + Solution -> Transformation (proof others got it) -> Offer -> Response (the ask). + +## 4 Ps - Picture, Promise, Prove, Push +Picture the desired outcome -> Promise it -> Prove it (evidence) -> Push (CTA + reason to act now). + +## The 4 U's (run every headline through this): is it Useful, Urgent, Unique, and Ultra-specific? + +## Rule (the "slippery slide", Sugarman): the only job of the first sentence is to get the second one read. Every line earns the next. diff --git a/src/plugins/marketing/snippets/copywriting/headlines.txt b/src/plugins/marketing/snippets/copywriting/headlines.txt new file mode 100644 index 0000000..4c014f5 --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/headlines.txt @@ -0,0 +1,19 @@ +# Headlines (Ogilvy, Caples) - 5x as many people read the headline as the body. It is 80% of the work. + +## Ogilvy's rules +- The headline promises a BENEFIT or news, and flags the target audience. +- Put the brand/product in the headline. +- Specifics beat generalities (numbers, named outcomes, timeframes). +- "How to", "Introducing/Now/Announcing" (news), and bracketed clarifiers pull well. +- Never sacrifice clarity for cleverness. A pun the reader must decode is a dead headline. + +## Caples' proven headline types +Direct ("Half-price sale") · News ("Announcing...") · How-to ("How to [outcome] without [pain]") · Question ("Do you make these mistakes?") · Command ("Stop wasting...") · Reason-why ("7 reasons...") · Testimonial ("I [result] in [time]"). + +## Swipe templates (fill in) +- How to [desired outcome] without [pain/objection]. +- [Number] ways to [outcome] (even if [obstacle]). +- The [adjective] way to [outcome]. +- Do you [problem]? Here is [solution]. +- Get [outcome] in [timeframe] - or [risk reversal]. +- [Audience]: [the one thing they want], finally. diff --git a/src/plugins/marketing/snippets/copywriting/hooks.txt b/src/plugins/marketing/snippets/copywriting/hooks.txt new file mode 100644 index 0000000..98d99e5 --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/hooks.txt @@ -0,0 +1,24 @@ +# Hooks - the first 1-3 seconds (ads, short-form video, social, email subject, opening line) +# Rule: if the hook does not land in 2-3 seconds, they scroll. The hook's only job is to buy the next 3 seconds. + +## Hook frameworks +- Curiosity / open loop: pose a question or tease a payoff, delay the answer (open loop -> tease payoff -> withhold the explanation). +- Pain-point: name the audience's exact frustration in the first line. "Still [painful thing]?" +- Pattern interrupt: do or say something unexpected that breaks the scroll autopilot (visual or claim). +- Contrarian / myth-bust: "Everyone tells you X. They're wrong." +- Result / proof: lead with the outcome + specifics. "How I [result] in [time] without [pain]." +- Step-by-step / listicle: "3 ways to [outcome]" - structured, low-overwhelm. +- Warning / negative: "Stop doing X if you want Y." + +## Short-form video / ad structure (the 4 beats) +1. Hook (0-3s) - a clear, specific promise + striking first frame + legible on-screen text. Use an outcome/number/contrast, not a vague topic. +2. Value drop (4-15s) - deliver on the hook fast. +3. Story / payoff (16-45s) - proof, demo, transformation. +4. CTA (last ~5s) - one clear action. + +## Swipe openers +- "If you [audience], stop scrolling." +- "I tried [thing] for [time]. Here is what happened." +- "Nobody talks about [surprising truth]." +- "[Number] [things] that [outcome] - the last one is [twist]." +- "POV: you [relatable situation]." diff --git a/src/plugins/marketing/snippets/copywriting/landing-anatomy.txt b/src/plugins/marketing/snippets/copywriting/landing-anatomy.txt new file mode 100644 index 0000000..3d65883 --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/landing-anatomy.txt @@ -0,0 +1,13 @@ +# Landing page anatomy (conversion order) + +1. Hero: headline (the #1 value/outcome) + subhead (who it is for + how) + primary CTA + a hero visual/proof. Pass the 5-second test: a stranger instantly gets what it is, who it is for, why care. +2. Social-proof bar: logos / user counts / ratings directly under the hero. +3. Problem -> solution: name the pain in the customer's words, then show the mechanism. +4. Benefits, not features: FAB - lead each block with the outcome. +5. How it works: 3 simple steps (the "plan" - reduce perceived effort). +6. Proof: testimonials, case studies, data, before/after. +7. Objection handling / FAQ: kill the top 3-5 reasons NOT to buy (price, risk, switching cost, trust). +8. Risk reversal: guarantee / free trial / "cancel anytime". +9. Final CTA: restate the core value + the single action. + +Above the fold must answer: what is it, who is it for, what do I get, what do I do next. One primary action per page. diff --git a/src/plugins/marketing/snippets/copywriting/persuasion.txt b/src/plugins/marketing/snippets/copywriting/persuasion.txt new file mode 100644 index 0000000..062635c --- /dev/null +++ b/src/plugins/marketing/snippets/copywriting/persuasion.txt @@ -0,0 +1,11 @@ +# Persuasion - Cialdini's 7 principles of influence. Use ethically; weave into copy and offers. + +1. Reciprocity - give first (free value, tools, useful content); people return the favor. +2. Commitment & consistency - get a small yes first; people stay consistent with prior actions and stated identity. +3. Social proof - show others (especially SIMILAR others) doing it: counts, logos, reviews, testimonials, "most popular". +4. Authority - signal credible expertise: credentials, data, named experts, press, demonstrated competence. +5. Liking - we say yes to those we like: similarity, genuine specifics, shared identity, a real human voice. +6. Scarcity - limited quantity / time / access raises desire. Must be REAL or it destroys trust. +7. Unity - shared identity ("we", "people like us", a movement or category). The strongest, most modern trigger. + +Rule: proof beats adjectives. Replace every "best / leading / amazing / world-class" with a specific number, a named customer, or a live demonstration. diff --git a/src/plugins/marketing/snippets/gtm/channels.txt b/src/plugins/marketing/snippets/gtm/channels.txt new file mode 100644 index 0000000..723a58d --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/channels.txt @@ -0,0 +1,13 @@ +# Channels: the 19 traction channels + the Bullseye framework (Traction, Weinberg & Mares) + +## The 19 channels (scan ALL - do not default to the 1-2 you already know) +Viral marketing · PR · Unconventional PR (stunts) · SEM (paid search) · Social & display ads · Offline ads · SEO · Content marketing · Email marketing · Engineering as marketing (free tools/calculators) · Targeting blogs · Business development (partnerships) · Sales · Affiliate programs · Existing platforms (app stores, marketplaces) · Trade shows · Offline events · Speaking engagements · Community building. + +## Bullseye framework (how to choose) +1. Brainstorm - a realistic idea for EVERY one of the 19 channels (the outer ring). +2. Rank into 3 columns: A promising (inner ring), B possible, C long-shot. +3. Prioritize - pick the ~3 most promising for the middle ring. +4. Test - cheap, fast, parallel experiments on those 3 (measure cost, conversion, volume, payback). +5. Focus - pour resources into the ONE channel that is working (the bullseye). + +Rule: most startups get traction from a SINGLE channel at a time, and it is usually not the one you assumed. Test before you scale. diff --git a/src/plugins/marketing/snippets/gtm/growth-model.txt b/src/plugins/marketing/snippets/gtm/growth-model.txt new file mode 100644 index 0000000..43af8ec --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/growth-model.txt @@ -0,0 +1,24 @@ +# Growth model: AARRR metrics + growth loops + +## AARRR "pirate metrics" (Dave McClure) - instrument the whole journey +- Acquisition - users arrive (from which channel?). +- Activation - first valuable experience (the "aha"); the #1 lever for most products. +- Retention - they come back (the FOUNDATION - without it the funnel leaks faster than you can fill it). +- Referral - they bring others. +- Revenue - they pay. +Find the leakiest step first; fix activation/retention before pouring money into acquisition. + +## Growth loops > funnels (Brian Balfour / Reforge) +A funnel is linear (pour in the top, leak out the bottom). A LOOP reinvests the output back into the input: + new users -> take an action producing an output (content, invites, data, revenue) -> that output drives NEW acquisition -> repeat. +Loop types: viral (users invite users), content (UGC -> indexable pages -> SEO -> users), paid (revenue funds ads that acquire revenue-generating users). +Design at least one loop; loops compound, funnels do not. + +## North Star metric: one number capturing delivered customer value (nights booked, messages sent, docs created). Align the team to move it. + +## Unit economics (know these cold) +- CAC = total sales + marketing spend / new customers acquired (track per channel). +- LTV = ARPA x gross margin / churn rate (or avg revenue x margin x avg lifetime). +- LTV:CAC >= 3:1 is the healthy benchmark; < 1 means you lose money on every customer. +- CAC payback < 12 months (SMB) or < 18-24 months (enterprise) is healthy. +- Retention/churn is the master variable - a small churn improvement swings LTV massively. Fix retention before scaling acquisition. diff --git a/src/plugins/marketing/snippets/gtm/launch.txt b/src/plugins/marketing/snippets/gtm/launch.txt new file mode 100644 index 0000000..e4b2771 --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/launch.txt @@ -0,0 +1,13 @@ +# Product launch + +## Tier the launch to the news (do not tentpole a minor update) +- Tier 1 / tentpole - major product or category moment: full narrative, press, event, coordinated channels, exec involvement. +- Tier 2 / standard - notable feature: blog + email + social + in-app + sales enablement. +- Tier 3 / soft - minor update: changelog + in-app note. + +## Phases +1. Pre-launch - positioning + narrative locked, assets ready, beta/early access, build a waitlist/audience, brief sales & support. +2. Launch - coordinate ALL channels in one window: homepage, email, social, PR, Product Hunt/community, in-app. One message, many surfaces. +3. Post-launch - measure (signups, activation, coverage), follow-up content, nurture, iterate the message on what actually landed. + +Rule: a launch is a MESSAGE moment, not a feature dump. Lead with the customer outcome and the "why now", never the feature list. diff --git a/src/plugins/marketing/snippets/gtm/lifecycle.txt b/src/plugins/marketing/snippets/gtm/lifecycle.txt new file mode 100644 index 0000000..cee42f4 --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/lifecycle.txt @@ -0,0 +1,16 @@ +# Lifecycle / email marketing (the retention + monetization engine) +# Trigger on BEHAVIOR (signups, feature use, drop-off), not on a blast calendar. Automated flows make roughly 3x the revenue of one-off campaigns. + +## The core flows (build in this order) +1. Welcome (on signup) - set expectations, one clear next action, point at the "aha". Highest-converting automated email. +2. Onboarding (first days) - educate toward the activation moment, do not sell. One feature/step per email; triggered by what they have and have not done. +3. Nurture (pre-purchase / free users) - teach, give value, build the case; move them to the next stage. +4. Engagement / retention - prompt the next valuable action, celebrate milestones, reactivate before they churn. +5. Win-back (gone quiet) - "we miss you" + a real reason to return (new value or offer); cheaper than acquiring new. +6. Transactional / behavioral - receipts, alerts, milestones, abandoned-cart (high intent, high revenue). + +## Rules +- Right message, right moment: real-time behavioral triggers beat scheduled blasts. +- Fewer, more relevant beats frequent + generic. Segment by stage and behavior. +- One job per email, one primary CTA. +- Measure to the value metric (activation, repeat purchase, retention), not opens. diff --git a/src/plugins/marketing/snippets/gtm/motions.txt b/src/plugins/marketing/snippets/gtm/motions.txt new file mode 100644 index 0000000..e609f22 --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/motions.txt @@ -0,0 +1,13 @@ +# Go-to-market motions - pick by deal size, complexity, and who decides. + +| motion | fits when | engine | +|---|---|---| +| Product-led (PLG) | low price, self-serve, fast time-to-value, individual/team adopts | the product IS the funnel: free/trial -> activation -> expansion. Optimize onboarding + the "aha" moment. | +| Sales-led | high ACV, complex, multi-stakeholder, security/procurement | reps + demos + pilots; marketing feeds pipeline (demand gen, MQL -> SQL). | +| Marketing-led | mid-market, content + brand drive inbound | content/SEO/ads build demand, light-touch sales closes. | +| Community-led | developer / prosumer / passion categories | community, advocacy, and word of mouth drive adoption. | + +## Rules +- Short time-to-value + low price -> PLG. High price + buying committee -> sales-led. +- Do not bolt enterprise sales onto a product nobody activates in; do not put PLG friction in front of a $100k deal. +- The motion must match the product: a self-serve product needs self-serve GTM. diff --git a/src/plugins/marketing/snippets/gtm/pricing.txt b/src/plugins/marketing/snippets/gtm/pricing.txt new file mode 100644 index 0000000..4f3c99c --- /dev/null +++ b/src/plugins/marketing/snippets/gtm/pricing.txt @@ -0,0 +1,19 @@ +# Pricing & packaging (a marketing lever, not just finance) + +## Price on VALUE, not cost. Anchor to the outcome delivered or the cost of the alternative - never cost-plus. + +## Good-Better-Best (3 tiers) - the default packaging +- Three tiers; most buyers pick the MIDDLE. Design the middle as the plan you want sold (the target). +- A high "Best"/enterprise tier anchors perception and makes the middle look reasonable (anchoring / decoy effect). +- "Fences" between tiers = what gates the upgrade: usage (seats/volume), features, support/SLA, security/compliance. + +## Value metric: charge for the thing that scales with the value the customer gets (seats, GB, contacts, API calls, transactions). A good value metric grows revenue as the customer succeeds. + +## Tactics +- Anchor high first (show the expensive option before the cheap one). +- Annual discount for commitment; charm/odd pricing where it fits the brand. +- Free tier / trial ONLY if it drives activation and the value metric pulls users to paid (PLG). + +## Test willingness-to-pay: van Westendorp ("at what price is it too expensive / too cheap / getting expensive / a bargain?"). + +Anti-pattern: cost-plus pricing, one-size pricing, a free tier that cannibalizes instead of converting, a price the buyer cannot map to value. diff --git a/src/plugins/marketing/snippets/messaging/narrative.txt b/src/plugins/marketing/snippets/messaging/narrative.txt new file mode 100644 index 0000000..92f5e38 --- /dev/null +++ b/src/plugins/marketing/snippets/messaging/narrative.txt @@ -0,0 +1,16 @@ +# Strategic narrative (Andy Raskin) - the company story IS the company strategy + +A great strategic narrative (sales decks, fundraising, recruiting, the homepage spine) runs: +1. Name the big, undeniable SHIFT in the world (the "why now"). Make it feel inevitable. +2. Show there will be winners and losers because of that shift (raise the stakes - tension). +3. Tease the Promised Land - the desirable, hard-to-reach future the customer wants. This is a future STATE, not your product. +4. Introduce your capabilities as "magic gifts" - the features that help the hero reach the Promised Land. +5. Present evidence you can make the story come true (proof, customers, traction, demos). + +Lead with the shift and the stakes, NOT the product. One story aligns sales, marketing, product, and fundraising. + +## Message hierarchy (build once positioning is set) +- 1 core message (the single thing you want remembered) -> +- 3 supporting pillars (the proof themes) -> +- evidence under each pillar (features, stats, proof points, customer quotes). +Everything you write maps to this tree. If it does not ladder up to the core message, cut it. diff --git a/src/plugins/marketing/snippets/messaging/storybrand.txt b/src/plugins/marketing/snippets/messaging/storybrand.txt new file mode 100644 index 0000000..17262fc --- /dev/null +++ b/src/plugins/marketing/snippets/messaging/storybrand.txt @@ -0,0 +1,13 @@ +# StoryBrand SB7 (Donald Miller) - the customer is the hero, the brand is the guide + +Cast the message as a story where the CUSTOMER is the hero (never the brand): +1. A Character (the customer) who wants something. +2. has a Problem - on 3 levels: external (the tangible problem), internal (how it makes them feel), philosophical (why it is just plain wrong). +3. meets a Guide (your brand) who shows empathy + authority. +4. who gives them a Plan (clear, simple steps to buy and succeed). +5. and Calls them to Action (a direct CTA + a transitional CTA for the not-ready). +6. that helps them avoid Failure (the stakes - what is at risk if they do nothing). +7. and ends in Success (the transformation - who they become). + +Rule: the brand is the GUIDE, not the hero. Lead with the customer's want + problem, not your features. +One-liner template: "Most [customers] struggle with [problem]. We offer [solution] so you can [success]." diff --git a/src/plugins/marketing/snippets/messaging/value-prop-canvas.txt b/src/plugins/marketing/snippets/messaging/value-prop-canvas.txt new file mode 100644 index 0000000..b111cca --- /dev/null +++ b/src/plugins/marketing/snippets/messaging/value-prop-canvas.txt @@ -0,0 +1,15 @@ +# Value Proposition Canvas (Osterwalder / Strategyzer) + +Two sides that must FIT. + +## Customer profile (their world - observe, do not invent) +- Jobs - the functional, social, AND emotional tasks the customer is trying to get done. +- Pains - frustrations, risks, obstacles before/during/after the job. +- Gains - outcomes and benefits they want (required, expected, desired, and unexpected). + +## Value map (your offer) +- Products & services - what you offer. +- Pain relievers - how your offer removes SPECIFIC customer pains (map each reliever to a pain). +- Gain creators - how your offer produces SPECIFIC gains (map each creator to a gain). + +FIT = your pain relievers and gain creators address the customer's TOP-RANKED pains and gains, not all of them. Rank by importance to the customer, then build the message around the top 2-3. diff --git a/src/plugins/marketing/snippets/positioning/differentiation.txt b/src/plugins/marketing/snippets/positioning/differentiation.txt new file mode 100644 index 0000000..2860fed --- /dev/null +++ b/src/plugins/marketing/snippets/positioning/differentiation.txt @@ -0,0 +1,13 @@ +# Differentiation: Blue Ocean - compete by being different, not by out-spending (Kim & Mauborgne) + +Value innovation = pursue differentiation AND low cost at once by redrawing the market, instead of beating rivals on the same factors. + +## Four Actions / ERRC grid - rebuild the value curve by asking: +- ELIMINATE - which factors the industry takes for granted should be removed entirely? +- REDUCE - which factors should be cut well below the industry standard? +- RAISE - which factors should be raised well above the standard? +- CREATE - which factors should you offer that the industry never has? + +Example ([yellow tail] / Casella wine): eliminated wine jargon and aging prestige, reduced the range, raised approachability, created "easy, fun, adventurous" - winning non-wine-drinkers, a whole new buyer. + +Use it to find an uncontested angle for positioning: the CREATE and ELIMINATE rows are where the differentiated story lives. Pairs with Dunford (the attributes you raise/create become your unique value) and category design (a new value curve can justify a new category). diff --git a/src/plugins/marketing/snippets/positioning/dunford.txt b/src/plugins/marketing/snippets/positioning/dunford.txt new file mode 100644 index 0000000..664a9d0 --- /dev/null +++ b/src/plugins/marketing/snippets/positioning/dunford.txt @@ -0,0 +1,23 @@ +# Positioning (April Dunford, Obviously Awesome) + +Positioning = making your product the obvious leader at delivering something a +well-defined set of customers cares a lot about. It is NOT a tagline, messaging, +or brand story - those come AFTER positioning. + +## The 5 components +1. Competitive alternatives - what customers would do if you did not exist (not just rival products: a spreadsheet, an agency, hiring someone, doing nothing). +2. Unique attributes - features/capabilities you have that the alternatives lack. +3. Value - the benefit those attributes enable for the customer. Ask "so what, for the customer?" on every attribute until you reach a real outcome. +4. Target customer segment - the customers who care MOST about that value (the ones who buy fast and tell their friends). +5. Market category - the context you put the product in so the value is obvious to the target. + +## Process (run IN THIS ORDER) +competitive alternatives -> unique attributes -> value ("so what?") -> target (who cares most) -> market category (chosen LAST, deliberately). + +Choosing the category last is the key move: the category frames everything, so pick the frame that makes your unique value obvious. + +## Output: a positioning statement the whole team can repeat +For [target] who [need], [product] is the [category] that [unique value], unlike [alternative], because [unique attribute]. + +## The single-minded proposition (the sharp end) +Boil it to ONE sentence the market remembers: "[Brand] is the ONLY [category] that [unique value] for [target]." If you cannot honestly say "the only...", your differentiation is not sharp enough - go back to unique attributes and cut until one is undeniable. diff --git a/src/plugins/marketing/snippets/positioning/icp.txt b/src/plugins/marketing/snippets/positioning/icp.txt new file mode 100644 index 0000000..0ec307d --- /dev/null +++ b/src/plugins/marketing/snippets/positioning/icp.txt @@ -0,0 +1,18 @@ +# Ideal Customer Profile (ICP) - who EXACTLY, not "everyone" + +The ICP is the narrow set who get the most value, buy fastest, and tell others. It deepens positioning component 4 (target). + +## Define on +- Firmographics (B2B): industry, company size, revenue, geo, stage, tech stack. +- Demographics + psychographics (B2C): role, life stage, values, identity, habits. +- Triggers: the event that makes them look NOW (new job, growth spurt, a failure, a deadline, a new regulation). +- Job-to-be-done + the pain ranked #1 for them. + +## The "who cares most" test (Dunford): rank candidate segments by who values your UNIQUE attributes the most. Start with the one that buys fast and refers. + +## Early-vangelist (Steve Blank) for new products - the best first customer: +has the problem · knows they have it · is actively looking · has cobbled together a stopgap · has budget. + +## Anti-ICP: explicitly name who you do NOT serve. A sharp "not for X" makes the "for Y" credible and the message louder. + +Rule: niche down until the message feels almost too specific - that is when it converts. "For everyone" lands with no one. diff --git a/src/plugins/marketing/snippets/positioning/styles.txt b/src/plugins/marketing/snippets/positioning/styles.txt new file mode 100644 index 0000000..15188bf --- /dev/null +++ b/src/plugins/marketing/snippets/positioning/styles.txt @@ -0,0 +1,7 @@ +# Three styles of positioning (Dunford) - pick the frame that fits + +1. Head to head - position to WIN an existing category. Use only if you can credibly be the leader. Risky for challengers. +2. Big fish, small pond - position in a SUB-SEGMENT of an existing category you can dominate. Safer; own a niche first, then expand. +3. Create a new category - define and lead a brand-new category. Highest risk/reward; requires educating the market (see category design) and is a multi-year bet. + +Rule: most products should NOT create a category. Default to dominating a sub-segment (big fish, small pond) before anything bigger. diff --git a/src/plugins/marketing/snippets/research/voice-of-customer.txt b/src/plugins/marketing/snippets/research/voice-of-customer.txt new file mode 100644 index 0000000..bd0e8df --- /dev/null +++ b/src/plugins/marketing/snippets/research/voice-of-customer.txt @@ -0,0 +1,23 @@ +# Voice of Customer (VoC) & message mining (Joanna Wiebe / Copyhackers) +# This is HOW you get marketing words straight from the customer - the highest-leverage copy method. + +## Rule: do not write copy from your head. STEAL the customer's own words. + +## Mine these sources for raw language +- Product reviews - yours AND competitors'. 3-star reviews are the most honest. (G2, Amazon, App Store, Trustpilot, Capterra.) +- Support tickets, chat logs, sales-call recordings, win/loss interviews. +- Survey open-ends: "what almost stopped you from buying?", "what's your #1 frustration with [job]?", "describe the moment you realized you needed this". +- Communities: Reddit, forums, Discord, social replies, review-site Q&A. + +## What to pull (tag each verbatim quote) +- Desired outcomes / jobs (what they're trying to get done). +- Pains - in their EXACT phrasing of the frustration. +- Objections / hesitations (what almost stopped them). +- The moment of value ("I finally...", "now I can...", "it just..."). + +## Turn quotes into copy +- Use their exact phrases as headlines/subheads. Customers convert on THEIR language, not your jargon. +- The "so what?" / "and that means..." test: take a feature, ask "so what for the customer?" until you reach the outcome they actually named. +- Build a swipe file of the strongest verbatim lines; assemble the page from real quotes. + +Anti-pattern: aspirational brand language no real customer has ever said. If a customer wouldn't say it out loud, cut it. diff --git a/src/plugins/marketing/tools/brief.ts b/src/plugins/marketing/tools/brief.ts new file mode 100644 index 0000000..ddf10d7 --- /dev/null +++ b/src/plugins/marketing/tools/brief.ts @@ -0,0 +1,24 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { z } from "zod"; +import { buildBrief } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_brief", + "Assemble a product-marketing brief for a specific brand: returns the ordered workflow (which frameworks/tools to apply, in sequence) for the deliverables you need. It routes the work - you produce the marketing.", + { + brand: z.string().describe("The brand/product to market (one line: what it is + who it is for if known)."), + deliverables: z.array(z.string()).optional().describe("Subset of: positioning, messaging, copy, brand, gtm. Omit for the full workflow."), + }, + async ({ brand, deliverables }) => { + const steps = buildBrief(deliverables); + let text = `# Marketing brief: ${brand}\n\n`; + text += `Apply these in order. Each step names the tool(s) that supply the framework; you do the marketing.\n\n`; + steps.forEach((s, i) => { + text += `${i + 1}. **${s.step}** - ${s.why}\n tools: \`${s.tools}\`\n`; + }); + text += `\nStart with intake: who is it for, what does it do, what are the competitive alternatives, what is unique.\n`; + return { content: [{ type: "text" as const, text }] }; + }, + ); +} diff --git a/src/plugins/marketing/tools/get-anti-patterns.ts b/src/plugins/marketing/tools/get-anti-patterns.ts new file mode 100644 index 0000000..07d0b6b --- /dev/null +++ b/src/plugins/marketing/tools/get-anti-patterns.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { ANTI_PATTERNS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_anti_patterns", + "Marketing red flags with fixes: feature-dumping, we-we copy, vague unproven claims, marketing-to-everyone, better-not-different, premature scaling, vanity metrics. Use to QA any marketing output before shipping.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Marketing anti-patterns\n\n${ANTI_PATTERNS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-awareness-stages.ts b/src/plugins/marketing/tools/get-awareness-stages.ts new file mode 100644 index 0000000..f2e9744 --- /dev/null +++ b/src/plugins/marketing/tools/get-awareness-stages.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { AWARENESS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_awareness_stages", + "Eugene Schwartz's 5 stages of market awareness (unaware -> most-aware) + market sophistication, with how the copy must change per stage. Use to decide what to say before writing.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Market awareness\n\n${AWARENESS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-brand-strategy.ts b/src/plugins/marketing/tools/get-brand-strategy.ts new file mode 100644 index 0000000..99742f7 --- /dev/null +++ b/src/plugins/marketing/tools/get-brand-strategy.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { BRAND_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_brand_strategy", + "Evidence-based brand strategy: Byron Sharp's laws (penetration over loyalty, mental & physical availability, distinctive assets, double jeopardy), Binet & Field's 60/40 brand-vs-activation split, and category design (different-not-better). Use for the longer game.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Brand strategy\n\n${BRAND_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-channels.ts b/src/plugins/marketing/tools/get-channels.ts new file mode 100644 index 0000000..26ba57f --- /dev/null +++ b/src/plugins/marketing/tools/get-channels.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { CHANNELS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_channels", + "The 19 traction channels + the Bullseye framework (Traction, Weinberg & Mares): scan all channels, rank, test ~3 cheaply, focus on the one that works. Use to choose acquisition channels.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Channels\n\n${CHANNELS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-copywriting-formulas.ts b/src/plugins/marketing/tools/get-copywriting-formulas.ts new file mode 100644 index 0000000..4a80969 --- /dev/null +++ b/src/plugins/marketing/tools/get-copywriting-formulas.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { FORMULAS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_copywriting_formulas", + "Copywriting formulas with fill-in templates: PAS, AIDA, BAB, FAB, PASTOR, 4 Ps, the 4 U's. Use to structure any headline, ad, landing page, or email. Apply the formula yourself - this supplies the templates.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Copywriting formulas\n\n${FORMULAS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-growth-model.ts b/src/plugins/marketing/tools/get-growth-model.ts new file mode 100644 index 0000000..07f7704 --- /dev/null +++ b/src/plugins/marketing/tools/get-growth-model.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { GROWTH_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_growth_model", + "Growth model: AARRR pirate metrics (acquisition/activation/retention/referral/revenue) + growth loops vs funnels (Reforge) + the North Star metric. Use to design how growth compounds.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Growth model\n\n${GROWTH_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-gtm.ts b/src/plugins/marketing/tools/get-gtm.ts new file mode 100644 index 0000000..6dc55b0 --- /dev/null +++ b/src/plugins/marketing/tools/get-gtm.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { GTM_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_gtm", + "Go-to-market motions (PLG vs sales-led vs marketing-led vs community-led, and when each fits) + the product-launch playbook (launch tiers and pre/launch/post phases). Use to decide how it reaches the market.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Go-to-market\n\n${GTM_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-hooks.ts b/src/plugins/marketing/tools/get-hooks.ts new file mode 100644 index 0000000..9f15bc0 --- /dev/null +++ b/src/plugins/marketing/tools/get-hooks.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { HOOKS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_hooks", + "Hook frameworks for the first 1-3 seconds (ads, short-form video, social, subject lines): curiosity/open-loop, pain-point, pattern-interrupt, contrarian, result, plus the 4-beat short-form structure and swipe openers. Use to grab attention before the scroll.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Hooks\n\n${HOOKS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-icp.ts b/src/plugins/marketing/tools/get-icp.ts new file mode 100644 index 0000000..331c3a8 --- /dev/null +++ b/src/plugins/marketing/tools/get-icp.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { ICP_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_icp", + "Define the Ideal Customer Profile: firmographics/psychographics, buying triggers, the 'who cares most' test, the early-vangelist profile, and the anti-ICP. Use during positioning to decide who EXACTLY it is for - not 'everyone'.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Ideal Customer Profile\n\n${ICP_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-lifecycle.ts b/src/plugins/marketing/tools/get-lifecycle.ts new file mode 100644 index 0000000..69fa3d9 --- /dev/null +++ b/src/plugins/marketing/tools/get-lifecycle.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { LIFECYCLE_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_lifecycle", + "Lifecycle / email marketing flows: welcome, onboarding, nurture, engagement/retention, win-back, and behavioral/transactional - triggered on behavior, not a blast calendar. Use to design the retention and monetization engine after acquisition.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Lifecycle marketing\n\n${LIFECYCLE_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-messaging.ts b/src/plugins/marketing/tools/get-messaging.ts new file mode 100644 index 0000000..9d97106 --- /dev/null +++ b/src/plugins/marketing/tools/get-messaging.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { MESSAGING_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_messaging", + "Messaging frameworks: value-proposition canvas (jobs/pains/gains), StoryBrand SB7 (customer is the hero), strategic narrative (Raskin - story = strategy), and the message hierarchy. Use after positioning is set.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Messaging\n\n${MESSAGING_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-persuasion.ts b/src/plugins/marketing/tools/get-persuasion.ts new file mode 100644 index 0000000..72e71ad --- /dev/null +++ b/src/plugins/marketing/tools/get-persuasion.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { PERSUASION_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_persuasion", + "Persuasion + headlines + landing-page anatomy: Ogilvy/Caples headline rules and swipe templates, Cialdini's 7 principles of influence, and the conversion-ordered landing page structure. Use while writing.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Persuasion, headlines & landing pages\n\n${PERSUASION_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-positioning.ts b/src/plugins/marketing/tools/get-positioning.ts new file mode 100644 index 0000000..3e372ae --- /dev/null +++ b/src/plugins/marketing/tools/get-positioning.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { POSITIONING_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_positioning", + "Positioning framework (April Dunford): the 5 components in order (competitive alternatives -> unique attributes -> value -> target -> category) + the 3 positioning styles + a positioning-statement template. Use FIRST, before any messaging or copy.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Positioning\n\n${POSITIONING_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-pricing.ts b/src/plugins/marketing/tools/get-pricing.ts new file mode 100644 index 0000000..33dfe49 --- /dev/null +++ b/src/plugins/marketing/tools/get-pricing.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { PRICING_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_pricing", + "Pricing & packaging as a marketing lever: value-based pricing, good-better-best tiering, anchoring, fences between tiers, the value metric, and willingness-to-pay testing. Use to package and price the offer.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Pricing & packaging\n\n${PRICING_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-voice-of-customer.ts b/src/plugins/marketing/tools/get-voice-of-customer.ts new file mode 100644 index 0000000..f456227 --- /dev/null +++ b/src/plugins/marketing/tools/get-voice-of-customer.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { VOC_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_voice_of_customer", + "Voice-of-Customer / message mining (Copyhackers): how to harvest the customer's EXACT words from reviews, support, calls, and surveys, and turn them into copy. The method for getting marketing words straight from real customers. Use FIRST, before writing anything.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Voice of Customer\n\n${VOC_DOC}\n` }] }), + ); +} diff --git a/src/plugins/marketing/tools/get-voice.ts b/src/plugins/marketing/tools/get-voice.ts new file mode 100644 index 0000000..301d7bd --- /dev/null +++ b/src/plugins/marketing/tools/get-voice.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { VOICE_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "marketing_get_voice", + "Brand voice: the 12 archetypes (Mark & Pearson) with core desire/voice/example, plus the 4 tone dimensions (Nielsen Norman) for defining and applying a consistent voice. Use to set how the brand sounds.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Brand voice\n\n${VOICE_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/data.ts b/src/plugins/product-manager/data.ts index 9a19d8b..283be66 100644 --- a/src/plugins/product-manager/data.ts +++ b/src/plugins/product-manager/data.ts @@ -57,6 +57,12 @@ export const JTBD_DOC: string = snippet("jtbd/jtbd.txt"); // Rubrics the AGENT applies (ground truth, not a verdict the tool computes). export const OPPORTUNITY_RUBRIC_DOC: string = snippet("rubrics/opportunity-vs-solution.txt"); export const JOB_CRITERIA_DOC: string = snippet("rubrics/job-criteria.txt"); +export const PRIORITIZATION_DOC: string = snippet("prioritization/frameworks.txt"); +export const DECISION_TOOLKIT_DOC: string = snippet("decisions/toolkit.txt"); +export const MVP_DOC: string = snippet("scope/mvp.txt"); +export const ROADMAP_DOC: string = snippet("roadmap/roadmap.txt"); +export const METRICS_DOC: string = snippet("metrics/metrics.txt"); +export const PRODUCT_SENSE_DOC: string = snippet("product-sense/develop.txt"); // --- The one legitimate piece of logic: a deterministic STRUCTURE gate. --- // This does NOT judge whether the value/viability reasoning is good (that is the diff --git a/src/plugins/product-manager/index.ts b/src/plugins/product-manager/index.ts index c31f30f..ef93c76 100644 --- a/src/plugins/product-manager/index.ts +++ b/src/plugins/product-manager/index.ts @@ -9,6 +9,12 @@ import { register as opportunityVsSolution } from "./tools/opportunity-vs-soluti import { register as validateJobStatement } from "./tools/validate-job-statement.js"; import { register as scoreRice } from "./tools/score-rice.js"; import { register as resolveProductDecision } from "./tools/resolve-product-decision.js"; +import { register as getPrioritization } from "./tools/get-prioritization.js"; +import { register as getDecisionTools } from "./tools/get-decision-tools.js"; +import { register as getMvpScoping } from "./tools/get-mvp-scoping.js"; +import { register as getRoadmapping } from "./tools/get-roadmapping.js"; +import { register as getMetrics } from "./tools/get-metrics.js"; +import { register as getProductSense } from "./tools/get-product-sense.js"; function register(server: McpServer): void { getFourRisks(server); @@ -20,6 +26,12 @@ function register(server: McpServer): void { validateJobStatement(server); scoreRice(server); resolveProductDecision(server); + getPrioritization(server); + getDecisionTools(server); + getMvpScoping(server); + getRoadmapping(server); + getMetrics(server); + getProductSense(server); } export const productManagerPlugin: Plugin = { diff --git a/src/plugins/product-manager/snippets/decisions/toolkit.txt b/src/plugins/product-manager/snippets/decisions/toolkit.txt new file mode 100644 index 0000000..253a35d --- /dev/null +++ b/src/plugins/product-manager/snippets/decisions/toolkit.txt @@ -0,0 +1,16 @@ +# Decision-making toolkit (make better calls under uncertainty) + +## Type 1 vs Type 2 decisions (Bezos) - match speed to reversibility +- Type 1 / one-way door: hard or impossible to reverse. Decide carefully, more data, senior eyes. +- Type 2 / two-way door: easily reversible. Decide FAST, delegate, do not agonize - you can undo it. +Anti-pattern: treating reversible (Type 2) decisions as if they were irreversible -> slow, over-analyzed. Most product decisions are Type 2. + +## The 70% rule (Bezos): decide with ~70% of the info you wish you had. Waiting for 90% is too slow. Be good at being wrong fast and course-correcting. + +## Pre-mortem (Gary Klein, via Kahneman): BEFORE committing, imagine it is months later and the project FAILED. Everyone writes why. Surfaces the blind spots and failure modes optimism hides. Run it on every significant build. + +## Disagree and commit: once the call is made, even dissenters commit fully. State the disagreement, then row in the same direction. Kills passive resistance and endless re-litigation. + +## Decision record (log it): for any non-trivial call write down the decision, date, options considered, the reasoning, the assumptions, and what would make you reverse it. Cheap to write; kills hindsight bias and re-arguing later. + +## Decision quality != outcome quality: a good decision (good process + best available info) can have a bad outcome, and vice versa. Judge the process. For repeated bets, use expected value (probability x payoff), not gut. diff --git a/src/plugins/product-manager/snippets/metrics/metrics.txt b/src/plugins/product-manager/snippets/metrics/metrics.txt new file mode 100644 index 0000000..c7c4904 --- /dev/null +++ b/src/plugins/product-manager/snippets/metrics/metrics.txt @@ -0,0 +1,15 @@ +# Product metrics - measure outcomes, not output + +## North Star Metric (NSM): the ONE metric that best captures the value customers get (nights booked, messages sent, weekly active teams). A leading indicator of sustainable growth - align the org to move it, and pair with 2-4 input metrics that drive it. + +## One Metric That Matters (OMTM): at any stage, focus the team on the single metric that matters most right now (it changes by stage and goal). + +## OKRs: Objective (qualitative, ambitious, time-boxed) + 2-4 Key Results (measurable OUTCOMES, not tasks). A KR is a result ("activation 20% -> 35%"), never a to-do ("ship feature X"). + +## HEART (Google) - UX quality: Happiness, Engagement, Adoption, Retention, Task success. For each, define Goals -> Signals -> Metrics. + +## AARRR pirate funnel (acquisition / activation / retention / referral / revenue) - find the leakiest stage. (see marketing_get_growth_model) + +## Input vs output (leading vs lagging): optimize the INPUT metrics you control (the levers); watch OUTPUT metrics (revenue) as results. Avoid vanity metrics - totals that only go up and do not tie to value. + +## Rule: a metric without a target and an owner is decoration. Instrument activation and retention before scaling acquisition. diff --git a/src/plugins/product-manager/snippets/prioritization/frameworks.txt b/src/plugins/product-manager/snippets/prioritization/frameworks.txt new file mode 100644 index 0000000..53a270f --- /dev/null +++ b/src/plugins/product-manager/snippets/prioritization/frameworks.txt @@ -0,0 +1,21 @@ +# Prioritization frameworks - pick the one that fits the decision. (RICE is the default scorer; here are the rest.) + +## MoSCoW - scope a release +Must have (non-negotiable, it breaks without it) / Should have (high value, not blocking) / Could have (nice, first to drop under pressure) / Won't have (explicitly out, this release). Forces the "Won't" - the discipline of saying no out loud. + +## Kano model (Noriaki Kano) - classify features by how they drive satisfaction +- Basic / must-be: expected; absent = anger, present = neutral. Table stakes. +- Performance / linear: more is better; satisfaction scales with how well you do it. +- Excitement / delighters: unexpected; present = delight, absent = no harm. The differentiators. +- Indifferent: nobody cares - cut it. +- Reverse: its presence actively annoys some users. +Rule: cover all Basics, compete on Performance, win on a few Excitement. Delighters decay into Basics over time. + +## ICE = Impact x Confidence x Ease. Fast and rough; good for experiment/growth backlogs (highest-learning, lowest-effort first). + +## WSJF (Weighted Shortest Job First, SAFe) = Cost of Delay / Job Duration. Do high-cost-of-delay short jobs first. +- Cost of Delay = user/business value + time criticality + risk-reduction / opportunity-enablement. + +## Opportunity scoring (Ulwick / ODI) - find gaps where IMPORTANCE is high and SATISFACTION is low. That gap is the underserved opportunity. Score ~ importance + (importance - satisfaction). + +## Rule: prioritize against a desired OUTCOME, not a feature wish-list. Prioritization is the act of saying no to good ideas. diff --git a/src/plugins/product-manager/snippets/product-sense/develop.txt b/src/plugins/product-manager/snippets/product-sense/develop.txt new file mode 100644 index 0000000..2922def --- /dev/null +++ b/src/plugins/product-manager/snippets/product-sense/develop.txt @@ -0,0 +1,22 @@ +# How to develop product sense (Jules Walter, Julie Zhuo) - a learned skill, not a gift. Deliberate practice. + +## 1. Customer immersion (the foundation) +- Talk to users regularly: scheduled interviews, usability tests, read support tickets. Ask open-ended questions; watch body language and emotion. +- Shadow users at work: sit beside a real customer doing a real task (yours or a competitor's). You see what surveys miss - environment, interruptions, workarounds, emotional cues. +- Do support and sales calls yourself. Empathy is raw data. + +## 2. Product teardowns / critiques (build pattern recognition) +- Spend 1-2 hours a month trying new products and deconstructing them: why does this work, why does that not? +- Use Julie Zhuo's critique questions: what is the signup / getting-started experience? what is the core flow? what would I change and why? +- Compare 3+ products in the SAME category - how does each solve the same job differently? Keep a written pattern library. + +## 3. Principles-first, not technique-copying (Cagan) +- Master enduring principles so you can judge WHEN a technique applies, instead of copying trendy frameworks. Techniques churn; principles endure. + +## 4. Close the loop (calibrate your intuition) +- Before shipping, PREDICT the outcome and write it down. After shipping, compare to what actually happened. The gap is where product sense sharpens. + +## 5. Learn from strong product thinkers +- Work near them and critique with them if you can. If not, study Julie Zhuo, Stewart Butterfield, Rahul Vohra, Marty Cagan, Shreyas Doshi. + +Rule: product sense = heavy customer exposure + deliberate teardowns + closing the predict/outcome loop, repeated. A practice, not a vibe. diff --git a/src/plugins/product-manager/snippets/roadmap/roadmap.txt b/src/plugins/product-manager/snippets/roadmap/roadmap.txt new file mode 100644 index 0000000..f98d9fe --- /dev/null +++ b/src/plugins/product-manager/snippets/roadmap/roadmap.txt @@ -0,0 +1,15 @@ +# Roadmapping - communicate direction without faking precision + +## Now / Next / Later - the default modern roadmap. Three horizons of decreasing certainty: +- Now: committed, in progress (specific). +- Next: likely next, shaped but not committed (themes). +- Later: directional bets (problems / outcomes, not features). +Shows direction without false-precision date promises. + +## Outcome-based, not feature-based (Cagan): give teams a prioritized set of PROBLEMS / OUTCOMES to solve, not a dated feature list. A feature roadmap with deadlines is the feature-factory anti-pattern. + +## Theme-based: organize around customer problems / strategic themes, each tied to an outcome metric. + +## GIST (Itamar Gilad): Goals -> Ideas -> Steps -> Tasks. Goals are outcomes; ideas are many and cheap; step-projects test them; tasks execute. Decouples stable direction from disposable features. + +## Rules: tie every roadmap item to a goal/outcome; the further out, the fuzzier (problems, not features); revisit continuously - the roadmap is a living bet, not a contract. diff --git a/src/plugins/product-manager/snippets/scope/mvp.txt b/src/plugins/product-manager/snippets/scope/mvp.txt new file mode 100644 index 0000000..d4aafa0 --- /dev/null +++ b/src/plugins/product-manager/snippets/scope/mvp.txt @@ -0,0 +1,15 @@ +# MVP & scope-cutting - ship the smallest thing that creates and captures value + +## MVP = the smallest version that lets you LEARN the riskiest thing (or deliver the core value) - not a tiny pile of features, not a broken half-product. "Viable" matters as much as "minimal". + +## Riskiest Assumption Test (RAT): instead of building the whole MVP, find the assumption that, if wrong, kills the idea, and test THAT first with the cheapest experiment that de-risks it. Often a landing page, a concierge / Wizard-of-Oz, or 5 customer tests - no code. + +## Slice vertically, not horizontally: ship a thin end-to-end "walking skeleton" (one real user does one real job start to finish), then thicken. Never ship a horizontal layer nobody can use yet. + +## Story slicing - cut a big story to the thinnest valuable slice: by workflow step, by user type, happy-path-first (defer edge cases), manual-before-automated, one-platform-first. + +## The cut test: for every item in scope ask "if we remove this, does the core value still work?" If yes, cut it from v1. Default to cutting. + +## De-risk order: value risk first (do they want it?), then usability, then feasibility. Do not perfect the build of something nobody wants. + +Anti-pattern: gold-plating v1, building all edge cases before validating the core, an "MVP" that is secretly a full product. diff --git a/src/plugins/product-manager/tools/get-decision-tools.ts b/src/plugins/product-manager/tools/get-decision-tools.ts new file mode 100644 index 0000000..010ae31 --- /dev/null +++ b/src/plugins/product-manager/tools/get-decision-tools.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { DECISION_TOOLKIT_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_decision_tools", + "Decision-making toolkit: Type-1/Type-2 (reversible vs one-way-door) decisions, the 70% rule, pre-mortems, disagree-and-commit, decision records, and decision-vs-outcome quality. Use to make and document calls under uncertainty.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Decision toolkit\n\n${DECISION_TOOLKIT_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/tools/get-metrics.ts b/src/plugins/product-manager/tools/get-metrics.ts new file mode 100644 index 0000000..cbd0601 --- /dev/null +++ b/src/plugins/product-manager/tools/get-metrics.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { METRICS_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_metrics", + "Product metrics: North Star metric, One Metric That Matters, OKRs (outcomes not tasks), Google's HEART, AARRR, and input-vs-output / vanity-metric traps. Use to define what success is measured by.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Product metrics\n\n${METRICS_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/tools/get-mvp-scoping.ts b/src/plugins/product-manager/tools/get-mvp-scoping.ts new file mode 100644 index 0000000..10f613f --- /dev/null +++ b/src/plugins/product-manager/tools/get-mvp-scoping.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { MVP_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_mvp_scoping", + "MVP & scope-cutting: what an MVP really is, the Riskiest Assumption Test, vertical slicing / walking skeleton, story slicing, the cut test, and de-risk order (value->usability->feasibility). Use to cut a build to its thinnest valuable slice.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# MVP & scope-cutting\n\n${MVP_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/tools/get-prioritization.ts b/src/plugins/product-manager/tools/get-prioritization.ts new file mode 100644 index 0000000..5d28b69 --- /dev/null +++ b/src/plugins/product-manager/tools/get-prioritization.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { PRIORITIZATION_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_prioritization", + "Prioritization frameworks beyond RICE: MoSCoW (release scoping), Kano (basic/performance/excitement), ICE, WSJF / cost-of-delay, and opportunity scoring (importance vs satisfaction gap). Use to decide what to build and in what order.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Prioritization\n\n${PRIORITIZATION_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/tools/get-product-sense.ts b/src/plugins/product-manager/tools/get-product-sense.ts new file mode 100644 index 0000000..f6bbc18 --- /dev/null +++ b/src/plugins/product-manager/tools/get-product-sense.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { PRODUCT_SENSE_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_product_sense", + "How to develop product sense (Jules Walter, Julie Zhuo): customer immersion, product teardowns/critiques, principles-first learning, and closing the predict/outcome loop. The deliberate practice for building product judgment.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Developing product sense\n\n${PRODUCT_SENSE_DOC}\n` }] }), + ); +} diff --git a/src/plugins/product-manager/tools/get-roadmapping.ts b/src/plugins/product-manager/tools/get-roadmapping.ts new file mode 100644 index 0000000..5c503e4 --- /dev/null +++ b/src/plugins/product-manager/tools/get-roadmapping.ts @@ -0,0 +1,11 @@ +import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { ROADMAP_DOC } from "../data.js"; + +export function register(server: McpServer): void { + server.tool( + "product_manager_get_roadmapping", + "Roadmapping: Now/Next/Later horizons, outcome-based (not feature-based) roadmaps, theme-based organization, and GIST. Use to communicate direction without faking date precision or sliding into a feature factory.", + {}, + async () => ({ content: [{ type: "text" as const, text: `# Roadmapping\n\n${ROADMAP_DOC}\n` }] }), + ); +} diff --git a/tests/marketing-behaviour.test.ts b/tests/marketing-behaviour.test.ts new file mode 100644 index 0000000..e3bf48b --- /dev/null +++ b/tests/marketing-behaviour.test.ts @@ -0,0 +1,63 @@ +import { test, expect } from "bun:test"; +import { buildBrief, FULL_WORKFLOW } from "../src/plugins/marketing/data.ts"; +import { captureTool, extractTextContent } from "./helpers.ts"; +import { register as getPositioning } from "../src/plugins/marketing/tools/get-positioning.ts"; +import { register as getFormulas } from "../src/plugins/marketing/tools/get-copywriting-formulas.ts"; +import { register as getChannels } from "../src/plugins/marketing/tools/get-channels.ts"; +import { register as brief } from "../src/plugins/marketing/tools/brief.ts"; +import { register as getVoc } from "../src/plugins/marketing/tools/get-voice-of-customer.ts"; + +// --- the brief assembler --- +test("full workflow leads with VoC research, then positioning", () => { + expect(FULL_WORKFLOW[0].step).toBe("Research"); + expect(FULL_WORKFLOW.map((s) => s.step)).toContain("Position"); +}); + +test("buildBrief returns the full workflow when no deliverables given", () => { + expect(buildBrief()).toEqual(FULL_WORKFLOW); +}); + +test("buildBrief for copy returns write+voice+check, not positioning", () => { + const steps = buildBrief(["copy"]).map((s) => s.step); + expect(steps).toContain("Write"); + expect(steps).toContain("Voice"); + expect(steps).toContain("Check"); + expect(steps).not.toContain("Position"); +}); + +// --- tools serve ground-truth frameworks --- +test("get_positioning returns Dunford's components", async () => { + const tool = captureTool(getPositioning); + expect(tool.name).toBe("marketing_get_positioning"); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/competitive alternatives/i); + expect(text).toMatch(/market category/i); +}); + +test("get_copywriting_formulas returns PAS and AIDA templates", async () => { + const tool = captureTool(getFormulas); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/PAS/); + expect(text).toMatch(/AIDA/); +}); + +test("get_channels returns the Bullseye framework", async () => { + const tool = captureTool(getChannels); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/Bullseye/i); +}); + +test("brief assembles an ordered plan for a specific brand", async () => { + const tool = captureTool(brief); + expect(tool.name).toBe("marketing_brief"); + const text = extractTextContent(await tool.invoke({ brand: "a meditation app for busy parents" })); + expect(text).toMatch(/meditation app/); + expect(text).toMatch(/Position/); +}); + +test("get_voice_of_customer returns the message-mining method", async () => { + const tool = captureTool(getVoc); + expect(tool.name).toBe("marketing_get_voice_of_customer"); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/exact words|verbatim|reviews/i); +}); diff --git a/tests/persona-registry-behaviour.test.ts b/tests/persona-registry-behaviour.test.ts index 712a880..dc536d7 100644 --- a/tests/persona-registry-behaviour.test.ts +++ b/tests/persona-registry-behaviour.test.ts @@ -9,6 +9,14 @@ test("registry loads the product-manager persona manifest", () => { expect(pm!.gate_policy.net_new).toBe("hard"); }); +test("registry loads the marketing capability persona", () => { + const personas = loadPersonas(); + const m = personas.find((p) => p.id === "marketing"); + expect(m).toBeDefined(); + expect(m!.mode).toBe("capability"); + expect(m!.owns.plugin).toBe("marketing"); +}); + test("a malformed manifest is skipped, not thrown", () => { expect(() => loadPersonas()).not.toThrow(); }); diff --git a/tests/plugin-registry-behaviour.test.ts b/tests/plugin-registry-behaviour.test.ts index a1e10c8..3f89fba 100644 --- a/tests/plugin-registry-behaviour.test.ts +++ b/tests/plugin-registry-behaviour.test.ts @@ -17,10 +17,10 @@ function getRegisteredTools() { return tools; } -test("all 14 plugins register at least one tool", () => { +test("all 15 plugins register at least one tool", () => { const tools = getRegisteredTools(); const pluginPrefixes = new Set(tools.map((t) => t.name.split("_")[0])); - expect(pluginPrefixes.size).toBe(14); + expect(pluginPrefixes.size).toBe(15); }); test("product-manager plugin registers its gate tools", () => { @@ -30,6 +30,13 @@ test("product-manager plugin registers its gate tools", () => { expect(toolNames.has("product_manager_resolve_product_decision")).toBe(true); }); +test("marketing plugin registers its tools", () => { + const tools = getRegisteredTools(); + const toolNames = new Set(tools.map((t) => t.name)); + expect(toolNames.has("marketing_get_positioning")).toBe(true); + expect(toolNames.has("marketing_brief")).toBe(true); +}); + test("every registered tool has a non-empty name and description", () => { const tools = getRegisteredTools(); for (const tool of tools) { diff --git a/tests/product-manager-behaviour.test.ts b/tests/product-manager-behaviour.test.ts index f9b39e5..d6e2a19 100644 --- a/tests/product-manager-behaviour.test.ts +++ b/tests/product-manager-behaviour.test.ts @@ -12,6 +12,10 @@ import { register as oppVsSol } from "../src/plugins/product-manager/tools/oppor import { register as validateJob } from "../src/plugins/product-manager/tools/validate-job-statement.ts"; import { register as scoreRiceTool } from "../src/plugins/product-manager/tools/score-rice.ts"; import { register as resolveDecision } from "../src/plugins/product-manager/tools/resolve-product-decision.ts"; +import { register as getPrioritization } from "../src/plugins/product-manager/tools/get-prioritization.ts"; +import { register as getDecisionTools } from "../src/plugins/product-manager/tools/get-decision-tools.ts"; +import { register as getMvpScoping } from "../src/plugins/product-manager/tools/get-mvp-scoping.ts"; +import { register as getProductSense } from "../src/plugins/product-manager/tools/get-product-sense.ts"; // --- data layer --- test("four risks are exactly the canonical four", () => { @@ -109,3 +113,32 @@ test("resolve_product_decision PASSes when value and viability are supplied", as })); expect(text).toMatch(/PASS/); }); + +test("get_prioritization includes Kano and MoSCoW", async () => { + const tool = captureTool(getPrioritization); + expect(tool.name).toBe("product_manager_get_prioritization"); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/Kano/); + expect(text).toMatch(/MoSCoW/); +}); + +test("get_decision_tools includes Type 1/Type 2 and pre-mortem", async () => { + const tool = captureTool(getDecisionTools); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/Type 1/); + expect(text).toMatch(/[Pp]re-mortem/); +}); + +test("get_mvp_scoping includes the riskiest assumption test", async () => { + const tool = captureTool(getMvpScoping); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/Riskiest Assumption|riskiest assumption/); +}); + +test("get_product_sense covers teardowns and customer immersion", async () => { + const tool = captureTool(getProductSense); + expect(tool.name).toBe("product_manager_get_product_sense"); + const text = extractTextContent(await tool.invoke({})); + expect(text).toMatch(/teardown/i); + expect(text).toMatch(/immersion|customer/i); +});