generating-output-styles

Creates custom output styles for Claude Code that modify system prompts and behavior. Use when the user asks to create output styles, customize Claude's response format, generate output-style files, or mentions output style configuration.

25 stars

Best use case

generating-output-styles is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Creates custom output styles for Claude Code that modify system prompts and behavior. Use when the user asks to create output styles, customize Claude's response format, generate output-style files, or mentions output style configuration.

Teams using generating-output-styles should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/generating-output-styles/SKILL.md --create-dirs "https://raw.githubusercontent.com/ComeOnOliver/skillshub/main/skills/aiskillstore/marketplace/emz1998/generating-output-styles/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/generating-output-styles/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How generating-output-styles Compares

Feature / Agentgenerating-output-stylesStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Creates custom output styles for Claude Code that modify system prompts and behavior. Use when the user asks to create output styles, customize Claude's response format, generate output-style files, or mentions output style configuration.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Generating Output Styles

Creates custom output styles for Claude Code following Anthropic's standards and best practices.

## Context

Output styles modify Claude Code's system prompt to adapt its behavior beyond software engineering. They directly affect the main agent loop and control response tone, structure, and approach.

**Key capabilities:**
- Generate valid output style markdown files with frontmatter
- Apply proper naming and description standards
- Structure instructions following progressive disclosure
- Configure keep-coding-instructions appropriately
- Place files in correct locations (user vs project level)

## Workflow

### Phase 1: Gather Requirements

1. Determine the output style purpose and target behavior
2. Identify if coding instructions should be retained
3. Choose placement: `~/.claude/output-styles/` (user) or `.claude/output-styles/` (project)
4. Reference output style documentation at `.claude/skills/output-style/references/output-style-docs.md`

### Phase 2: Create Output Style File

1. **Craft frontmatter:**
   - `name`: Clear, descriptive name (shown in UI)
   - `description`: Brief explanation for users
   - `keep-coding-instructions`: true/false (default: false)

2. **Write system prompt modifications:**
   - Start with role definition
   - Define specific behaviors and approaches
   - Include formatting guidelines
   - Add any special instructions or constraints
   - Keep instructions concise and actionable

3. **Structure content:**
   - Use markdown headers for organization
   - Provide concrete examples when helpful
   - Avoid contradicting core Claude Code functionality
   - Focus on additive instructions, not restrictions

### Phase 3: Validate and Save

1. Verify YAML frontmatter syntax (opening/closing ---)
2. Ensure description is user-friendly and clear
3. Confirm keep-coding-instructions matches requirements
4. Save to appropriate location
5. Test activation with `/output-style` command

## Implementation Strategy

**File format:**
```markdown
---
name: Style Name
description: User-facing description of what this style does
keep-coding-instructions: false
---

# Custom Style Instructions

You are an interactive CLI tool that helps users with software engineering tasks. [Custom instructions...]

## Specific Behaviors

[Define how the assistant should behave in this style...]
```

**Naming guidelines:**
- Use title case for `name` field
- Keep names concise but descriptive
- Avoid technical jargon in names
- Examples: "Explanatory", "Learning", "Technical Writer"

**Description guidelines:**
- Write for end users, not developers
- Explain what the style does, not how
- Keep under 200 characters
- Focus on benefits and use cases

**keep-coding-instructions:**
- `false` (default): Removes software engineering instructions, clean slate
- `true`: Retains coding guidance, adds modifications on top

## Constraints

- Must include valid YAML frontmatter with all required fields
- System prompt modifications should complement, not contradict, core Claude Code
- Cannot override tool permissions or security restrictions
- File must use `.md` extension
- Must be placed in recognized output-styles directory
- Description shown in UI, so must be user-friendly

## Success Criteria

- Valid markdown file with proper YAML frontmatter
- Name and description follow guidelines
- keep-coding-instructions set appropriately
- System prompt instructions are clear and actionable
- File saved to correct location
- Can be activated via `/output-style` command
- Produces expected behavioral changes when active

## Examples

**Example 1: Technical Writer Style**

```markdown
---
name: Technical Writer
description: Produces detailed documentation with comprehensive explanations
keep-coding-instructions: true
---

# Technical Writer Instructions

You are an interactive CLI tool that helps users with software engineering tasks.

## Documentation Approach

- Provide comprehensive explanations for all code changes
- Include detailed comments in code
- Document edge cases and assumptions
- Create thorough README sections when relevant
- Explain trade-offs in implementation decisions

## Formatting

- Use clear section headers
- Include code examples with explanations
- Add inline comments for complex logic
- Structure responses with intro, body, conclusion
```

**Example 2: Minimalist Style**

```markdown
---
name: Minimalist
description: Provides concise responses with minimal explanation
keep-coding-instructions: true
---

# Minimalist Instructions

You are an interactive CLI tool that helps users with software engineering tasks.

## Communication Style

- Keep responses under 5 lines when possible
- Use code without explanatory prose
- Omit obvious explanations
- Respond with direct answers
- Only elaborate when explicitly asked
```

## Quick Reference

**Common output style patterns:**

1. **Educational styles**: Set `keep-coding-instructions: true`, add explanatory guidance
2. **Specialized domain styles**: Set `keep-coding-instructions: false`, define new role
3. **Formatting styles**: Set `keep-coding-instructions: true`, add response structure rules
4. **Tone modifiers**: Set `keep-coding-instructions: true`, adjust communication style

**Testing workflow:**
1. Create output style file
2. Run `/output-style` to verify it appears in menu
3. Activate the style
4. Test with representative tasks
5. Iterate based on behavior
6. Verify style persists in `.claude/settings.local.json`

