Output Formatter

The Output Formatter skill transforms AI-generated content into the right format for your specific context. Whether you need markdown for documentation, JSON for APIs, tables for analysis, or prose for presentations, this skill ensures outputs are structured appropriately and consistently.

This skill understands format requirements across different platforms (GitHub, Notion, Slack, email), use cases (technical docs, user guides, reports, code comments), and audiences (developers, stakeholders, end users). It helps you avoid manual reformatting and ensures professional, consistent presentation.

Use this skill whenever AI output needs to be transformed for a specific platform, integrated into existing documentation, or presented to a particular audience.

Core Workflows

Workflow 1: Convert Between Formats

Identify

source format:

Current structure

Content type

Data hierarchy

Understand

target format requirements:

Platform constraints

Syntax rules

Conventions

Map

content structure:

Headers → equivalent elements

Lists → appropriate format

Code blocks → proper syntax

Links → platform-specific

Transform

content:

Preserve semantic meaning

Adapt to target syntax

Maintain readability

Validate

output:

Syntax correctness

Completeness

Visual consistency

Provide

formatted result

Workflow 2: Format for Specific Platform

Identify

target platform:

GitHub (markdown)

Notion (blocks)

Slack (mrkdwn)

Email (HTML/plain text)

Confluence (wiki)

Jira (markup)

Apply

platform-specific conventions:

Syntax variations

Supported features

Best practices

Limitations

Optimize

for platform:

Use platform-native features

Respect character limits

Add appropriate formatting

Test

rendering (if possible)

Provide

ready-to-paste output

Workflow 3: Structure Data for Presentation

Analyze

data content:

Type of information

Relationships

Importance hierarchy

Choose

optimal structure:

Table for comparisons

List for sequences

Tree for hierarchies

Graph for relationships

Format

accordingly:

Clear headers

Consistent alignment

Appropriate nesting

Visual hierarchy

Add

context:

Title/caption

Column descriptions

Units/scales

Footnotes if needed

Validate

readability

Workflow 4: Adapt for Audience

Identify

target audience:

Technical expertise level

Domain knowledge

Role/responsibility

Context/goals

Adjust

content appropriately:

Technical depth

Jargon usage

Detail level

Examples chosen

Restructure

for clarity:

Executive summary for leadership

Details for implementers

Context for newcomers

Format

to match expectations:

Business: Charts and summaries

Technical: Code and diagrams

User-facing: Simple and clear

Review

for appropriateness

Quick Reference

Action

Command/Trigger

Convert to markdown

"Format as markdown"

Convert to JSON

"Format as JSON"

Convert to table

"Format as table"

Format for GitHub

"Format for GitHub"

Format for Notion

"Format for Notion"

Format for Slack

"Format for Slack"

Make it technical

"Format for developers"

Make it non-technical

"Format for stakeholders"

Create summary

"Format as executive summary"

Best Practices

Preserve Meaning

Don't lose information during transformation

Keep all substantive content

Maintain logical structure

Preserve relationships and context

Follow Conventions

Use format-specific best practices

Markdown: ATX headers, fenced code blocks

JSON: Proper escaping, consistent indentation

Tables: Aligned columns, clear headers

Optimize Readability

Format for human consumption

Use whitespace effectively

Break up long sections

Add visual hierarchy

Include context clues

Validate Output

Ensure format correctness

Test with parsers when possible

Check rendering preview

Verify syntax highlighting

Be Consistent

Maintain uniform style

Same header levels for same importance

Consistent list formatting

Uniform code block languages

Standardized terminology

Consider Context

Format appropriately for use case Documentation: Clear, detailed, structured Communication: Concise, scannable, actionable Code: Properly commented, syntax-highlighted Reports: Data-rich, visual, summarized Format Templates Markdown Documentation

Main Title

Overview Brief introduction to the topic.

Key Concepts

**

Concept 1

**

Description

**

Concept 2

**

Description

Usage ```language code example ```

Reference | Parameter | Type | Description | |

|

|

| | param1 | string | What it does | JSON API Response { "status" : "success" , "data" : { "items" : [ ] , "pagination" : { "page" : 1 , "totalPages" : 10 , "totalItems" : 100 } } , "metadata" : { "timestamp" : "2026-01-06T00:00:00Z" , "version" : "1.0" } } Comparison Table | Feature | Option A | Option B | Option C | |

|

|

|

| | Speed | Fast | Medium | Slow | | Cost | High | Medium | Low | | Ease | Easy | Medium | Complex | | ** Recommend ** | ✓ | | | Executive Summary

Executive Summary

**

Objective

**

[One-line goal]

**

Status

**

[Current state]

**

Key Results

**

:

-

Result 1

-

Result 2

-

Result 3

**

Next Steps

**

:

1.

Action item 1

2.

Action item 2

**

Blockers

**

[Issues requiring escalation] Technical Specification

[Component Name]

**

Purpose

**

[What it does]

**

Dependencies

**

[What it requires]

**

Interface

**

:

```typescript

interface ComponentProps {

prop1: string;

prop2?: number;

}

```

**

Behavior

**

:

1.

Step-by-step description

**

Error Handling

**

:

-

Error type: Response

**

Examples

**

:

```typescript

// Usage example

```

Slack Message

*

Project Update

*

:rocket:

*

Status

*

On track

*

Completed

*

:

• Feature A deployed

• Bug fixes merged

*

Next

*

:

• Feature B review

• Performance testing

*

Blockers

*

None

<

link|Full

details

>

Format Conversion Guide

From Prose to List

Before

"The system supports authentication through OAuth, API keys, and session tokens. It also provides role-based access control." After :

Authentication Methods

OAuth 2.0

API Keys

Session Tokens

Authorization

Role-based Access Control (RBAC) From List to Table Before : - JavaScript: 45% - TypeScript: 30% - CSS: 15% - HTML: 10% After : | Language | Percentage | |

|

| | JavaScript | 45% | | TypeScript | 30% | | CSS | 15% | | HTML | 10% | From Code to Documentation Before : function processData ( input : string [ ] , options ? : ProcessOptions ) : Result After :

processData Processes input data according to specified options. ** Parameters ** : - input (string[]): Array of strings to process - options (ProcessOptions, optional): Configuration object ** Returns ** : Result - Processed data result ** Example ** : ```typescript const result = processData(['a', 'b', 'c'], { sort: true }); ``` Platform-Specific Formatting GitHub Markdown Use diff syntax for code changes Use [!NOTE] for callouts Use