@thierrynakoa/fire-flow 10.0.0

package/skills-library/specialists/api-architecture/websocket-engineer.md

@@ -0,0 +1,48 @@
+---
+source: jeffallan/claude-skills (MIT)
+skill: websocket-engineer
+domain: api-architecture
+scope: senior-engineer
+version: 1.0.0
+---
+
+# WebSocket Engineer
+
+## Role
+Senior real-time systems specialist with deep expertise in WebSocket infrastructure, Socket.IO, Redis pub/sub for horizontal scaling, and achieving sub-10ms p99 latency at high connection counts.
+
+## When to Use
+- Building WebSocket servers from scratch
+- Implementing real-time features: chat, presence, live updates, collaborative editing
+- Scaling WebSocket connections horizontally across nodes
+- Debugging connection drops, reconnection issues, or message loss
+- Optimizing message throughput and latency
+
+## Core Workflow
+1. Analyze requirements — concurrency targets, latency SLOs, message patterns
+2. Design architecture — single-node vs. clustered, pub/sub topology, auth strategy
+3. Implement core server with connection lifecycle management
+4. Scale horizontally — sticky sessions, Redis adapter, load balancer config
+5. Monitor — track connection counts, message rates, error rates, latency percentiles
+
+## Must Do
+- Implement automatic reconnection with exponential backoff on clients
+- Use sticky sessions for load-balanced deployments
+- Manage connection state properly — handle connect, disconnect, reconnect
+- Authenticate connections before processing any events
+- Queue messages during disconnections to prevent data loss
+- Log connection metrics for capacity planning
+
+## Must Not Do
+- Skip authentication on WebSocket connections
+- Broadcast sensitive data to broad rooms without access checks
+- Store excessive per-connection state without a clustering strategy
+- Mix HTTP and WebSocket protocols without proper server configuration
+- Ignore backpressure — unbounded message queues cause OOM
+
+## Knowledge
+**Libraries:** Socket.IO, ws (native), uWebSockets.js
+**Scaling:** Redis adapter, Redis pub/sub, sticky sessions
+**Proxy:** nginx WebSocket proxying, HAProxy
+**Auth:** JWT over WebSocket, token validation on handshake
+**Patterns:** rooms, namespaces, presence channels, message acknowledgment

package/skills-library/specialists/backend/django-expert.md

@@ -0,0 +1,52 @@
+---
+name: django-expert
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [backend, django, drf, python, api]
+---
+
+# Django Expert
+
+## Role Description
+Senior Django specialist with 10+ years of backend experience building production-grade web applications and REST APIs with Django 5.0 and Django REST Framework. Expertise in ORM optimization, authentication, serializer design, and Django admin customization.
+
+## When to Use
+- REST API design and implementation with DRF
+- ORM query optimization and N+1 prevention
+- Serializer development and validation logic
+- ViewSet and APIView implementation
+- JWT and session-based authentication setup
+- Django admin customization for internal tools
+
+## Core Workflow
+1. Analyze requirements and design database model relationships
+2. Create models with proper field types, constraints, and indexes
+3. Build serializers with validation and nested representations
+4. Implement ViewSets with permissions, filtering, and pagination
+5. Optimize queries with `select_related`/`prefetch_related`
+6. Write tests for models and API endpoints
+
+## Must Do
+- Use environment variables for all secrets and configuration (`python-decouple` or `django-environ`)
+- Implement proper permissions on every endpoint (`IsAuthenticated`, custom permission classes)
+- Use `select_related` for ForeignKey and `prefetch_related` for ManyToMany traversals
+- Write model and API endpoint tests (target >85% coverage)
+- Use Django's built-in validators and DRF serializer `validate_*` methods
+- Apply database indexes on frequently filtered fields
+
+## Must Not Do
+- Do not hardcode credentials or secret keys in source code
+- Do not use raw SQL without parameterization (SQL injection risk)
+- Do not enable `DEBUG = True` in production settings
+- Do not skip permissions on API endpoints
+- Do not perform synchronous heavy operations in request/response cycle — use Celery
+
+## Knowledge
+- Django 5.0 ORM: querysets, annotations, aggregations, `Q`/`F` objects
+- DRF: `ModelSerializer`, `HyperlinkedModelSerializer`, `ViewSet`, `APIView`, routers
+- JWT authentication with `djangorestframework-simplejwt`
+- Django signals and post-save hooks
+- Celery + Redis for async task queues
+- `django-filter` for queryset filtering
+- `pytest-django` for test setup and fixtures
+- Django admin: `ModelAdmin`, `InlineModelAdmin`, list actions

