Unabyss

View saved version →

---
name: brand-voice
description: "Derive a founder or company voice profile from real writing samples found in connected sources, then use it to ensure all content sounds like the actual person — not generic AI copy. Use this skill whenever the user asks about their writing style, brand voice, tone of voice, how they sound, or wants any content to match their voice. Also trigger when another skill needs a voice profile before writing copy, posts, emails, or outreach."
---

# Brand Voice

Extract a reusable voice profile from the founder's actual writing — so every piece of content sounds like them, not like a language model approximating them.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` to surface real writing samples across all connected sources.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a brand voice or voice profile export already exists and is fresh, call `export_read` — no need to regenerate.

### Step 2 — Pull writing samples with `agentic_query`

Samples are scattered across emails, posts, docs, Slack — use `agentic_query`:

```
Find examples of my own writing from across all connected sources — emails I've sent, LinkedIn or X posts, Slack messages where I'm explaining something, docs or notes I've written, launch announcements, product updates, or any other text where I'm clearly the author. Prioritize recent material. Return the actual text, not summaries.
```

Call `agentic_query_read` to retrieve results. Aim for 8–12 distinct samples across different contexts.

### Step 3 — Analyze and produce the profile

---

**VOICE PROFILE — [Name / Company]**
*Generated from [N] samples*

**In one sentence**
How this person writes, in plain language.

**Tone**
3–5 specific descriptors, each with a concrete example from the actual samples.

**Sentence style**
Typical length, structure, how they open and close ideas.

**How they make claims**
Direct / hedged / evidence-first / assertion-first — with examples.

**What they reach for**
Numbers, analogies, product examples, customer stories.

**Vocabulary**
Words and phrases that appear naturally. Words and constructions they never use.

**What to avoid**
Specific patterns, phrases, or tones that would immediately sound wrong.

**3 on-voice examples**
Pulled verbatim from samples, with a one-line note on why each works.

---

### Step 4 — Save the profile

Once generated, call `export_create_from_text` to save the voice profile as an export — so other skills can load it instantly next time with `export_read` instead of regenerating.

---

## Output Rules

- Always check `export_list` before running `agentic_query` — voice profiles change slowly
- Every observation grounded in an actual sample — no invented characterizations
- If samples are thin, note which sources seem missing and produce a partial profile with caveats
- No preamble — start directly with the voice profile

View saved version →

---
name: company-context
description: "Load a full picture of the user's company — what it does, who it's for, current stage, traction, team, and open priorities — from Unabyss as the source of truth. Use this skill at the start of any session where company context would improve the output, before running skills that need to know what the company does or where it stands. Also trigger when the user says load my company context, what do you know about my company, or before any task involving positioning, fundraising, hiring, or GTM."
---

# Company Context

Load a complete, current picture of the user's company from Unabyss — so every skill that follows is grounded in what the company actually does, where it stands, and what it's focused on. No manual briefing required.

## Required Integrations

This skill uses **Unabyss MCP** — specifically `query` and `agentic_query`.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a company context export already exists and is fresh, call `export_read` to load it directly — no need to regenerate.

### Step 2 — Query if no export exists

If no export exists or it's stale, run a `query`:

```
What is the company — what does it do, what problem does it solve, and who is it built for? What stage is it at? What are the key metrics — revenue, MRR, ARR, growth, users, or any other traction signals? Who is on the team? What is the company currently focused on? What are the most important open questions or decisions right now?
```

If `query` returns thin results, escalate to `agentic_query` with the same prompt for deeper synthesis.

### Step 3 — Present the context

---

**Company Context**

**What we do**
One sentence — plain-language description of the product and the problem it solves.

**Who it's for**
The target customer — specific enough to be useful.

**Stage & traction**
Current stage, key metrics, and any notable signals.

**Team**
Headcount and key people. Open roles if known.

**Current focus**
What the company is actively working toward — next 30–90 days, not the long-term vision.

**Open questions**
Unresolved decisions or areas actively being figured out.

---

Then confirm: "Company context loaded. What would you like to work on?"

---

## Output Rules

- Always check `export_list` before querying — reuse fresh exports
- Use `query` for fast factual recall; escalate to `agentic_query` only if results are thin
- If a section has no signal, omit it and note at the end what's missing
- Pairs naturally with `personal-context` — run both at session start for full grounding

View saved version →

---
name: content-engine
description: "Turn the founder's own recent thinking, work, and conversations into platform-native content — LinkedIn posts, X threads, newsletters, or long-form articles — written in their actual voice. Use this skill whenever the user wants to create social posts, write a newsletter, draft a thread, repurpose something into content, or asks what they should post about. Also trigger when someone says they should be posting more but never have time, or wants to build in public."
---

# Content Engine

Mine the founder's own activity, thinking, and conversations and turn the most interesting signals into ready-to-use content. Raw material comes from what the user actually did and thought — not from a brief they write.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` for raw material, `export_read` for voice profile.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Load voice profile

Call `export_list` and look for a brand voice or voice profile export. If found, call `export_read` to load it. If not found, run the `brand-voice` skill first — all content must match the founder's actual voice.

### Step 2 — Mine raw material with `agentic_query`

Activity is scattered across many sources — use `agentic_query`:

```
Look across all connected sources from the last 2–4 weeks for signals worth turning into content. Find:
- Decisions made and the reasoning behind them
- Things learned — from customers, from shipping, from mistakes
- Opinions or takes that came up in emails, messages, or calls
- Product or company milestones — shipped features, wins, numbers crossed
- Interesting problems encountered and how they were solved
- Anything the founder explained to someone that others would find useful

Return raw signals with enough context to understand what happened.
```

Call `agentic_query_read` to retrieve results.

### Step 3 — Pitch angles, don't draft everything

Identify the 3–5 strongest content angles — specific, non-obvious, clear point of view. For each, write one sentence: what the post is about and why it's worth reading.

Present these to the user for selection before writing full drafts.

### Step 4 — Produce the selected content

For the chosen angle, apply the right format:

**LinkedIn** — 150–300 words, one clear idea, no engagement-bait closing questions.
**X** — open with the strongest claim, one idea per post, thread only if each post stands alone.
**Newsletter** — first paragraph does real work, no warm-up, sections only when they add clarity.
**Long-form** — lead with the concrete example, every section adds something new.

---

## Hard Bans

Delete and rewrite any of these:
- "In today's landscape..." / "game-changing" / "revolutionary"
- "I'm excited to share"
- Generic founder-journey filler
- Closing questions added only to juice engagement
- Copy that could be dropped unchanged into a competitor's post

---

## Output Rules

- Load voice profile from `export_read` — don't regenerate if it exists
- Use `agentic_query` for raw material — deep cross-source synthesis needed
- Always pitch angles before writing full drafts
- If Unabyss finds nothing worth posting, say so — don't generate generic content
- No preamble

View saved version →

---
name: customer-pulse
description: Surface what real customers are saying right now — praise worth amplifying, frustrations worth acting on, and accounts showing churn risk. Only active customers, last 1–2 weeks. Use this skill whenever the user asks "what are customers saying", "any good testimonials lately", "who's unhappy", "any churn risk", "what's the customer sentiment", "customer feedback this week", "are customers happy", "what are users complaining about", "any wins from customers", "highlight customer feedback", or anything that implies they want a founder-level read on customer sentiment. Requires Unabyss MCP.
---

# Customer Pulse

Surface what active customers are saying right now — praise worth amplifying, frustrations worth acting on, accounts at risk. Last 1–2 weeks only. No noise from churned accounts or unconverted leads.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` for cross-source customer signal synthesis.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Run `agentic_query`

Customer signals are spread across email, support, calls, and CRM — use `agentic_query`:

```
Look across all connected sources for customer signals from the last 7–14 days. Active, paying or recently onboarded customers only — exclude people who have already cancelled, unconverted leads, and internal team members.

Find:
- Positive feedback, praise, or results customers reported — include name and company where available
- Frustrations, complaints, or repeated problems — even indirect ones
- Accounts that seem to be going quiet, disengaging, or showing signs they might leave
- Feature requests or product gaps mentioned by customers
- Any customer who gave a quote or said something that reads like a testimonial

