<div align="center">

🎯 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 49 specialized domains

Quick Start • Skills Overview • Usage Examples • Contributing

</div>

---

What is This?

The Claude Codex Skills Directory is a comprehensive collection of 49 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	49 specialized domains
Reference Docs	400+ comprehensive guides
Automation Scripts	8 helper tools
Technologies Covered	110+ frameworks and libraries
Expertise Level	Senior/lead engineer per skill
Documentation	38,000+ lines of battle-tested knowledge

🎓 Skills Overview

<table> <tr> <td align="center" width="25%"> <img src="assets/logos/python.svg" width="80" height="80" alt="AI/ML Mastery"/> <br/> <b>AI/ML Mastery</b> <br/> _{PyTorch • TensorFlow • LLMs} <br/> <a href="backend-skills/ai-ml-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/bun.svg" width="80" height="80" alt="Bun.js Mastery"/> <br/> <b>Bun.js + Docker</b> <br/> _{TypeScript • Hono • Drizzle} <br/> <a href="backend-skills/bunjs-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/golang.svg" width="80" height="80" alt="Golang Mastery"/> <br/> <b>Golang Mastery</b> <br/> _{Chi • SQLX • Concurrency} <br/> <a href="backend-skills/golang-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/nuxt.svg" width="80" height="80" alt="Nuxt.js Mastery"/> <br/> <b>Nuxt.js + TanStack</b> <br/> _{Vue 3 • Nuxt 3 • Query} <br/> <a href="frontend-skills/nuxtjs-mastery-skill/">📚 Docs</a> </td> </tr> <tr> <td align="center" width="25%"> <img src="assets/logos/rabbitmq.svg" width="80" height="80" alt="RabbitMQ Mastery"/> <br/> <b>RabbitMQ Mastery</b> <br/> _{AMQP • Clustering • HA} <br/> <a href="data-skills/rabbitmq-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/react.svg" width="80" height="80" alt="React + TanStack"/> <br/> <b>React + TanStack</b> <br/> _{Router • Query • Table • Form} <br/> <a href="frontend-skills/react-tanstack-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/rust.svg" width="80" height="80" alt="Rust Mastery"/> <br/> <b>Rust Mastery</b> <br/> _{Axum • SQLX • Memory Safety} <br/> <a href="backend-skills/rust-mastery-skill/">📚 Docs</a> </td> <td align="center" width="25%"> <img src="assets/logos/solidjs.svg" width="80" height="80" alt="SolidJS Mastery"/> <br/> <b>SolidJS + SolidStart</b> <br/> _{Fine-Grained Reactivity} <br/> <a href="frontend-skills/solidjs-solidstart-mastery-skill/">📚 Docs</a> </td> </tr> </table>

🧠 Backend Skills

• AI/ML Mastery Production ML systems, LLM-enabled backends, model serving, evaluation discipline, and MLOps guardrails.

• Bun.js + Docker TypeScript APIs, Hono, Docker delivery, operational hardening, and runtime-aware backend design.

• Golang Idiomatic services, concurrency ownership, error handling, performance, and production-grade APIs.

• Rust Memory-safe services, Axum/SQLX patterns, async correctness, and systems-level production rigor.

• Zig Explicit memory management, systems-aware backend design, low-level control, and predictable performance.

• Erlang / Elixir OTP supervision, actor-model concurrency, BEAM reliability, distributed systems, and operable services.

🗃️ Data Skills

• PostgreSQL Schema design, indexing, transactions, migrations, reliability, and production operations.

• CockroachDB Distributed SQL, multi-region topology, contention, transaction retries, and survivability.

• MongoDB Document modeling, indexing, replication, sharding, and operational reliability.

• Redis Caching strategy, data structures, persistence tradeoffs, memory pressure, and degraded mode behavior.

• Kafka Topic design, partitioning, consumer groups, delivery semantics, lag, and event-driven operations.

• Elasticsearch Index design, relevance, shard strategy, search operations, and production cluster tuning.

• RabbitMQ AMQP, message patterns, clustering, high availability, and performance tuning.