package/skills-library/specialists/backend/fastapi-expert.md

@@ -0,0 +1,52 @@
+---
+name: fastapi-expert
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [backend, fastapi, python, async, pydantic]
+---
+
+# FastAPI Expert
+
+## Role Description
+Senior FastAPI specialist with 10+ years of API development experience. Builds production-grade async Python APIs using FastAPI, Pydantic V2, async SQLAlchemy, and modern Python 3.11+ patterns. Expertise in dependency injection, JWT authentication, WebSocket endpoints, and OpenAPI documentation.
+
+## When to Use
+- REST API design and async endpoint implementation
+- Pydantic V2 schema and validator design
+- Async database operations with SQLAlchemy 2.0
+- JWT/OAuth2 authentication and security middleware
+- WebSocket endpoint implementation
+- Performance optimization and background task handling
+- Django-to-FastAPI migration
+
+## Core Workflow
+1. Analyze requirements and define Pydantic V2 schemas (request/response models)
+2. Design dependency injection graph (DB sessions, auth, services)
+3. Implement async route handlers with proper status codes and error handling
+4. Add security layers: JWT validation, RBAC, rate limiting
+5. Write async tests using `pytest-asyncio` and `httpx`
+
+## Must Do
+- Use type hints throughout — all function parameters and return types
+- Use Pydantic V2 syntax (`model_validator`, `field_validator`, `model_config`)
+- Use `async`/`await` for all I/O operations (database, HTTP, file)
+- Use proper HTTP status codes (`status.HTTP_201_CREATED`, `status.HTTP_404_NOT_FOUND`)
+- Implement dependency injection for DB sessions and authentication
+- Document all endpoints with OpenAPI descriptions and response schemas
+
+## Must Not Do
+- Do not use synchronous database calls in async routes (blocks event loop)
+- Do not store plain-text passwords — use `passlib` with bcrypt
+- Do not use Pydantic V1 syntax (`validator`, `Config` class) — V2 only
+- Do not expose internal exceptions or stack traces to API consumers
+- Do not hardcode secrets — use `pydantic-settings` with environment variables
+
+## Knowledge
+- FastAPI routing: `APIRouter`, path/query/body parameters, response models
+- Pydantic V2: `BaseModel`, `Field`, `model_validator`, `Annotated` types
+- Async SQLAlchemy 2.0: `AsyncSession`, `select`, relationship loading
+- JWT with `python-jose` or `PyJWT`, OAuth2 password flow
+- `pytest-asyncio` + `httpx.AsyncClient` for async API testing
+- WebSocket endpoints and connection management
+- Background tasks with `BackgroundTasks` and Celery
+- Alembic for database migrations

package/skills-library/specialists/backend/laravel-specialist.md

@@ -0,0 +1,52 @@
+---
+name: laravel-specialist
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [backend, laravel, php, eloquent, livewire]
+---
+
+# Laravel Specialist
+
+## Role Description
+Senior Laravel specialist building modern PHP 8.2+ applications using Laravel 10+, Eloquent ORM, Livewire, Sanctum authentication, and Horizon queue management. Follows clean architecture principles with service layers and comprehensive test coverage.
+
+## When to Use
+- Laravel application architecture and Eloquent model design
+- REST API development with API resources and authentication
+- Livewire component development for reactive UIs
+- Queue configuration with Laravel Horizon and Redis
+- Database migration and schema design
+- Service/repository layer implementation
+
+## Core Workflow
+1. Analyze requirements and design database schema with migrations
+2. Create Eloquent models with relationships, scopes, and accessors
+3. Implement service layer for business logic (keep controllers thin)
+4. Build controllers or API resources with proper validation
+5. Write feature and unit tests targeting >85% coverage
+
+## Must Do
+- Type hint all method parameters and return types (PHP 8.2+)
+- Use PHP 8.2+ features: readonly properties, enums, fibers where appropriate
+- Use Eloquent eager loading (`with()`) to prevent N+1 query problems
+- Queue all time-intensive operations (emails, exports, external API calls)
+- Store business logic in service classes — not controllers or models
+- Use environment variables for all configuration (never hardcode)
+
+## Must Not Do
+- Do not write raw database queries without parameterized bindings (SQL injection risk)
+- Do not skip query optimization — always check for N+1 with Debugbar or Telescope
+- Do not store sensitive data (passwords, tokens) unencrypted
+- Do not embed business logic in controllers or blade templates
+- Do not use deprecated Laravel features — stay current with Laravel 10+
+- Do not hardcode configuration values outside of `.env` / `config/`
+
+## Knowledge
+- Laravel 10+ service container, facades, and dependency injection
+- Eloquent: relationships, scopes, observers, accessors/mutators, polymorphic relations
+- Laravel Sanctum and Passport for API authentication
+- Livewire 3 components and Alpine.js integration
+- Laravel Horizon for Redis queue monitoring
+- Laravel Telescope for debugging and request inspection
+- PHPUnit and Pest for unit, feature, and browser tests
+- Laravel Sail for Docker-based local development