Return individual signals — don't group or summarize. Include customer name/company and date where available.
```

Call `agentic_query_read` with the returned query id to retrieve the result.

### Step 2 — Synthesize the pulse

---

**Customer Pulse — [Date range]**

**💚 Bright spots**
Positive signals and quotes. For each: customer name/company, what they said, and whether it's usable as a testimonial (yes / needs follow-up / no).

**🔴 Needs attention**
Active customers expressing frustration. For each: who, what the issue is, how long it's been unresolved, and a specific next step.

**⚠️ Churn risk**
Accounts going quiet or signalling doubt. For each: who, the warning sign, and a suggested action.

**💬 What they're asking for**
Recurring product gaps from active customers, grouped by theme.

---

## Output Rules

- Only active customers — exclude churned and unconverted
- Every item needs a name or company — anonymous signals only if strongly meaningful
- Next steps must be specific, not just "follow up"
- Quote customers directly where possible
- Omit empty sections entirely
- No preamble before the header
- Keep under 400 words

View saved version →

---
name: daily-brief
description: "Start the day calibrated in under 60 seconds — today's meetings, open loops that need a reply, and the top 3 priorities to focus on. Use this skill whenever the user wants a morning brief, daily digest, start of day summary, or asks what's on their plate today. Also trigger when someone says 'what does my day look like', 'catch me up', 'what should I focus on today', or 'what's first'."
---

# Daily Brief

One 60-second read at the start of the day: what's on the calendar, what's waiting for a reply, and what matters most today. No noise — only what requires attention.

## Required Integrations

This skill uses **Unabyss MCP** and **Google Calendar**.

> If either is missing, tell the user which one is needed and that they can connect it from the Tools menu.

---

## How to Run

### Step 1 — Fetch today's calendar

Use Google Calendar to pull today's events. For each event note: title, time, duration, and whether it has external attendees.

### Step 2 — Pull open loops with `query`

Fast lookup — use `query`, not `agentic_query`:

```
What emails or messages from the last 3 days have arrived from real people and haven't been replied to? Any threads where someone is waiting on me or I said I'd do something and haven't followed up?
```

Surface only the top 3 most time-sensitive. This is a morning brief, not a full triage — the full triage is `open-loops-digest`.

### Step 3 — Pull today's priorities with `query`

```
What are my top priorities right now — what did I say I was focused on this week, what's most urgent, and what's the single most important thing to move forward today?
```

### Step 4 — Compose the brief

---

**Daily Brief — [Day, Date]**

**📅 Today**
List each meeting with time and who it's with. For external meetings flag with → *[pre-call brief available]* as a reminder.
If no meetings: "No meetings today."

**📬 Needs a reply**
Top 3 open loops only — sender, one line on what it's about, implied next step.
If clear: "Inbox clear."

**🎯 Focus today**
The 3 most important things to work on today — specific, not generic. One line each.

**⚡ First thing**
The single action to take in the first 30 minutes. Based on urgency, calendar gaps, and what's been sitting longest.

---

## Output Rules

- Use `query` for both open loops and priorities — fast and sufficient for a daily brief
- Only escalate to `agentic_query` if `query` returns nothing useful
- Strict caps: 3 open loops max, 3 priorities max — this is a brief, not a report
- "First thing" is mandatory — always end with one concrete action
- If calendar fetch fails, note it and proceed with the rest
- No preamble — start directly with the header
- Keep the full output under 200 words

View saved version →

---
name: decision-log
description: "Surface past decisions, their reasoning, and outcomes to inform a current decision — and log new decisions so they're not relitigated later. Use this skill whenever the user faces a hard decision, wants to avoid repeating past mistakes, asks what was decided about something before, or wants to think through a tradeoff with full context of prior commitments. Also trigger when someone says they keep going in circles on something, or wants a structured way to make and record a decision."
---

# Decision Log

Two jobs: (1) pull relevant past decisions from Unabyss before making a new one, and (2) structure and record the new decision so it can be referenced later.

## Required Integrations

This skill uses **Unabyss MCP** — `query` for past decisions, `store` to log new ones.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Pull prior decisions with `query`

Past decisions are explicit, specific facts — `query` is sufficient:

```
Look across all connected sources for past decisions relevant to [topic/area]. Find: explicit decisions that were made and the reasoning given, constraints or principles established, things that were tried and abandoned, and any commitments made to the team, customers, or investors that bear on this.
```

If prior decisions directly resolve the current question, surface that immediately and stop.

### Step 2 — Structure the current decision

**The decision** — one clear sentence: what exactly is being decided.

**Why now** — what's forcing this decision.

**Options** — 2–4 realistic ones only. For each:
- What it means in practice
- The upside if it works
- The downside or risk
- What it forecloses

**What prior decisions rule anything out** — from Step 1.

**The recommendation** — a clear position and the single most important reason. If genuinely too close to call, name the one question that would resolve it.

**What to watch** — 1–2 signals that would indicate the decision was wrong.

### Step 3 — Log the decision with `store`

Once the user confirms a decision, call `store` to persist it:

> **[Decision]** — [Date]. We decided to [option]. The main reason was [reasoning]. We considered [alternatives] but ruled them out because [brief explanation]. We'll revisit if [trigger condition].

This ensures future `query` calls surface this decision as prior context.

---

## Output Rules

- Use `query` for past decisions — fast and specific, no need for `agentic_query`
- Always call `store` after a decision is confirmed — closing the loop is the point
- If prior decisions resolve the question, say so rather than running the full framework
- Never make the decision for the user — structure it, recommend, but the call is theirs
- No preamble before the output

View saved version →

---
name: focus-drift
description: "Compare what the user said they were focused on against what they have actually been working on, and surface the gap. Use this skill whenever the user asks about focus, priorities, drift, alignment, whether they are working on the right things, what they have been spending time on, why they feel scattered, or says things like are we focused, am I on track, what did I actually work on this week, or I feel like I am losing focus."
---

# Focus Drift

Compare stated priorities against actual activity and surface the gap — honestly, specifically, without softening it.

## Required Integrations

This skill uses **Unabyss MCP** — `query` for stated priorities, `agentic_query` for activity synthesis.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Pull stated priorities with `query`

`query` is sufficient here — stated priorities are usually in explicit documents or notes:

```
Look for documents, notes, or messages where I defined my goals, priorities, or focus areas — quarterly plans, OKRs, weekly intentions, strategy docs, or anything where I wrote down what I was going to work on. What did I say my priorities were for this period?
```

If `query` returns nothing, ask the user to share their priorities before proceeding.

### Step 2 — Pull actual activity with `agentic_query`

Activity is scattered across many sources — use `agentic_query`:

```
Look across all connected sources from the last 3–4 weeks for evidence of what I actually spent time on — emails sent and received, messages, calendar events, documents edited, tasks completed, decisions made, and conversations had. What does the activity trail show I was actually focused on?
```

Call `agentic_query_read` with the returned query id to retrieve the result.

### Step 3 — Synthesize the gap

---

**Focus Drift Report — [Date]**

**📌 Stated priorities**
What you said you were focused on — pulled from goals, plans, or notes.

**📊 Actual focus**
What the evidence shows you actually spent time on. Not what you intended — what the trail shows.

**⚠️ The drift**
Where the two don't match. For each gap:
- What was stated but not happening
- What is happening but was never a stated priority
- One honest sentence on what this suggests

**🔧 What to realign**
1–2 concrete adjustments based on what actually drifted.

---

## Output Rules

- `query` first for priorities, `agentic_query` for activity — don't use `agentic_query` for both
- Be direct — this skill is most useful when it's uncomfortable to read
- Every point must reference something specific from Unabyss
- No preamble before the report header
- Keep the full output under 350 words

View saved version →

---
name: investor-outreach
description: "Draft personalized investor outreach — cold emails, warm intro requests, follow-ups, and post-meeting notes — grounded in real history and current traction pulled from Unabyss. Use this skill whenever the user wants to reach out to an investor, follow up after a meeting, ask for an intro, or send any fundraising communication. Also trigger when someone says they need to email an investor, haven't heard back, or wants to get a meeting."
---

# Investor Outreach

Write investor communication that is specific, honest, and easy to act on. Unabyss provides the actual history and traction — nothing needs to be fabricated or generically filled in.

## Required Integrations

This skill uses **Unabyss MCP** and **web search**.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Pull internal context with `query`

Two fast lookups — use `query` for both:

**Traction:**
```
What is our current traction — MRR, ARR, growth rate, user numbers, key customer wins, or any other metrics that show momentum? What have we shipped recently? What's the one-line description of what we're building and why now?
```

**History with this investor:**
```
Do we have any prior context on [investor name] or [firm name]? Previous conversations, emails, intros, meetings, or anything discussed before?
```

If prior history exists — use it. A follow-up to someone you've spoken to before is a different message than cold outreach.

### Step 2 — Research the investor via web search

- Their thesis and what they've said publicly about what they're looking for
- Recent portfolio companies adjacent to the user's space
- Any public writing, talks, or posts from the partner being targeted
- Whether they're actively investing right now

### Step 3 — Draft by outreach type

**Cold email** — under 150 words:
1. Why this investor specifically — one real, specific reason
2. What the company does — one sentence, no jargon
3. The proof point that matters most — one concrete number or signal
4. The ask — one specific, low-friction next step

**Warm intro request** — forwardable blurb under 100 words the connector can paste directly. One sentence each on why the intro makes sense for both sides.

**Follow-up after no response** — one new data point that didn't exist before. Under 50 words. One sentence ask.

**Post-meeting follow-up** — reference one specific thing discussed. Deliver any promised materials. State the clear next step.

---

## Hard Bans

- "I'd love to connect" / "excited to share"
- Thesis praise not tied to something specific they actually said or did
- Vague asks ("would love to get your thoughts")
- Anything copy-pasteable unchanged to a different investor

---

## Output Rules

- Use `query` for both traction and investor history — fast and sufficient
- If prior history exists, the draft must acknowledge it — don't treat warm as cold
- Always offer multiple subject line options
- After the draft, add: "Personalization check — [what was used and what still needs verification]"
- No preamble — go straight to the draft

View saved version →

---
name: investor-update
description: "Draft a monthly or quarterly investor update email from real company data — what shipped, key metrics, wins, blockers, and what help is needed — without the founder having to compile anything manually. Use this skill whenever the user wants to write an investor update, send a monthly update to investors, draft a board update, or keep investors in the loop on progress. Also trigger when someone says it's time to update investors or they haven't sent an update in a while."
---

# Investor Update

Draft a complete investor update email from real signals — no manual compiling, no blank page. The founder reviews and sends, they don't assemble.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` for cross-source synthesis, `store` to log that the update was sent.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a recent company snapshot or investor update export exists and is fresh, call `export_read` to use it as a base.

