AI-powered lifecycle messaging generator for SaaS companies.

Mango Lollipop uses Claude Code to analyze your business, generate a complete lifecycle messaging matrix using the AARRR pirate metrics framework, write full message copy in your brand voice, and produce production-ready deliverables -- all from your terminal.

It builds on proven industry templates, copywriting frameworks, and lifecycle best practices so you don't have to start from a blank page or reinvent the wheel.

See a live demo -- interactive dashboard, message previews, executive overview, and event spec generated for a fictional B2B SaaS company.

• Local only

  Runs entirely on your machine through Claude Code. No hosted services, no accounts, no data leaving your terminal.

• Production-ready deliverables

  Everything it generates (Excel, HTML, markdown) is ready to hand off to engineering or share with stakeholders. No "demo quality" output.

• Some effort required

  This is a collaborative tool, not a magic button. You review each step, give feedback, and steer the output. The AI does the heavy lifting, but your judgment makes it good.

• Step by step

  Each skill runs independently so you can review, iterate, and course-correct before moving on. Rushing through produces mediocre results.

• Scalable

  Works for a 5-message onboarding sequence or a 50-message lifecycle system. The framework scales; the effort stays manageable.

• Easy, not complex

  No build tools, no databases, no config files to wrestle with. Install, init, and start talking to Claude Code.

• Excel matrix -- your lifecycle messaging source of truth (matrix.xlsx) with a Welcome sheet, color-coded stages, and 5 data sheets
• Interactive dashboard -- sortable, filterable message matrix with tag sidebar and journey map (dashboard.html)
• Message previews -- channel-specific visual previews for email, in-app, SMS, and push (messages.html)
• Executive overview -- clean, printable summary for stakeholders (overview.html)
• Full message copy -- emails, in-app, push, SMS written in your voice (messages/)
• Developer hand-off -- introduction email + technical event spec for your engineering team
• Iterative refinement -- tweak anything conversationally through Claude Code

Starting fresh? Mango Lollipop builds your entire messaging system from scratch based on your product, audience, and voice.

Have existing messages? Paste them in, share your stats, and Mango Lollipop audits what you have, fills gaps, and improves what's not working.

# Install
npm install -g mango-lollipop

# Update to the latest version
mango-lollipop update

# Initialize a project
mango-lollipop init my-company

# Open Claude Code in your project and run the start skill
/start

Mango Lollipop is designed to be used step by step. Each skill produces output you should review before moving on -- this is how you get good results instead of a wall of AI-generated text you have to untangle later.

Stay in Claude Code for the entire workflow. Every step is a slash command.

Step 1: Analyze your business

> /start

Paste your website URL and Claude will pull most of the information it needs automatically. It'll ask follow-up questions about your channels, voice, and key features. Review analysis.json when it's done -- this is the foundation everything else builds on.

Step 2: Generate the messaging matrix

> /generate-matrix

Creates every message with triggers, guards, suppressions, and timing. Open matrix.xlsx and review the strategy. Too many messages? Wrong triggers? Use /iterate to tweak before moving on.

Step 3: Write the message copy

> /generate-messages

Spins up a team of AI copywriters that work in parallel, each writing a batch of 10 messages in your brand voice. Spot-check a few messages in the messages/ folder when they're done. If the tone is off, tell Claude and it'll adjust.

Step 4: Generate visual deliverables

> /generate-dashboard

Creates the interactive dashboard, message previews, and executive overview. Open dashboard.html in your browser to explore the full matrix with filters, journey maps, and channel-specific message previews.

Step 5: Hand off to engineering

> /dev-handoff

Generates two files: dev-handoff-email.md (an introduction email you can customize and send to your engineering team) and event-spec.html (the full technical event spec with payloads and code examples). Review both before sharing.

At any point, use /iterate to go back and change things conversationally, or /audit if you have existing messages you want analyzed first.

All 7 skills run inside Claude Code as slash commands.

Gathers your product info, voice samples, channel preferences, and event taxonomy. Paste your website URL and Claude extracts most of the details automatically -- you just confirm and fill in the gaps.

Prerequisites: An initialized project (mango-lollipop init) Outputs: analysis.json, updated mango-lollipop.json

