claude-skills-reference/engineering-team/README.md

# Engineering Skills Collection

Complete set of 18 engineering role skills tailored to your tech stack (ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin, Flutter, Postgres, GraphQL, Go, Python).

## ⚡ Installation

### Quick Install (Recommended)

Install all engineering skills with one command:

```bash
# Install all engineering skills to all supported agents
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team

# Install to Claude Code only
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team --agent claude

# Install to Cursor only
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team --agent cursor
```

### Install Individual Skills

```bash
# Core Engineering
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-architect
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-frontend
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-backend
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-fullstack
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-qa
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-devops
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-secops
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/code-reviewer
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-security

# Cloud & Enterprise
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/aws-solution-architect
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/ms365-tenant-manager

# Development Tools
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/tdd-guide
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/tech-stack-evaluator

# AI/ML/Data
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-data-scientist
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-data-engineer
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-ml-engineer
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-prompt-engineer
npx ai-agent-skills install alirezarezvani/claude-skills/engineering-team/senior-computer-vision
```

**Supported Agents:** Claude Code, Cursor, VS Code, Copilot, Goose, Amp, Codex

**Complete Installation Guide:** See [../INSTALLATION.md](../INSTALLATION.md) for detailed instructions, troubleshooting, and manual installation.

---

## 📦 Skills Package

All skills follow the exact structure from your fullstack-engineer example:

```
skill-name/
├── SKILL.md                  # Main skill documentation
├── references/               # 3 detailed reference guides
│   ├── [topic]_patterns.md
│   ├── [topic]_guide.md
│   └── [topic]_practices.md
└── scripts/                  # 3 automation scripts
    ├── [tool]_generator.py
    ├── [tool]_analyzer.py
    └── [tool]_scaffolder.py
```

## 🎯 Skills Overview

### 1. Senior Software Architect (`senior-architect.zip`)

**Purpose:** System architecture design, tech stack decisions, architecture diagrams

**Key Capabilities:**
- Architecture diagram generation (C4, sequence, component)
- Dependency analysis and visualization
- Architecture Decision Records (ADR) creation
- System design patterns (Monolithic, Microservices, Serverless)
- Integration pattern templates
- Tech stack decision framework

**Scripts:**
- `architecture_diagram_generator.py` - Generate professional architecture diagrams
- `project_architect.py` - Scaffold architecture documentation
- `dependency_analyzer.py` - Analyze dependencies and detect issues

**References:**
- `architecture_patterns.md` - Comprehensive architecture patterns
- `system_design_workflows.md` - Step-by-step design process
- `tech_decision_guide.md` - Tech stack selection guide

**Use When:**
- Designing new system architecture
- Making technology stack decisions
- Creating technical documentation
- Evaluating architectural trade-offs

---

### 2. Senior Frontend Engineer (`senior-frontend.zip`)

**Purpose:** Frontend development with React, Next.js, TypeScript

**Key Capabilities:**
- React component scaffolding
- Bundle size analysis and optimization
- Performance optimization
- Next.js App Router patterns
- State management (Zustand, Context)
- UI/UX best practices

**Scripts:**
- `component_generator.py` - Generate React components
- `bundle_analyzer.py` - Analyze and optimize bundles
- `frontend_scaffolder.py` - Scaffold frontend projects

**References:**
- `react_patterns.md` - React best practices and patterns
- `nextjs_optimization_guide.md` - Next.js performance guide
- `frontend_best_practices.md` - Modern frontend practices

**Use When:**
- Building React/Next.js applications
- Optimizing frontend performance
- Implementing UI components
- Managing application state

---

### 3. Senior Backend Engineer (`senior-backend.zip`)

**Purpose:** Backend development with Node.js, Express, GraphQL, Go, Python

**Key Capabilities:**
- REST & GraphQL API design
- Database optimization (PostgreSQL)
- Authentication/Authorization
- API load testing
- Microservice patterns
- Error handling strategies

**Scripts:**
- `api_scaffolder.py` - Generate API endpoints
- `database_migration_tool.py` - Database migration management
- `api_load_tester.py` - API performance testing

**References:**
- `api_design_patterns.md` - API design best practices
- `database_optimization_guide.md` - Database performance guide
- `backend_security_practices.md` - Security implementation

**Use When:**
- Designing APIs (REST/GraphQL)
- Optimizing database queries
- Implementing authentication
- Building microservices

---

### 4. Senior Fullstack Engineer (`senior-fullstack.zip`)

**Purpose:** End-to-end application development

**Key Capabilities:**
- Full project scaffolding
- Code quality analysis
- Full-stack architecture
- Frontend-backend integration
- Testing strategies
- Deployment workflows

**Scripts:**
- `fullstack_scaffolder.py` - Generate complete projects
- `project_scaffolder.py` - Project structure creation
- `code_quality_analyzer.py` - Comprehensive code analysis

**References:**
- `tech_stack_guide.md` - Complete tech stack reference
- `architecture_patterns.md` - Full-stack architecture
- `development_workflows.md` - Development best practices

**Use When:**
- Starting new full-stack projects
- Analyzing code quality
- Implementing complete features
- Setting up development environments

