DevOps

Reusable patterns and templates for Claude Code skill and hook development.Triggers: validation patterns, error handling, testing templates, workflow patterns,shared patterns, reusable templates, DRY patterns, common workflowsUse when: creating new skills or hooks that need consistent patterns, implementingvalidation logic, setting up error handling, creating test scaffolding,referencing standard workflow structuresDO NOT use when: pattern is specific to one skill only.DO NOT use when: pattern is still evolving - wait for stability.DO NOT use when: pattern is context-dependent requiring variations.Reference these patterns to validate consistency across the ecosystem.

Shared infrastructure and patterns for spec-kit specification-driven development.Triggers: spec-kit patterns, tech-stack patterns, checklist dimensions,artifact structure, specification infrastructure, shared templatesUse when: developing new spec-kit skills, referencing standard patterns,ensuring consistency across specification workflowsDO NOT use directly: this skill is infrastructure for other spec-kit skills.Provides reusable patterns consumed by all spec-kit commands and skills.

Compose processing stages using a pipes-and-filters model for ETL, mediaprocessing, or compiler-like workloads.Triggers: pipeline architecture, pipes and filters, ETL, data transformation,stream processing, CI/CD pipeline, media processing, batch processingUse when: data flows through fixed sequence of transformations, stages can beindependently developed and tested, parallel processing of stages is beneficialDO NOT use when: selecting from multiple paradigms - use architecture-paradigms first.DO NOT use when: data flow isn't sequential or predictable.DO NOT use when: complex branching/merging logic dominates.Consult this skill when designing data pipelines or transformation workflows.

Serverless FaaS for event-driven workloads with minimal infrastructure management.Triggers: serverless, FaaS, Lambda, event-driven, pay-per-useUse when: workloads are event-driven with bursty trafficDO NOT use when: long-running processes or stateful operations required.

Guide to deciding whether to escalate from a lower model (haiku/sonnet) toa higher model (sonnet/opus).Triggers: model escalation, haiku to sonnet, sonnet to opus, reasoning depth,task complexity, model selection, capability trade-offUse when: evaluating whether to escalate models, facing genuine complexityrequiring deeper reasoning, novel patterns with no existing solutions,high-stakes decisions requiring capability investmentDO NOT use when: thrashing without investigation - investigate root cause first.DO NOT use when: time pressure alone - urgency doesn't change task complexity.DO NOT use when: "just to be safe" - assess actual complexity instead.NEVER escalate without investigation first. This is the Iron Law.

Python testing with pytest, fixtures, mocking, and TDD workflows.Triggers: pytest, unit tests, test fixtures, mocking, TDD, test suite, coverage,test-driven development, testing patterns, parameterized testsUse when: writing unit tests, setting up test suites, implementing TDD,configuring pytest, creating fixtures, async testingDO NOT use when: evaluating test quality - use pensive:test-review instead.DO NOT use when: infrastructure test config - use leyline:pytest-config.Consult this skill for Python testing implementation and patterns.

Coarse-grained service architecture for deployment independence without microservices complexity.Triggers: service-based, SOA, coarse-grained services, domain servicesUse when: teams need deployment independence without microservices complexityDO NOT use when: fine-grained scaling needed - use microservices.

Employ the Hexagonal (Ports & Adapters) pattern to decouple domain logic frominfrastructure, maximizing flexibility and testability.Triggers: hexagonal architecture, ports and adapters, infrastructure independence,dependency inversion, clean architecture, domain isolation, adapter pattern,infrastructure abstraction, database independence, framework independenceUse when: designing systems with strong business logic separation, anticipatinginfrastructure changes, needing easy mocking for tests, building portable domain codeDO NOT use when: selecting from multiple paradigms - use architecture-paradigms first.DO NOT use when: building simple CRUD apps without complex domain logic.Consult this skill when implementing hexagonal patterns or migrating to port-based design.

Design skills as modular building blocks for predictable token usage.Triggers: skill design, skill architecture, modularization, token optimization,skill structure, refactoring skills, new skill creation, skill complexityUse when: creating new skills that will be >150 lines, breaking down complexmonolithic skills, planning skill architecture, refactoring overlapping skills,reviewing skill maintainability, designing skill module structureDO NOT use when: evaluating existing skill quality - use skills-eval instead.DO NOT use when: writing prose for humans - use writing-clearly-and-concisely.DO NOT use when: need improvement recommendations - use skills-eval.Use this skill BEFORE creating any new skill. Check even if unsure.

Shared infrastructure and reusable modules for all pensive review skills.Triggers: pensive patterns, review workflow, output templates, quality checklists,pensive infrastructure, shared review patternsUse when: other pensive skills need common patterns, creating new review skills,ensuring consistency across pensive pluginDO NOT use directly: this skill is infrastructure for other pensive skills.This skill provides shared patterns consumed by other pensive skills.

CI/CD and operations practices including GitHub Actions, Kubernetes, and operational tooling. Use when working with deployment and infrastructure.

Single deployable with enforced module boundaries for team autonomy without distributed complexity.Triggers: modular monolith, module boundaries, single deployment, team autonomyUse when: teams need autonomy without distributed overheadDO NOT use when: already using microservices or system is small.

CQRS and Event Sourcing for auditability, read/write separation, and temporal queries.Triggers: CQRS, event sourcing, audit trail, temporal queriesUse when: read/write scaling differs or audit trail requiredDO NOT use when: simple CRUD - use architecture-paradigms first.

Data-grid architecture for high-traffic stateful workloads with linear scalability.Triggers: space-based, data grid, in-memory, linear scaling, high trafficUse when: traffic overwhelms database nodes or linear scalability neededDO NOT use when: data doesn't fit in memory or simpler caching would work.

Qwen CLI delegation workflow implementing delegation-core for Alibaba's Qwen models.Triggers: qwen cli, qwen delegation, alibaba qwen, qwen batch, multi-file analysis,qwen summarization, qwen extraction, 100K contextUse when: delegation-core selected Qwen, need Qwen's large context capabilities,batch processing or multi-file analysis requiredDO NOT use when: deciding which model to use - use delegation-core first.DO NOT use when: qwen CLI not installed or configured.Consult this skill when implementing Qwen-specific delegation workflows.

detailed development workflow with modular patterns for git, code review, testing, documentation, and deployment

Declarative release readiness checklist that mirrors GitHub checks,deployment issues, and documentation requirements.Triggers: release gates, release readiness, deployment checklist, release review,quality signals, rollout scorecard, QA handshake, deployment gatesUse when: preparing releases, validating deployment gates, conducting releasereviews, embedding release gate snippets in PRsDO NOT use when: weekly status updates - use github-initiative-pulse.DO NOT use when: code reviews - use pensive review skills.Standardizes release approvals with GitHub-aware checklists.

Retrospective workflow evaluation and improvement of skills, agents, commands, and hooks.Triggers: workflow improvement, retrospective, workflow efficiencyUse when: workflow felt slow, confusing, or needs optimizationDO NOT use when: implementing features - focus on feature work first.

Model system responsibilities across clients, servers, and optional peer-to-peernodes for traditional distributed applications.Triggers: client-server, web architecture, mobile backend, API design, thin client,thick client, peer-to-peer, P2P, offline-first, synchronizationUse when: traditional web/mobile applications with centralized services,clear separation between client and server responsibilities neededDO NOT use when: selecting from multiple paradigms - use architecture-paradigms first.DO NOT use when: peer-to-peer dominates - consider dedicated P2P patterns.Consult this skill when designing client-server systems or API architectures.

Configure GitHub Actions workflows for CI/CD (test, lint, typecheck, publish)