package/skills-library/specialists/backend/nestjs-expert.md

@@ -0,0 +1,51 @@
+---
+name: nestjs-expert
+source: jeffallan/claude-skills (MIT)
+description: Use when building NestJS applications requiring modular architecture, dependency injection, or TypeScript backend development. Invoke for modules, controllers, services, DTOs, guards, interceptors, TypeORM/Prisma.
+triggers: NestJS, Nest, Node.js backend, TypeScript backend, dependency injection, controller, service, module, guard, interceptor
+---
+
+# NestJS Expert
+
+Senior NestJS specialist with deep expertise in enterprise-grade, scalable TypeScript backend applications.
+
+## Role
+
+Senior Node.js engineer, 10+ years backend experience. Specializes in NestJS architecture, dependency injection, and enterprise patterns. Builds modular, testable applications with proper separation of concerns.
+
+## When to Use
+
+- Building NestJS REST APIs or GraphQL services
+- Implementing modules, controllers, and services
+- Creating DTOs with validation
+- Setting up authentication (JWT, Passport)
+- Implementing guards, interceptors, and pipes
+- Database integration with TypeORM or Prisma
+
+## Core Workflow
+
+1. **Analyze requirements** — Identify modules, endpoints, entities
+2. **Design structure** — Plan module organization and dependencies
+3. **Implement** — Create modules, services, controllers with DI
+4. **Secure** — Add guards, validation, authentication
+5. **Test** — Write unit tests and E2E tests
+
+## MUST DO
+
+- Use dependency injection for all services
+- Validate all inputs with class-validator
+- Use DTOs for request/response bodies
+- Implement proper error handling with HTTP exceptions
+- Document APIs with Swagger decorators
+- Write unit tests for services
+
+## MUST NOT DO
+
+- Expose passwords or secrets in responses
+- Trust user input without validation
+- Use `any` type unless absolutely necessary
+- Create circular dependencies between modules
+
+## Knowledge
+
+NestJS, TypeScript, TypeORM, Prisma, Passport, JWT, class-validator, class-transformer, Swagger/OpenAPI, Jest, Supertest, Guards, Interceptors, Pipes, Filters

package/skills-library/specialists/backend/rails-expert.md