---

### 5. Senior QA Testing Engineer (`senior-qa.zip`)

**Purpose:** Quality assurance and test automation for React/Next.js applications

**Tech Stack Focus:**
- Jest + React Testing Library (unit/integration)
- Playwright (E2E testing)
- Istanbul/NYC (coverage analysis)
- MSW (API mocking)

**Key Capabilities:**
- Component test generation with accessibility checks
- Coverage gap analysis with critical path detection
- E2E test scaffolding with Page Object Model
- Test pyramid implementation (70/20/10 ratio)
- CI/CD integration patterns

**Scripts:**
- `test_suite_generator.py` - Scans React components, generates Jest + RTL tests with accessibility assertions
- `coverage_analyzer.py` - Parses Istanbul/LCOV reports, identifies untested critical paths, generates HTML reports
- `e2e_test_scaffolder.py` - Scans Next.js routes, generates Playwright tests with Page Object Model classes

**References:**
- `testing_strategies.md` - Test pyramid, coverage targets, CI/CD integration patterns
- `test_automation_patterns.md` - Page Object Model, fixtures, mocking strategies, async testing
- `qa_best_practices.md` - Test naming, isolation, flaky test handling, debugging strategies

**Use When:**
- Setting up React/Next.js testing infrastructure
- Generating component test suites with RTL
- Analyzing coverage gaps in critical paths
- Scaffolding Playwright E2E tests for Next.js routes

---

### 6. Senior DevOps Engineer (`senior-devops.zip`)

**Purpose:** CI/CD, infrastructure automation, deployment

**Key Capabilities:**
- CI/CD pipeline setup (GitHub Actions, CircleCI)
- Infrastructure as Code (Terraform)
- Docker containerization
- Kubernetes orchestration
- Deployment automation
- Monitoring setup

**Scripts:**
- `pipeline_generator.py` - Generate CI/CD pipelines
- `terraform_scaffolder.py` - Create IaC templates
- `deployment_manager.py` - Manage deployments

**References:**
- `cicd_pipeline_guide.md` - Pipeline setup and best practices
- `infrastructure_as_code.md` - IaC patterns and examples
- `deployment_strategies.md` - Blue-green, canary deployments

**Use When:**
- Setting up CI/CD pipelines
- Automating deployments
- Managing infrastructure
- Containerizing applications

---

### 7. Senior SecOps Engineer (`senior-secops.zip`)

**Purpose:** Security operations and compliance

**Key Capabilities:**
- Security scanning automation
- Vulnerability assessment
- Compliance checking (GDPR, SOC2)
- Security audit automation
- Incident response
- Security metrics

**Scripts:**
- `security_scanner.py` - Scan for vulnerabilities
- `vulnerability_assessor.py` - Assess security risks
- `compliance_checker.py` - Check compliance status

**References:**
- `security_standards.md` - OWASP Top 10, security standards
- `vulnerability_management_guide.md` - Vulnerability handling
- `compliance_requirements.md` - Compliance frameworks

**Use When:**
- Implementing security controls
- Conducting security audits
- Managing vulnerabilities
- Ensuring compliance

---

### 8. Code Reviewer (`code-reviewer.zip`)

**Purpose:** Code review automation and quality checking

**Key Capabilities:**
- Automated PR analysis
- Code quality metrics
- Security scanning
- Best practice checking
- Review checklist generation
- Anti-pattern detection

**Scripts:**
- `pr_analyzer.py` - Analyze pull requests
- `code_quality_checker.py` - Check code quality
- `review_report_generator.py` - Generate review reports

**References:**
- `code_review_checklist.md` - Comprehensive checklist
- `coding_standards.md` - Language-specific standards
- `common_antipatterns.md` - What to avoid

**Use When:**
- Reviewing pull requests
- Ensuring code quality
- Identifying issues
- Providing feedback

---

### 9. Senior Security Engineer (`senior-security.zip`)

**Purpose:** Security architecture and penetration testing

**Key Capabilities:**
- Threat modeling
- Security architecture design
- Penetration testing automation
- Cryptography implementation
- Security auditing
- Zero Trust architecture

**Scripts:**
- `threat_modeler.py` - Create threat models
- `security_auditor.py` - Perform security audits
- `pentest_automator.py` - Automate penetration tests

**References:**
- `security_architecture_patterns.md` - Security design patterns
- `penetration_testing_guide.md` - Pen testing methodologies
- `cryptography_implementation.md` - Crypto best practices

**Use When:**
- Designing security architecture
- Conducting penetration tests
- Implementing cryptography
- Performing security audits

---

## 🚀 Quick Start Guide

### Installation

1. **Download the skills** you need from the files above
2. **Extract** the zip file
3. **Install dependencies** (if needed):
   ```bash
   # For Python scripts
   pip install -r requirements.txt
   
   # For Node.js tools
   npm install
   ```

### Using a Skill

Each skill follows the same pattern:

```bash
# 1. Read the SKILL.md file
cat SKILL.md

# 2. Check the reference documentation
ls references/

# 3. Run the scripts
python scripts/[script-name].py --help

# Example: Generate architecture diagrams
cd senior-architect
python scripts/architecture_diagram_generator.py --type c4 --output ./docs
```

