Back to Documentation & Writing

Metabase Documentation Writer

metabasedocumentationmarkdownstyle-guidetechnical-writing
4.5 (141)47.7k📄 NOASSERTION🕒 2026-06-16Source ↗

Install this skill

npx skills add metabase/metabase

Works across Claude Code, Cursor, Codex, Copilot & Antigravity

What this skill does

  • Applies Metabase-specific conversational tone and voice guidelines
  • Standardizes UI element referencing using bold formatting
  • Enforces consistent code snippet and command-line block patterns
  • Automatically runs Prettier on modified files for clean formatting
  • Checks for common pitfalls like vague headers or overly formal vocabulary

When to use it

  • Writing new feature documentation for a Metabase-related project
  • Updating existing markdown files to match project style standards
  • Drafting technical configuration guides for self-hosted instances
  • Refining instructional steps to make them more accessible and direct

When not to use it

  • Writing marketing copy or non-technical blog posts
  • Generating documentation for non-Metabase software stacks

How to invoke it

Example prompts that trigger this skill:

  • Draft a guide on setting up database connections using the Metabase style.
  • Refactor this documentation file to follow Metabase documentation standards.
  • Edit this markdown block to be more conversational and direct.
  • Check these instructions for tone, formatting, and clarity.

Example workflow

  1. Draft initial content using natural, conversational language.
  2. Pass the draft to the agent to apply Metabase specific styling rules.
  3. The agent formats code snippets and UI elements according to the guide.
  4. The agent executes the required Prettier command to normalize white space.
  5. Review the suggested changes for tone and actionable instruction structure.

Prerequisites

  • bun
  • Prettier configured in the project

Pitfalls & limitations

  • !May struggle with highly abstract concepts that require complex explanation
  • !Strict adherence to 'no we' style can sometimes feel jarring if applied to non-documentation text
  • !Requires active oversight to ensure technical accuracy of code examples

FAQ

Why does this skill avoid using the word 'we'?
Metabase docs focus on the product and the user. Using 'Metabase' or 'it' instead of 'we' keeps the documentation objective and product-focused.
How does it ensure consistent formatting?
After editing the text, the skill is configured to run 'bun run prettier --write' to ensure consistent whitespace and line endings across all files.
Should I use this for non-technical writing?
No, this skill is specifically tuned for technical documentation and configuration guides where clarity and speed to a solution are the primary goals.
Does this skill provide technical fact-checking?
It focuses on style, tone, and structure. You are responsible for ensuring the technical commands and logic remain accurate.

How it compares

Generic LLM prompts often lean toward overly formal or marketing-heavy language; this skill enforces a specific, developer-centric 'colleague-to-colleague' style and automates the required formatting steps.

Source & trust

48k stars📄 NOASSERTION🕒 Updated 2026-06-16🛡 runs-shell

From the source: “# Documentation Writing Skill @./../_shared/metabase-style-guide.md ## When writing documentation ### Start here 1. **Who is this for?** Match complexity to audience. Don't oversimplify hard things or overcomplicate simple ones. 2. **What do they need?** Get them to the answer fast. Nobody wants to …”

View the full SKILL.md source

# Documentation Writing Skill

@./../_shared/metabase-style-guide.md

## When writing documentation

### Start here

1. **Who is this for?** Match complexity to audience. Don't oversimplify hard things or overcomplicate simple ones.
2. **What do they need?** Get them to the answer fast. Nobody wants to be in docs longer than necessary.
3. **What did you struggle with?** Those common questions you had when learning? Answer them (without literally including the question).

### Writing process

**Draft:**

- Write out the steps/explanation as you'd tell a colleague
- Lead with what to do, then explain why
- Use headings that state your point: "Set SAML before adding users" not "SAML configuration timing"

**Edit:**

