Claude Code Communication Style Skill

Overview

This skill template pushes Codex to adopt Claude Code's distinctive approach:

1. Thorough analysis and planning - Comprehensive upfront thinking even when it doesn't change implementation
2. Polished communication - Professional, well-organized presentation of code and documentation

What This Skill Provides

Skill Structure

claude-code-style-skill/
├── SKILL.md              # Core principles, patterns, and guidelines (~380 lines)
└── references/
    └── examples.md       # Detailed examples demonstrating the patterns

Communication Standards

• Structured response patterns for feature requests, code reviews, and debugging
• Progressive disclosure (executive summary → details → code)
• Professional formatting and documentation quality standards

Analytical Framework

• Comprehensive code analysis before implementation
• Explicit trade-off discussion and alternative consideration
• Clear rationale documentation for decisions

Quality Checklists

• Pre-flight checks for code, analysis, and documentation
• Anti-pattern identification
• Adaptation guidelines for different audience types

Progressive Disclosure Design

• SKILL.md loads automatically when skill triggers (lean, ~380 lines)
• references/examples.md loads only when Claude needs concrete examples (detailed, ~400 lines)

Usage Options

Option 1: Direct Use as SKILL.md

Place the SKILL.md file in your Codex skills directory:

/mnt/skills/user/claude-code-style/SKILL.md

The skill will trigger automatically for coding tasks based on the description in the frontmatter.

Option 2: Customize for Your Workflow

The skill includes extensive examples and patterns you can adapt:

• Modify response templates to match your preferred structure
• Adjust verbosity levels in different sections
• Add domain-specific patterns (e.g., ML model deployment, data pipelines)
• Incorporate team-specific conventions

Option 3: Extract Specific Patterns

You can pull out individual sections for focused improvements:

• Copy just the "Pattern 1: Task Analysis Response" section for feature planning
• Use only the "Code Quality" checklist as a pre-commit review guide
• Extract the error handling examples for a coding standards reference

Key Features

1. Response Patterns

Three comprehensive templates:

• Task Analysis Response: For feature requests and implementation planning
• Code Review Response: For evaluating existing code
• Debugging Response: For systematic problem investigation

2. Communication Principles

• Analysis before action (building user confidence through context)
• Structured planning with clear phasing and dependencies
• Polished presentation with professional formatting

3. Quality Standards

Before-you-ship checklists for:

• Code presentation
• Technical analysis
• Documentation

4. Practical Examples (in references/examples.md)

Two complete examples demonstrating the style:

• Feature request: Adding API pagination
• Code review: Authentication middleware

Both show the full Claude Code treatment with comprehensive analysis, clear planning, and polished presentation. Load when you need concrete demonstrations of the patterns.

Customization Ideas

For A Risk Management Context

Add financial domain patterns:

### Pattern 4: Risk Analysis Response

When analyzing risk frameworks or stress testing:

**Risk Context**
- Current risk measurement approach
- Data requirements and availability
- Existing constraints and limitations

**Proposed Enhancement**
- Technical implementation details
- Integration with existing systems
- Calibration and validation approach

**Impact Analysis**
- Effect on risk budgeting
- Computational requirements
- Reporting implications

For Specific Tech Stacks

Add language/framework-specific sections:

## Python-Specific Guidelines

**Type Hints**
- Use explicit type annotations for function signatures
- Leverage Protocol for structural typing
- Apply TypedDict for complex dictionary structures

**Error Handling**
- Prefer specific exceptions over generic Exception
- Use context managers for resource cleanup
- Implement proper logging at each exception catch point

For Team Conventions

Incorporate your organization's standards:

## Team Standards

**Code Review Checklist**
- [ ] Follows firm's naming conventions
- [ ] Includes risk management logging hooks
- [ ] Updated relevant integration tests
- [ ] Performance impact documented
- [ ] Reviewed by quantitative team if touching PnL

Integration Tips

Deploying the Skill

Full Deployment (Recommended) Place the complete skill directory in /mnt/skills/user/claude-code-style/ and let Codex use all components. The progressive disclosure design means the agent only loads examples when needed, so there's minimal token overhead.

Testing First If you want to validate before full deployment:

1. Try the skill on 3-5 representative coding tasks
2. Compare responses with and without the skill
3. Note which aspects provide the most value
4. Adjust verbosity in SKILL.md if needed

Customizing Scope

If the full skill feels too comprehensive, you can create lighter versions:

Minimal Version - Core principles only:

• Keep only: Analysis Before Action, Structured Planning, Quality Standards sections
• Remove: All response pattern templates, just keep the principles
• Use when: You want general guidance without prescriptive templates

Domain-Specific Version - Focused on your work:

• Add risk management patterns to Pattern 4
• Include your firm's coding standards in Quality Standards
• Add finance-specific examples to references/examples.md
• Use when: You want it tailored to hedge fund context

Template-Only Version - Structure without philosophy:

• Keep only: The three response pattern templates
• Remove: Principles and guidelines sections
• Use when: You want structure but Codex to use its own judgment on depth

Measuring Impact

After deploying, evaluate improvements in:

Response Quality

• Are analyses more comprehensive before implementation?
• Is planning more structured and phased?
• Are trade-offs explicitly discussed?

Communication Clarity

• Are responses better organized?
• Is formatting more consistent?
• Are rationales clearly explained?

Efficiency

• Fewer clarification questions needed?
• Less back-and-forth to understand approach?
• Faster code review because explanations are clearer?

Practical Test: Compare Codex responses on the same task with/without the skill. The difference should be immediately apparent in analysis depth and presentation quality.

When to Dial It Back

The skill emphasizes thorough analysis, but context matters:

Use full treatment for:

• Novel implementations
• High-risk changes
• Cross-cutting architectural decisions
• Security-sensitive code
• Complex debugging situations

Streamline for:

• Straightforward bug fixes
• Following established patterns
• Repeated similar tasks
• User explicitly requests brevity

The skill includes guidance on this balance, but you can adjust the defaults based on your typical work.

Technical Notes

Token Usage: This skill uses progressive disclosure for efficiency:

• SKILL.md (~380 lines, ~3000 tokens): Core principles and patterns, loaded when skill triggers
• references/examples.md (~400 lines, ~5000 tokens): Detailed examples, loaded only when Claude needs concrete demonstrations
• Frontmatter description (~100 words): Always in context for triggering

This design minimizes context bloat while keeping detailed examples available when needed.

Compatibility: Works with any Codex installation that supports skills. No special dependencies.

Maintenance: Update response patterns as you discover what works best for your use cases. The skill is designed to evolve with your workflow. Add new examples to references/examples.md as you identify useful patterns.

Getting Started

1. Review the skill: Read through SKILL.md to understand the patterns
2. Try it out: Use it on a few coding tasks to see the difference
3. Customize: Adapt templates and examples to your domain
4. Refine: Adjust verbosity and structure based on what provides value
5. Share: If your team finds it useful, consider creating team-specific variants

Questions to Consider

As you use this skill:

• Which types of analysis provide the most value?
• Are there response patterns you use frequently that should be templated?
• What domain-specific examples would make this more useful?
• Which quality checks catch the most issues?
• Where is verbosity helpful vs. where does it slow things down?

Your answers to these will guide how you evolve the skill for your specific needs.