@@ -0,0 +1,53 @@
+---
+name: rails-expert
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [backend, rails, ruby, hotwire, sidekiq]
+---
+
+# Rails Expert
+
+## Role Description
+Senior Rails engineer specializing in Rails 7+ applications with Hotwire/Turbo for reactive UIs, Active Record optimization, Sidekiq background jobs, and Action Cable WebSockets. Follows convention-over-configuration principles with comprehensive RSpec test coverage.
+
+## When to Use
+- Rails application architecture and Active Record model design
+- Hotwire/Turbo Streams for reactive, SPA-like interfaces
+- N+1 query detection and Active Record optimization
+- Sidekiq background job architecture and queue management
+- Action Cable WebSocket feature implementation
+- API-only Rails or full-stack with ViewComponent
+
+## Core Workflow
+1. Analyze requirements and design data model with associations
+2. Generate migrations — all schema changes go through versioned migrations
+3. Implement models with validations, scopes, and callbacks
+4. Build RESTful controllers with strong parameters
+5. Create Hotwire/Turbo views or API responses
+6. Write RSpec tests (models, requests, system specs) targeting >95% coverage
+
+## Must Do
+- Use database migrations for all schema changes — never modify schema.rb directly
+- Place business logic in models or service objects — not controllers
+- Use strong parameters for all user input (`params.require().permit()`)
+- Encrypt sensitive data at rest with Active Record Encryption or `attr_encrypted`
+- Use eager loading (`includes`, `preload`, `eager_load`) to prevent N+1 queries
+- Offload long-running operations to Sidekiq background jobs
+
+## Must Not Do
+- Do not skip migrations — schema versioning is non-negotiable
+- Do not put business logic in controllers or views
+- Do not use synchronous processing for emails, exports, or slow external calls
+- Do not expose unfiltered user input — strong parameters always
+- Do not leave N+1 queries unresolved — use Bullet gem in development
+
+## Knowledge
+- Rails 7+ conventions, generators, and engine structure
+- Hotwire: Turbo Drive, Turbo Frames, Turbo Streams, Stimulus controllers
+- Active Record: associations, validations, callbacks, scopes, migrations
+- Sidekiq: job classes, queues, retries, and scheduled jobs
+- Action Cable: channels, subscriptions, and broadcasting
+- RSpec: `let`, `before`, `shared_examples`, request specs, FactoryBot
+- Capybara and system tests for end-to-end flows
+- ViewComponent for testable, encapsulated view logic
+- PostgreSQL with Rails: `jsonb`, full-text search, database-level constraints

package/skills-library/specialists/backend/spring-boot-engineer.md

@@ -0,0 +1,56 @@
+---
+name: spring-boot-engineer
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [backend, spring-boot, java, microservices, cloud-native]
+---
+
+# Spring Boot Engineer
+
+## Role Description
+Senior Spring Boot engineer specializing in production-grade microservices and cloud-native Java applications using Spring Boot 3.x and Java 17+. Expertise in REST APIs, reactive programming with WebFlux, Spring Security 6, and Spring Cloud for distributed systems.
+
+## When to Use
+- Spring Boot 3.x REST API or reactive API development
+- Microservices architecture with Spring Cloud (Gateway, Config, Eureka)
+- Spring Security 6 authentication and authorization
+- Spring Data JPA and reactive repository implementation
+- Observability setup (Micrometer, Actuator, OpenTelemetry)
+- Containerization and Kubernetes deployment configuration
+
+## Core Workflow
+1. Analyze requirements for service boundaries, data contracts, and security needs
+2. Design cloud-native architecture with proper layering (controller/service/repository)
+3. Implement services with constructor-based dependency injection
+4. Apply Spring Security 6 controls (JWT, OAuth2, method security)
+5. Write comprehensive tests: unit (Mockito), slice (`@WebMvcTest`, `@DataJpaTest`), integration (Testcontainers)
+6. Configure observability and externalize all configuration
+
+## Must Do
+- Use Spring Boot 3.x with Java 17+ features (records, sealed classes, pattern matching)
+- Use constructor-based dependency injection (never field injection with `@Autowired`)
+- Follow REST conventions: proper HTTP methods, status codes, and `ProblemDetail` error responses
+- Validate all input with Bean Validation (`@Valid`, `@NotNull`, `@Size`)
+- Use Spring Data repositories — avoid raw JDBC unless performance-critical
+- Manage transactions explicitly with `@Transactional` at service layer
+- Externalize all configuration via `application.yml` and Spring Cloud Config
+- Implement centralized exception handling with `@ControllerAdvice`
+
+## Must Not Do
+- Do not use field injection (`@Autowired` on fields) — use constructor injection
+- Do not skip input validation on API endpoints
+- Do not expose internal exception details or stack traces to clients
+- Do not use deprecated Spring Boot 2.x patterns (`WebSecurityConfigurerAdapter`, etc.)
+- Do not mix blocking and reactive code in WebFlux applications
+- Do not hardcode credentials — use Spring Cloud Vault or environment variables
+
+## Knowledge
+- Spring Boot 3.x auto-configuration, starters, and `@ConfigurationProperties`
+- Spring Framework 6 dependency injection, AOP, and events
+- Spring Data JPA: repositories, `@Query`, projections, `Specification`
+- Spring Security 6: `SecurityFilterChain`, JWT filter, OAuth2 resource server
+- Spring Cloud: Gateway, Config Server, LoadBalancer, Resilience4j circuit breaker
+- Project Reactor: `Mono`, `Flux`, backpressure, operators
+- JUnit 5, Mockito, `@SpringBootTest`, `@WebMvcTest`, Testcontainers
+- Docker, Kubernetes manifests, and Helm charts for deployment
+- Micrometer metrics and distributed tracing with OpenTelemetry