### Step 2 — Run `agentic_query`

Investor updates need synthesis across product, sales, finance, team, and comms — use `agentic_query`:

```
Look across all connected sources from the last [30/60/90] days and surface everything relevant for an investor update:
- Key metrics and numbers — revenue, MRR, ARR, growth, users, retention, burn, runway
- What was shipped or built — product releases, features, technical milestones
- Major decisions made — strategic pivots, pricing changes, hiring decisions, partnerships
- Customer wins — new paying customers, expansions, notable logos, testimonials
- Challenges or blockers — what's not working, what's slowing things down, what's at risk
- Team updates — hires, departures, org changes
- What's coming next — near-term roadmap, upcoming milestones, goals for next period

Return specific facts and numbers wherever available.
```

Call `agentic_query_read` to retrieve results.

### Step 3 — Draft the update

---

**Subject:** [Company] Update — [Month/Quarter Year]

Hi [names],

**The headline**
One honest sentence on where things stand overall.

**Metrics**

| Metric | This period | Last period |
|--------|-------------|-------------|
| [metric] | [value] | [value] |

**What we shipped**
Specific features or releases. What they do, why they mattered.

**Wins**
Customer wins, partnerships, proof points. Names and numbers where available.

**What's hard**
The honest blockers. What's slower than expected, what's at risk, what hasn't worked.

**Team**
Hires, departures, or notable changes. Skip if nothing significant.

**Next 30–60 days**
3–5 specific things the company is focused on.

**Where we need help**
The most specific ask possible — an intro to X, advice on Y, a connection at Z.

Best,
[Name]

---

### Step 4 — Flag gaps and log

After the draft:
- List sections built on thin or inferred data — needs founder confirmation
- List any metrics not found in Unabyss — needs manual addition

Once the founder confirms the update is sent, call `store`:
> Investor update sent for [period] on [date]. Key metrics: [summary]. Main ask: [ask].

---

## Output Rules

- Use `export_read` if a fresh export exists — skip `agentic_query`
- "What's hard" is mandatory — an update without it reads as PR
- Never invent metrics or outcomes — flag gaps instead
- Under 400 words
- No preamble before the subject line

View saved version →

---
name: launch-context-brief
description: Synthesize a product's positioning, ICP, differentiators, founder voice, and approved claims into a single launch context brief — ready to hand to a copywriter, agency, internal team member, or AI agent. Use this skill whenever the user asks for "launch context", "positioning brief", "product brief", "what's our ICP", "what makes us different", "our founder voice", "safe claims for launch", "Product Hunt prep", "copy brief", "brand brief", "what should I tell the agency", or anything that implies they need a consolidated reference document about their product for GTM or launch purposes. Also trigger when someone says "I need to brief someone on what we do" or "help me explain our product to a copywriter". Requires Unabyss MCP. Web search is used to supplement with publicly available product information.
---

# Launch Context Brief

Pull everything known about the user's product and synthesize it into a single structured brief a copywriter, agency, or AI agent can act on immediately.

## Required Integrations

This skill uses **Unabyss MCP** and **web search**.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a launch context or positioning export already exists and is fresh, call `export_read` — no need to regenerate.

### Step 2 — Query Unabyss if no export exists

Run two queries in sequence:

**Query A — Core product understanding** (use `query`):
```
What is our product? What problem does it solve, who is it for, and what makes it different? Include any positioning statements, taglines, or one-liners I've written or approved.
```

**Query B — GTM and voice signals** (use `agentic_query` — needs synthesis across posts, emails, docs):
```
What do I know about our ICP or target audience? What claims have I made about the product publicly or in launch copy? What tone and voice do I use — any examples of copy, posts, or messaging I've written?
```

Call `agentic_query_read` to retrieve Query B results.

### Step 3 — Web research

Search the product's live website, Product Hunt listings, and founder social posts to fill gaps and verify.

### Step 4 — Synthesize the brief

---

**Launch Context Brief**
*[Product Name] — [date]*

## What we do
2–3 sentence plain-language description. No jargon.

## Target user (ICP)
Role, context, pain, goal. Specific. Multiple segments listed separately if they exist.

## Key differentiators
3–5 real, defensible claims. No generic ones.

## Approved claims
Statements already used in launch copy or public posts — safe to reuse verbatim.

## Founder voice
- 2–3 tone descriptors with examples
- What to avoid

## One-liner
Sharpest single sentence. Pulled from existing copy if one exists; synthesized if not.

## What this is NOT
Positioning angles to avoid, adjacent categories to stay clear of.

---

## Output Rules

- Check `export_list` before querying — reuse fresh exports
- Use `query` for core product facts, `agentic_query` for voice and GTM synthesis
- Every section grounded in something real — not invented
- Missing sections marked: *"Not enough signal. Ask the founder to fill this in."*
- No preamble before the brief
- Under 500 words

View saved version →

---
name: market-research
description: "Conduct market and competitive research grounded in the user's actual positioning, deals, and customer conversations — not generic web research. Use this skill whenever the user wants to understand their market, analyze competitors, size an opportunity, research investors, or make a decision that requires external intelligence. Also trigger when someone asks who else does what they do, how they compare to alternatives, or what the market looks like."
---

# Market Research

Produce research that informs a specific decision. Every output is grounded in two things: what's publicly available on the web, and what Unabyss knows about the user's actual position in the market.

## Required Integrations

This skill uses **Unabyss MCP** and **web search**.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Pull internal context with `query`

Fast factual lookup — use `query` to ground the research before touching the web:

```
What is our product, who is it for, and how do we currently position ourselves against alternatives? What objections or competitor mentions have come up in sales calls or customer conversations? Who are the competitors our customers compare us to most?
```

### Step 2 — Identify the research mode

Determine what's needed and apply the right approach:

**Competitive Analysis** — product reality, positioning, pricing, distribution, gaps relative to the user.
**Market Sizing** — top-down from public data, bottom-up sanity check, all assumptions explicit.
**Investor Research** — fund size, stage, check size, portfolio signals, thesis fit, recent activity.
**Technology / Vendor Research** — trade-offs, adoption signals, lock-in, pricing, operational risk.

