> ## Documentation Index
> Fetch the complete documentation index at: https://docs.groovin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Skill: Draft a LinkedIn message in your voice

> A skill that drafts LinkedIn messages, replies, follow-ups and connection notes in your own voice, then sends them through Groovin once you approve.

This skill writes one LinkedIn message that sounds like you, shows it to you, and sends it through Groovin only once you say yes. It handles replies, follow-ups on unanswered messages, first messages and connection requests with a note.

It works best after you've run [Analyze LinkedIn messages](https://docs.groovin.ai/mcp/skills/analyze-linkedin-messages.md), which creates the two files it reads: your voice profile and your message templates. Without them, it drafts from your past messages in the conversation, or from a few examples you paste.

## What it does

1. **Loads your voice** from `linkedin-writing-voice.md` and `linkedin_msg_templates.md`.
2. **Reads the context**: the LinkedIn conversation if there is one, and your CRM if a CRM connector is available.
3. **Drafts** in the right format and language, using the template that fits the situation. It only uses facts it actually has: no invented posts, events or mutual connections.
4. **Shows you** the recipient and the exact text.
5. **Sends** once you approve. If the person is linked to a CRM contact, Groovin records the message there automatically.
6. **Learns** from your edits: when you rewrite a draft, it offers to add the habit to your voice profile.

> [!WARNING]
>
> One message, one person, and always with your approval. This skill is built for writing to people one by one, not for sequences or bulk campaigns.

## Before you start

