Senior Ml Engineer Skill for Claude
> ML engineering skill for productionizing models, building MLOps pipelines, and integrating LLMs. Covers model deployment, feature stores, drift monitoring, RAG systems, and cost optimization.
Install
one command, takes just this skill from the repositorynpx skills add https://github.com/borghei/Claude-Skills --skill senior-ml-engineerWhat comes with it
46 571 bytes besides the instructionThe instruction itself
8 sections, as written by the authorSenior ML Engineer
Production ML engineering patterns for model deployment, MLOps infrastructure, and LLM integration.
Core Capabilities
- Model deployment — export to ONNX/TorchScript/SavedModel, containerize, canary rollout, and serve via FastAPI, Triton, TF Serving, TorchServe, or Ray Serve with p95<100ms / error<0.1% gates.
- MLOps pipelines — feature stores (Feast/Tecton), experiment tracking (MLflow/W&B), model registry, A/B testing, and drift-triggered retraining.
- LLM integration — provider abstraction, retry/fallback with exponential backoff, token counting, response caching, cost tracking, and Pydantic output validation.
- RAG systems — vector database selection, chunking strategies, ingestion, retrieval, and reranking.
- Model monitoring — latency/error tracking, input drift detection (KS test, PSI), prediction-shift alerts, and automated retraining triggers.
When to Use
- Deploying a trained model to production with canary rollout and monitoring.
- Standing up MLOps infrastructure (feature store, registry, retraining).
- Integrating LLM APIs with provider abstraction and cost control.
- Building a RAG pipeline (vector DB + chunking + retrieval + reranking).
- Setting up drift detection and model-health alerting.
Clarify First
Before generating artifacts, confirm these inputs. If any is unknown or vague, ASK — do not assume:
- [ ] Task — model deployment / RAG pipeline build / monitoring setup (selects the script and workflow)
- [ ] Serving target & rollout — container vs K8s and canary vs direct (drives the generated Dockerfile/manifests and health gates)
- [ ] Model or data interface — the input/output contract, and for RAG the corpus + vector store (shapes the scaffold)
Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.
Tools
| Tool | Purpose | Command |
|------|---------|---------|
| model_deployment_pipeline.py | Generate deployment artifacts (Dockerfile, K8s manifests, health checks) | python scripts/model_deployment_pipeline.py --input <path> --output <path> [--config <file>] |
| rag_system_builder.py | Scaffold a RAG pipeline with vector store + retrieval logic | python scripts/rag_system_builder.py --input <path> --output <path> [--config <file>] |
| ml_monitoring_suite.py | Set up drift detection, alerting, and dashboards | python scripts/ml_monitoring_suite.py --input <path> --output <path> [--config <file>] |
All tools support --verbose/-v and emit JSON (status, start_time, end_time, processed_items) to stdout. See references/tool-reference.md for full flag detail.
References
Load the reference that matches the task — keep this file lean and pull detail on demand:
- references/production-ml-workflows.md — the five step-by-step workflows (model deployment, MLOps setup, LLM integration, RAG, monitoring) with all code templates, serving/vector-DB/chunking/cost tables, the troubleshooting matrix, and success criteria. Read when executing any workflow.
- references/tool-reference.md — full flag/parameter tables and output formats for the three scripts. Read when scripting the tools.
- references/mlops_production_patterns.md — model deployment pipeline with Kubernetes manifests, feature store architecture with Feast examples, model monitoring with drift detection code, A/B testing with traffic splitting, automated retraining with MLflow. Read when building MLOps infra.
- references/llm_integration_guide.md — provider abstraction layer, retry/fallback with tenacity, prompt templates (few-shot, CoT), token optimization with tiktoken, cost calculation and tracking. Read when integrating an LLM.
- references/rag_system_architecture.md — RAG pipeline implementation code, vector database comparison/integration, chunking strategies, embedding model selection, hybrid search and reranking. Read when building a RAG system.
Scope & Limitations
This skill covers:
- End-to-end model deployment pipelines (packaging, containerization, serving, canary rollout)
- MLOps infrastructure setup (feature stores, experiment tracking, model registries, retraining)
- LLM integration patterns (provider abstraction, retries, caching, cost tracking)
- RAG system architecture (vector databases, chunking, retrieval, reranking)
This skill does NOT cover:
- Model training algorithms or hyperparameter tuning (see
senior-data-scientist) - Raw data pipeline construction and ETL orchestration (see
senior-data-engineer) - Prompt engineering techniques, few-shot design, or prompt optimization (see
senior-prompt-engineer) - Image/video model architectures or computer vision inference optimization (see
senior-computer-vision)
Integration Points
| Skill | Integration | Data Flow |
|-------|-------------|-----------|
| senior-data-scientist | Receives trained models and evaluation metrics for deployment | Data Scientist exports model artifacts and baseline metrics; ML Engineer packages and deploys |
| senior-data-engineer | Consumes feature pipelines and data quality outputs | Data Engineer builds ETL and feature pipelines; ML Engineer reads from feature store for serving |
| senior-prompt-engineer | Provides LLM serving infrastructure for prompt workflows | Prompt Engineer designs prompts; ML Engineer deploys provider abstraction and manages cost/latency |
| senior-devops | Leverages CI/CD and Kubernetes infrastructure for model serving | DevOps manages cluster and pipelines; ML Engineer defines deployment manifests and health checks |
| senior-computer-vision | Deploys vision models through shared serving infrastructure | CV Engineer trains and exports models; ML Engineer handles Triton/TorchServe deployment and monitoring |
| senior-security | Applies security scanning to model containers and API endpoints | Security reviews container images and endpoint auth; ML Engineer remediates findings before promotion |
Last Updated: June 2026
Version: 1.1.0
Other skills for the same job
different authors, same section of the catalogue
Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability.
Build production ML systems with PyTorch 2.x, TensorFlow, and modern ML frameworks. Implements model serving, feature engineering, A/B testing, and monitoring. Use PROACTIVELY for ML model deployment, inference optimization, or production ML infrastructure.
World-class ML engineering skill for productionizing ML models, MLOps, and building scalable ML systems. Expertise in PyTorch, TensorFlow, model deployment, feature stores, model monitoring, and ML infrastructure. Includes LLM integration, fine-tuning, RAG systems, and agentic AI. Use when deploying ML models, building ML platforms, implementing MLOps, or integrating LLMs into production systems.
Expert in Langfuse - the open-source LLM observability platform. Covers tracing, prompt management, evaluation, datasets, and integration with LangChain, LlamaIndex, and OpenAI. Essential for debugging, monitoring, and improving LLM applications in production. Use when: langfuse, llm observability, llm tracing, prompt management, llm evaluation.
Use this skill for reinforcement learning tasks including training RL agents (PPO, SAC, DQN, TD3, DDPG, A2C, etc.), creating custom Gym environments, implementing callbacks for monitoring and control, using vectorized environments for parallel training, and integrating with deep RL workflows. This skill should be used when users request RL algorithm implementation, agent training, environment design, or RL experimentation.
Managed vector database for production AI applications. Fully managed, auto-scaling, with hybrid search (dense + sparse), metadata filtering, and namespaces. Low latency (<100ms p95). Use for production RAG, recommendation systems, or semantic search at scale. Best for serverless, managed infrastructure.
Deploy, evaluate, fine-tune, and manage Foundry agents end-to-end with azd: hosted agent scaffold/run/deploy, prompt agent create, batch eval, continuous eval, prompt optimizer, Agent Optimizer scaffold, agent.yaml, dataset curation from traces, model fine-tuning (SFT/DPO/RFT). USE FOR: azd ai agent, azd provision/deploy, deploy agent, hosted agent, create agent, add tool to agent, invoke agent, evaluate agent, continuous eval, continuous monitoring, agent CI/CD, optimize prompt, improve prompt, optimize agent instructions, agent optimizer, deploy model, Foundry project, RBAC, role assignment, permissions, quota, capacity, region, troubleshoot agent, deployment failure, AI Services, create Foundry resource, provision, knowledge index, customize deployment, onboard, availability, fine-tune, SFT, DPO, RFT, training-data, grader, distillation, fine-tuned model, large file upload. DO NOT USE FOR: Azure Functions, App Service, general Azure deploy (use azure-deploy), general Azure prep (use azure-prepare).
Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching.
How to use it
Take borghei/senior-ml-engineer from the repository into ~/.claude/skills for personal
use, or into .claude/skills inside a project.
The agent identifies a skill by the name field in its header. Two skills with the
same name cannot sit side by side — one of them will be ignored.