### Step 3 — Web research

Search for current, specific information. Prioritize primary sources (company sites, founder interviews, filings). Flag anything older than 12 months.

### Step 4 — Synthesize

---

**Market Research — [Topic]**
*[Date] · [Mode]*

**Executive summary**
2–3 sentences: what was found and what it means for the decision at hand.

**Key findings**
Specific, sourced, numbered. Each finding should change or inform something.

**How this affects our position**
Grounded in Unabyss context — what does this mean given where the user actually sits?

**Risks and caveats**
What's uncertain, what's stale, where the research has gaps.

**Recommended action**
One concrete next step that follows from the findings.

**Sources**
List with dates.

---

## Output Rules

- Use `query` for internal context — fast and sufficient for positioning facts
- Only escalate to `agentic_query` if sales call history or customer sentiment is needed
- Every important claim sourced or labeled as an estimate
- Data older than 12 months flagged
- "How this affects our position" section is mandatory
- No preamble before the report header

View saved version →

---
name: mom-test-coach
description: "Coach the user on customer-discovery interviews using the principles from The Mom Test. Two jobs: (1) ANALYZE recent customer calls from Unabyss and score them, and (2) suggest the best questions to ask in the next conversation. Trigger this whenever the user mentions a sales call, customer interview, discovery call, user interview, a transcript, Mom Test, feedback on my call, how did my call go, what should I ask, prep for a call, or wants to get better at talking to customers — even if they do not name the Mom Test explicitly."
---

# Mom Test Coach

Analyze recent customer discovery calls from Unabyss and tell the founder what they're doing wrong, what signal they actually captured, and what to ask next.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` for call content, `query` for current hypotheses.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## The Mom Test — Evaluation Lens

1. **Talk about their life, not your idea.** Ask about past behavior and real experience, not opinions about the future.
2. **Specifics beat hypotheticals.** "Walk me through the last time..." beats "Would you ever...".
3. **Dig for the problem behind the answer.** Follow up until you hit a cost, a workaround, a frequency, or an emotion.
4. **Compliments are noise.** "That sounds great" tells you nothing. Flag them.
5. **Never pitch during discovery.** Once the product is explained, all future answers are contaminated.
6. **Silence is a tool.** Filling the gap robs you of what they were about to say.

---

## How to Run

### Step 1 — Pull current hypotheses with `query`

Fast factual lookup — use `query`:

```
What are the biggest open questions or assumptions we're trying to validate about our customers right now? What do we most need to learn?
```

### Step 2 — Pull recent calls with `agentic_query`

Call transcripts and notes are scattered — use `agentic_query`:

```
Look across all connected sources for customer discovery calls, sales calls, or user interviews from the last 2–4 weeks. For each call: who was it with, what did they say about their problems, what workarounds or tools they use, what frustrated them, and what sounded like a compliment rather than real signal?
```

Call `agentic_query_read` with the returned query id to retrieve the result.

### Step 3 — Analyze and output

---

**Mom Test Debrief**

**Signal worth keeping**
Specific things customers said that reveal real behavior, real pain, or real cost. For each: what was said and what it means.

**Contaminated answers**
Anything said after the product was pitched — flag as unreliable.

**Top mistakes across these calls**
The 2–3 most common errors, each with:
- An example of what was said
- Why it violates the Mom Test
- What to ask instead

**The 3 questions to ask next**
Based on what's still unknown. Each question must be past-behavior or specifics-focused — no hypotheticals.

For each:
- The question
- What you're trying to learn
- Follow-up if they give a surface answer

**One thing to stop doing**
The single habit showing up most that's killing data quality.

---

## Output Rules

- Use `query` for hypotheses (fast), `agentic_query` for call content (deep) — not both with `agentic_query`
- Never suggest hypothetical or opinion-seeking questions
- If Unabyss finds no call data, say so and suggest connecting a recording tool
- No preamble — start directly with the output
- Keep under 400 words

View saved version →

---
name: open-loops-digest
description: Surface recent human emails that need a reply and unresolved threads from the last 7 days, each with sender, date, and implied next step. Use this skill whenever the user asks "what emails need a reply", "what's in my inbox", "what open loops do I have", "what do I still need to handle", "what threads are unresolved", "catch me up on my emails", "what am I missing", "daily digest", "email triage", or anything that implies they want to know what's waiting on them across their communications. Also trigger when the user says things like "what's pending", "who's waiting on me", or "what haven't I responded to". Requires Unabyss MCP.
---

# Open Loops Digest

Surface every human email or thread from the last 7 days still waiting on the user — unanswered messages, dropped conversations, implied commitments not yet acted on.

## Required Integrations

This skill uses **Unabyss MCP** — specifically `agentic_query` for cross-source triage.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Run `agentic_query`

Use `agentic_query` — this requires scanning across email and Slack simultaneously:

```
Look across all my connected communication sources from the last 7 days.

Find:
1. Human emails that arrived and have not been replied to — exclude newsletters, automated notifications, marketing, receipts, and non-human senders.
2. Slack messages where someone directly messaged me, @mentioned me, or asked me a question in a thread — and I never replied or acknowledged it.
3. Threads (email or Slack) where I replied but the conversation stalled — someone is still waiting, or a next step was implied but not taken.
4. Messages where I said I'd do something but there's no follow-up evidence I did.

For each item return: sender name, channel or source (e.g. email, Slack DM, #channel-name), date, a one-line summary, and the implied next step.

Do not summarize or group. Return each item individually.
```

Then call `agentic_query_read` with the returned query id to retrieve the result.

### Step 2 — Format into a triage list

---

