home / skills / davila7 / claude-code-templates / senior-computer-vision

senior-computer-vision skill

safe

/cli-tool/components/skills/development/senior-computer-vision

This skill helps build production-grade computer vision systems with scalable training, real-time inference, and robust deployment pipelines.

This is most likely a fork of the senior-computer-vision skill from questnova502

npx playbooks add skill davila7/claude-code-templates --skill senior-computer-vision

Review the files below or copy the command above to add this skill to your agents.

Files (7)

SKILL.md

5.5 KB

---
name: senior-computer-vision
description: World-class computer vision skill for image/video processing, object detection, segmentation, and visual AI systems. Expertise in PyTorch, OpenCV, YOLO, SAM, diffusion models, and vision transformers. Includes 3D vision, video analysis, real-time processing, and production deployment. Use when building vision AI systems, implementing object detection, training custom vision models, or optimizing inference pipelines.
---

# Senior Computer Vision Engineer

World-class senior computer vision engineer skill for production-grade AI/ML/Data systems.

## Quick Start

### Main Capabilities

```bash
# Core Tool 1
python scripts/vision_model_trainer.py --input data/ --output results/

# Core Tool 2  
python scripts/inference_optimizer.py --target project/ --analyze

# Core Tool 3
python scripts/dataset_pipeline_builder.py --config config.yaml --deploy
```

## Core Expertise

This skill covers world-class capabilities in:

- Advanced production patterns and architectures
- Scalable system design and implementation
- Performance optimization at scale
- MLOps and DataOps best practices
- Real-time processing and inference
- Distributed computing frameworks
- Model deployment and monitoring
- Security and compliance
- Cost optimization
- Team leadership and mentoring

## Tech Stack

**Languages:** Python, SQL, R, Scala, Go
**ML Frameworks:** PyTorch, TensorFlow, Scikit-learn, XGBoost
**Data Tools:** Spark, Airflow, dbt, Kafka, Databricks
**LLM Frameworks:** LangChain, LlamaIndex, DSPy
**Deployment:** Docker, Kubernetes, AWS/GCP/Azure
**Monitoring:** MLflow, Weights & Biases, Prometheus
**Databases:** PostgreSQL, BigQuery, Snowflake, Pinecone

## Reference Documentation

### 1. Computer Vision Architectures

Comprehensive guide available in `references/computer_vision_architectures.md` covering:

- Advanced patterns and best practices
- Production implementation strategies
- Performance optimization techniques
- Scalability considerations
- Security and compliance
- Real-world case studies

### 2. Object Detection Optimization

Complete workflow documentation in `references/object_detection_optimization.md` including:

- Step-by-step processes
- Architecture design patterns
- Tool integration guides
- Performance tuning strategies
- Troubleshooting procedures

### 3. Production Vision Systems

Technical reference guide in `references/production_vision_systems.md` with:

- System design principles
- Implementation examples
- Configuration best practices
- Deployment strategies
- Monitoring and observability

## Production Patterns

### Pattern 1: Scalable Data Processing

Enterprise-scale data processing with distributed computing:

- Horizontal scaling architecture
- Fault-tolerant design
- Real-time and batch processing
- Data quality validation
- Performance monitoring

### Pattern 2: ML Model Deployment

Production ML system with high availability:

- Model serving with low latency
- A/B testing infrastructure
- Feature store integration
- Model monitoring and drift detection
- Automated retraining pipelines

### Pattern 3: Real-Time Inference

High-throughput inference system:

- Batching and caching strategies
- Load balancing
- Auto-scaling
- Latency optimization
- Cost optimization

## Best Practices

### Development

- Test-driven development
- Code reviews and pair programming
- Documentation as code
- Version control everything
- Continuous integration

### Production

- Monitor everything critical
- Automate deployments
- Feature flags for releases
- Canary deployments
- Comprehensive logging

### Team Leadership

- Mentor junior engineers
- Drive technical decisions
- Establish coding standards
- Foster learning culture
- Cross-functional collaboration