## Related Documentation

- Output Style Docs: `.claude/skills/output-style/references/output-style-docs.md`
- Output Style Template: `.claude/templates/output-style.md` (if exists)
- Settings Documentation: Claude Code settings reference

Related Skills

generating-unit-tests

25
from ComeOnOliver/skillshub

This skill enables Claude to automatically generate comprehensive unit tests from source code. It is triggered when the user requests unit tests, test cases, or test suites for specific files or code snippets. The skill supports multiple testing frameworks including Jest, pytest, JUnit, and others, intelligently detecting the appropriate framework or using one specified by the user. Use this skill when the user asks to "generate tests", "create unit tests", or uses the shortcut "gut" followed by a file path.

generating-test-reports

25
from ComeOnOliver/skillshub

This skill generates comprehensive test reports with coverage metrics, trends, and stakeholder-friendly formats (HTML, PDF, JSON). It aggregates test results from various frameworks, calculates key metrics (coverage, pass rate, duration), and performs trend analysis. Use this skill when the user requests a test report, coverage analysis, failure analysis, or historical comparisons of test runs. Trigger terms include "test report", "coverage report", "testing trends", "failure analysis", and "historical test data".

generating-test-doubles

25
from ComeOnOliver/skillshub

This skill uses the test-doubles-generator plugin to automatically create mocks, stubs, spies, and fakes for unit testing. It analyzes dependencies in the code and generates appropriate test doubles based on the chosen testing framework, such as Jest, Sinon, or others. Use this skill when you need to generate test doubles, mocks, stubs, spies, or fakes to isolate units of code during testing. Trigger this skill by requesting test double generation or using the `/gen-doubles` or `/gd` command.

generating-test-data

25
from ComeOnOliver/skillshub

This skill enables Claude to generate realistic test data for software development. It uses the test-data-generator plugin to create users, products, orders, and custom schemas for comprehensive testing. Use this skill when you need to populate databases, simulate user behavior, or create fixtures for automated tests. Trigger phrases include "generate test data", "create fake users", "populate database", "generate product data", "create test orders", or "generate data based on schema". This skill is especially useful for populating testing environments or creating sample data for demonstrations.

generating-stored-procedures

25
from ComeOnOliver/skillshub

This skill uses the stored-procedure-generator plugin to create production-ready stored procedures, functions, triggers, and custom database logic. It supports PostgreSQL, MySQL, and SQL Server. Use this skill when the user asks to "generate stored procedure", "create database function", "write a trigger", or needs help with "database logic", "optimizing database performance", or "ensuring transaction safety" in their database. The skill is activated by requests related to database stored procedures, functions, or triggers.

generating-orm-code

25
from ComeOnOliver/skillshub

This skill enables Claude to generate ORM models and database schemas. It is triggered when the user requests the creation of ORM models, database schemas, or wishes to generate code for interacting with databases. The skill supports various ORMs including TypeORM, Prisma, Sequelize, SQLAlchemy, Django ORM, Entity Framework, and Hibernate. Use this skill when the user mentions terms like "ORM model", "database schema", "generate entities", "create migrations", or specifies a particular ORM framework like "TypeORM entities" or "SQLAlchemy models". It facilitates both database-to-code and code-to-database schema generation.

generating-infrastructure-as-code

25
from ComeOnOliver/skillshub

This skill enables Claude to generate Infrastructure as Code (IaC) configurations. It uses the infrastructure-as-code-generator plugin to create production-ready IaC for Terraform, CloudFormation, Pulumi, ARM Templates, and CDK. Use this skill when the user requests IaC configurations for cloud infrastructure, specifying the platform (e.g., Terraform, CloudFormation) and cloud provider (e.g., AWS, Azure, GCP), or when the user needs help automating infrastructure deployment. Trigger terms include: "generate IaC", "create Terraform", "CloudFormation template", "Pulumi program", "infrastructure code".

generating-smart-commits

25
from ComeOnOliver/skillshub

This skill generates conventional commit messages using AI analysis of staged Git changes. It automatically determines the commit type (feat, fix, docs, etc.), identifies breaking changes, and formats the message according to conventional commit standards. Use this when asked to create a commit message, write a Git commit, or when the user uses the `/commit-smart` or `/gc` command. It is especially useful after changes have been staged with `git add`.

generating-trading-signals

25
from ComeOnOliver/skillshub

Generate trading signals using technical indicators (RSI, MACD, Bollinger Bands, etc.). Combines multiple indicators into composite signals with confidence scores. Use when analyzing assets for trading opportunities or checking technical indicators. Trigger with phrases like "get trading signals", "check indicators", "analyze for entry", "scan for opportunities", "generate buy/sell signals", or "technical analysis".

generating-rest-apis

25
from ComeOnOliver/skillshub

Generate complete REST API implementations from OpenAPI specifications or database schemas. Use when generating RESTful API implementations. Trigger with phrases like "generate REST API", "create RESTful API", or "build REST endpoints".

generating-helm-charts

25
from ComeOnOliver/skillshub

Execute use when generating Helm charts for Kubernetes applications. Trigger with phrases like "create Helm chart", "generate chart for app", "package Kubernetes deployment", or "helm template". Produces production-ready charts with Chart.yaml, values.yaml, templates, and best practices for multi-environment deployments.

generating-grpc-services

25
from ComeOnOliver/skillshub

Generate gRPC service definitions, stubs, and implementations from Protocol Buffers. Use when creating high-performance gRPC services. Trigger with phrases like "generate gRPC service", "create gRPC API", or "build gRPC server".