senior-ml-engineer
by alirezarezvanisenior-ml-engineer helps agents plan production ML systems: model deployment, MLOps pipelines, monitoring, drift detection, RAG architecture, and LLM integration. Includes reference guides and starter scripts for deployment, monitoring, and RAG that teams should adapt before production.
This skill scores 74/100, which means it is acceptable for directory listing and likely useful for users who want an agent to reason about production ML, MLOps, LLM integration, and RAG workflows. The listing should set expectations that the written guidance and references are the main value, while the included scripts look more like scaffolds than production-ready tools.
- Strong triggerability: frontmatter names concrete use cases including MLOps pipelines, model deployment, drift detection, RAG systems, LLM integration, and automated retraining.
- Operational guidance is substantive in the main skill and references, including deployment steps, canary rollout, validation metrics such as p95 latency and error rate, serving option comparisons, and RAG pipeline flow.
- Good progressive disclosure through separate reference documents for LLM integration, MLOps production patterns, and RAG architecture, giving agents reusable implementation patterns beyond a generic prompt.
- Bundled scripts appear mostly scaffolded, with placeholder comments such as "Add validation logic" and generic processing rather than fully working deployment, monitoring, or RAG tools.
- No install command or README is present in the skill path, so users must infer installation and usage from SKILL.md and references.
Overview of senior-ml-engineer skill
What senior-ml-engineer is for
The senior-ml-engineer skill is a production ML engineering assistant for turning trained models, LLM features, and RAG prototypes into deployable systems. It focuses on MLOps decisions: model packaging, serving architecture, monitoring, drift detection, canary rollout, feature-store planning, RAG retrieval design, LLM API reliability, and cost controls.
Best-fit users and projects
Use this skill when you already have a model, embedding pipeline, or LLM product idea and need an implementation plan that accounts for operations. It is most useful for ML engineers, backend engineers, platform teams, and technical leads who need practical guidance for Docker, Kubernetes, MLflow, Kubeflow-style workflows, vector databases, monitoring, or production inference APIs.
What differentiates this skill
Compared with a generic ML prompt, the senior-ml-engineer skill is organized around production workflows rather than model experimentation. The repository includes reference guides for MLOps production patterns, LLM integration, and RAG architecture, plus script scaffolds for deployment, monitoring, and RAG building. Its strongest value is helping an agent ask operational questions: latency target, traffic split, fallback behavior, observability, evaluation gates, and retraining triggers.
Important adoption caveat
The included Python scripts are starter scaffolds, not turnkey production tools. They provide logging, configuration loading, and CLI structure, but you should expect to add real validation, cloud integrations, test logic, security controls, and deployment-specific code. Install it for planning and structured engineering assistance, not as a drop-in MLOps platform.
How to Use senior-ml-engineer skill
senior-ml-engineer install and repository path
Install the skill from the GitHub skill repository with:
npx skills add alirezarezvani/claude-skills --skill senior-ml-engineer
Then inspect the source at engineering-team/skills/senior-ml-engineer. Read SKILL.md first to understand triggers and workflow scope. After that, open references/mlops_production_patterns.md, references/llm_integration_guide.md, and references/rag_system_architecture.md based on your use case. Treat scripts/model_deployment_pipeline.py, scripts/ml_monitoring_suite.py, and scripts/rag_system_builder.py as templates to adapt, not finished automation.
Inputs the skill needs
For high-quality senior-ml-engineer usage, provide the production context, not just the model type. Include:
- Model framework and artifact format:
PyTorch,TensorFlow,ONNX,TorchScript,SavedModel - Serving target: REST API, batch inference, GPU inference, streaming, edge deployment
- Infrastructure: Docker, Kubernetes, cloud provider, CI/CD, registry, secrets manager
- SLOs: p95 latency, throughput, uptime, maximum error rate, cost ceiling
- Rollout plan: staging, canary percentage, rollback condition, A/B test requirements
- Monitoring needs: drift, latency, data quality, accuracy proxy, human review loop
- For RAG: document types, chunking constraints, vector database, reranking, evaluation set
- For LLM APIs: provider choices, retry policy, fallback model, token budget, safety constraints
Turn a rough request into a strong prompt
Weak prompt: “Help me deploy my ML model.”
Stronger prompt: “Use the senior-ml-engineer skill. I have a PyTorch fraud model exported as TorchScript, expected 80 requests/sec, p95 latency under 120 ms, deployed on Kubernetes with Docker images in GitHub Actions. Propose a staging-to-canary deployment plan, FastAPI or Triton serving choice, health checks, monitoring metrics, rollback criteria, and a minimal file layout. Assume model accuracy must be monitored using delayed labels available after 7 days.”
This works better because the skill can map requirements to concrete deployment gates, serving tradeoffs, and monitoring design instead of giving a generic checklist.
Suggested workflow for Machine Learning teams
Start with architecture selection, then move to implementation detail. For model serving, ask for a comparison of FastAPI, Triton Inference Server, TensorFlow Serving, and batch scoring against your latency and throughput needs. For MLOps, ask for CI/CD stages, artifact versioning, registry layout, staging validation, canary metrics, and rollback thresholds. For RAG, ask for chunking, embedding, vector search, reranking, prompt assembly, and hallucination evaluation. For LLM integration, ask for provider abstraction, retries, rate-limit handling, observability, and cost estimation.
senior-ml-engineer skill FAQ
Is senior-ml-engineer for Machine Learning beginners?
It can help beginners understand production ML vocabulary, but it is not primarily a training or data science tutoring skill. It assumes you are moving beyond notebooks into deployment, monitoring, or system design. If you need help choosing a model architecture or improving training accuracy, use a modeling or research-oriented skill first.
When should I not use this skill?
Do not use senior-ml-engineer as the main skill for exploratory data analysis, feature discovery, academic model design, or writing a first notebook. It is also a poor fit if you need fully managed platform-specific instructions without supplying your stack. For example, “deploy this somewhere” is too broad; “deploy to EKS with Helm, Prometheus, and canary rollout” is a good fit.
How is it different from ordinary prompting?
Ordinary prompts often produce broad MLOps lists. This skill gives the agent a more production-oriented frame: artifact format, containerization, staging validation, canary rollout, p95 latency checks, error-rate thresholds, model drift, feature-store patterns, RAG validation, retry logic, and token-cost controls. That structure reduces missed operational steps.
Are the included scripts safe to run directly?
Review them before use. The scripts appear to be generic CLI scaffolds with logging and placeholder execution methods. They are useful starting points for your own deployment pipeline, monitoring suite, or RAG builder, but they do not replace tested internal automation. Add config validation, dependency management, tests, authentication, environment handling, and real integrations before using them in production.
How to Improve senior-ml-engineer skill
Improve senior-ml-engineer results with constraints
The best way to improve senior-ml-engineer output is to provide measurable constraints. Instead of asking for “a scalable design,” specify expected QPS, p95 latency, model size, GPU availability, batch window, uptime target, cloud environment, compliance constraints, and cost limit. These details change serving choices, monitoring depth, and rollback policy.
Common failure modes to watch for
The skill may overgeneralize if you omit your stack, assume Kubernetes when a simpler service is enough, or propose monitoring before you have reliable ground-truth labels. RAG answers can also become too abstract unless you provide document volume, update frequency, query type, and evaluation examples. For LLM integration, missing token budget and rate-limit details often leads to unrealistic cost and retry designs.
Iterate after the first output
Ask for a second pass that turns the recommendation into artifacts: a deployment checklist, Dockerfile, API contract, Kubernetes manifest outline, monitoring dashboard metrics, alert thresholds, or CI/CD stages. Then ask the skill to identify risks and missing assumptions. This converts the senior-ml-engineer guide from advice into an implementation plan your team can review.
Adapt the repository references to your environment
Use the reference documents as decision frameworks, not fixed architecture. If you run small CPU models, prefer simpler FastAPI deployment before adding heavyweight serving infrastructure. If you run GPU inference at high throughput, ask the skill to evaluate Triton, batching, and autoscaling. If you build RAG, adapt chunking, reranking, and vector database choices to your corpus rather than copying defaults.