Add 25 world-class Claude Code skills for comprehensive software development

Created comprehensive skill collection covering all aspects of modern software
development with production-ready patterns, best practices, and detailed documentation.

## Skills Organized by Domain

### Code Quality & Architecture (2 skills)
- advanced-code-refactoring: SOLID principles, design patterns, refactoring patterns
- code-review: Automated/manual review, security, performance, maintainability

### API & Integration (2 skills)
- api-integration-expert: REST/GraphQL/WebSocket with auth, retry, caching
- graphql-schema-design: Schema design, resolvers, optimization, subscriptions

### Database & Data (3 skills)
- database-optimization: SQL/NoSQL tuning, indexing, query optimization
- data-pipeline: ETL/ELT with Airflow, Spark, dbt
- caching-strategies: Redis, Memcached, CDN, invalidation patterns

### Security & Authentication (2 skills)
- security-audit: OWASP Top 10, vulnerability scanning, security hardening
- auth-implementation: OAuth2, JWT, session management, SSO

### Testing & Quality (2 skills)
- test-automation: Unit/integration/E2E tests, TDD/BDD, coverage
- performance-profiling: CPU/memory profiling, Core Web Vitals optimization

### DevOps & Infrastructure (3 skills)
- docker-kubernetes: Containerization, orchestration, production deployments
- ci-cd-pipeline: GitHub Actions, automated testing, deployment strategies
- logging-monitoring: Observability with Datadog, Prometheus, Grafana, ELK

### Frontend Development (3 skills)
- frontend-accessibility: WCAG 2.1 compliance, ARIA, keyboard navigation
- ui-component-library: Design systems with React/Vue, Storybook
- mobile-responsive: Responsive design, mobile-first, PWAs

### Backend & Scaling (2 skills)
- backend-scaling: Load balancing, sharding, microservices, horizontal scaling
- real-time-systems: WebSockets, SSE, WebRTC for real-time features

### ML & AI (1 skill)
- ml-model-integration: Model serving, inference optimization, monitoring

### Development Tools (2 skills)
- git-workflow-optimizer: Git workflows, branching strategies, conflict resolution
- dependency-management: Package updates, security patches, version conflicts

### Code Maintenance (3 skills)
- error-handling: Robust error patterns, logging, graceful degradation
- documentation-generator: API docs, README, technical specifications
- migration-tools: Database/framework migrations with zero downtime

## Key Features

Each skill includes:
- YAML frontmatter with name, description, allowed tools
- Clear purpose and when to use
- Comprehensive capabilities overview
- Production-ready code examples
- Best practices and patterns
- Success criteria
- Tool-specific configurations

## Highlights

- 25 comprehensive skills covering full development lifecycle
- Production-ready patterns and examples
- Security-first approach throughout
- Performance optimization built-in
- Comprehensive testing strategies
- DevOps automation and infrastructure as code
- Modern frontend with accessibility focus
- Scalable backend architectures
- Data engineering and ML integration
- Advanced Git workflows

## File Structure

claude_skills/
├── README.md (comprehensive documentation)
├── advanced-code-refactoring/
│   ├── SKILL.md (main skill definition)
│   ├── reference.md (design patterns, SOLID principles)
│   └── examples.md (refactoring examples)
├── api-integration-expert/
│   └── SKILL.md (REST/GraphQL/WebSocket integration)
├── [23 more skills...]

Total: 25 skills + comprehensive README + supporting documentation

## Usage

