Senior Computer Vision

Name: Senior Computer Vision
Author: davila7

davila7/claude-code-templates

976 installs
29.9k repo stars
Updated July 27, 2026
davila7/claude-code-templates

senior-computer-vision is an agent skill that generates production-grade computer vision system designs with scalability, reliability, observability, and security patterns for developers architecting enterprise CV pipeli

About

senior-computer-vision is a Claude Code Templates skill for world-class computer vision architecture aimed at senior engineers. It encodes production-first design—planning for 10x load growth, 99.9% uptime targets, maintainable modules, and full observability—plus performance patterns like batch processing, caching, and resource-aware algorithms. Security and privacy guardrails cover input validation, encryption, access control, and audit logging. Developers reach for senior-computer-vision when drafting distributed CV pipelines, inference services, or enterprise-scale vision platforms instead of notebook-only prototypes.

Production-first design principles covering scalability to 10x load, 99.9% uptime, maintainability, and full observabili
Performance-by-design patterns including efficient algorithms, strategic caching, batch processing and resource awarenes
Security and privacy built-in with input validation, data encryption, access control and audit logging
Three advanced architecture patterns: Distributed Processing, Real-Time Systems, and ML at Scale
Reliability best practices including circuit breakers, retries, failure design and continuous health monitoring

Senior Computer Vision by the numbers

976 all-time installs (skills.sh)
+25 installs in the week ending Jul 28, 2026 (Skillselion tracking)
Ranked #1,080 of 16,659 AI & Agent Building skills by installs in the Skillselion catalog
Security screen: MEDIUM risk (skills.sh audit)
Data as of Jul 28, 2026 (Skillselion catalog sync)

npx skills add https://github.com/davila7/claude-code-templates --skill senior-computer-vision

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/davila7/claude-code-templates/senior-computer-vision.svg)](https://skillselion.com/skills/davila7/claude-code-templates/senior-computer-vision)

Installs	976
repo stars	★ 29.9k
Security audit	3 / 3 scanners passed
Last updated	July 27, 2026
Repository	davila7/claude-code-templates ↗

How do you design production computer vision systems?

Generate production-grade computer vision system designs and architectures that meet enterprise standards for scalability, reliability, and observability.

Who is it for?

Senior computer vision engineers designing scalable inference pipelines and enterprise-grade vision platforms.

Skip if: Beginners learning OpenCV basics or teams needing only a single-model notebook without production architecture.

When should I use this skill?

User asks for production CV architecture, distributed vision processing, enterprise CV reliability, or observability for inference services.

What you get

CV architecture documents with distributed processing diagrams, observability plans, security controls, and performance patterns.

CV architecture specification
Distributed processing design
Observability and security plan

By the numbers

Targets 10x scalability headroom and 99.9% uptime in production CV designs

Files

SKILL.mdMarkdownGitHub ↗

Senior Computer Vision Engineer

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

Quick Start

Main Capabilities

# 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

# 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

#!/usr/bin/env python3
"""
Dataset Pipeline Builder
Production-grade tool for senior computer vision engineer
"""

import os
import sys
import json
import logging
import argparse
from pathlib import Path
from typing import Dict, List, Optional
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DatasetPipelineBuilder:
    """Production-grade dataset pipeline builder"""
    
    def __init__(self, config: Dict):
        self.config = config
        self.results = {
            'status': 'initialized',
            'start_time': datetime.now().isoformat(),
            'processed_items': 0
        }
        logger.info(f"Initialized {self.__class__.__name__}")
    
    def validate_config(self) -> bool:
        """Validate configuration"""
        logger.info("Validating configuration...")
        # Add validation logic
        logger.info("Configuration validated")
        return True
    
    def process(self) -> Dict:
        """Main processing logic"""
        logger.info("Starting processing...")
        
        try:
            self.validate_config()
            
            # Main processing
            result = self._execute()
            
            self.results['status'] = 'completed'
            self.results['end_time'] = datetime.now().isoformat()
            
            logger.info("Processing completed successfully")
            return self.results
            
        except Exception as e:
            self.results['status'] = 'failed'
            self.results['error'] = str(e)
            logger.error(f"Processing failed: {e}")
            raise
    
    def _execute(self) -> Dict:
        """Execute main logic"""
        # Implementation here
        return {'success': True}

def main():
    """Main entry point"""
    parser = argparse.ArgumentParser(
        description="Dataset Pipeline Builder"
    )
    parser.add_argument('--input', '-i', required=True, help='Input path')
    parser.add_argument('--output', '-o', required=True, help='Output path')
    parser.add_argument('--config', '-c', help='Configuration file')
    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
    
    args = parser.parse_args()
    
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)
    
    try:
        config = {
            'input': args.input,
            'output': args.output
        }
        
        processor = DatasetPipelineBuilder(config)
        results = processor.process()
        
        print(json.dumps(results, indent=2))
        sys.exit(0)
        
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Inference Optimizer
Production-grade tool for senior computer vision engineer
"""

import os
import sys
import json
import logging
import argparse
from pathlib import Path
from typing import Dict, List, Optional
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class InferenceOptimizer:
    """Production-grade inference optimizer"""
    
    def __init__(self, config: Dict):
        self.config = config
        self.results = {
            'status': 'initialized',
            'start_time': datetime.now().isoformat(),
            'processed_items': 0
        }
        logger.info(f"Initialized {self.__class__.__name__}")
    
    def validate_config(self) -> bool:
        """Validate configuration"""
        logger.info("Validating configuration...")
        # Add validation logic
        logger.info("Configuration validated")
        return True
    
    def process(self) -> Dict:
        """Main processing logic"""
        logger.info("Starting processing...")
        
        try:
            self.validate_config()
            
            # Main processing
            result = self._execute()
            
            self.results['status'] = 'completed'
            self.results['end_time'] = datetime.now().isoformat()
            
            logger.info("Processing completed successfully")
            return self.results
            
        except Exception as e:
            self.results['status'] = 'failed'
            self.results['error'] = str(e)
            logger.error(f"Processing failed: {e}")
            raise
    
    def _execute(self) -> Dict:
        """Execute main logic"""
        # Implementation here
        return {'success': True}

def main():
    """Main entry point"""
    parser = argparse.ArgumentParser(
        description="Inference Optimizer"
    )
    parser.add_argument('--input', '-i', required=True, help='Input path')
    parser.add_argument('--output', '-o', required=True, help='Output path')
    parser.add_argument('--config', '-c', help='Configuration file')
    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
    
    args = parser.parse_args()
    
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)
    
    try:
        config = {
            'input': args.input,
            'output': args.output
        }
        
        processor = InferenceOptimizer(config)
        results = processor.process()
        
        print(json.dumps(results, indent=2))
        sys.exit(0)
        
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Vision Model Trainer
Production-grade tool for senior computer vision engineer
"""