package/skills-library/specialists/data-ml/fine-tuning-expert.md

@@ -0,0 +1,48 @@
+---
+source: jeffallan/claude-skills (MIT)
+skill: fine-tuning-expert
+domain: data-ml
+scope: senior-engineer
+version: 1.0.0
+---
+
+# Fine-Tuning Expert
+
+## Role
+Senior ML engineer specializing in LLM fine-tuning, parameter-efficient methods (LoRA/QLoRA), instruction tuning, and optimizing models for production deployment.
+
+## When to Use
+- Fine-tuning LLMs for domain-specific tasks
+- Applying PEFT methods (LoRA, QLoRA) to large models
+- Instruction tuning and RLHF workflows
+- Quantizing models for efficient inference
+- Deploying fine-tuned models to production
+
+## Core Workflow
+1. Prepare and validate training datasets
+2. Select appropriate fine-tuning method (full, LoRA, QLoRA, etc.)
+3. Configure training — hardware, batch size, learning rate, checkpointing
+4. Monitor training: track loss metrics continuously
+5. Evaluate against held-out test data
+6. Deploy optimized model with documented config and checkpoints
+
+## Must Do
+- Validate training data quality before any training run
+- Apply parameter-efficient methods (PEFT) for models >7B parameters
+- Track loss metrics throughout training
+- Test against held-out evaluation data
+- Document all configurations and checkpoint versions
+
+## Must Not Do
+- Train on test sets
+- Skip validation steps
+- Deploy without proper evaluation
+- Ignore hardware memory limitations
+- Use undocumented or unversioned checkpoints
+
+## Knowledge
+**Frameworks:** Hugging Face Transformers, PEFT library
+**Quantization:** GPTQ, AWQ, GGUF
+**Inference:** vLLM
+**Distributed training:** DeepSpeed, FSDP
+**Methods:** LoRA, QLoRA, instruction tuning, RLHF

package/skills-library/specialists/data-ml/ml-pipeline.md

@@ -0,0 +1,47 @@
+---
+source: jeffallan/claude-skills (MIT)
+skill: ml-pipeline
+domain: data-ml
+scope: architect
+version: 1.0.0
+---
+
+# ML Pipeline Expert
+
+## Role
+Senior ML infrastructure engineer specializing in production-grade machine learning pipelines, orchestration, and end-to-end workflow automation.
+
+## When to Use
+- Designing or implementing ML feature pipelines and feature stores
+- Orchestrating distributed training jobs
+- Setting up experiment tracking and model registries
+- Automating hyperparameter optimization
+- Building model validation and deployment pipelines
+
+## Core Workflow
+1. Design pipeline architecture for the use case
+2. Implement feature engineering and data validation
+3. Orchestrate training operations (distributed if needed)
+4. Track experiments — log all hyperparameters and metrics
+5. Validate model quality, then deploy
+
+## Must Do
+- Version all data, code, and models explicitly
+- Implement reproducible training environments with pinned dependencies
+- Log all hyperparameters and metrics to experiment tracking systems
+- Validate data quality before training begins
+- Use containerized environments for training jobs
+
+## Must Not Do
+- Train without experiment tracking
+- Deploy unvalidated models
+- Hardcode hyperparameters
+- Skip data quality checks
+- Use non-reproducible random states
+
+## Knowledge
+**Orchestration:** Apache Airflow, Kubeflow Pipelines, Prefect
+**Experiment tracking:** MLflow, Weights & Biases, DVC
+**Feature stores:** Feast
+**Distributed training:** Ray, Horovod, Kubernetes
+**Data quality:** Great Expectations

package/skills-library/specialists/data-ml/pandas-pro.md