Personal skills: cp -r claude_skills/* ~/.claude/skills/
Project skills: cp -r claude_skills/* .claude/skills/

Skills automatically activate based on context and description triggers.

claude_skills/performance-profiling/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: performance-profiling
+description: Expert in application performance analysis, profiling, optimization, and monitoring. Use when identifying performance bottlenecks, optimizing slow code, reducing memory usage, or improving application speed.
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash
+---
+
+# Performance Profiling Expert
+
+## Purpose
+Identify and fix performance bottlenecks through profiling, analysis, and optimization of CPU, memory, network, and rendering performance.
+
+## Capabilities
+- CPU profiling and flame graphs
+- Memory profiling and leak detection
+- Bundle size optimization
+- Render performance optimization
+- Database query performance
+- Network performance analysis
+- Core Web Vitals optimization
+- Performance budgets
+
+## Profiling Tools
+- Chrome DevTools Performance
+- Node.js --inspect
+- Lighthouse
+- WebPageTest
+- webpack-bundle-analyzer
+- Clinic.js
+- New Relic / Datadog APM
+
+## Performance Optimization Patterns
+
+```typescript
+// 1. Memoization
+import { useMemo, useCallback } from 'react';
+
+function ExpensiveComponent({ data }: Props) {
+  // Memoize expensive calculations
+  const processedData = useMemo(() => {
+    return data.map(item => expensiveOperation(item));
+  }, [data]);
+
+  // Memoize callbacks
+  const handleClick = useCallback(() => {
+    console.log('clicked');
+  }, []);
+
+  return <div>{processedData.map(renderItem)}</div>;
+}
+
+// 2. Code splitting
+const HeavyComponent = lazy(() => import('./HeavyComponent'));
+
+function App() {
+  return (
+    <Suspense fallback={<Loading />}>
+      <HeavyComponent />
+    </Suspense>
+  );
+}
+
+// 3. Virtual scrolling for long lists
+import { FixedSizeList } from 'react-window';
+
+function VirtualList({ items }: Props) {
+  return (
+    <FixedSizeList
+      height={600}
+      itemCount={items.length}
+      itemSize={50}
+      width="100%"
+    >
+      {({ index, style }) => (
+        <div style={style}>{items[index].name}</div>
+      )}
+    </FixedSizeList>
+  );
+}
+
+// 4. Debouncing and throttling
+import { debounce } from 'lodash';
+
+const debouncedSearch = debounce(async (query: string) => {
+  const results = await searchAPI(query);
+  setResults(results);
+}, 300);
+
+// 5. Image optimization
+<Image
+  src="/large-image.jpg"
+  alt="Description"
+  width={800}
+  height={600}
+  loading="lazy"
+  placeholder="blur"
+  quality={85}
+/>
+
+// 6. Efficient data fetching
+async function getDataInParallel() {
+  const [users, posts, comments] = await Promise.all([
+    fetchUsers(),
+    fetchPosts(),
+    fetchComments(),
+  ]);
+  return { users, posts, comments };
+}
+
+// 7. Worker threads for CPU-intensive tasks
+const worker = new Worker(new URL('./worker.ts', import.meta.url));
+worker.postMessage({ data: largeDataset });
+worker.onmessage = (e) => setResult(e.data);
+```
+
+## Memory Leak Detection
+
+```javascript
+// Common memory leak patterns to avoid
+// 1. Forgotten timers
+useEffect(() => {
+  const timer = setInterval(() => fetchData(), 1000);
+  return () => clearInterval(timer); // Clean up!
+}, []);
+
+// 2. Detached DOM nodes
+// Always remove event listeners
+element.removeEventListener('click', handler);
+
+// 3. Closures holding references
+let cache = {}; // Growing forever
+function memoize(fn) {
+  return (arg) => {
+    if (!cache[arg]) cache[arg] = fn(arg);
+    return cache[arg];
+  };
+}
+// Solution: Use WeakMap or LRU cache with size limit
+```
+
+## Performance Budgets
+```json
+{
+  "budgets": [
+    {
+      "type": "bundle",
+      "maximumSize": "250kb"
+    },
+    {
+      "type": "script",
+      "maximumSize": "170kb"
+    },
+    {
+      "type": "image",
+      "maximumSize": "150kb"
+    }
+  ],
+  "metrics": {
+    "FCP": "< 1.8s",
+    "LCP": "< 2.5s",
+    "TBT": "< 200ms",
+    "CLS": "< 0.1"
+  }
+}
+```
+
+## Success Criteria
+- ✓ LCP < 2.5s
+- ✓ FID < 100ms
+- ✓ CLS < 0.1
+- ✓ Bundle size under budget
+- ✓ No memory leaks
+- ✓ 60fps rendering
+