Initial commit

2025-11-30 08:37:14 +08:00
commit 353f62980d
17 changed files with 4887 additions and 0 deletions
--- a/skills/using-dev-team/SKILL.md
+++ b/skills/using-dev-team/SKILL.md
@@ -0,0 +1,460 @@
+---
+name: using-dev-team
+description: |
+  10 specialist developer agents for backend (Go/TypeScript/Python), DevOps, frontend,
+  design, QA, and SRE. Dispatch when you need deep technology expertise.
+
+trigger: |
+  - Need deep expertise for specific technology (Go, TypeScript, Python)
+  - Building infrastructure/CI-CD → devops-engineer
+  - Frontend with design focus → frontend-designer
+  - Test strategy needed → qa-analyst
+  - Reliability/monitoring → sre
+
+skip_when: |
+  - General code review → use default plugin reviewers
+  - Planning/design → use brainstorming
+  - Debugging → use systematic-debugging
+
+related:
+  similar: [using-ring]
+---
+
+# Using Ring Developer Specialists
+
+The ring-dev-team plugin provides 10 specialized developer agents. Use them via `Task tool with subagent_type:`.
+
+**Remember:** Follow the **ORCHESTRATOR principle** from `using-ring`. Dispatch agents to handle complexity; don't operate tools directly.
+
+---
+
+## 10 Developer Specialists
+
+### 1. Backend Engineer (Language-Agnostic)
+**`ring-dev-team:backend-engineer`**
+
+**Specializations:**
+- Language-agnostic backend design (adapts to Go/TypeScript/Python/Java/Rust)
+- Microservices architecture patterns
+- API design (REST, GraphQL, gRPC)
+- Database modeling & optimization
+- Authentication & authorization
+- Message queues & event-driven systems
+- Caching strategies
+
+**Use When:**
+- You need backend expertise without language commitment
+- Designing multi-language systems
+- Comparing backend approaches across languages
+- Architecture that might use multiple languages
+- Language choice is not yet decided
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:backend-engineer"
+  model: "opus"
+  prompt: "Design a user authentication service, recommend the best language and explain trade-offs"
+```
+
+---
+
+### 2. Backend Engineer (Go)
+**`ring-dev-team:backend-engineer-golang`**
+
+**Specializations:**
+- Go microservices & API design
+- Database optimization (PostgreSQL, MongoDB)
+- Message queues (Kafka, RabbitMQ)
+- OAuth2, JWT, API security
+- gRPC and performance optimization
+
+**Use When:**
+- Designing Go services from scratch
+- Optimizing database queries
+- Implementing authentication/authorization
+- Troubleshooting concurrency issues
+- Reviewing Go backend architecture
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:backend-engineer-golang"
+  model: "opus"
+  prompt: "Design a Go service for user authentication with JWT and OAuth2 support"
+```
+
+---
+
+### 3. Backend Engineer (TypeScript/Node.js)
+**`ring-dev-team:backend-engineer-typescript`**
+
+**Specializations:**
+- TypeScript/Node.js backend services
+- Express, Fastify, NestJS frameworks
+- TypeScript type safety & ORM (Prisma, TypeORM)
+- Node.js performance optimization
+- Async/await patterns & error handling
+- REST & GraphQL APIs
+- Testing with Jest/Vitest
+
+**Use When:**
+- Building TypeScript/Node.js backends
+- Migrating from JavaScript to TypeScript
+- NestJS or Express service design
+- Node.js-specific optimization
+- Full-stack TypeScript projects
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:backend-engineer-typescript"
+  model: "opus"
+  prompt: "Design a NestJS service with Prisma ORM for user management"
+```
+
+---
+
+### 4. Backend Engineer (Python)
+**`ring-dev-team:backend-engineer-python`**
+
+**Specializations:**
+- Python backend services (FastAPI, Django, Flask)
+- SQLAlchemy & Django ORM
+- Async Python (asyncio, aiohttp)
+- Data processing & API integration
+- Python type hints & validation (Pydantic)
+- Celery for background tasks
+- Testing with pytest
+
+**Use When:**
+- Building Python backend services
+- FastAPI or Django projects
+- Data-heavy backend services
+- Machine learning API integration
+- Python-specific optimization
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:backend-engineer-python"
+  model: "opus"
+  prompt: "Design a FastAPI service with SQLAlchemy for e-commerce orders"
+```
+
+---
+
+### 5. DevOps Engineer
+**`ring-dev-team:devops-engineer`**
+
+**Specializations:**
+- CI/CD pipelines (GitHub Actions, GitLab CI)
+- Containerization (Docker, Docker Compose)
+- Kubernetes deployment & scaling
+- Infrastructure as Code (Terraform, Helm)
+- Cloud infrastructure setup
+
+**Use When:**
+- Setting up deployment pipelines
+- Containerizing applications
+- Managing Kubernetes clusters
+- Infrastructure provisioning
+- Automating infrastructure changes
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:devops-engineer"
+  model: "opus"
+  prompt: "Create a GitHub Actions CI/CD pipeline for Go service deployment to Kubernetes"
+```
+
+---
+
+### 6. Frontend Engineer
+**`ring-dev-team:frontend-engineer`**
+
+**Specializations:**
+- React/Next.js application architecture
+- TypeScript for type safety
+- State management (Redux, Zustand, Context)
+- Component design patterns
+- Form handling and validation
+- CSS-in-JS and styling solutions
+
+**Use When:**
+- Building React/Next.js applications
+- Implementing complex UI components
+- State management design
+- Performance optimization for frontend
+- Accessibility improvements
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:frontend-engineer"
+  model: "opus"
+  prompt: "Design a React dashboard with real-time data updates and TypeScript"
+```
+
+---
+
+### 7. Frontend Engineer (TypeScript)
+**`ring-dev-team:frontend-engineer-typescript`**
+
+**Specializations:**
+- TypeScript-first React/Next.js architecture
+- Advanced TypeScript patterns (generics, utilities, branded types)
+- Type-safe state management (Zustand, Redux Toolkit)
+- Type-safe API integration (tRPC, React Query)
+- Component library with strict TypeScript
+- Server Components with TypeScript (Next.js App Router)
+- Type-safe routing & form validation
+
+**Use When:**
+- Building TypeScript-first frontend projects
+- Requiring advanced type safety (e.g., branded types, strict inference)
+- Type-safe full-stack integration (tRPC)
+- Migrating JavaScript frontend to TypeScript
+- Complex TypeScript patterns (conditional types, mapped types)
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:frontend-engineer-typescript"
+  model: "opus"
+  prompt: "Design a type-safe React dashboard with tRPC, Zod validation, and branded types"
+```
+
+---
+
+### 8. Frontend Designer
+**`ring-dev-team:frontend-designer`**
+
+**Specializations:**
+- Distinctive, production-grade UI with high visual design quality
+- Bold typography with characterful, non-generic fonts
+- Cohesive color systems with dominant colors and sharp accents
+- High-impact animations and micro-interactions
+- Unexpected layouts with asymmetry, overlap, and spatial tension
+- Atmosphere through textures, gradients, shadows, and visual depth
+
+**Use When:**
+- Building interfaces where aesthetics matter (landing pages, portfolios, marketing)
+- Creating memorable, visually striking user experiences
+- Designing dashboards with distinctive visual identity
+- Implementing creative motion and interaction design
+- Establishing distinctive visual languages and design systems
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:frontend-designer"
+  model: "opus"
+  prompt: "Create a brutalist landing page for a tech startup with bold typography and unexpected layouts"
+```
+
+**Note:** Use frontend-designer for visual aesthetics and design excellence. Use frontend-engineer for complex state management, business logic, and application architecture.
+
+---
+
+### 9. QA Analyst
+**`ring-dev-team:qa-analyst`**
+
+**Specializations:**
+- Test strategy & planning
+- E2E test automation (Cypress, Playwright)
+- Unit test coverage analysis
+- API testing strategies
+- Performance testing
+- Compliance validation
+
+**Use When:**
+- Planning testing strategy for features
+- Setting up E2E test suites
+- Improving test coverage
+- API testing and validation
+- Quality gate design
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:qa-analyst"
+  model: "opus"
+  prompt: "Create a comprehensive E2E test strategy for user authentication flow"
+```
+
+---
+
+### 10. Site Reliability Engineer (SRE)
+**`ring-dev-team:sre`**
+
+**Specializations:**
+- Observability (monitoring, logging, tracing)
+- Alerting strategies & SLOs
+- Incident response automation
+- Performance optimization
+- Scalability analysis
+- System reliability patterns
+
+**Use When:**
+- Designing monitoring/observability systems
+- Setting up alerts and SLOs
+- Incident response planning
+- Performance bottleneck analysis
+- Reliability engineering
+
+**Example dispatch:**
+```
+Task tool:
+  subagent_type: "ring-dev-team:sre"
+  model: "opus"
+  prompt: "Design monitoring and alerting for a Go microservice with 99.9% SLO"
+```
+
+---
+
+## Decision Matrix: Which Specialist?
+
+| Need | Specialist | Use Case |
+|------|-----------|----------|
+| Backend (language-agnostic, multi-language) | Backend Engineer | Architecture without language commitment |
+| Go API, database, concurrency | Backend Engineer (Go) | Go-specific service architecture |
+| TypeScript/Node.js backend, NestJS, Express | Backend Engineer (TypeScript) | TypeScript backend services |
+| Python backend, FastAPI, Django, data | Backend Engineer (Python) | Python-specific backend services |
+| CI/CD, Docker, Kubernetes, IaC | DevOps Engineer | Deployment pipelines, infrastructure |
+| React, TypeScript, components, state | Frontend Engineer | General UI development, performance |
+| Advanced TypeScript, type-safe frontend, tRPC | Frontend Engineer (TypeScript) | Type-safe React/Next.js projects |
+| Visual design, typography, motion, aesthetics | Frontend Designer | Distinctive UI, design systems |
+| Test strategy, E2E, coverage | QA Analyst | Testing architecture, automation |
+| Monitoring, SLOs, performance, reliability | SRE | Observability, incident response |
+
+---
+
+## Choosing Between Generalist and Specialist Agents
+
+### Backend Engineers
+
+**Use `backend-engineer` (language-agnostic) when:**
+- Language hasn't been decided yet
+- Comparing multiple language options
+- Multi-language system architecture
+- You want recommendations on language choice
+
+**Use language-specific engineers when:**
+- Language is already decided
+- You need framework-specific guidance (NestJS, FastAPI, etc.)
+- Performance optimization for specific runtime
+- Language-specific patterns and idioms
+
+**Example decision:**
+- "Should I use Go or TypeScript?" → **backend-engineer** (agnostic)
+- "How do I optimize this Go service?" → **backend-engineer-golang**
+- "Design a FastAPI endpoint" → **backend-engineer-python**
+
+### Frontend Engineers
+
+**Use `frontend-engineer` (general) when:**
+- Standard React/Next.js projects
+- TypeScript is used but not central concern
+- Focus on component design, state, architecture
+- General frontend best practices
+
+**Use `frontend-engineer-typescript` when:**
+- TypeScript is central to project success
+- Need advanced type patterns (branded types, generics)
+- Type-safe API integration (tRPC, Zod)
+- Migrating JavaScript to TypeScript
+- Strict type safety requirements
+
+**Example decision:**
+- "Build a React dashboard" → **frontend-engineer**
+- "Build type-safe full-stack with tRPC" → **frontend-engineer-typescript**
+
+---
+
+## When to Use Developer Specialists vs General Review
+
+### Use Developer Specialists for:
+- ✅ **Deep technical expertise needed** – Architecture decisions, complex implementations
+- ✅ **Technology-specific guidance** – "How do I optimize this Go service?"
+- ✅ **Specialized domains** – Infrastructure, SRE, testing strategy
+- ✅ **Building from scratch** – New service, new pipeline, new testing framework
+
+### Use General Review Agents for:
+- ✅ **Code quality assessment** – Architecture, patterns, maintainability
+- ✅ **Correctness & edge cases** – Business logic verification
+- ✅ **Security review** – OWASP, auth, validation
+- ✅ **Post-implementation** – Before merging existing code
+
+**Both can be used together:** Get developer specialist guidance during design, then run general reviewers before merge.
+
+---
+
+## Dispatching Multiple Specialists
+
+If you need multiple specialists (e.g., backend engineer + DevOps engineer), dispatch in **parallel** (single message, multiple Task calls):
+
+```
+✅ CORRECT:
+Task #1: ring-dev-team:backend-engineer-golang
+Task #2: ring-dev-team:devops-engineer
+(Both run in parallel)
+
+❌ WRONG:
+Task #1: ring-dev-team:backend-engineer-golang
+(Wait for response)
+Task #2: ring-dev-team:devops-engineer
+(Sequential = 2x slower)
+```
+
+---
+
+## ORCHESTRATOR Principle
+
+Remember:
+- **You're the orchestrator** – Dispatch specialists, don't implement directly
+- **Don't read specialist docs yourself** – Dispatch to specialist, they know their domain
+- **Combine with using-ring principle** – Skills + Specialists = complete workflow
+
+### Good Example (ORCHESTRATOR):
+> "I need a Go service. Let me dispatch backend-engineer-golang to design it."
+
+### Bad Example (OPERATOR):
+> "I'll manually read Go best practices and design the service myself."
+
+---
+
+## Available in This Plugin
+
+**Agents:**
+- backend-engineer (language-agnostic)
+- backend-engineer-golang
+- backend-engineer-typescript
+- backend-engineer-python
+- devops-engineer
+- frontend-engineer
+- frontend-engineer-typescript
+- frontend-designer
+- qa-analyst
+- sre
+
+**Skills:**
+- using-dev-team: Plugin introduction and agent selection guide
+- writing-code: Developer agent selection and invocation patterns
+
+**Note:** If a skill documents a developer agent but you can't find it, you may not have ring-dev-team enabled. Check `.claude-plugin/marketplace.json` or install ring-dev-team plugin.
+
+---
+
+## Integration with Other Plugins
+
+- **using-ring** (default) – ORCHESTRATOR principle for ALL agents
+- **using-finops-team** – Financial/regulatory agents
+- **using-pm-team** – Pre-dev workflow agents
+
+Dispatch based on your need:
+- General code review → default plugin agents
+- Specific domain expertise → ring-dev-team agents
+- Regulatory compliance → ring-finops-team agents
+- Feature planning → ring-pm-team agents
--- a/skills/writing-code/SKILL.md
+++ b/skills/writing-code/SKILL.md
@@ -0,0 +1,398 @@
+---
+name: writing-code
+description: |
+  Developer agent selection matrix - helps identify the best developer specialist
+  based on technology stack, domain, and requirements.
+
+trigger: |
+  - Starting implementation work
+  - Need to choose between multiple developer agents
+  - Technology stack determines agent choice
+
+skip_when: |
+  - Already know which agent to use → dispatch directly
+  - Not implementation work → use other skills
+---
+
+# Writing Code - Developer Agent Selection
+
+## Purpose
+
+This skill helps you identify and dispatch the most appropriate developer agent from the ring-dev-team plugin based on the task requirements.
+
+## Available Developer Agents
+
+| Agent | Specialization | Best For |
+|-------|----------------|----------|
+| `ring-dev-team:backend-engineer` | Language-agnostic backend (adapts to any language) | Unknown stack, polyglot systems, API design across languages |
+| `ring-dev-team:backend-engineer-golang` | Go, APIs, microservices, databases, message queues | Go backend services, REST/gRPC APIs, database design, multi-tenancy |
+| `ring-dev-team:backend-engineer-typescript` | TypeScript/Node.js, Express, Fastify, Prisma | Node.js backend, TypeScript APIs, full-stack TypeScript projects |
+| `ring-dev-team:backend-engineer-python` | Python, FastAPI, Django, SQLAlchemy, Celery | Python backend, ML services, data pipelines, FastAPI/Django APIs |
+| `ring-dev-team:frontend-engineer` | React, Next.js, TypeScript, state management | UI components, dashboards, forms, client-side logic |
+| `ring-dev-team:frontend-engineer-typescript` | TypeScript-first React/Next.js, type-safe state | Type-heavy frontends, complex state, full-stack TypeScript |
+| `ring-dev-team:frontend-designer` | Visual design, typography, UI aesthetics | Landing pages, marketing sites, design systems, distinctive interfaces |
+| `ring-dev-team:devops-engineer` | CI/CD, Docker, Kubernetes, Terraform, IaC | Pipelines, containerization, infrastructure, deployment |
+| `ring-dev-team:qa-analyst` | Test strategy, E2E, performance testing | Test plans, automation frameworks, quality gates |
+| `ring-dev-team:sre` | Monitoring, observability, reliability | Alerting, SLOs, incident response, performance |
+
+## Decision Matrix
+
+### By Technology Stack
+
+```
+Backend work?
+├── Go/Golang code?
+│   └── Yes → backend-engineer-golang
+├── TypeScript/Node.js backend?
+│   └── Yes → backend-engineer-typescript
+├── Python backend (FastAPI/Django)?
+│   └── Yes → backend-engineer-python
+├── Unknown/multiple languages?
+│   └── Yes → backend-engineer (language-agnostic)
+└── Frontend work?
+    ├── React/Next.js?
+    │   ├── TypeScript-heavy with complex state?
+    │   │   └── Yes → frontend-engineer-typescript
+    │   ├── Visual design/UI aesthetics focus?
+    │   │   └── Yes → frontend-designer
+    │   └── Component logic/functionality focus?
+    │       └── Yes → frontend-engineer
+    ├── Infrastructure/CI-CD/Docker?
+    │   └── Yes → devops-engineer
+    ├── Testing/QA/Automation?
+    │   └── Yes → qa-analyst
+    └── Monitoring/Reliability/Performance?
+        └── Yes → sre
+```
+
+### By Task Type
+
+| Task | Primary Agent | Supporting Agent |
+|------|---------------|------------------|
+| Build REST API (Go) | backend-engineer-golang | qa-analyst (tests) |
+| Build REST API (TypeScript) | backend-engineer-typescript | qa-analyst (tests) |
+| Build REST API (Python) | backend-engineer-python | qa-analyst (tests) |
+| Build REST API (unknown language) | backend-engineer | qa-analyst (tests) |
+| Create UI component | frontend-engineer | qa-analyst (E2E) |
+| Create type-safe UI component | frontend-engineer-typescript | qa-analyst (E2E) |
+| Design landing page | frontend-designer | frontend-engineer (implementation) |
+| Full-stack TypeScript feature | backend-engineer-typescript | frontend-engineer-typescript |
+| Set up CI/CD | devops-engineer | sre (monitoring) |
+| Write test suite | qa-analyst | - |
+| Add monitoring | sre | devops-engineer (infra) |
+| Database schema (Go) | backend-engineer-golang | - |
+| Database schema (TypeScript) | backend-engineer-typescript | - |
+| Database schema (Python) | backend-engineer-python | - |
+| Deploy to K8s | devops-engineer | sre (observability) |
+| Performance optimization | sre | backend-engineer-* |
+
+## Agent Dispatch Pattern
+
+### Single Agent Task
+
+```
+Task tool:
+  subagent_type: "ring-dev-team:backend-engineer-golang"
+  prompt: "Design and implement a REST API for user authentication with JWT tokens"
+```
+
+### Multi-Agent Workflow
+
+For complex features requiring multiple specialists:
+
+```
+Step 1: Backend API
+  Task tool → ring-dev-team:backend-engineer-golang
+  "Implement the user service with CRUD operations"
+
+Step 2: Frontend Integration
+  Task tool → ring-dev-team:frontend-engineer
+  "Create React components to consume the user API"
+
+Step 3: Testing
+  Task tool → ring-dev-team:qa-analyst
+  "Write E2E tests for the user registration flow"
+
+Step 4: Deployment
+  Task tool → ring-dev-team:devops-engineer
+  "Create Kubernetes manifests and CI/CD pipeline"
+
+Step 5: Observability
+  Task tool → ring-dev-team:sre
+  "Add monitoring, alerting, and SLO definitions"
+```
+
+## Agent Capabilities Detail
+
+### backend-engineer
+
+**Technologies:**
+- Language-agnostic (adapts to Go, TypeScript, Python, Java, Rust, etc.)
+- RESTful API design principles
+- Database design (SQL and NoSQL)
+- Message queues and event streaming
+- Authentication and authorization patterns
+
+**Patterns:**
+- Clean Architecture / Hexagonal
+- Repository pattern
+- Dependency injection
+- SOLID principles
+- API design best practices
+
+**Best practices:**
+- Language-appropriate error handling
+- Security best practices (OWASP)
+- Scalability and performance
+- Testing strategies
+- Documentation standards
+
+**When to use:**
+- Codebase uses unknown or multiple languages
+- Need language-agnostic architecture advice
+- Polyglot systems requiring consistency
+- Initial API design before language selection
+
+### backend-engineer-golang
+
+**Technologies:**
+- Go (Fiber, Gin, Echo frameworks)
+- PostgreSQL, MongoDB, Redis
+- RabbitMQ, Kafka
+- gRPC, REST
+- OAuth2, JWT, WorkOS
+
+**Patterns:**
+- Clean Architecture / Hexagonal
+- Repository pattern
+- Dependency injection
+- Multi-tenancy (schema-per-tenant, row-level)
+
+**Best practices:**
+- Error handling (no panic in production)
+- Context propagation
+- Graceful shutdown
+- Connection pooling
+
+### backend-engineer-typescript
+
+**Technologies:**
+- TypeScript, Node.js
+- Express, Fastify, NestJS
+- Prisma, TypeORM, Sequelize
+- PostgreSQL, MongoDB, Redis
+- Bull, BullMQ (job queues)
+- JWT, Passport.js, OAuth2
+
+**Patterns:**
+- Layered architecture
+- Dependency injection (NestJS, tsyringe)
+- Repository pattern
+- DTO validation (class-validator, Zod)
+- Middleware patterns
+
+**Best practices:**
+- Strict TypeScript configuration
+- Async/await error handling
+- Type-safe database queries
+- Request validation
+- Graceful shutdown
+- Logging and observability
+
+### backend-engineer-python
+
+**Technologies:**
+- Python 3.10+
+- FastAPI, Django, Flask
+- SQLAlchemy, Django ORM
+- PostgreSQL, MongoDB, Redis
+- Celery, RQ (task queues)
+- Pydantic (validation)
+- pytest, unittest
+
+**Patterns:**
+- MVC / MVT (Django)
+- Dependency injection (FastAPI)
+- Repository pattern
+- Service layer pattern
+- Type hints and validation
+
+**Best practices:**
+- Type hints everywhere
+- Exception handling
+- Virtual environments
+- Async/await (asyncio)
+- Database migrations (Alembic)
+- API documentation (OpenAPI)
+
+### frontend-engineer
+
+**Technologies:**
+- React 18+, Next.js 14+
+- TypeScript
+- Tailwind CSS, Styled Components
+- React Query, Zustand, Redux
+- Jest, React Testing Library, Playwright
+
+**Patterns:**
+- Component composition
+- Custom hooks
+- Server components (Next.js)
+- Optimistic updates
+
+**Best practices:**
+- Accessibility (WCAG 2.1)
+- Performance (Core Web Vitals)
+- Type safety
+- Error boundaries
+
+### frontend-engineer-typescript
+
+**Technologies:**
+- TypeScript (strict mode)
+- React 18+, Next.js 14+
+- Zod, io-ts (runtime validation)
+- tRPC (end-to-end type safety)
+- TanStack Query (React Query)
+- Zustand, Jotai (type-safe state)
+- Vitest, Jest with type coverage
+
+**Patterns:**
+- Type-driven development
+- Generic components with type constraints
+- Discriminated unions for state
+- Type-safe API clients
+- Schema-driven forms
+
+**Best practices:**
+- No `any` types (strict mode)
+- Type guards and narrowing
+- Exhaustive switch statements
+- Runtime validation at boundaries
+- Type-safe routing
+- Inference over explicit types
+
+### frontend-designer
+
+**Technologies:**
+- Figma, Sketch design systems
+- Tailwind CSS, CSS-in-JS
+- Typography systems (Google Fonts, custom fonts)
+- Animation libraries (Framer Motion, GSAP)
+- Color theory and accessibility tools
+
+**Patterns:**
+- Visual hierarchy
+- Responsive design principles
+- Design tokens
+- Component variants
+
+**Best practices:**
+- Accessible color contrast (WCAG AA/AAA)
+- Responsive typography scales
+- Consistent spacing systems
+- Performance-optimized assets
+- Brand consistency
+
+### devops-engineer
+
+**Technologies:**
+- Docker, Docker Compose
+- Kubernetes, Helm
+- Terraform, Pulumi
+- GitHub Actions, GitLab CI
+- AWS, GCP, Azure
+
+**Patterns:**
+- GitOps
+- Infrastructure as Code
+- Blue-green / Canary deployments
+- Secret management
+
+**Best practices:**
+- Immutable infrastructure
+- Least privilege
+- Automated rollbacks
+- Cost optimization
+
+### qa-analyst
+
+**Technologies:**
+- Jest, Vitest, Go testing
+- Playwright, Cypress
+- k6, Artillery (load testing)
+- Postman, Newman
+
+**Patterns:**
+- Test pyramid
+- Page Object Model
+- Data-driven testing
+- Contract testing
+
+**Best practices:**
+- Shift-left testing
+- Test isolation
+- Deterministic tests
+- CI integration
+
+### sre
+
+**Technologies:**
+- Prometheus, Grafana
+- Datadog, New Relic
+- PagerDuty, OpsGenie
+- Jaeger, OpenTelemetry
+
+**Patterns:**
+- SLI/SLO/SLA definitions
+- Error budgets
+- Incident management
+- Chaos engineering
+
+**Best practices:**
+- Alerting hygiene
+- Runbooks
+- Post-mortems
+- Capacity planning
+
+## When NOT to Use Developer Agents
+
+- **Code review** → Use `ring-default:code-reviewer` (parallel with business-logic and security)
+- **Planning/Design** → Use `ring-default:brainstorming` or `ring-default:write-plan`
+- **Debugging** → Use `ring-default:systematic-debugging` skill
+- **Architecture exploration** → Use `ring-default:codebase-explorer`
+
+## Integration with Ring Workflows
+
+### With TDD (test-driven-development)
+
+```
+1. Use qa-analyst to design test cases
+2. Use appropriate developer agent to implement
+3. Use qa-analyst to verify test coverage
+```
+
+### With Code Review (requesting-code-review)
+
+```
+1. Use developer agent to implement
+2. Use ring-default reviewers (parallel) to review
+3. Use developer agent to address findings
+```
+
+### With Pre-Dev Planning
+
+```
+1. Use pm-team skills for planning (PRD, TRD)
+2. Use ring-default:write-plan for implementation plan
+3. Use this skill to identify developer agents for each task
+4. Dispatch agents per task with code review between
+```
+
+## Remember
+
+1. **Match agent to task** - Don't use backend agent for frontend work
+2. **Combine agents for full-stack** - Complex features need multiple specialists
+3. **Always review** - Use code reviewers after implementation
+4. **Follow skill workflows** - TDD, systematic debugging, verification
+5. **Document decisions** - Agents can explain their choices