import os
import sys
import json
import logging
import argparse
from pathlib import Path
from typing import Dict, List, Optional
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class VisionModelTrainer:
    """Production-grade vision model trainer"""
    
    def __init__(self, config: Dict):
        self.config = config
        self.results = {
            'status': 'initialized',
            'start_time': datetime.now().isoformat(),
            'processed_items': 0
        }
        logger.info(f"Initialized {self.__class__.__name__}")
    
    def validate_config(self) -> bool:
        """Validate configuration"""
        logger.info("Validating configuration...")
        # Add validation logic
        logger.info("Configuration validated")
        return True
    
    def process(self) -> Dict:
        """Main processing logic"""
        logger.info("Starting processing...")
        
        try:
            self.validate_config()
            
            # Main processing
            result = self._execute()
            
            self.results['status'] = 'completed'
            self.results['end_time'] = datetime.now().isoformat()
            
            logger.info("Processing completed successfully")
            return self.results
            
        except Exception as e:
            self.results['status'] = 'failed'
            self.results['error'] = str(e)
            logger.error(f"Processing failed: {e}")
            raise
    
    def _execute(self) -> Dict:
        """Execute main logic"""
        # Implementation here
        return {'success': True}

def main():
    """Main entry point"""
    parser = argparse.ArgumentParser(
        description="Vision Model Trainer"
    )
    parser.add_argument('--input', '-i', required=True, help='Input path')
    parser.add_argument('--output', '-o', required=True, help='Output path')
    parser.add_argument('--config', '-c', help='Configuration file')
    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
    
    args = parser.parse_args()
    
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)
    
    try:
        config = {
            'input': args.input,
            'output': args.output
        }
        
        processor = VisionModelTrainer(config)
        results = processor.process()
        
        print(json.dumps(results, indent=2))
        sys.exit(0)
        
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()

Related skills

Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la462k185k

Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.379k15.8k

CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.378k92.5k

Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.375k

Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72

Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k8

How it compares

Use senior-computer-vision for enterprise CV system design; use model-training skills when the gap is dataset or algorithm tuning only.

FAQ

What production targets does senior-computer-vision assume?

senior-computer-vision assumes production-first design with 10x scalability headroom, 99.9% uptime goals, maintainable documented modules, and observability across inference and batch pipelines.

Does senior-computer-vision cover security?

senior-computer-vision includes security and privacy patterns—input validation, data encryption, access control, and audit logging—for enterprise computer vision deployments.

Is Senior Computer Vision safe to install?

skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.

AI & Agent Buildingagentsautomation

About

Senior Computer Vision by the numbers

Add your badge

How do you design production computer vision systems?

Who is it for?

When should I use this skill?

What you get

By the numbers

Files

Senior Computer Vision Engineer

Quick Start

Main Capabilities

Core Expertise

Tech Stack

Reference Documentation

1. Computer Vision Architectures

2. Object Detection Optimization

3. Production Vision Systems

Production Patterns

Pattern 1: Scalable Data Processing

Pattern 2: ML Model Deployment

Pattern 3: Real-Time Inference

Best Practices

Development

Production

Team Leadership

Performance Targets

Security & Compliance

Common Commands

Resources

Senior-Level Responsibilities

Computer Vision Architectures

Overview

Core Principles

Production-First Design

Performance by Design

Security & Privacy

Advanced Patterns

Pattern 1: Distributed Processing

Pattern 2: Real-Time Systems

Pattern 3: ML at Scale

Best Practices

Code Quality

Performance

Reliability

Tools & Technologies

Further Reading

Object Detection Optimization

Overview

Core Principles

Production-First Design

Performance by Design

Security & Privacy

Advanced Patterns

Pattern 1: Distributed Processing

Pattern 2: Real-Time Systems

Pattern 3: ML at Scale

Best Practices

Code Quality

Performance

Reliability

Tools & Technologies

Further Reading

Production Vision Systems

Overview

Core Principles

Production-First Design

Performance by Design

Security & Privacy

Advanced Patterns

Pattern 1: Distributed Processing

Pattern 2: Real-Time Systems

Pattern 3: ML at Scale

Best Practices

Code Quality

Performance

Reliability

Tools & Technologies

Further Reading

Related skills