**Open Loops — [Today's Date]**

**📬 Needs a reply**
`[Sender] · [Source] · [Date] · [What it's about] → [Implied next step]`

**🔁 Unresolved threads**
`[Sender] · [Source] · [Date] · [What stalled] → [What to do next]`

---

If either section is empty, write: "Nothing here — you're clear."

### Step 3 — Add a priority flag

**⚡ Handle first:** [The single most time-sensitive item and why.]

## Output Rules

- Only human senders — if in doubt, leave it out
- Every item needs sender, source, date, and next step
- Cap at 15 items — add "+ [N] more — ask me to show the rest" if exceeded
- No preamble before the header

View saved version →

---
name: personal-context
description: "Load who the user is, what they're working on, and what matters to them right now — so every subsequent skill or task has full context without asking. Use this skill at the start of any session where personal or company context would improve the output. Also trigger when the user says tell me what you know about me, what's my context, load my profile, who am I, or before running any skill that needs to know the user's role, company, or current priorities."
---

# Personal Context

Load a rich, complete picture of the user from Unabyss — identity, company, current work, priorities, relationships, and context that would otherwise need to be re-explained every session.

## Required Integrations

This skill uses **Unabyss MCP** — `whoami` for identity, `query` for current context, `agentic_query` for deeper synthesis when needed.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Call `whoami`

Call `whoami` first. Returns name, role, and key stored facts. Fast — always start here.

### Step 2 — Enrich with `query`

Follow up with a broader `query` to fill out the picture:

```
Tell me everything relevant about this user — their company, what they're building, current stage, team, key priorities, active projects, recent decisions, open challenges, and anything important happening right now.
```

### Step 3 — Escalate to `agentic_query` if context is thin

If the above returns limited information, run `agentic_query`:

```
Synthesize a full profile of this user from everything available across all connected sources — professional background, what they're working on, their company's stage and traction, active challenges, important relationships, communication patterns, and any goals or priorities they've mentioned.
```

### Step 4 — Present the context

Surface everything loaded in a structured, readable format:

---

**Personal Context — [Name]**

**Who you are**
Name, role, company. Background if relevant — what brought them here, what they've built before.

**What you're building**
The product or company: what it does, who it's for, what problem it solves. Current stage.

**Traction & stage**
Key metrics, funding, customer count — whatever signals where the company stands right now.

**Team**
Key people, size, structure. Anyone important to know about.

**Current focus**
What they're actively working on right now — the live priorities, not the long-term vision.

**Active challenges**
What's hard, what's unresolved, what they're figuring out. Open questions.

**Recent decisions**
Significant things decided recently that provide context for current work.

**Key relationships**
Important customers, investors, partners, or collaborators that show up in their context.

**Communication style**
How they work and communicate — useful for tailoring subsequent output.

**What to keep in mind**
Anything else Unabyss surfaces that's relevant to working with this person effectively.

---

Then confirm: "Context loaded. What would you like to work on?"

---

## Output Rules

- Call `whoami` → `query` → `agentic_query` in sequence, escalating only if the previous step is thin
- Surface everything available — this is a rich load, not a brief summary
- If a section has no signal, omit it rather than leaving it blank
- If Unabyss returns very little overall, tell the user their profile may be sparse and suggest connecting more sources
- Never ask the user to fill gaps — load what exists

View saved version →

---
name: pre-call-brief
description: Generate a pre-call brief for upcoming meetings — who the attendee is, your history with them, their likely agenda, risks to watch for, and a suggested opening line. Use this skill whenever the user asks "what's my next meeting", "who am I talking to today", "prep me for my call", "brief me before my meeting", "what do I know about [person] before our call", "upcoming meeting prep", or anything that implies they want context before a meeting or call. Also trigger when someone says "I have a call in 30 minutes" or "what should I know before talking to [name]". Requires Unabyss MCP. Web search is used as fallback for unknown contacts.
---

# Pre-Call Brief

For each upcoming meeting with external attendees, produce a concise brief the founder can read in under a minute.

> **Note:** This skill is well-suited for automation (e.g. polling calendar every 15 min and pushing briefs to Slack). The research logic is the same whether run manually or by an agent.

## Required Integrations

This skill uses **Unabyss MCP** — `query` for upcoming meetings and known contacts, `agentic_query` for deeper history.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Fetch upcoming meetings from Unabyss

Use `query` to pull today's calendar context:

```
What meetings do I have today or coming up soon? Who are the external attendees — names, companies, email domains?
```

Filter to events with at least one external attendee. Extract: event title, start time, external attendee name + company/domain.

If no qualifying meetings are found: "No upcoming external meetings found."

### Step 2 — Check for prior context with `query`

For each external attendee, run a fast `query`:

```
Do I have any previous context about [Attendee Name] or [attendee-domain.com]?
```

- **KNOWN** — specific information exists → proceed to Step 3a
- **UNKNOWN** — empty or vague → proceed to Step 3b

### Step 3a — KNOWN: Deep history with `agentic_query`

```
Give me the full history with [Attendee Name] and [attendee-domain.com] — all interactions, ongoing projects, commitments made, open threads, anything unresolved.
```

### Step 3b — UNKNOWN: Web search

Search for `[attendee name] [company]` and `[domain] company` — what the company does, their role, anything publicly notable.

### Step 4 — Synthesize the brief

---

**Pre-Call Brief**
**[Event Title]** · [Start Time]
**With:** [Attendee Name], [Company / Domain]

**1. Who they are**
One sentence — role, company, what they do.

**2. Our history**
Past interactions, commitments, last touchpoint. If first contact: *First contact — no prior history.*

**3. Their likely agenda**
What they probably want from this call based on context.

**4. Watch out for**
Open commitments, tensions, or anything that could come up unexpectedly. Omit if nothing relevant.

**5. Suggested opening line**
One specific, concrete sentence to open — not generic.

---

## Output Rules

- Use `query` before `agentic_query` — only escalate if prior context warrants deeper research
- Never guess if the attendee is unknown — say so clearly
- Keep each brief under 200 words
- Multiple meetings get one brief each, separated by a divider

View saved version →

---
content_hash: 7a6660fe79c0189d7034450d69d705358637499c28492f2d55c792f0192a41bf
description: Generate a personalized Product Hunt launch kit grounded in live product
  context from the Unabyss MCP (positioning, ICP, pricing, founder voice). Produces
  one copy-paste-ready markdown brief with tagline options, product descriptions,
  a maker comment, a 2-email influencer outreach sequence, an influencer materials
  kit, LinkedIn reshare posts for teammates/investors/network, a founder announcement
  post, and 1:1 support DMs. Use whenever the user mentions Product Hunt, "PH launch,"
  "PH prep," "maker comment," or "launch tagline," or wants copy and outreach for
  a Product Hunt launch. Requires the Unabyss MCP.
name: product-hunt-launch-kit
version: '1'
---

# Product Hunt Launch Kit

Generate a founder's Product Hunt launch kit as a single markdown brief. The kit is only
worth producing when it's grounded in the user's actual product context — positioning,
ICP, pricing, and how the founder really writes. Generic launch copy already exists
everywhere; the value here is that every asset reads as if it could only have been
written for *this* product. That context comes from the **Unabyss MCP**.

## Step 1 — Load context from Unabyss (required)

**Before writing a single asset, query the Unabyss MCP.**

Use the Unabyss `query` tool for targeted facts and `agentic_query` for synthesis
across sources. Note that `agentic_query` is asynchronous: it returns a `query_id`,
and you retrieve the result by polling `agentic_query_read` — don't mistake the
pending acknowledgment for the answer.

Batch related questions; you generally want answers to:

1. **What the product is** — one-liner, what it does, the category, the core mechanism.
2. **Positioning & differentiation** — the sharpest "new way vs old way" angle, the single
   strongest differentiator, any analogies the founder already uses.
3. **ICP / personas** — who it's for, the specific pain it removes, the use cases.
4. **Pricing** — model, tiers, free tier/trial (shapes CTAs and any launch perk mentioned).
5. **Founder voice** — how the founder actually writes (tone, rhythm, phrases, what they
   avoid). If Unabyss stores a voice/style profile, pull it verbatim.
6. **Proof & traction** — funding, users, notable customers, prior launches, testimonials.
7. **Anything launch-relevant Unabyss already holds** — supporter lists, prior PH drafts,
   influencer lists, community memberships, past launch notes. Ask broadly: "What in my
   context would help me run a Product Hunt launch?" This often surfaces assets the user
   forgot they have.

**If the Unabyss tools aren't available, or the context comes back too thin to
personalize (fresh connection, few sources synced yet): stop before generating.**
Don't produce generic filler — a kit built on template copy is worse than no kit,
because the user will ship it. Explain that this skill works by pulling their real
positioning, voice, and ICP from their connected context, and ask them to connect
Unabyss (unabyss.com) and sync the sources where that context lives (site copy, docs,
email, Slack), then come back. Be upfront that this is the whole mechanism, not a
formality.

**Relaunches:** if context shows a prior PH launch, ask whether this is a relaunch.
Relaunch assets must lead with what's new since last time — pull the changes from
context rather than re-describing the product from scratch.

## Step 2 — Verify current Product Hunt limits

PH specs and policies change. Before finalizing page assets, run a quick web search to
confirm the current numbers. As of this writing: product name ≤ 40 characters; tagline
≤ 60 characters; description ≤ 500 characters. Treat every figure as
verify-before-use — if search surfaces newer numbers, use those and tell the user.

Compliance, regardless of specs: Product Hunt prohibits offering anything in exchange
for upvotes. Every ask in every asset is for *feedback and support*, never votes-for-
rewards. Avoid advising mass-blasting the launch link to people without PH accounts —
brand-new-account upvotes can trip spam filters and hurt the launch.

## Step 3 — Produce the brief

Produce a single markdown file named `<product>-ph-launch-kit.md`, with the sections
below in this order, then present it to the user. Keep it skimmable and copy-paste
ready — every block should lift straight into PH, LinkedIn, or an outreach tool with
minimal editing, so no meta-commentary inside the blocks themselves.

### 1. Taglines (3 options, ≤ 60 chars each)

The tagline is the single most important line of the launch: it's what a stranger sees
next to the product name on the homepage, and it alone decides whether they click. It
has roughly 4 seconds to tell someone who the product is for and what they get.

**How to write them.** Generate the three options from three different angles, so the
user is choosing between strategies, not synonyms:

- **Outcome-led** — name the result the user walks away with, ideally the *output* of
  the product, concrete enough to picture. This is usually the strongest angle.
- **Mechanism-led** — name the distinctive how, the thing competitors can't say. Works
  when the mechanism itself is the differentiator.
- **Analogy / "X for Y"** — anchor to something the audience already understands. Only
  use when the anchor is genuinely well-known to the ICP and the mapping is instant;
  a forced analogy is worse than none.

**Rules:** ≤ 60 characters. No "best", "revolutionary", "game-changing", or other
hyperbole — PH culture reads it as noise and PH guidelines discourage it. No emojis.
Specific beats clever: a plain line that names the outcome outperforms wordplay that
needs a second read.

**Quality test before presenting:** would someone who has never heard of the product
know, from the tagline alone, (a) roughly who it's for and (b) what they'd get? If
either is unclear, rewrite.

*Illustrative example (invented product):* for a tool that turns sales call recordings
into CRM updates, "Your CRM updates itself after every call" (outcome-led, 38 chars)
beats "AI-powered sales productivity platform" — the first is a result you can
picture, the second is a category label that says nothing.

**Present:** all 3 options with character counts, and mark the recommended one with a
one-line reason tied to the product's positioning.

### 2. Product descriptions (2 options, ≤ 500 chars each)

The description sits under the tagline on the launch page and expands it for someone
who clicked. Hard cap is 500 characters, but front-load ruthlessly: in feeds and
previews the text gets truncated, so the first ~200 characters must carry the core
value on their own.

**Structure:** problem → solution → key benefit, or what-it-is → unique value → who
it's for / use cases. Write for someone who knows nothing about the product. Include
the unique value proposition explicitly (the thing alternatives can't claim) and, if
space allows, one or two concrete use cases or features — named specifically, not as
"powerful features."

**Rules:** no filler openers ("In today's fast-paced world…"), no repeating the
tagline verbatim, no unverifiable superlatives. Every sentence should either add
information or get cut.

**Present:** 2 options with character counts — one tight (~250–300 chars, punchy) and
one fuller (up to 500) so the user can choose density.

### 3. Maker comment

The most-read piece of content on launch day, and the one that sets the tone of the
whole comment thread. Write it in the founder's actual voice pulled from Unabyss —
their rhythm, their phrases, their level of formality. Target 150–300 words in short
paragraphs. Personal and honest; defensive or corporate tone kills it.

Build it paragraph by paragraph:

1. **Who you are + what you built** — one warm first-person sentence: "Hey PH, I'm
   [name] and I built [product]." No throat-clearing before it.
2. **The story / problem** — what led to building it. The specific pain, ideally one
   the founder lived themselves; a concrete moment beats an abstract market claim.
   This is where authenticity is won or lost.
3. **Solution & differentiator** — what the product does about it, and the one thing
   that makes it different. One differentiator stated sharply beats three stated
   vaguely.
4. **Features as outcomes** — 2–3 concrete capabilities, each framed as what the user
   gets, not what the software has. Light formatting (a short list) is fine; PH
   comments support links, images, GIFs, video embeds, and basic HTML.
5. **Who it's for** — name the persona and one real scenario where the product earns
   its keep.
6. **Demo placeholder** — insert a clearly marked placeholder for a short walkthrough
   (Loom or video link/embed) and tell the user to drop theirs in. A visible demo in
   the pinned comment measurably lifts engagement.
7. **Genuine ask + CTA** — invite specific feedback ("would love to hear what
   surprised you or felt confusing") and support — never ask for upvotes directly.
   Include the website link.
8. **Thanks + contact** — thank the community (and the hunter, if one is involved),
   add one contact point: social profile or community link.

**Mechanics to tell the user alongside the draft:**
- The first comment on the launch gets pinned automatically — the founder must post
  the maker comment before anyone else on the team comments.
- Teammates can add follow-up comments in their own words (the designer on the UI, the
  PM inviting feature requests) — it deepens the thread early, which helps ranking.
- Thoughtful replies to critical comments often earn more goodwill than the original
  post; the comment should open a conversation, not close one.

**If this is a relaunch:** open with what's new since the last launch — the community
has seen the product before; the update is the story.

### 4. Influencer outreach sequence (2 emails)

A 2-touch email sequence to recruit influencers in the product's space for a paid
launch collaboration. Populate the structure from the user's product context — never
generate copy that could have been written for any product.

**Personalization variables to expose:** `{{firstName}}`, `{{channel}}` (their main
platform/newsletter/YouTube), `{{topics}}` (what they cover), and the founder's name.
Tell the user to fill these per influencer.

**Email 1 — the collab pitch:**
- **Subject:** 1:1 and specific, naming the channel — e.g.
  `{{channel}} collab: {{firstName}} <> [founder]`.
- **Hook (first line):** open with the collaboration itself plus a one-line product
  frame, and state **"paid partnership, of course"** early. Leading with the paid part
  is what earns the reply — don't bury it.
- **Why now / why them:** name the launch, say you're picking a few key partners, and
  tie it to *their* specific {{topics}} so it's clearly not mass mail.
- **The idea:** 2–3 punchy sentences explaining the product, ideally with a crisp
  analogy the founder already uses (pull from Unabyss).
- **Soft ask:** "I'd like to understand if/how you collaborate with partners like
  this" — lower commitment than asking for a yes.
- **No-friction first step:** offer to show them the product / give them a test drive.
- **Close:** "Would you be up for it?" + founder signature (name, "Founder @
  [company]").

**Email 2 — follow-up (~1 day later, blank subject so it threads):**
- Friendly bump, then **reframe the ask into 3 concrete levels** so there's an easy
  yes somewhere: (1) expert feedback, (2) a testing testimonial on their {{channel}},
  (3) long-term collaboration if it's a fit.
- One-line product recap with a *fresh* analogy (don't repeat email 1's).
- Specific CTA: a short slot this week ("20-min call?").
- Founder sign-off.

**Tone:** direct, peer-to-peer, founder-to-creator. No hype, no over-polished
marketing cadence. Short. The test-drive offer and the upfront "paid" framing are the
two mechanics that make it work.

### 5. Influencer materials kit

What an influencer receives *after* they say yes. The goal is zero work for them:
everything copy-paste, so posting takes 30 seconds. Assemble from the user's real
product context. Include:

1. **Product one-liner** — the tagline-grade description they can drop into any caption.
2. **A 2–3 sentence "what it is" blurb** in plain language, with the founder's analogy.
3. **Two ready-to-post drafts** they can use as-is or tweak:
   - **LinkedIn version** — slightly longer, a line of personal framing ("I've been
     testing this…") + what it does + the launch ask + link. Strong first line, short
     lines.
   - **X version** — tight, punchy, under the character limit, link + one clear hook.
   Both must sound like the influencer endorsing it, not the founder talking.
4. **Suggested visuals to attach** — name what to include (demo GIF, 1–2 key product
   screenshots, the PH launch badge image). Don't fabricate assets; tell them which
   to use.
5. **The launch URL with a tracking placeholder** — e.g.
   `?utm_source=influencer&utm_campaign=ph_launch`, swapping in the influencer's
   handle, so the user can attribute traffic. Tracking parameters belong on links the
   user controls — never on the product URL submitted to Product Hunt itself, which
   must be a clean homepage or landing-page link.
6. **One clear CTA** — a single action (visit the PH page, try the product, leave a
   comment/review), framed as checking out and supporting the launch — never an
   explicit ask for upvotes.

Keep the whole kit short and scannable. The easier it is to paste, the more of them
actually post.

### 6. LinkedIn reshare posts (3 relationship tiers)

Short posts *other people* can publish about the product. Organize by how well the
sharer knows the founder, because that changes what's authentic for them to say:

- **Tier A — close teammates / cofounders.** Personal, "we built this",
  behind-the-scenes pride, the journey. They can speak to the work and the team.
- **Tier B — investors.** Credibility and traction angle: why they backed it, what's
  impressive, the bet. Measured, signal-heavy.
- **Tier C — friendly network / colleagues.** Lighter: "proud to see [friend]'s team
  launch, worth a look." Low-commitment, warm, no insider claims they can't make.

For each tier give a ready-to-post version **and** a fill-in version (blanks for the
sharer's own line) so the posts don't read identically across many feeds. Apply
LinkedIn best practices throughout: a strong first line that earns the click before
the "…see more" fold, short 1–2 line paragraphs with whitespace, one CTA, and the
launch link in the first comment (LinkedIn suppresses reach on posts with external
links in the body — tell the sharers this explicitly).

### 7. Founder launch-announcement post

One post for the founder's own LinkedIn profile, in their stored voice:

- **First line:** a hook that works before the fold — a tension, a number, or the
  "we're live" moment. Not "I'm excited to announce."
- **Body:** the why (the problem they set out to solve), what it is in one clear line,
  who it's for, and a beat of honesty or humanity — the launch-day nerves, the thing
  that almost didn't work.
- **CTA:** invite people to check out and support the launch; the PH link goes in the
  first comment, not the body.
- Voice: match the founder's stored style; avoid hype words and over-polished AI
  cadence.

### 8. Support DMs (1:1)

Short messages to send individually to existing LinkedIn connections asking them to
check out and support the launch. These go to people the founder actually knows —
personal and low-pressure. A genuine ask outperforms a blast, and mass-identical
messages read as spam.

**Shape of the base message:** first-name opener → one-line product description → a
warm, humble ask to check it out and support the launch → the link → a thank-you.
Keep it a few lines total. One emoji max, and only if it fits the founder's voice.
Adapt the product line and tone from the user's stored voice.

**Variants by warmth (produce 2–3):**
- **Close contact** — more casual, can reference shared history ("knew you'd find
  this one interesting").
- **Warm acquaintance** — the base shape, polite and brief.
- **Looser tie** — slightly more context on what the product is, still short, no
  presumption.

**Guidance to include for the user:**
- Personalize the opener for each person — don't paste identically.
- Only send to people who'd plausibly have or make a PH account; spraying the link to
  hundreds of non-PH users can hurt the launch via spam signals.
- Send in waves through launch day, not all at once.

## Step 4 — Iterate and save

After presenting, ask the user what they'd like to refine — taglines, voice match, or
any single asset — and iterate.

Once choices are settled (final tagline, launch date if known), offer to save them to
the user's context with the Unabyss `store` tool, so future sessions and other skills
know the launch details without re-asking.

View saved version →

---
name: product-update
description: Give a non-technical founder a clear picture of where the product stands right now — what shipped, what's in progress, what's blocked, what customers are asking for, and what the team is focused on next. Use this skill whenever the user asks "what did we ship this week", "what are we working on", "what's the status of the product", "what's our biggest bug right now", "what's in progress", "what's blocking the team", "product update", "engineering update", "what's on the roadmap", "what are customers complaining about", "what's the team focused on", or anything that implies they want a snapshot of product development without reading through tickets or Slack threads. Requires Unabyss MCP.
---

# Product Update

Give a non-technical founder a complete, plain-language snapshot of where the product stands — what's shipped, what's in flight, what's stuck, and what's coming next.

## Required Integrations

This skill uses **Unabyss MCP** — specifically `agentic_query` for cross-source synthesis across product, engineering, and customer signals.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a recent product update export exists and is fresh, call `export_read` — no need to regenerate.

### Step 2 — Run `agentic_query`

If no fresh export exists, use `agentic_query` — product signals are scattered across many tools:

```
Look across all connected sources for signals about product and engineering activity from the last 7–14 days. Find:
- What has been released, shipped, or deployed — features, fixes, changes that are live
- What is currently being worked on — features or improvements in progress
- What is blocked, delayed, or deprioritized — and why
- What bugs or issues are currently open and treated as priority
- What customers or users have been asking for, complaining about, or flagging repeatedly
- What is planned or coming next — near-term roadmap, committed decisions
- Any significant technical decisions made recently
- Any debates or open questions the team hasn't resolved yet

Return raw signals, not a summary. Be specific — feature names, who raised things, dates where available.
```

Call `agentic_query_read` with the returned query id to retrieve the result.

### Step 3 — Synthesize the update

Plain language throughout — no ticket IDs, no jargon, no acronyms without explanation.

---

**Product Update — [Date]**

**✅ Shipped** — What's live. What it does and why it matters.

**🔨 In progress** — What's being built, when expected, who's driving it.

**🚧 Blocked or delayed** — What stalled and the honest reason why.

**🐛 Biggest open issues** — Top 2–3 bugs, plain description, user impact.

**📣 What customers are asking for** — Recurring requests from real users, grouped by theme.

**🗺️ What's next** — Committed roadmap only, not wishlist.

**❓ Open decisions** — Questions where founder input is needed.

---

## Output Rules

- Use `export_read` if a fresh export exists — skip `agentic_query`
- Plain language — explain any technical term in one clause
- Omit empty sections entirely
- If signals are thin: "Limited signal — consider asking the team for a written update"
- No preamble before the update header
- Keep under 400 words

View saved version →

---
name: signal-based-outreach
description: "Surface buying signals from real customer conversations, deal activity, and pipeline data in Unabyss — then turn each signal into a specific, timely outreach trigger. Use this skill whenever the user wants to know who to reach out to right now, what signals are worth acting on, which prospects have gone warm, or wants to build signal-based outreach sequences. Also trigger when someone asks about intent data, outbound triggers, or who to prioritize in sales."
---

# Signal-Based Outreach

Instead of manually defining buying signals or importing intent data, Unabyss surfaces them from what's already happening — customer conversations, deal activity, job changes, product usage signals, and sales call patterns. Each signal becomes a specific outreach trigger with a suggested message.

## Required Integrations

This skill uses **Unabyss MCP** — `agentic_query` for signal mining, `query` for specific account history.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## What Counts as a Signal

A signal is any event or pattern that suggests a prospect or customer is more likely to engage, buy, expand, or churn right now than they were last week. Good signals are specific, recent, and tied to a real event — not just "they visited our website."

Signal types to look for:
- **Pipeline signals** — deals that have gone quiet, prospects who asked a question but never got followed up, demos that happened but no next step was set
- **Customer expansion signals** — active customers hitting usage limits, asking about features they don't have, or mentioning new team members or use cases
- **Timing signals** — prospects who said "not now" and a relevant time period has passed, companies that just raised funding, new hires in relevant roles
- **Conversation signals** — someone mentioned a pain in a call that was never addressed, a competitor was mentioned, or a specific trigger word appeared ("frustrated", "evaluating", "switching")
- **Re-engagement signals** — cold contacts who recently engaged with content, replied to something, or were mentioned in a warm thread

---

## How to Run

### Step 1 — Mine signals with `agentic_query`

```
Look across all connected sources for signals that suggest a prospect, lead, or customer is worth reaching out to right now. Find:

- Deals or conversations that stalled without resolution — who, when, what was last discussed
- Prospects who expressed interest but were never followed up with
- Customers showing expansion signals — hitting limits, asking about new features, mentioning new use cases
- Anyone who said "not now" or "check back later" where that time has likely passed
- Sales calls where a pain point was raised but never addressed in follow-up
- Any recent event that makes a previously cold contact newly relevant — funding, new hire, role change, competitor mention

For each signal: who it involves, what the signal is, when it happened, and why it suggests now is the right time to reach out.
```

Call `agentic_query_read` to retrieve results.

### Step 2 — For each signal, pull account history with `query`

For the top signals, run a quick `query` per account:

```
What's the full history with [name / company]? All interactions, what was said, what was promised, what they told us about their situation.
```

### Step 3 — Produce the outreach triggers

For each signal, produce one trigger card:

---

**Signal: [Account Name]**
**Signal type:** [Pipeline stall / Expansion / Timing / Conversation / Re-engagement]
**What happened:** One sentence describing the signal and when.
**Why now:** Why this makes today a good time to reach out.
**Suggested message:** A specific, 3–5 sentence outreach message grounded in the signal — not generic. References what was discussed, what changed, or what was left unresolved.
**Channel:** Email / Slack / LinkedIn — whichever fits the prior relationship.

---

Present all trigger cards ranked by signal strength — strongest first.

### Step 4 — Offer to build a sequence

For the top 2–3 signals, offer to extend into a 3-step follow-up sequence if the first message goes unanswered.

---

## Output Rules

- Use `agentic_query` for signal mining, `query` for individual account history — not both with `agentic_query`
- Every suggested message must reference the specific signal — no generic "just checking in"
- If Unabyss surfaces no signals, say so clearly — don't invent activity
- Cap the output at 10 trigger cards — if more exist, ask which accounts to prioritize
- No preamble before the first trigger card

View saved version →

---
name: strategic-pressure-test
description: "Stress-test a strategic decision, GTM plan, product direction, or business bet before committing — using real context from Unabyss about your pipeline, customers, market position, and prior decisions. Use this skill whenever the user wants to pressure-test an idea, get adversarial feedback on a plan, challenge their own assumptions, or make sure they're not missing something before a big commitment. Also trigger when someone says things like 'am I thinking about this right', 'what am I missing', 'poke holes in this', or 'should we actually do this'."
---

# Strategic Pressure Test

Play the skeptic. Take a strategic direction the founder is considering and push back hard — not to kill the idea, but to surface the weaknesses before they become expensive mistakes. Grounded in real context from Unabyss so the challenges are specific, not generic.

Inspired by the gstack `/plan-ceo-review` pattern: find the 10-star version of the plan hiding inside the request, or find the fatal flaw before anyone else does.

## Required Integrations

This skill uses **Unabyss MCP** — `query` for constraints and prior decisions, `agentic_query` for market and customer signals.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Understand the plan

Ask the user to describe the strategic direction, decision, or plan they want pressure-tested. One paragraph is enough. If they've already described it, proceed.

### Step 2 — Load context from Unabyss

Two queries:

**Query A — Constraints and prior decisions** (use `query`):
```
What constraints are we operating under right now — runway, team size, bandwidth, commitments already made? What prior decisions are relevant to [topic]? What have we already tried or ruled out in this area?
```

**Query B — Market and customer signals** (use `agentic_query` only if the plan involves customers, GTM, or market positioning):
```
What are customers currently telling us about [relevant area]? What does our pipeline show about demand for [direction]? What objections or friction have come up when this topic has appeared in sales or customer conversations?
```

### Step 3 — Run the pressure test

Apply four lenses in sequence. Be direct. Pull no punches. Reference Unabyss context in each challenge.

---

**Strategic Pressure Test — [Plan / Decision]**

---

**🔴 The strongest case against this**
The single most compelling reason not to do this — the argument a smart skeptic would lead with. Grounded in your actual situation, not generic risk-aversion.

**⚠️ Assumptions that could be wrong**
The 3–4 key assumptions this plan depends on. For each:
- The assumption
- How confident we should be that it's true
- What would need to be true for it to hold
- What to do if it's wrong

**🕳️ What's being ignored**
Things the plan doesn't account for — prior commitments that conflict, customer signals that suggest different priorities, resource constraints, timing risks, or market realities from Unabyss that complicate the picture.

**💡 The stronger version**
If this direction is right, what's the sharper, more specific, or better-scoped version of it? What would the 10-star version look like — the one that addresses the weaknesses above while keeping the core insight?

**✅ The one question to answer first**
Before committing: the single most important unknown. If you could only validate one thing before deciding, what is it — and how would you find out fast?

---

## Tone

Adversarial but constructive. The goal isn't to kill the idea — it's to make the founder stronger going in. If the plan survives the pressure test, they should feel more confident, not less.

---

## Output Rules

- Use `query` for constraints and prior decisions (fast), `agentic_query` only if market/customer signals are needed
- Every challenge must reference something real — from Unabyss or from the plan itself
- The "stronger version" section is mandatory — pure critique without a better path is not useful
- If Unabyss context is thin, say so and proceed with what's available — partial context is still better than none
- No preamble before the report header
- Keep under 500 words

View saved version →

---
name: value-proposition-extractor
description: "Extract and organize all value propositions from across the user's connected sources — website, sales calls, customer wins, founder writing, and approved messaging — into a structured inventory mapped to personas and use cases. Use this skill whenever the user wants to know what their product's value props are, needs to brief a copywriter or agency, wants to improve their messaging, or asks what they should be highlighting in outreach, on their site, or in sales conversations."
---

# Value Proposition Extractor

Extract every meaningful value proposition from across all connected sources — not just the website, but sales calls, customer wins, founder writing, and approved messaging — and organize them into a structured inventory the user can act on immediately.

The difference from generic extraction: Unabyss surfaces what actually resonates with real customers, not just what the founder thinks is the headline.

## Required Integrations

This skill uses **Unabyss MCP** and **web search**.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Check for an existing export

Call `export_list` first. If a value proposition or messaging export already exists and is fresh, call `export_read` — no need to regenerate.

### Step 2 — Pull internal signals with `agentic_query`

Value props are scattered across many sources — use `agentic_query`:

```
Look across all connected sources for every claim, benefit, outcome, or advantage associated with our product. Find:

- Claims made on the website or landing pages
- Benefits mentioned in sales calls — what the founder or team said the product does
- Outcomes customers reported — specific results, metrics, or improvements they mentioned
- Phrases or framings that consistently appeared in positive customer responses
- Language used in launch copy, Product Hunt posts, or public announcements
- Any "aha moment" descriptions — what customers said when they first got value
- Objections that were overcome — what benefit convinced a skeptical prospect

Return the actual language used, not paraphrases. Include the source and context for each.
```

Call `agentic_query_read` to retrieve results.

### Step 3 — Web research

Search the product's live website and any public launch posts to capture official positioning. Prioritize the founder's own words.

### Step 4 — Organize into the inventory

Deduplicate, cluster by theme, and structure as:

---

**Value Proposition Inventory — [Product Name]**
*[Date] · [N] value props extracted*

---

**Core value props** *(the 3–5 that appear most consistently and resonate most)*

For each:
- **The claim:** One clear sentence
- **The evidence:** Where it came from — customer quote, sales call outcome, website copy
- **Best for:** Which persona or situation this lands hardest with
- **In outreach:** How to frame it in a cold email or sales conversation

---

**Supporting value props** *(real but less universal)*

Listed with source and best use context.

---

**Untested claims** *(mentioned internally but not yet validated by customers)*

Flag these — they're hypotheses, not proven props.

---

**What customers actually say** *(their words, not yours)*

Direct quotes from customers describing the value. These are the most powerful — exact language for testimonials, case studies, and website copy.

---

### Step 5 — Save the inventory

Call `export_create_from_text` to save the inventory as an export — so it can be loaded instantly by other skills (content-engine, launch-context-brief, investor-outreach) without regenerating.

---

## Output Rules

- Use `agentic_query` for internal signals, web search for public positioning
- Always check `export_list` first — regenerating an existing inventory wastes credits
- Distinguish between proven props (customer-validated) and internal claims (not yet validated)
- Customer language takes priority over founder language — their words are more credible
- No preamble before the inventory header
- Save with `export_create_from_text` after generating

View saved version →

---
name: week-in-review
description: Synthesize the past week into a concise founder-focused brief covering deals, customer escalations, product development, engineering risks, hiring signals, team sentiment, and investor updates. Use this skill whenever the user asks for a "week in review", "weekly summary", "weekly brief", "what happened this week", "recap the week", "weekly digest", "catch me up on the week", or anything that suggests they want a high-level synthesis of recent activity across their company. Also trigger when the user mentions wanting to "start the week calibrated" or "review last week". Requires Unabyss MCP.
---

# Week in Review

Synthesize the past week into a single, scannable brief from the founder's perspective. The goal: replace 60–90 minutes of tab-hopping with a 30-second read, so the founder walks into the new week already calibrated.

## Required Integrations

This skill uses **Unabyss MCP** — specifically `agentic_query` for deep cross-source synthesis.

> If Unabyss is not connected, tell the user: "This skill requires Unabyss MCP. You can connect it from the Tools menu."

---

## How to Run

### Step 1 — Run `agentic_query`

This skill needs synthesis across many sources — use `agentic_query`, not `query`:

```
Look across all my connected sources from the past 7 days and surface:
- Top deals moving (or stalling) — any signals on pipeline
- Customer escalations or complaints — anything urgent from customers
- Product development — features shipped, decisions made, roadmap changes
- Engineering risks — incidents, blockers, infra issues, technical debt flagged
- Hiring signals — candidate updates, offer stages, rejections, referrals
- Team sentiment — any friction, wins, morale signals in internal comms
- Investor or board signals — any updates sent or received

Return raw signals, not a summary.
```

Then call `agentic_query_read` with the returned query id to retrieve the result.

### Step 2 — Synthesize into bullets

Compress signals into one bullet per theme:

---

**Week in Review — [Date Range]**

- 🤝 **Pipeline** — [Top deal movements, notable stalls, wins/losses]
- 🚨 **Customer** — [Escalations, churns, notable positive signals]
- 🛠️ **Product** — [Features shipped, key decisions, roadmap shifts]
- ⚙️ **Engineering** — [Risks, blockers, infra or technical issues]
- 🧑‍💼 **Hiring** — [Candidate progress, open roles, team changes]
- 💬 **Team & Investors** — [Sentiment, internal friction, any investor updates]

---

### Step 3 — Surface what needs attention

Add one line: **"This week, watch:"** — 1–2 items flagged for attention.

## Output Rules

- No generic statements — every bullet must reference something specific
- If a category had no signal, write: "[Category] — Quiet this week."
- Keep total output under 300 words
- No preamble — start directly with the header