At work, we shared this prompt - `Please analyze all public repositories by Rachael Wright-Munn, GitHub handle - ChaelCodes. Create a skill called "code-like-chael" that outlines how to code like her.` and this is an excerpt of the skill Claude created.

SKILL.md

Error in user YAML: (<unknown>): mapping values are not allowed in this context at line 2 column 74

---
name: code-like-chael
description: Guide for coding in the style of Rachael Wright-Munn (GitHub: ChaelCodes).
---

Code Like Chael

Guide for coding in the style of Rachael Wright-Munn (GitHub: ChaelCodes), based on analysis of her public repositories and technical writing.

Core Philosophy & Values

Community-First Development

• Public learning: Build in public, share code openly, create "library of examples" through public contributions
• Inclusive collaboration: Adopt codes of conduct (Contributor Covenant), use inclusive language
• Teaching mindset: Write documentation that guides users progressively from setup to mastery
• Joy in coding: Bring playfulness to programming; it shouldn't feel like pure labor

Pragmatic Problem-Solving

• Casual completion over competition: Focus on solving problems well, not racing for maximum points
• Practical over theoretical: Address real-world user experience, including common bugs and workarounds
• Convention over configuration: Trust framework defaults unless there's a specific reason to override
• Simplicity: Keep solutions focused; avoid over-engineering

Developer Experience Matters

• Demystify tools: "Docker isn't Magic" - make complex tools understandable
• Clear explanations: Frameworks should be less mysterious through documentation
• Visible achievements: Maintain public presence; work persists beyond individual jobs

Development Tools

• Debugging: Use binding.irb for interactive debugging
• Exit debugging: Exit with exit! to terminate
• Task automation: Create Rake tasks for repetitive setup
• Template generation: Use string substitution for scaffolding

Git Workflow

• Branch protection: Work in feature branches
• Collaborative approach: Use forks for external contributions
• Keep current: Regular upstream syncing

Commit Messages

Style Patterns

Format Preferences

• Use imperative mood (standard): "Remove sign up form", "Fix Rails/Output"
• Keep length short-to-moderate (40-70 characters)
• Include issue numbers when relevant: "[#234] change the view for 404"
• Provide body text for context on complex changes

Examples

Remove sign up form

Only allow admins and organizers to edit the 'organizer' field

Extract Rails dependencies

[#234] Change the view for 404

Evolving Standards

• Detailed body sections for multi-step changes
• Cite version numbers in dependency updates
• Link to changelogs and resources

Note: Conventional commits (feat:, fix:) are not consistently used

Documentation

README Structure

Progressive Disclosure

1. Project Purpose: Clear, concise description of what it does
2. Key Features: Highlight main functionality
3. Technology Stack: List frameworks, versions, key dependencies
4. Setup Instructions: Step-by-step with exact commands
5. Development Workflow: Common tasks and automation
6. Community Guidelines: Code of conduct, contribution process

Tone & Voice

• Conversational and approachable
• Include personality: "casual completion run, not necessarily for maximum points"
• Personal enthusiasm: "This conference was amazing!"
• Focus on collaboration and shared learning

Code of Conduct

• Explicitly adopt Contributor Covenant
• Make behavioral expectations clear upfront
• Foster inclusive, respectful collaboration

Contributing Guidelines

Should Include:

• How to submit PRs, issues, documentation
• Development environment options (local, Docker)
• Testing requirements and commands
• Code quality expectations
• Version control process (fork, branch, sync)

Cross-Language Patterns

Consistent Across Projects

1. Clear file organization: Separate concerns into dedicated directories
2. Configuration over magic: Make settings explicit and customizable
3. Documentation focus: README as primary entry point
4. Testing infrastructure: Always include test framework
5. Version specification: Pin versions for reproducibility
6. Automation: Reduce manual setup through scripting
7. Inclusive practices: Code of conduct, respectful language
8. Personality in docs: Make projects feel human and approachable

Community & Collaboration

Open Source Engagement

• Contribute to social impact projects (CASA for foster youth)
• Participate in coding challenges (Advent of Code)
• Build community tools (Ruby events index)
• Share knowledge through streaming and blogging
• Fork and improve existing projects

Content Creation

• Streaming: Live coding on Twitch (ChaelCodes channel)
• Blogging: Technical tutorials and reflections at chael.codes
• Talks: Conference presentations and podcasts
• Examples: Create public "library of examples" for learning

Professional Development

• Maintain visible public work
• Build professional networks through open source
• Document learning journey publicly
• Bring joy back to coding as legitimate professional development

Summary Checklist

When coding like Chael:

Philosophy

• Can this be solved without code? (YAGNI mindset)
• Am I prioritizing community and learning?
• Does this bring joy and reduce friction?

Code Organization

• Follow language/framework conventions strictly
• Use clear, semantic naming
• Keep classes and methods focused (single responsibility)
• Organize imports/associations/validations/methods logically

Security

• Layer authentication before authorization
• Deny by default for mutations, allow for reads
• Use strong parameters and CSRF protection
• Handle authorization errors gracefully

Testing

• Comprehensive test coverage (RSpec + Capybara)
• Use factories for test data
• Focus on behavior, not implementation
• Include test infrastructure in automation

Quality

• Run linter (RuboCop) with practical rules
• Add comments only for WHY, not WHAT
• Use guard clauses over deep nesting
• Keep methods short and readable

Documentation

• Progressive README structure
• Conversational, approachable tone
• Include personality and enthusiasm
• Code of conduct and contribution guidelines

Community

• Share work publicly
• Use inclusive language
• Foster respectful collaboration
• Make tools and concepts accessible

---

This skill is based on analysis of ChaelCodes' public repositories, blog posts, and community contributions. It captures patterns observed across multiple projects and languages, with emphasis on Ruby/Rails development where most examples exist.

Remember: The goal is not to copy exactly, but to embody the spirit of pragmatic, joyful, community-focused development that characterizes Chael's approach to code.

Honestly, reading this makes me a bit teary. :)