* Groovin MCP connected to your AI assistant. See [Setup](https://docs.groovin.ai/mcp/setup.md).
* Recommended: the two files produced by [Analyze LinkedIn messages](https://docs.groovin.ai/mcp/skills/analyze-linkedin-messages.md), kept where your assistant can read them (your working folder or your project files).
* The skill installed. See [how to install a skill](https://docs.groovin.ai/mcp/skills.md#how-to-install-a-skill).

## How to use it

Just ask, in your own words:

```text theme={null}
Reply to Sarah Chen's last LinkedIn message. She asked about pricing.
```

```text theme={null}
Marc Dupont hasn't answered my message from last week. Draft a follow-up.
```

```text theme={null}
Invite Julia Weber to connect, with a short note about her talk at SaaStr.
```

```text theme={null}
Go through my unread LinkedIn messages one by one and draft a reply for each.
```

## The skill

Copy the text below and install it as explained in [how to install a skill](https://docs.groovin.ai/mcp/skills.md#how-to-install-a-skill).

> [accordion] draft-linkedin-message — SKILL.md (version 2026-10-12)
>
> ```markdown theme={null}
> ---
> name: draft-linkedin-message
> description: Draft a LinkedIn message, reply, follow-up or connection note in the user's own voice, show it for approval, and send it through Groovin only once the user says yes. Use when the user asks to write, answer, reply to, follow up on or nudge a LinkedIn conversation, to message someone on LinkedIn, or to invite someone to connect with a note. Reads the voice profile and templates produced by the analyze-linkedin-messages skill when they exist. One message to one person at a time, never sequences or bulk sends. Requires the Groovin connector.
> ---
>
> # Draft a LinkedIn message
>
> <!-- Groovin skill | version 2026-10-12 | https://groovin.mintlify.app/mcp/skills -->
>
> Write one LinkedIn message that sounds like the user, get it approved, send it. In that order, every time.
>
> Two rules sit above everything else:
>
> - **Nothing is sent without an explicit yes** to the exact text and the exact recipient, given in this conversation.
> - **One message, one person.** No sequences, no "send this to all of them". If the user asks for several, draft and approve them one by one.
>
> ---
>
> ## Step 1: Load the voice
>
> Look for these two files wherever this environment keeps the user's files (working folder, project files, or pasted into the conversation):
>
> - `linkedin-writing-voice.md`: how the user writes
> - `linkedin_msg_templates.md`: their opener, reply and nudge templates, each with a "Use when"
>
> If an instructions file points to a writing style file under another name, use that.
>
> If neither exists, say so in one line and offer two ways forward:
>
> - run the `analyze-linkedin-messages` skill first (a few minutes, done once)
> - draft now from the thread itself: if there is an existing conversation, the user's own past messages in it are the style sample. If there is none, ask for two or three messages they wrote and are happy with.
>
> Do not fall back to a generic "professional" tone. A message in the wrong voice is worse than asking.
>
> ## Step 2: Understand the situation
>
> Work out which of these it is. Ask only if the request leaves it open.
>
> | Situation | Format | What it needs |
> |---|---|---|
> | Reply to something they said | DM | The thread |
> | Nudge after the user's own unanswered message | DM | The thread, and how long it has been quiet |
> | First message to a connection | DM | Why now |
> | Message to someone outside the network | InMail, if the user has it | Why now, and a subject line |
> | Connection request with a note | Invite note, 300 characters maximum | Why connect |
>
> Then gather context, cheapest first:
>
> 1. **The thread.** If a conversation exists, read it with `get_linkedin_chat_messages`. To find it, call `list_linkedin_conversation_attendees` with a `limit` and match the person; the result gives the `conversation_id`. Reading conversations carries no LinkedIn limit.
> 2. **The CRM.** If a CRM connector is available, look the person up for deal, meeting and email context. `lookup_crm_contacts` tells you whether Groovin already links them to a CRM contact.
> 3. **The profile.** Use what you already have (the thread, the attendee list, what the user pasted). Call `get_linkedin_profile` only when the draft truly needs something that is missing, and only for this one person.
>
> Before a connection request, check it makes sense: `list_linkedin_relations` with a `name_filter` (already connected?) and `list_linkedin_pending_invitations` (already invited?). If either is true, say so instead of drafting.
>
> ## Step 3: Draft
>
> **Pick the language.** Reply in the language of the thread. For a first message, follow what the voice profile says decides the language; if it says nothing, ask.
>
> **Pick a template, if one fits.** Match the situation against each template's "Use when", in the right format and language. Prefer the one with the better track record, but say so only if the user asks. If nothing fits, write from the voice rules alone. Never bend the situation to fit a template.
>
> **Fill the slots from real data only.** `{trigger_event}`, `{shared_context}`, `{last_touchpoint}` and the rest must come from the thread, the CRM, the profile or the user. If you do not have it, ask or leave it out. Never invent a post they wrote, an event you both attended, or a mutual connection.
>
> **Apply the voice rules for this format.** Rules marked for invite notes apply to invite notes only. Respect the user's greeting, length, punctuation, capitalisation, emoji and sign-off habits exactly as documented, including the ones that look like mistakes. Use the formal or informal address the profile records for this kind of person.
>
> **Respect the "Never does" and anti-slop lists.** Check the draft against them before showing it.
>
> **Keep it the length the user writes.** If the profile says their replies run 15 to 40 words, a 90-word draft is wrong however good it reads.
>
> For an invite note, count the characters. Over 300 does not send.
>
> ## Step 4: Show it
>
> Present, in this order:
>
> 1. Who it goes to (name, and company or headline) and how it will be sent: into the existing conversation, as a new message, or as a connection request.
> 2. The draft, exactly as it would be sent.
> 3. One line on what it is based on, only when useful ("uses your follow-up after silence template", "no template matched, written from your voice rules").
>
> If the conversation is a **group chat**, say so before anything else: the message would reach everyone in it.
>
> Offer one alternative only if there is a real choice to make (shorter, different ask). Do not present three versions by default.
>
> Take edits. When the user rewrites part of the draft, that edit is the new truth: use their words, do not polish them.
>
> ## Step 5: Send, only on a yes
>
> Send only after the user has clearly approved this text for this person. "Looks good", "send it", "go" count. Silence, "ok" to an earlier version, or approval of a different draft do not.
>
> - Message: `send_linkedin_message`, with the `conversation_id` when there is one.
> - Connection request: `send_linkedin_invitation`, with the approved note as `message`, or none.
>
> Send the approved text unchanged.
>
> After sending, confirm in one line. If the person is linked to a CRM contact, Groovin records the message or invitation there on its own; do not write it again.
>
> **If the send fails or times out, do not retry blindly.** It may have gone through. Check the conversation (`get_linkedin_chat_messages`) or the pending invitations first, tell the user what you found, and resend only if it is not there.
>
> Do not mark conversations as read unless the user asks.
>
> ## Step 6: Learn from the edit
>
> If the user changed the draft in a way that looks like a habit rather than a one-off (cut the greeting, removed the sign-off, switched to informal address), offer once to add it to `linkedin-writing-voice.md`. Add it only if they agree, as a rule with a note that it came from a correction rather than from the sample.
>
> ---
>
> ## Several messages in a row
>
> When the user wants to work through a list (unread messages, stale conversations, a shortlist to invite):
>
> - Go one person at a time: context, draft, approval, send, next.
> - You may prepare the next draft while waiting, but each send needs its own yes.
> - Keep a short running tally (sent, skipped, left for later) and show it at the end.
> - LinkedIn limits how much an account can send: roughly 100 messages a day, and 80 to 100 connection requests a day, about 200 a week. Well before those numbers, say that it is time to stop for the day. This skill is for writing to people one by one, not for campaigns.
>
> ## Failure handling
>
> - **No Groovin tools available**: draft only, and say the message has to be sent by hand.
> - **Every Groovin call failing, including after it was working**: the connection has expired. Tell the user to reconnect Groovin in their connector settings. Do not retry.
> - **A result that starts with "Groovin connector problem"**: relay it and follow what it says.
> - **LinkedIn asks for the recipient's email on a connection request**: ask the user for it and pass it as `recipient_email`.
> - **The person cannot be identified with certainty** (two people with the same name): ask. Never send to a best guess.
> ```

> [!NOTE]
>
> **Version 2026-10-12.** Skills are plain text: adapt this one to how you work. When a new version is published here, replace your copy.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.