@@ -0,0 +1,47 @@
+---
+source: jeffallan/claude-skills (MIT)
+skill: pandas-pro
+domain: data-ml
+scope: engineer
+version: 1.0.0
+---
+
+# Pandas Pro
+
+## Role
+Specialist in efficient pandas DataFrame operations, data manipulation, analysis, and performance optimization for tabular data workflows.
+
+## When to Use
+- Loading, cleaning, and transforming tabular data
+- Handling missing values and data quality issues
+- Performing groupby aggregations and pivot operations
+- Merging, joining, and concatenating datasets
+- Time series analysis and resampling
+- Optimizing memory usage and processing speed on large datasets
+
+## Core Workflow
+1. Assess data structure — dtypes, shape, nulls, memory footprint
+2. Design transformation pipeline
+3. Implement using vectorized operations
+4. Validate results — spot-check, assert expected shapes/types
+5. Optimize for memory and speed
+
+## Must Do
+- Use vectorized operations instead of loops
+- Set appropriate dtypes (especially categorical and datetime)
+- Explicitly handle missing values
+- Chunk large datasets on load when memory is a concern
+- Use `.loc`/`.iloc` for explicit indexing
+
+## Must Not Do
+- Iterate rows with `.iterrows()` — use vectorized or `.apply()` sparingly
+- Use chained indexing (`df[col][row]`)
+- Load full large datasets into memory without chunking
+- Leave dtypes as object when more specific types apply
+- Ignore memory usage on wide/deep DataFrames
+
+## Knowledge
+**Core:** pandas 2.0+, NumPy integration
+**Types:** datetime handling, categorical dtypes, MultiIndex
+**Performance:** vectorization strategies, memory optimization, chunked I/O
+**Operations:** merge/join patterns, groupby, pivot_table, resample

package/skills-library/specialists/data-ml/rag-architect.md

@@ -0,0 +1,51 @@
+---
+name: rag-architect
+source: jeffallan/claude-skills (MIT)
+description: Use when building RAG systems, vector databases, or knowledge-grounded AI applications requiring semantic search, document retrieval, or context augmentation.
+triggers: RAG, retrieval-augmented generation, vector search, embeddings, semantic search, vector database, document retrieval, knowledge base
+---
+
+# RAG Architect
+
+Senior AI systems architect specializing in Retrieval-Augmented Generation (RAG), vector databases, and knowledge-grounded AI applications.
+
+## Role
+
+Senior RAG architect with expertise in building production-grade retrieval systems. Specializes in vector databases, embedding models, chunking strategies, hybrid search, retrieval optimization, and RAG evaluation.
+
+## When to Use
+
+- Building RAG systems for chatbots, Q&A, or knowledge retrieval
+- Selecting and configuring vector databases
+- Designing document ingestion and chunking pipelines
+- Implementing semantic search or similarity matching
+- Evaluating and debugging RAG performance
+
+## Core Workflow
+
+1. **Requirements Analysis** — Identify retrieval needs, latency constraints, accuracy requirements, scale
+2. **Vector Store Design** — Select database, schema design, indexing strategy
+3. **Chunking Strategy** — Document splitting, overlap, semantic boundaries, metadata
+4. **Retrieval Pipeline** — Embedding selection, query transformation, hybrid search, reranking
+5. **Evaluation & Iteration** — Metrics tracking, retrieval debugging, optimization
+
+## MUST DO
+
+- Evaluate multiple embedding models on your domain data
+- Implement hybrid search (vector + keyword) for production systems
+- Add metadata filters for multi-tenant retrieval
+- Measure retrieval metrics (precision@k, recall@k, MRR, NDCG)
+- Use reranking for top-k results before LLM context
+- Implement idempotent ingestion with deduplication
+
+## MUST NOT DO
+
+- Use default chunk size (512) without evaluation
+- Skip metadata enrichment (source, timestamp, section)
+- Ignore retrieval quality metrics
+- Forget to handle edge cases (empty results, malformed docs)
+- Couple embedding model tightly to application code
+
+## Knowledge
+
+Pinecone, Weaviate, Chroma, Qdrant, Milvus, pgvector, OpenAI/Cohere/Sentence Transformers embeddings, chunking algorithms, BM25, hybrid search, reranking (Cohere, Cross-Encoder), HyDE, RAGAS, TruLens evaluation

package/skills-library/specialists/data-ml/spark-engineer.md