• ClickHouse Columnar analytics, MergeTree design, ingestion, partitioning, and high-scale OLAP operations.

• MySQL Relational schema design, indexing, transactions, replication, online migrations, and operational reliability.

• OpenSearch Search and log analytics, mappings, shard topology, retention, security, and cluster operations.

• NATS Subject design, request-reply, JetStream durability, consumer semantics, and lightweight messaging platform operations.

• Cassandra Wide-column data modeling, consistency, compaction, repair, and operating large distributed clusters safely.

• ScyllaDB Shard-aware low-latency wide-column operations, topology, repair discipline, and workload tuning.

• Snowflake Warehouse strategy, governed data products, security, sharing, and enterprise analytics platform economics.

• Flink Stateful stream processing, event-time correctness, checkpoints, scaling, and low-latency data platform operations.

• Spark Distributed batch and streaming processing, shuffle-aware performance, lakehouse integration, and cluster economics.

• Airflow DAG design, orchestration reliability, scheduler scaling, dependency control, and workflow platform governance.

• dbt Analytics engineering architecture, model governance, testing, lineage, and trustworthy transformation platform operations.

⚙️ DevOps Skills

• Docker Image design, build performance, runtime hardening, networking, debugging, and supply-chain aware delivery.

• Kubernetes Workload design, rollout safety, cluster operations, networking, security, observability, and platform reliability.

• Prometheus Metrics strategy, PromQL, alerting, TSDB operations, remote write, and observability platform reliability.

• Grafana Dashboard design, alerting UX, multi-source correlation, governance, and operator decision workflows.

• OpenTelemetry Traces, collectors, semantic conventions, sampling, and cross-signal observability architecture.

• Terraform Module design, state strategy, environment promotion, policy, drift control, and infrastructure change safety.

• Helm Chart design, values governance, release safety, upgrade workflows, and Kubernetes packaging standards.

• NGINX Ingress Edge routing, TLS, performance tuning, multi-tenant ingress governance, and production traffic operations.

• Istio Service mesh architecture, traffic policy, mTLS, identity, observability, and multi-tenant mesh operations.

• Envoy Proxy architecture, listeners, upstream policy, resilience controls, xDS governance, and traffic debugging.

• Loki Log architecture, label strategy, retention, cost-aware query design, and multi-tenant logging platform operations.

• Tempo Trace storage architecture, ingest scaling, correlation workflows, retention, and shared trace platform reliability.

• Jaeger Distributed tracing architecture, sampling, storage backends, query workflows, and operational trace governance.

• Ansible Idempotent automation, inventory strategy, role design, change safety, and fleet configuration governance.

• Pulumi Programmatic IaC, stack design, policy, state safety, multi-language platform tradeoffs, and deployment safety.

• Vault Secrets architecture, auth methods, dynamic secrets, PKI, auditability, and secure platform operations.

• GitHub Actions CI/CD workflow design, runner isolation, supply-chain safety, release automation, and multi-repo governance.

• Argo CD GitOps architecture, sync safety, app boundaries, drift control, and declarative delivery platform operations.

• Tekton Kubernetes-native pipelines, task contracts, execution isolation, provenance, and multi-tenant CI/CD operations.

• Keycloak Identity architecture, realms and clients, federation, token lifecycle, and IAM platform governance.

• OPA Gatekeeper Kubernetes policy architecture, admission safety, Rego governance, exception control, and enforcement operations.

• cert-manager Certificate automation, issuer boundaries, ACME challenge strategy, renewal safety, and PKI operations on Kubernetes.

🚀 Quick Start

Using a Single Skill