- Read aloud. Does it sound like you talking? If it's too formal, simplify.
- Cut anything that doesn't directly help the reader
- Check each paragraph has one clear purpose
- Verify examples actually work (don't give examples that error)

**Polish:**

- Make links descriptive (never "here")
- Backticks only for code/variables, **bold** for UI elements
- American spelling, serial commas
- Keep images minimal and scoped tight

**Format:**

- Run prettier on the file after making edits: `bun run prettier --write <file-path>`
- This ensures consistent formatting across all documentation

### Common patterns

**Instructions:**

```markdown
Run:
\`\`\`
command-to-run
\`\`\`

Then:
\`\`\`
next-command
\`\`\`

This ensures you're getting the latest changes.
```

Not: "(remember to run X before Y...)" buried in a paragraph.

**Headings:**

- "Use environment variables for configuration" ✅
- "Environment variables" ❌ (too vague)
- "How to use environment variables for configuration" ❌ (too wordy)

**Links:**

- "Check out the [SAML documentation](link)" ✅
- "Read the docs [here](link)" ❌

### Watch out for

- Describing tasks as "easy" (you don't know the reader's context)
- Using "we" when talking about Metabase features (use "Metabase" or "it")
- Formal language: "utilize", "reference", "offerings"
- Too peppy: multiple exclamation points
- Burying the action in explanation
- Code examples that don't work
- Numbers that will become outdated

### Quick reference

| Write This                 | Not This           |
| -------------------------- | ------------------ |
| people, companies          | users              |
| summarize                  | aggregate          |
| take a look at             | reference          |
| can't, don't               | cannot, do not     |
| **Filter** button          | \`Filter\` button  |
| Check out [the docs](link) | Click [here](link) |

Quoted from metabase/metabase for reference — see the original for the authoritative, latest version.

📄 Full skill instructions — original source: metabase/metabase
The docs-write skill ensures your technical content matches the specific editorial standards of the Metabase project. Instead of generic AI writing, this tool enforces a conversational, direct, and user-centric tone that prioritizes clarity over fluff. It helps technical writers and developers create instructions that effectively solve user problems without unnecessary jargon or filler. By applying specific formatting rules—such as standardizing UI references with bold text, managing code blocks with precision, and strictly avoiding formal or detached language—this skill produces documentation that feels like it was written by an engineer talking to a colleague. It is essential for maintaining a consistent voice across the Metabase ecosystem, ensuring that every guide, tutorial, or configuration step is readable, actionable, and formatted correctly for immediate developer consumption.

How to Use This Skill Unit

Option A: Project-Specific (Recommended)

  1. Click "Download" above
  2. In your project, create the directory: .agent/skills/docs-write/
  3. Save the file as SKILL.md
  4. The agent will automatically discover the skill based on its description.

Option B: Global Installation (All Agents)

Save the file to these locations to make it available across all projects:

  • Claude Code: ~/.claude/skills/metabase/metabase/docs-write/SKILL.md
  • Cursor: ~/.cursor/skills/metabase/metabase/docs-write/SKILL.md
  • Antigravity: ~/.gemini/antigravity/skills/metabase/metabase/docs-write/SKILL.md

🚀 Install with CLI:
npx skills add metabase/metabase

Read the Master Guide: Mastering Agent Skills

Recommended Rules

View more rules

Recommended Workflows

View more workflows

Recommended MCP Servers

View more MCP servers

Take It Further

Maximize your productivity with these powerful resources

📋

Define Your Standards

Set up coding standards to ensure this workflow produces consistent, high-quality results.

Browse Rules Library
📖

Master Workflows

Learn how to create custom workflows, use Turbo Mode, and build your automation library.

Complete Guide

How to use this Skill in Claude Code & Cursor

For Claude Code (CLI)

To use this skill in Claude Code, copy the rule content into your project's custom instructions or follow our Add-Skill CLI guide. This ensures Claude follows your standards during every code generation.

For Cursor & Windsurf

For Cursor or Windsurf, individual skills are best used in the "Rules for AI" section. This specific unit helps the agent avoid documentation & writing issues, leading to cleaner, more efficient code.

Why the skill format matters: the standardized Agent Skills format lets your AI agent load detailed instructions only when they are relevant, keeping your prompt clean while improving results.

Source & attribution

This skill is categorized under Documentation & Writing and is published by metabase, maintained in metabase/metabase.

← Browse All Agent Skills
Sponsored AI assistant. Recommendations may be paid.