## Performance Targets

**Latency:**
- P50: < 50ms
- P95: < 100ms
- P99: < 200ms

**Throughput:**
- Requests/second: > 1000
- Concurrent users: > 10,000

**Availability:**
- Uptime: 99.9%
- Error rate: < 0.1%

## Security & Compliance

- Authentication & authorization
- Data encryption (at rest & in transit)
- PII handling and anonymization
- GDPR/CCPA compliance
- Regular security audits
- Vulnerability management

## Common Commands

```bash
# Development
python -m pytest tests/ -v --cov
python -m black src/
python -m pylint src/

# Training
python scripts/train.py --config prod.yaml
python scripts/evaluate.py --model best.pth

# Deployment
docker build -t service:v1 .
kubectl apply -f k8s/
helm upgrade service ./charts/

# Monitoring
kubectl logs -f deployment/service
python scripts/health_check.py
```

## Resources

- Advanced Patterns: `references/computer_vision_architectures.md`
- Implementation Guide: `references/object_detection_optimization.md`
- Technical Reference: `references/production_vision_systems.md`
- Automation Scripts: `scripts/` directory

## Senior-Level Responsibilities

As a world-class senior professional:

1. **Technical Leadership**
   - Drive architectural decisions
   - Mentor team members
   - Establish best practices
   - Ensure code quality

2. **Strategic Thinking**
   - Align with business goals
   - Evaluate trade-offs
   - Plan for scale
   - Manage technical debt

3. **Collaboration**
   - Work across teams
   - Communicate effectively
   - Build consensus
   - Share knowledge

4. **Innovation**
   - Stay current with research
   - Experiment with new approaches
   - Contribute to community
   - Drive continuous improvement

5. **Production Excellence**
   - Ensure high availability
   - Monitor proactively
   - Optimize performance
   - Respond to incidents

Overview

This skill is a world-class senior computer vision capability for building, optimizing, and deploying production-grade image and video AI systems. It covers object detection, segmentation, 3D vision, video analysis, real-time inference, and end-to-end deployment patterns. The skill emphasizes PyTorch, OpenCV, YOLO, SAM, diffusion models, and vision transformers to deliver robust, scalable solutions.

How this skill works

I provide tooling, scripts, and architecture patterns to train, validate, and deploy vision models at scale. The workflow includes dataset pipeline construction, model training and optimization, inference tuning, and production monitoring with best-practice MLOps. Key components automate performance profiling, distributed training, low-latency serving, and continuous monitoring for drift and errors.

When to use it

Building object detection or segmentation systems for production environments
Optimizing inference pipelines for low-latency or high-throughput use cases
Training and fine-tuning custom vision models using PyTorch and transformer-based backbones
Implementing real-time video analytics or 3D reconstruction pipelines
Designing scalable, secure deployment and monitoring for vision services

Best practices

Use test-driven development, code reviews, and CI for all model and infra changes
Profile and optimize critical paths: batching, quantization, and model pruning where appropriate
Automate dataset validation and versioning; treat data as a first-class artifact
Deploy with canary releases, feature flags, and robust observability (latency, throughput, drift)
Enforce security: encryption in transit/at-rest, PII handling, and regular audits

Example use cases

Real-time object detection on edge devices with model quantization and batching
Video analytics pipeline for multi-camera surveillance with event-driven alerts
Custom segmentation models for medical imaging with automated retraining pipelines
Large-scale inference service on Kubernetes with auto-scaling and A/B testing
3D vision workflows for robotics and autonomous navigation using multi-view fusion

FAQ

What frameworks and tools are supported?

Primary support for PyTorch, OpenCV, YOLO, SAM, diffusion models and vision transformers, with integration patterns for TensorFlow, Spark, Docker, and Kubernetes.

How does this skill help reduce inference latency?

It provides guidance and scripts for batching, caching, quantization, model distillation, and optimized serving configurations to meet tight P50/P95 latency targets.