### Skill Selection Guide

**Starting a new project?**
→ Use `senior-fullstack` or `senior-architect`

**Building frontend features?**
→ Use `senior-frontend`

**Designing APIs?**
→ Use `senior-backend`

**Setting up CI/CD?**
→ Use `senior-devops`

**Security concerns?**
→ Use `senior-secops` or `senior-security`

**Code review?**
→ Use `code-reviewer`

**Testing strategy?**
→ Use `senior-qa`

---

## 📚 Common Workflows

### Workflow 1: Starting a New Project

```bash
# Step 1: Design architecture
cd senior-architect
python scripts/project_architect.py my-app --pattern microservices

# Step 2: Scaffold project
cd ../senior-fullstack
python scripts/project_scaffolder.py my-app --type nextjs-graphql

# Step 3: Setup CI/CD
cd ../senior-devops
python scripts/pipeline_generator.py my-app --platform github
```

### Workflow 2: Code Review Process

```bash
# Step 1: Analyze PR
cd code-reviewer
python scripts/pr_analyzer.py ../my-app

# Step 2: Check quality
python scripts/code_quality_checker.py ../my-app

# Step 3: Generate report
python scripts/review_report_generator.py ../my-app --output review.md
```

### Workflow 3: Security Audit

```bash
# Step 1: Scan for vulnerabilities
cd senior-secops
python scripts/security_scanner.py ../my-app

# Step 2: Assess risks
python scripts/vulnerability_assessor.py ../my-app

# Step 3: Check compliance
python scripts/compliance_checker.py ../my-app --standard soc2
```

---

## 🛠 Tech Stack Support

All skills are optimized for your tech stack:

**Frontend:**
- React 18+
- Next.js 14+ (App Router)
- TypeScript
- Tailwind CSS
- React Native
- Flutter

**Backend:**
- Node.js 20+
- Express 4+
- GraphQL (Apollo Server)
- Go (Gin/Echo)
- Python (FastAPI)

**Database:**
- PostgreSQL 16+
- Prisma ORM
- NeonDB
- Supabase

**Mobile:**
- Swift (iOS)
- Kotlin (Android)
- React Native
- Flutter

**DevOps:**
- Docker
- Kubernetes
- Terraform
- GitHub Actions
- CircleCI
- AWS/GCP/Azure

**Tools:**
- Git (GitHub/GitLab/Bitbucket)
- Jira
- Confluence
- Figma
- Miro

---

## 📖 Best Practices

### Using Scripts

1. **Always read help first**: `python script.py --help`
2. **Test in development**: Run on sample projects first
3. **Review outputs**: Check generated files before using
4. **Customize as needed**: Scripts are starting points

### Using References

1. **Start with patterns**: Read the patterns guide first
2. **Follow workflows**: Use step-by-step workflows
3. **Adapt to context**: Adjust recommendations for your needs
4. **Document decisions**: Keep track of what works

### Combining Skills

Skills work best together:
- **Architect** + **Fullstack**: Design then build
- **DevOps** + **SecOps**: Deploy securely
- **Backend** + **QA**: Build and test APIs
- **Frontend** + **Code Reviewer**: Build quality UIs

---

## 🔄 Iteration and Updates

These skills are designed to evolve:

1. **Use the skill** on real projects
2. **Note improvements** needed
3. **Update scripts** and references
4. **Share learnings** with team

---

## 📝 Customization

Each skill can be customized:

### Updating Scripts

Edit Python scripts to add:
- Company-specific conventions
- Custom templates
- Additional checks
- Integration with your tools

### Updating References

Edit markdown files to add:
- Your patterns and practices
- Team standards
- Project examples
- Lessons learned

---

## 🎯 Summary

You now have **9 comprehensive engineering skills** that match your tech stack:

1. ✅ **Senior Architect** - System design and architecture
2. ✅ **Senior Frontend** - React/Next.js development
3. ✅ **Senior Backend** - API and backend development
4. ✅ **Senior Fullstack** - End-to-end development
5. ✅ **Senior QA** - Testing and quality assurance
6. ✅ **Senior DevOps** - CI/CD and infrastructure
7. ✅ **Senior SecOps** - Security operations
8. ✅ **Code Reviewer** - Code review automation
9. ✅ **Senior Security** - Security architecture

Each skill includes:
- **Comprehensive SKILL.md** with quick start guide
- **3 reference guides** with patterns and best practices
- **3 automation scripts** for common tasks

---

## 🚀 Next Steps

1. **Download** the skills you need most
2. **Extract** and explore the structure
3. **Read** SKILL.md for each skill
4. **Run** example scripts to understand capabilities
5. **Customize** for your specific needs
6. **Integrate** into your development workflow

---

## 💡 Tips

- **Start small**: Begin with 2-3 core skills
- **Test scripts**: Run on sample projects first
- **Read references**: They contain valuable patterns
- **Iterate**: Update skills based on usage
- **Share**: Use as team knowledge base

---

**Happy Engineering! 🎉**