> /start
# Paste your website URL, answer a few questions, done

Creates the complete AARRR messaging matrix with transactional messages, triggers, guards, and suppressions.

Prerequisites: analysis.json from /start Outputs: matrix.json, matrix.xlsx (6-sheet workbook with Welcome sheet and color-coded stages)

> /generate-matrix
# Generates TX-01 through RF-XX with full trigger/guard/suppression logic

Spins up a parallel team of AI copywriters that write full message copy in your brand voice, batched by 10.

Prerequisites: matrix.json from /generate-matrix Outputs: messages/{STAGE}/{ID}-{slug}.md files with YAML frontmatter and channel-specific body sections

> /generate-messages
# Writes all message copy, 10 messages at a time

Generates the interactive dashboard, message preview viewer, and printable executive overview.

Prerequisites: matrix.json, analysis.json, optionally messages/ directory Outputs: dashboard.html, messages.html, overview.html

> /generate-dashboard
# Creates 3 HTML files with journey maps, previews, and stats

Generates an introduction email from marketing to engineering and a detailed technical event implementation spec.

Prerequisites: matrix.json, analysis.json Outputs: dev-handoff-email.md, event-spec.html

> /dev-handoff
# Creates the email draft + interactive technical spec with code examples

Deep analysis of your current lifecycle messaging with a maturity scorecard, gap analysis, and improvement recommendations.

Prerequisites: Your existing messages (pasted or described during the session) Outputs: Audit report with maturity scores and prioritized recommendations

> /audit
# Paste your existing messages and stats for a full gap analysis

Modify the matrix conversationally -- add, remove, or tweak messages based on feedback.

Prerequisites: matrix.json Outputs: Updated matrix.json and matrix.xlsx

> /iterate
# "Add a win-back email for users who cancelled" or "Change AC-03 to fire after 5 days"

Every message maps to a pirate metrics lifecycle stage:

Transactional messages (TX) are separated from lifecycle messages. They're non-negotiable (email verification, password reset, receipts), legally distinct, and always generated.

Every message targets exactly one channel: email, in-app, sms, or push. If a logical message needs to go out on both email and in-app, it becomes two separate entries with sequential IDs.

Each message includes:

• Trigger -- the event that fires the message (e.g., user.email_verified, trial.ending_soon). Can be an event, a scheduled job, or a behavioral signal.
• Wait -- how long to pause after the trigger before sending. Uses ISO 8601 durations: P0D (instant), PT5M (5 minutes), P2D (2 days).
• Guards -- conditions that must ALL be true for the message to send. Example: "User has not completed onboarding" prevents sending a getting-started guide to someone who already finished it. Guards use AND logic.
• Suppressions -- conditions where ANY one being true cancels the message. Example: "User already used this feature" prevents nagging about a feature they've already discovered. Suppressions use OR logic.

This trigger/wait/guard/suppression model gives you precise control over when messages fire, what conditions must hold, and what should cancel them -- without hardcoding logic into your app.

mango-lollipop/
├── bin/                        # CLI entry point
├── .claude/skills/             # Claude Code slash commands (skills)
│   ├── start/SKILL.md         # Business analysis + onboarding
│   ├── generate-matrix/SKILL.md     # Matrix generation
│   ├── generate-messages/SKILL.md   # Message copy writing
│   ├── generate-dashboard/SKILL.md  # Dashboard + journey maps
│   ├── audit/SKILL.md         # Existing messaging audit
│   ├── dev-handoff/SKILL.md   # Developer hand-off documents
│   └── iterate/SKILL.md       # Conversational refinement
├── templates/                  # Output templates + event taxonomies
│   └── events/                 # Industry-specific event templates
├── lib/                        # Shared utilities (schema, excel, html, mermaid)
└── output/                     # Generated project output (gitignored)
    └── {project-name}/
        ├── mango-lollipop.json
        ├── analysis.json
        ├── matrix.json
        ├── matrix.xlsx
        ├── dashboard.html
        ├── messages.html
        ├── overview.html
        ├── dev-handoff-email.md
        ├── event-spec.html
        └── messages/
            ├── TX/
            ├── AQ/
            ├── AC/
            ├── RV/
            ├── RT/
            └── RF/

MIT