🎯 Claude and Codex Skills Directory

Elite Engineering Mastery Collection for Claude AI / ChatGPT Codex

Transform Claude AI / ChatGPT Codex into a senior/lead engineer across 8 specialized domains

Quick Start • Skills Overview • Usage Examples • Contributing

---

What is This?

The Claude Codex Skills Directory is a comprehensive collection of 8 mastery-level expertise systems that transform Claude AI / ChatGPT Codex into a world-class senior/lead engineer across multiple technology domains. Each skill embodies production experience with battle-tested patterns, anti-patterns to avoid, debugging strategies, and real-world decision frameworks.

📊 Skills at a Glance

| Metric | Count | |--------|-------| | Total Skills | 8 specialized domains | | Reference Docs | 64+ comprehensive guides | | Automation Scripts | 8 helper tools | | Technologies Covered | 30+ frameworks and libraries | | Expertise Level | Senior/lead engineer per skill | | Documentation | 10,000+ lines of battle-tested knowledge |

🎓 Skills Overview

🚀 Quick Start

Using a Single Skill

1. Point Claude to the relevant skill directory (e.g., ai-ml-mastery-skill/)
2. Claude will adopt the persona and expertise defined in SKILL.md
3. Reference files in references/ for deep-dive knowledge

Using Multiple Skills

Load multiple skills for cross-domain projects:

- golang-mastery-skill (backend API)
- react-tanstack-mastery-skill (frontend)
- rabbitmq-mastery-skill (message broker)

Example Prompt

"Load the AI/ML mastery skill and help me build a production-ready
sentiment analysis model using PyTorch. Include proper error handling,
logging, and Docker deployment."

📝 Usage Examples

Example 1: AI/ML - Building Sentiment Analysis with PyTorch

Scenario: You need a production-ready sentiment analysis model

Load Skill: ai-ml-mastery-skill

Ask Claude:

"Build a sentiment analysis model using PyTorch and transformers.
Include:
- Proper training loop with validation
- Error handling and logging
- Model checkpointing
- Docker deployment configuration
- Inference API endpoint"

Expected Output: Claude will provide expert-level implementation with:

• Clean PyTorch code following best practices
• Transformer-based architecture (BERT/RoBERTa)
• Production-ready error handling
• MLOps deployment patterns
• Performance optimization tips

---

Example 2: Full-Stack - Microservices Architecture

Scenario: Build a microservices system with async communication

Load Skills:

• golang-mastery-skill (backend services)
• react-tanstack-mastery-skill (frontend dashboard)
• rabbitmq-mastery-skill (message broker)

Ask Claude:

"Design a microservices architecture for an e-commerce platform with:
- Go backend services (orders, inventory, payments)
- RabbitMQ for async communication
- React frontend with TanStack Query
- Docker Compose setup"

Expected Output: Claude will design:

• Clean Go microservices architecture
• RabbitMQ messaging patterns (work queues, pub/sub, RPC)
• React frontend with proper state management
• Production-ready Docker setup
• API design and error handling

---

Example 3: Code Review - Rust Production Readiness

Scenario: Review existing Rust codebase for production deployment

Load Skill: rust-mastery-skill

Ask Claude:

"Review this Rust codebase for production readiness. Check for:
- Memory safety issues and potential panics
- Proper error handling with thiserror/anyhow
- Performance bottlenecks
- Security vulnerabilities
- Clean code violations
- Missing test coverage"

Expected Output: Claude will provide senior-level review with:

• Identification of unsafe patterns
• Error handling improvements
• Performance optimization suggestions
• Security hardening recommendations
• Test coverage analysis
• Refactoring suggestions

💡 Key Features

• Battle-Tested Patterns: Proven solutions from real production systems
• Anti-Patterns Documented: Learn what NOT to do and why
• Decision Frameworks: Clear guidance for architectural choices
• KISS Principle: Keep It Simple, Stupid - no over-engineering
• YAGNI Enforcement: You Aren't Gonna Need It - build what's required
• Explicit over Implicit: Clear, readable code without magic
• Production-Ready Focus: Security, error handling, logging, monitoring
• Library Curation: Battle-tested dependencies, not trendy experiments
• Debugging Guides: Systematic troubleshooting strategies
• Code Review Standards: Senior-level review checklists

📖 Philosophy & Values

All skills follow these core principles:

1. KISS - Keep It Simple, Stupid

• Simplicity over cleverness
• Readable code over "smart" code
• Boring technology that works

2. YAGNI - You Aren't Gonna Need It

• No premature optimization
• Build for today's requirements
• Add complexity only when proven necessary

3. Explicit over Implicit

• Clear variable names
• No hidden magic or DSLs
• Obvious code flow

4. Production-Ready by Default

• Proper error handling
• Logging and monitoring
• Security hardening
• Performance testing

5. Battle-Tested Technology

• Proven libraries and frameworks
• Stability over bleeding edge
• Community support and documentation

📂 Repository Structure

claude-codex-skills-directory/
├── README.md                           # This file
├── assets/
│   └── logos/                          # Technology logos
│       ├── python.svg
│       ├── bun.svg
│       ├── golang.svg
│       ├── nuxt.svg
│       ├── rabbitmq.svg
│       ├── react.svg
│       ├── rust.svg
│       └── solidjs.svg
│
├── ai-ml-mastery-skill/
│   ├── SKILL.md                        # AI/ML expertise guide
│   └── references/                     # 9 deep-dive docs
│       ├── deep-learning.md            # PyTorch, TensorFlow, JAX
│       ├── transformers-llm.md         # LLMs, fine-tuning, PEFT
│       ├── computer-vision.md          # Object detection, segmentation
│       ├── machine-learning.md         # sklearn, XGBoost, ensembles
│       ├── nlp.md                      # Text processing, embeddings
│       ├── mlops.md                    # Deployment, monitoring
│       ├── clean-code.md               # Patterns, anti-patterns
│       ├── debugging.md                # Profiling, optimization
│       └── data-engineering.md         # pandas, polars, dask
│
├── bunjs-mastery-skill/
│   ├── SKILL.md
│   ├── references/                     # 4 references
│   │   ├── clean-code-patterns.md      # Design patterns
│   │   ├── debugging-guide.md
│   │   ├── docker-patterns.md          # Advanced Docker
│   │   └── testing-strategy.md
│   ├── scripts/                        # 2 automation scripts
│   │   ├── init-project.sh             # Project bootstrap
│   │   └── healthcheck.ts              # Health check template
│   └── assets/                         # Project templates
│       └── proj