Using prompts as a shared skills store
Contents
Prompt management is currently in beta.
We'd love to hear your feedback as we develop this feature.
Your team's coding agents (Claude Code, Cursor, Codex, Windsurf, and others) all support MCP. PostHog Prompts combined with MCP gives you a centralized, versioned place to store and share reusable agent skills — across any tool, for any team member.
Why use prompts as a skills store?
- Works in any MCP-connected agent — Claude Code, Cursor, Codex, Windsurf, VS Code, and more
- Centrally managed — Update a skill once, every team member gets the latest version on their next fetch
- Full version history — See exactly what changed between versions using the diff view
- No vendor lock-in — Not tied to a specific agent or IDE
- Non-engineers can contribute — Anyone on your team can create and maintain skills through the PostHog UI
- Skills evolve with proper versioning — You or your agent can update skills, and every change is tracked
How it works
The pattern is simple:
- PostHog Prompts stores the skill content as versioned markdown
- MCP prompt tools (
prompt-get,prompt-list) let agents fetch and run skills at runtime
When a team member wants to use a skill, they ask their agent to fetch it from PostHog via MCP. The agent reads the instructions and follows them. No local files to sync, no git repos to pull — just one source of truth.
Prerequisites
- A PostHog account with LLM analytics enabled
- The PostHog MCP server configured in your coding agent
Step 1: Create a skill
A skill is just a PostHog prompt that contains agent instructions instead of an LLM system prompt. Let's create one — a skill called hog-release-notes that writes release notes in PostHog's voice.
Via the PostHog UI
- Navigate to LLM analytics > Prompts
- Click New prompt
- Name it
hog-release-notes - Paste your skill content (see example below)
- Click Create prompt
Via MCP
Ask your agent to create the skill:
Or call prompt-create directly:
Example skill content
A good skill gives the agent all the context it needs — where to find information, what format to use, and any project-specific knowledge. Here's what hog-release-notes might look like:
Notice the skill includes everything the agent needs to work autonomously — where to look for changes, what's already published, and how to format the output. The more context you bake in, the less you need to explain each time you run it.
Step 2: Use a skill from any agent
Once a skill exists in PostHog, any team member with the MCP server configured can use it. No extra setup needed — just ask your agent. Since PostHog MCP is already connected, your agent can fetch and run skills directly.
Discover available skills
This calls prompt-list and returns all prompts in your project.
Fetch and run a skill
The agent calls prompt-get with the name hog-release-notes, receives the skill content, and follows the instructions — writing release notes based on your branch's changes.
That's it. This works identically in Claude Code, Cursor, Codex, or any other MCP-connected agent. The skill lives in PostHog, not in any particular tool. You can also create and update skills the same way:
Step 3: Set up a bridge skill (optional shortcut)
Step 2 is all you need — but if your agent supports local slash commands (like Claude Code), you can optionally set up a bridge skill to make invocation a bit more convenient. Instead of typing "use PostHog MCP prompts to..." each time, you get a slash command.
You create one generic bridge that can fetch and run any skill by name:
Claude Code example
Create a file at .claude/skills/posthog-skills-store/SKILL.md:
This bridge is intentionally thin — it just bootstraps into PostHog, where the real instructions live. Now team members can type things like:
One local file, unlimited remote skills. But again, this is purely a convenience — everything the bridge does, you can do by asking your agent to use PostHog MCP prompts directly.
Example: a full session
Here's what using the skills store looks like in practice — from running a skill, to updating it mid-session, to a teammate picking up the changes automatically.
Running the skill
The agent had everything it needed — the skill told it where to find what's already published, how to discover what's new, and how to format the output.
Updating the skill mid-session
After reviewing the output, you decide the skill could be better:
That's it — the skill is updated in PostHog. You can review the diff in the PostHog UI to see exactly what changed.
A teammate benefits automatically
The next day, a teammate runs the same skill from their own agent (Claude Code, Cursor, or anything with PostHog MCP):
No sync, no PR, no "hey I updated the skill" message in Slack. The skill evolved, and everyone got the new version on their next fetch.
Updating and versioning skills
Skills are versioned just like any other PostHog prompt. Every edit creates a new immutable version.
Edit a skill
Via the UI: Open the prompt, click Edit latest, make changes, and click Publish version.
Via MCP: Ask your agent to update the skill:
This calls prompt-update and creates a new version.
Review changes
Use the Compare versions feature to see a diff between any two versions. This is especially useful when an agent has updated a skill — you can review exactly what it changed before the rest of your team picks it up.
Automatic propagation
Team members automatically get the latest version on their next fetch. No PRs, no syncing, no manual updates — just one source of truth in PostHog.
Team workflow tips
- Use descriptive, kebab-case names —
review-frontend-pr,write-api-docs,check-security-headers - Discover before you create — Run
prompt-listto see what skills your team already has before creating a duplicate - Port local skills to PostHog — If you have useful instructions saved locally, move them to PostHog so the whole team benefits
- Keep skills focused — One task per skill. A skill that does "everything" is a skill that does nothing well
- Let agents update skills — After an agent follows a skill, ask it to suggest improvements, then update the prompt via MCP