1. Point Claude to the relevant skill directory (e.g., backend-skills/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:

- backend-skills/golang-mastery-skill (backend API)
- frontend-skills/react-tanstack-mastery-skill (frontend)
- data-skills/rabbitmq-mastery-skill (message broker)
- data-skills/postgresql-mastery-skill (database design and operations)

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: backend-skills/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:

• backend-skills/golang-mastery-skill (backend services)
• frontend-skills/react-tanstack-mastery-skill (frontend dashboard)
• data-skills/rabbitmq-mastery-skill (message broker)
• data-skills/postgresql-mastery-skill (database design and operations)

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
- PostgreSQL database design and operations
- 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
• PostgreSQL database design and operations
• 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: backend-skills/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
├── README_ID.md                        # Indonesian documentation
├── assets/
│   └── logos/                          # Technology logos
│       ├── python.svg
│       ├── bun.svg
│       ├── golang.svg
│       ├── nuxt.svg
│       ├── rabbitmq.svg
│       ├── react.svg
│       ├── rust.svg
│       └── solidjs.svg
│
├── backend-skills/
│   ├── ai-ml-mastery-skill/
│   ├── bunjs-mastery-skill/
│   ├── erlang-elixir-mastery-skill/
│   ├── golang-mastery-skill/
│   ├── rust-mastery-skill/
│   └── zig-mastery-skill/
│
├── data-skills/
│   ├── airflow-mastery-skill/
│   ├── cassandra-mastery-skill/
│   ├── clickhouse-mastery-skill/
│   ├── cockroachdb-mastery-skill/
│   ├── dbt-mastery-skill/
│   ├── elasticsearch-mastery-skill/
│   ├── flink-mastery-skill/
│   ├── kafka-mastery-skill/
│   ├── mongodb-mastery-skill/
│   ├── mysql-mastery-skill/
│   ├── nats-mastery-skill/
│   ├── opensearch-mastery-skill/
│   ├── postgresql-mastery-skill/
│   ├── rabbitmq-mastery-skill/
│   ├── redis-mastery-skill/
│   ├── scylladb-mastery-skill/
│   ├── snowflake-mastery-skill/
│   └── spark-mastery-skill/

├── frontend-skills/
│   ├── nuxtjs-mastery-skill/
│   ├── react-tanstack-mastery-skill/
│   └── solidjs-solidstart-mastery-skill/
│
└── devops-skills/
    ├── ansible-mastery-skill/
    ├── argo-cd-mastery-skill/
    ├── cert-manager-mastery-skill/
    ├── docker-mastery-skill/
    ├── envoy-mastery-skill/
    ├── github-actions-mastery-skill/
    ├── grafana-mastery-skill/
    ├── helm-mastery-skill/
    ├── istio-mastery-skill/
    ├── jaeger-mastery-skill/
    ├── keycloak-mastery-skill/
    ├── kubernetes-mastery-skill/
    ├── loki-mastery-skill/
    ├── nginx-ingress-mastery-skill/
    ├── opa-gatekeeper-mastery-skill/
    ├── opentelemetry-mastery-skill/
    ├── prometheus-mastery-skill/
    ├── pulumi-mastery-skill/
    ├── tekton-mastery-skill/
    ├── tempo-mastery-skill/
    ├── terraform-mastery-skill/
    └── vault-mastery-skill/

🔧 Detailed Skill Breakdown

🐍 AI/ML Mastery

<details> <summary><b>Click to expand</b> - PyTorch, TensorFlow, LLMs, Computer Vision, NLP</summary>

Overview

Elite AI/ML Senior Engineer (DeepMind/OpenAI/Anthropic level). Transforms Claude AI / ChatGPT Codex into a world-class AI researcher and engineer capable of building production ML/DL systems from scratch.

What's Included

• SKILL.md: Core expertise guide with decision frameworks
• References (9 files):
  • Deep Learning: PyTorch, TensorFlow, JAX architectures
  • Transformers & LLMs: Fine-tuning, PEFT, LoRA, attention mechanisms
  • Computer Vision: Object detection, segmentation, GANs, CNNs
  • Machine Learning: sklearn, XGBoost, feature engineering, ensembles
  • NLP: Embeddings, sentiment analysis, NER, classification
  • MLOps: Deployment, monitoring, Docker, CI/CD
  • Clean Code: Patterns, anti-patterns, testing
  • Debugging: Profiling, optimization, troubleshooting
  • Data Engineering: pandas, polars, dask, data pipelines

Key Capabilities

• Build production ML/DL models from scratch
• Design custom neural network architectures
• Fine-tune LLMs (BERT, GPT, Llama) with PEFT/LoRA
• Implement computer vision pipelines (detection, segmentation)
• NLP systems (embeddings, transformers, classification)
• MLOps deployment with Docker and monitoring
• Performance optimization and debugging
• Data pipeline engineering

Trigger Keywords

ML, AI, deep learning, transformer, LLM, PyTorch, TensorFlow, computer vision, NLP, neural network

</details>

---

🍞 Bun.js + Docker Mastery

<details> <summary><b>Click to expand</b> - TypeScript, Bun Runtime, Hono, Drizzle ORM, Docker</summary>

Overview

Senior/Lead Developer in modern JavaScript/TypeScript. Expert in Bun.js runtime optimization, clean architecture, and production Docker deployments. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (4 files):
  • Clean Code Patterns: Design patterns, SOLID principles
  • Debugging Guide: Systematic troubleshooting
  • Docker Patterns: Multi-stage builds, optimization
  • Testing Strategy: Unit, integration, E2E testing
• Scripts (2 files):
  • init-project.sh: Bootstrap new Bun.js projects
  • healthcheck.ts: Health check endpoint template
• Assets:
  • Project Template: Full production-ready boilerplate with layered architecture

Key Capabilities

• Build high-performance Bun.js APIs (Hono framework)
• Clean code architecture (controllers, services, repositories)
• Docker containerization with multi-stage builds
• Database integration (Drizzle ORM, PostgreSQL)
• Error handling, validation, logging patterns
• Production deployment and optimization
• Code review with senior engineer standards

Trigger Keywords

Bun.js, Bun, TypeScript, Hono, Drizzle, Docker, JavaScript runtime

</details>

---

🐹 Golang Mastery

<details> <summary><b>Click to expand</b> - Go, Chi Router, SQLX, Concurrency, Microservices</summary>

Overview

Golang Senior/Lead Developer. Expert in Go idioms, concurrency patterns, and production-grade microservices. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (10 files):
  • Patterns: Design patterns in Go (factory, singleton, middleware)
  • Anti-Patterns: Common mistakes to avoid
  • Concurrency: Goroutines, channels, race conditions, sync primitives
  • Docker: Multi-stage builds, Alpine images, optimization
  • Libraries: Battle-tested packages (Chi, SQLX, Viper, Zap)
  • Coding Standards: Go idioms, gofmt, golangci-lint
  • Debugging: pprof, tracing, profiling
  • Code Review: Senior-level review checklist
  • Project Structure: Standard Go project layout
  • Examples: Real-world code examples
• Scripts:
  • init_project.py: Project scaffolder with templates

Key Capabilities

• Build production-grade Go microservices
• Implement clean concurrency patterns (no race conditions)
• Design RESTful APIs with proper error handling
• Database integration (SQLX, migrations)
• Docker containerization and deployment
• Performance profiling and optimization
• Code review with Go best practices

Trigger Keywords

Go, Golang, goroutine, channel, concurrency, microservice, Chi, SQLX

</details>

---

💚 Nuxt.js + TanStack Mastery

<details> <summary><b>Click to expand</b> - Vue 3, Nuxt 3, Composition API, TanStack Query, Pinia</summary>

Overview

Senior/Lead Vue.js Developer. Expert in Nuxt 3 full-stack development, TanStack Query integration, and performance optimization. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (8 files):
  • Folder Structure: Nuxt 3 file-based routing and organization
  • TanStack Query: Server state management, caching, mutations
  • Clean Code: Vue composition patterns, composables, utilities
  • Performance: Code splitting, lazy loading, SSR optimization
  • Debugging: Vue DevTools, source maps, error tracking
  • Common Pitfalls: Reactivity gotchas, hydration errors
  • Security: Auth patterns, XSS prevention, CSP
  • Libraries: Curated Vue ecosystem (Pinia, VueUse, Headless UI)

Key Capabilities

• Build Nuxt 3 full-stack applications (SSR/SSG/SPA)
• Type-safe routing with TanStack Router
• Server state management with TanStack Query
• Advanced data tables with TanStack Table
• Complex forms with TanStack Form
• Performance optimization (Core Web Vitals)
• Security hardening (XSS, auth, CSRF)
• Production deployment and monitoring

Trigger Keywords

Nuxt, Vue, Vue 3, Nuxt 3, TanStack Query, Pinia, composition API, SSR

</details>

---

🐰 RabbitMQ Mastery

<details> <summary><b>Click to expand</b> - AMQP, Message Patterns, Clustering, High Availability</summary>

Overview

Ultimate RabbitMQ Expert (Top 0.01% knowledge). Master of advanced messaging patterns, high availability, performance tuning, and production troubleshooting.

What's Included

• SKILL.md: Core expertise guide
• MANIFEST.json: Skill metadata
• References (6 files):
  • Patterns: Work queues, pub/sub, routing, topics, RPC, DLX, priority queues
  • Clustering: Quorum queues, stream queues, federation, shovel
  • Monitoring: Prometheus integration, alerting, health checks
  • Performance: Prefetch tuning, batch publishing, flow control
  • Security: TLS/mTLS, OAuth2, LDAP, vhost isolation
  • Troubleshooting: Memory issues, connection leaks, queue growth
• Scripts (3 files):
  • async_publisher.py: High-throughput async publisher
  • connection_pool.py: Connection pooling patterns
  • package_skill.py: Skill packaging utility

Key Capabilities

• Design advanced messaging architectures
• Implement HA with quorum queues and clustering
• Performance tuning (prefetch, batch, memory)
• Security hardening (TLS, auth, permissions)
• Monitoring with Prometheus
• Troubleshoot production issues
• Stream processing with RabbitMQ Streams

Trigger Keywords

RabbitMQ, AMQP, message queue, pub/sub, clustering, high availability, quorum queue

</details>

---

⚛️ React + TanStack Mastery

<details> <summary><b>Click to expand</b> - React, TanStack Router, Query, Table, Form, Start</summary>

Overview

Senior React Developer. Expert in the TanStack ecosystem (Router, Query, Table, Form, Start) and modern React patterns. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (9 files):
  • Folder Structure: React project organization (feature-based, layer-based)
  • TanStack Query: Server state, caching, mutations, optimistic updates
  • TanStack Router: Type-safe routing, loaders, prefetching
  • TanStack Table: Advanced data tables with sorting, filtering, pagination
  • TanStack Form: Type-safe forms, validation, field arrays
  • TanStack Start: Full-stack SSR framework (React Server Components)
  • Recommended Libraries: Curated ecosystem (Zustand, React Hook Form, Radix UI)
  • Common Pitfalls: Hooks rules, re-render issues, stale closures
  • Debugging Guide: React DevTools, profiler, error boundaries

Key Capabilities

• Build React SPAs and SSR apps (TanStack Start)
• Type-safe routing with TanStack Router
• Server state management with TanStack Query
• Advanced data tables with TanStack Table
• Complex forms with TanStack Form
• Performance optimization (memoization, lazy loading)
• State management patterns (Zustand, context)

Trigger Keywords

React, TanStack, TanStack Query, TanStack Router, TanStack Table, React hooks, SSR

</details>

---

🦀 Rust Mastery

<details> <summary><b>Click to expand</b> - Rust, Axum, SQLX, Memory Safety, Systems Programming</summary>

Overview

Senior/Lead Rust Developer in systems programming. Expert in memory safety, zero-cost abstractions, and production Rust services. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (6 files):
  • Advanced Patterns: Typestate, builder, new type, phantom data
  • Senior Habits: Ownership patterns, lifetime best practices
  • Debugging Guide: lldb, rust-gdb, cargo flamegraph, memory profiling
  • Code Review Guide: Senior-level checklist (safety, performance, idioms)
  • Trusted Libraries: Battle-tested crates (Axum, SQLX, Serde, tokio)
  • Bug Prevention: Anti-patterns, common pitfalls, clippy lints
• Scripts:
  • scaffold_project.py: Rust project generator
• Assets:
  • github-ci.yml: GitHub Actions CI/CD template

Key Capabilities

• Build production Rust services (Axum framework)
• Memory-safe systems programming
• Async/await with Tokio runtime
• Database integration (SQLX with compile-time checks)
• Error handling (thiserror, anyhow)
• Performance optimization (zero-cost abstractions)
• Docker deployment with multi-stage builds

Trigger Keywords

Rust, Axum, SQLX, tokio, async, memory safety, systems programming, ownership

</details>

---

🔷 SolidJS + SolidStart Mastery

<details> <summary><b>Click to expand</b> - SolidJS, Fine-Grained Reactivity, SolidStart, TanStack</summary>

Overview

Expert SolidJS Developer. Master of fine-grained reactivity, SolidStart full-stack framework, and TanStack ecosystem integration. Guides available in Indonesian.

What's Included

• SKILL.md: Core expertise guide
• References (5 files):
  • Debugging: Solid DevTools, reactivity debugging, source maps
  • Performance: Bundle optimization, code splitting, lazy loading
  • Patterns: Signals, stores, resources, context, control flow
  • Security: Auth patterns, XSS prevention, CSP
  • Testing: Solid Testing Library, unit tests, integration tests

Key Capabilities

• Build SolidJS SPAs with fine-grained reactivity
• SolidStart full-stack applications (SSR/SSG/streaming)
• Integrate TanStack ecosystem (Query, Router, Table)
• Performance optimization (no virtual DOM overhead)
• Error boundaries and suspense patterns
• Accessibility (ARIA, keyboard navigation)
• Production deployment

Trigger Keywords

SolidJS, Solid, SolidStart, fine-grained reactivity, signals, stores, SSR

</details>

🤝 Contributing

We welcome contributions to improve and expand the Claude Codex Skills Directory!

Ways to Contribute

1. Add New Skills

Create a new mastery skill for a technology domain:

• Follow the skill directory structure (see below)
• Include comprehensive SKILL.md with expertise guide
• Add reference documentation for deep dives
• Provide scripts or templates (optional)
• Submit a PR with clear description

2. Improve Existing Skills

Enhance current skills with:

• Additional reference documentation
• Updated library recommendations
• New code examples and patterns
• Bug fixes or error corrections
• Performance optimizations

3. Report Issues

• Found errors or outdated information? Open an issue
• Suggest new features or improvements
• Share your use cases and feedback

Skill Directory Structure

Every skill should follow this structure:

skill-name/
├── SKILL.md                    # Main skill definition (REQUIRED)
├── references/                 # Deep-dive documentation (RECOMMENDED)
│   ├── topic1.md
│   ├── topic2.md
│   └── ...
├── scripts/                    # Automation scripts (optional)
│   └── helper.py
└── assets/                     # Templates, configs (optional)
    └── template.yml

SKILL.md Frontmatter Format

Every SKILL.md must include frontmatter:

---
name: skill-identifier
description: |
  Detailed description of when and how to use this skill.
  Include trigger keywords and use cases.
  Explain the expertise level and persona.
---

Code Quality Standards

• Follow existing patterns: Maintain consistency with current skills
• Use clear names: Descriptive file and function names
• Document complex logic: Add comments where needed
• Include examples: Practical, real-world code samples
• Test before submitting: Verify all code and markdown renders correctly

Pull Request Process

1. Fork the repository
2. Create a feature branch: git checkout -b feature/new-skill-name
3. Commit your changes: git commit -m 'Add new skill: X'
4. Push to branch: git push origin feature/new-skill-name
5. Open a Pull Request with:
   • Clear, descriptive title
   • Detailed description of changes
   • List of added/modified files
   • Screenshots (if applicable)
   • Reference to related issues (if any)

Code of Conduct

• Be respectful and constructive
• Focus on the contribution, not the person
• Welcome newcomers and help them learn
• Follow the Contributor Covenant

Need Help?

If you have questions about contributing:

• Check existing issues for similar questions
• Open a new issue with the question label
• Review existing skills for examples

📥 Logo Sources & Credits

All logos are trademarks of their respective owners. This repository uses these logos for identification purposes only.

Logo Attribution

Logo	Filename	Source	License
Python	python.svg	python.org/community/logos	PSF Trademark
Bun.js	bun.svg	GitHub - oven-sh/bun	MIT
Go	golang.svg	go.dev/brand	CC BY 4.0
Vue/Nuxt	nuxt.svg	nuxt.com/design-kit	MIT
RabbitMQ	rabbitmq.svg	rabbitmq.com/trademarks	MPL
React	react.svg	react.dev	MIT
Rust	rust.svg	rust-lang.org/media-guide	CC-BY
SolidJS	solidjs.svg	solidjs.com/media	MIT

All product names, logos, and brands are property of their respective owners. All company, product and service names used in this repository are for identification purposes only. Use of these names, logos, and brands does not imply endorsement.

❓ FAQ

<details> <summary><b>How do I use these skills with Claude AI / ChatGPT Codex?</b></summary>

Point Claude AI / ChatGPT Codex to the relevant skill directory (e.g., backend-skills/ai-ml-mastery-skill/) or load specific files. The AI will adopt the persona and expertise defined in SKILL.md. You can also load multiple skills for cross-domain projects.

Example:

"Load the backend-skills/ai-ml-mastery-skill and help me design a neural network architecture"

</details> <details> <summary><b>Can I use multiple skills at once?</b></summary>

Yes! Load multiple skills for complex projects. For example:

• backend-skills/golang-mastery-skill + data-skills/rabbitmq-mastery-skill for backend microservices
• frontend-skills/react-tanstack-mastery-skill + frontend skills for full-stack apps
• Any combination that fits your project needs

</details> <details> <summary><b>Are these skills suitable for production use?</b></summary>

Absolutely. Each skill embodies production experience with:

• Battle-tested patterns from real systems
• Anti-patterns documented to avoid common mistakes
• Security and performance best practices
• Production deployment strategies
• Debugging and troubleshooting guides

These are NOT toy examples or tutorials. They represent senior/lead engineer expertise.

</details> <details> <summary><b>How are these different from regular prompts or documentation?</b></summary>

Regular prompts are one-off instructions. Skills are comprehensive expertise systems with:

• Structured Knowledge: Hierarchical organization (SKILL.md + references)
• Decision Frameworks: Clear guidance for architectural choices
• Real-World Patterns: Battle-tested solutions, not just theory
• Anti-Patterns: What NOT to do and why
• Code Review Standards: Senior-level quality expectations
• Library Curation: Proven dependencies over experiments
• Production Focus: Security, performance, monitoring
• Debugging Strategies: Systematic troubleshooting
• Scripts & Templates: Automation and boilerplates

Think of skills as hiring a senior engineer, not reading docs.

</details> <details> <summary><b>Can I contribute my own skill?</b></summary>

Yes! We welcome new skills. See the Contributing section for:

• Skill directory structure requirements
• SKILL.md frontmatter format
• Code quality standards
• Pull request process

We especially welcome skills in areas not yet covered (e.g., mobile development, databases, DevOps, security).

</details> <details> <summary><b>Why are some skills in Indonesian?</b></summary>

Several skills (Bun.js, Golang, Nuxt.js, React, Rust, SolidJS) include Indonesian language guides to serve Indonesian developers. The technical content and code examples are universal, with explanatory text in Indonesian for clarity.

</details> <details> <summary><b>How do I keep skills up to date?</b></summary>

Skills are maintained by the community:

• Watch this repository for updates
• Subscribe to releases for new skill versions
• Contribute updates when you find outdated information
• Open issues to report deprecated patterns or libraries

Each skill's reference docs include version information where applicable.

</details>

📄 License

This project is licensed under the MIT License.

MIT License

Copyright (c) 2024-2025 Axel Modra

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

See LICENSE file for full license text.

💬 Support

Getting Help

• Issues: Report bugs or request features
• Discussions: Ask questions or share ideas
• Pull Requests: Contribute improvements

Community

• Star this repository if you find it useful
• Share with other developers and AI practitioners
• Contribute skills for technologies you're expert in
• Provide feedback on existing skills

---

<div align="center">

Built with production engineering knowledge

Made with ❤️ by Axel Modra

🌏 Languages: English (this page) | Bahasa Indonesia

⬆ Back to Top

</div>