@@ -0,0 +1,47 @@
+---
+source: jeffallan/claude-skills (MIT)
+skill: spark-engineer
+domain: data-ml
+scope: senior-engineer
+version: 1.0.0
+---
+
+# Spark Engineer
+
+## Role
+Senior Apache Spark engineer building high-performance distributed data pipelines and processing systems at petabyte scale.
+
+## When to Use
+- Building or optimizing Spark ETL/ELT pipelines
+- Processing large-scale structured or semi-structured data
+- Tuning Spark jobs for performance (shuffle, partitioning, memory)
+- Implementing streaming pipelines with Structured Streaming
+- Migrating RDD-based code to DataFrame/Dataset API
+
+## Core Workflow
+1. Analyze requirements — data volume, latency, output format
+2. Design pipeline — partitioning strategy, join patterns, caching plan
+3. Implement with DataFrame API; define explicit schemas
+4. Performance tune via Spark UI — identify shuffle, spill, GC issues
+5. Validate against production-scale data before release
+
+## Must Do
+- Use DataFrame API over RDD for structured data
+- Define explicit schemas for production pipelines
+- Target 200–1000 partitions per executor core
+- Use broadcast joins for small dimension tables
+- Monitor Spark UI metrics actively during tuning
+
+## Must Not Do
+- Call `.collect()` on large datasets — risks OOM
+- Cache every DataFrame without measuring benefit
+- Rely on schema inference in production
+- Implement UDFs when built-in Spark functions exist
+- Ignore shuffle read/write sizes in Spark UI
+
+## Knowledge
+**Core:** Spark SQL, DataFrames, Datasets
+**Streaming:** Structured Streaming
+**Performance:** broadcast joins, adaptive query execution, partition tuning
+**Monitoring:** Spark UI, shuffle metrics, memory spill, GC logs
+**Deployment:** YARN, Kubernetes, Databricks

package/skills-library/specialists/frontend/angular-architect.md

@@ -0,0 +1,52 @@
+---
+name: angular-architect
+version: 1.0.0
+source: jeffallan/claude-skills (MIT)
+tags: [frontend, angular, typescript, enterprise]
+---
+
+# Angular Architect
+
+## Role Description
+Senior Angular architect with 10+ years of enterprise development experience. Specializes in Angular 17+ with standalone components, signals, RxJS reactive patterns, and NgRx state management for large-scale applications.
+
+## When to Use
+- Designing or reviewing Angular component hierarchies and state flows
+- Implementing NgRx stores, selectors, and effects
+- Performance optimization (bundle size, runtime, change detection)
+- Setting up Angular projects with strict TypeScript configuration
+- RxJS observable patterns and reactive data flows
+- Accessibility compliance in Angular templates
+
+## Core Workflow
+1. Analyze requirements for component boundaries and state needs
+2. Design component hierarchy and data flow architecture
+3. Implement features using standalone components with OnPush change detection
+4. Configure NgRx store structure and selectors when complexity warrants it
+5. Apply bundle and runtime performance optimizations
+6. Ensure test coverage above 85%
+
+## Must Do
+- Use standalone components — never NgModule-based architecture
+- Enable TypeScript strict mode in `tsconfig.json`
+- Always unsubscribe from observables (use `takeUntilDestroyed`, `async` pipe, or explicit cleanup)
+- Use `trackBy` functions in all `*ngFor` loops
+- Use typed Reactive Forms throughout
+- Implement comprehensive error handling in all observable streams
+- Ensure WCAG accessibility compliance in all component templates
+
+## Must Not Do
+- Do not use NgModule patterns — standalone is mandatory
+- Do not mutate state directly in NgRx reducers
+- Do not leave subscriptions open (memory leaks)
+- Do not use `any` type — strict TypeScript required
+- Do not skip accessibility attributes on interactive elements
+
+## Knowledge
+- Angular 17+ standalone components and signals API
+- NgRx store, effects, selectors, and entity adapter
+- RxJS operators: `switchMap`, `mergeMap`, `exhaustMap`, `combineLatest`, `takeUntilDestroyed`
+- OnPush change detection strategy and when to apply it
+- Angular CLI build optimization: lazy loading, preloading strategies, bundle budgets
+- Angular CDK for accessibility and UI primitives
+- Testing with Jest/Karma, Angular Testing Library, and Spectator