dev-suite

Plugin dev-suite from marketplace scientific-computing-workflows in imewei/MyClaude. Commands read from the repo's manifest — 26 days ago.

Skills (45)

• airflow-scientific-workflows

  Design Apache Airflow DAGs for scientific data pipelines, batch computations, distributed simulations, and time-series data ingestion with PostgreSQL/TimescaleDB integration. Use when orchestrating experimental workflows or coordinating scientific computations.

• api-design-principles

  Master REST and GraphQL API design including resource-oriented architecture, HTTP semantics, pagination (cursor/offset), versioning strategies, error handling, HATEOAS, DataLoader patterns, and documentation. Use when designing new APIs, implementing pagination, handling errors, or establishing API

• architecture-and-infra

  Meta-orchestrator for software architecture and infrastructure. Routes to clean architecture, microservices, monorepo, systems/CLI, containers, and cloud patterns. Use when designing system architecture, implementing microservices, managing monorepos, building CLI tools, containerizing services, or

• architecture-patterns

  Master Clean Architecture, Hexagonal Architecture, and DDD patterns including entities, value objects, aggregates, repositories, and domain events. Use when designing scalable backends, refactoring monoliths, or implementing domain-driven design.

• auth-implementation-patterns

  Master authentication patterns including JWT (access/refresh tokens), OAuth2/OpenID Connect, session-based auth, RBAC/ABAC, API keys, MFA, SSO, password hashing (bcrypt/argon2), secure cookies, and CSRF protection. Use when implementing auth systems, securing APIs, or designing access control.

• backend-patterns

  Meta-orchestrator for backend development patterns. Routes to Node.js, async Python, API design, GraphQL, WebSocket, and message queue skills. Use when building REST APIs, Node.js services, async Python backends, GraphQL endpoints, WebSocket connections, or message queue integrations.

• caching-patterns

  Design caching strategies with Redis, Memcached, and CDN layers including cache invalidation, write-through/write-behind, distributed caching, and cache stampede prevention. Use when implementing caching layers, Redis data structures, or optimizing response times.

• ci-cd-pipelines

  Meta-orchestrator for CI/CD pipeline design. Routes to GitHub Actions, GitLab CI, pipeline design, security scanning, and error resolution skills. Use when setting up GitHub Actions, GitLab CI, designing deployment pipelines, adding security scanning, or resolving CI/CD errors. For Julia package CI

• cloud-provider-patterns

  Design cloud-native architectures across AWS, GCP, and Azure including serverless (Lambda/Cloud Functions), managed services, IaC (Terraform/Pulumi), cost optimization, and multi-cloud strategies. Use when provisioning cloud resources, designing serverless functions, or writing Terraform/Pulumi conf

• code-review

  Systematic process for code review focused on security, performance, maintainability, and knowledge sharing. Use when reviewing pull requests, auditing code quality, or enforcing coding standards. Also use when checking for security vulnerabilities, evaluating test coverage, assessing error handling

• comprehensive-validation

  Reference patterns for multi-dimensional validation including OWASP Top 10 scanning, test coverage targets (>80%), WCAG 2.1 AA checks, and deployment readiness criteria. Provides domain knowledge for the /double-check command. Use when validating before deployment, running security scans, checking t

• config-gc

  Garbage collection for your Claude Code configuration. Periodically scans ~/.claude (skills, memory, hooks, permissions, MCP servers, caches) for redundant, stale, orphaned, or low-value items, then walks the user through a confirm-each-deletion cleanup. Use when the user says "clean up my config",

• containerization-patterns

  Build and optimize Docker containers and Kubernetes deployments including multi-stage builds, image security, pod design, Helm charts, and container orchestration. Use when writing Dockerfiles, creating K8s manifests, optimizing image size, or designing container architectures.

• data-and-security

  Meta-orchestrator for data layer and security patterns. Routes to database, SQL, caching, search, authentication, and secrets management skills. Use when designing database schemas, optimizing SQL queries, implementing caching, building search, adding authentication, or managing secrets.

• database-patterns

  Master database design patterns including ORM usage (SQLAlchemy, Prisma, TypeORM), schema migrations (Alembic, Flyway), query optimization, connection pooling, and data modeling. Use when designing database schemas, writing migrations, optimizing queries, or integrating ORMs.

• debugging-toolkit

  Scientific computing debugging patterns — JAX TracerBoolConversionError/ConcretizationTypeError, Julia @code_warntype type-stability, NaN/inf hunting, numerical reproducibility isolation, and memory profiling for JAX/Julia. For the structured pre-fix debugging workflow, use superpowers:systematic-de

• deployment-pipeline-design

  Design multi-stage CI/CD pipelines with approval gates, security checks, and progressive delivery (rolling, blue-green, canary, feature flags). Use when architecting deployment workflows, implementing GitOps, or establishing multi-environment promotion strategies.

• dev-hub

  Top-level router for software development lifecycle topics, with a dedicated track for scientific-computing code quality. Use for: FastAPI/asyncio backend services; full-stack web/mobile app development; system architecture (microservices/containers/cloud/CLI tools/Terraform/K8s); test automation/TD

• dev-workflows

  Meta-orchestrator for development workflows and tooling. Routes to Git workflow, documentation standards, data pipeline orchestration (Airflow), and systematic debugging skills. Use when managing Git branches and commits, maintaining documentation workflow standards, orchestrating data pipelines wit

• distributed-tracing

  Implement distributed tracing with OpenTelemetry, Jaeger, and Tempo including instrumentation, context propagation, sampling strategies, and trace analysis. Use when debugging latency issues, understanding service dependencies, or tracing error propagation across microservices.

• documentation-standards

  Reference standards and templates for technical documentation including API spec formats, README structure, and runbook conventions. Provides domain knowledge for the /docs command. Use when writing API documentation, creating runbooks, structuring READMEs, or reviewing documentation quality.

• e2e-testing-patterns

  Build reliable E2E tests with Playwright and Cypress for web testing, browser automation, and CI/CD integration. Use when writing E2E tests, implementing Page Object Model, mocking APIs, visual regression, or accessibility testing.

• error-handling-patterns

  Master error handling patterns including exception hierarchies, Result types, retry with exponential backoff, circuit breakers, graceful degradation, error aggregation, and structured error responses. Use when implementing fault-tolerant systems, designing API error responses, or building resilient

• git-workflow

  Master advanced Git workflows for collaborative development. Covers interactive rebasing, cherry-picking, bisecting for bug discovery, and managing pull requests. Use when resolving merge conflicts, setting up branching strategies, or managing complex Git history.

• github-actions-templates

  Create production GitHub Actions workflows for testing, building, and deploying. Use when setting up CI pipelines, Docker builds, Kubernetes deployments, matrix builds, security scans, or reusable workflows.

• gitlab-ci-patterns

  Build GitLab CI/CD pipelines with multi-stage workflows, caching, Docker builds, Kubernetes deployments, and security scanning. Use when creating .gitlab-ci.yml pipelines, setting up runners, implementing Terraform/IaC, or configuring GitOps workflows.

• grafana-dashboards

  Create production Grafana dashboards with panels, variables, alerts, and templates using RED/USE methods. Use when building API monitoring, infrastructure, database, or SLO dashboards with Prometheus data sources.

• iterative-error-resolution

  Reference patterns for CI/CD error classification, fix strategies, and resolution loops. Provides domain knowledge for the /fix-commit-errors command. Use when analyzing GitHub Actions failures, dependency conflicts, or build/test error patterns.

• message-queue-patterns

  Implement message queue architectures with Kafka, RabbitMQ, and SQS including event-driven design, message ordering, dead letter queues, consumer groups, and exactly-once processing. Use when designing async communication, event sourcing, or pub/sub systems.

• microservices-patterns

  Design microservices with proper service boundaries, event-driven communication (Kafka/RabbitMQ), resilience patterns (circuit breakers, retries, bulkheads), Saga pattern for distributed transactions, API Gateway, service discovery, database-per-service, CQRS, and distributed tracing. Use when decom

• modernization-migration

  Reference patterns for modernization strategies including Strangler Fig, framework migration playbooks, and database schema evolution. Provides domain knowledge for the /modernize command. Use when planning migration approaches, evaluating modernization trade-offs, or implementing Strangler Fig patt

• monorepo-management

  Master monorepo management with Turborepo, Nx, and pnpm workspaces. Use when setting up turbo.json or nx.json, organizing apps/* and packages/* directories, optimizing builds with caching, managing workspace dependencies, implementing shared configs, setting up CI/CD for monorepos, or publishing pac

• observability-and-sre

  Meta-orchestrator for observability and SRE practices. Routes to Prometheus, Grafana, distributed tracing, SLO implementation, and observability skills. Use when configuring Prometheus, building Grafana dashboards, implementing distributed tracing, defining SLOs, or setting up monitoring.

• observability-sre-practices

  Production observability, monitoring, SRE with OpenTelemetry, Prometheus, Grafana, incident management. Use for tracing/metrics/logs, SLOs/SLIs, alerts with AlertManager, Golden Signals, incident response, post-mortems, error budgets. Use when setting up monitoring, implementing tracing, configuring

• prometheus-configuration

  Configure Prometheus for metric collection, alerting, and monitoring with scrape configs, recording rules, alert rules, and service discovery. Use when setting up Prometheus servers, creating alert rules, or implementing Kubernetes monitoring.

• search-patterns

  Implement search infrastructure with Elasticsearch, OpenSearch, and Typesense including full-text search, faceted navigation, autocomplete, relevance tuning, and index management. Use when building search features, configuring analyzers, or optimizing search relevance.

• secrets-management

  Implement secrets management with HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, or platform-native solutions with encryption, rotation, and access control. Use when storing API keys, database passwords, TLS certificates, or implementing secret rotation.

• security-ci-template

  Security scanning and lock file validation templates for CI/CD pipelines. Use when implementing SAST/DAST scanning, dependency vulnerability checks, lock file validation, or automated security gates in GitHub Actions or GitLab CI.

• slo-implementation

  Reference patterns for SLI/SLO definitions, error budget policies, and burn rate alerting following SRE best practices. Provides domain knowledge for the /slo-implement command. Use when establishing reliability targets or designing multi-window burn rate alerts.

• sql-optimization-patterns

  Master SQL optimization with EXPLAIN analysis, indexing strategies (B-Tree, GIN, partial, covering), N+1 elimination, pagination (cursor-based), aggregate optimization, materialized views, and partitioning. Use when debugging slow queries, designing schemas, or reducing database load.

• systems-cli-engineering

  Design high-performance systems and production-grade CLI tools. Covers memory management, concurrency, and CLI UX design. Use when building CLI applications, optimizing system-level code, or implementing concurrent data pipelines in C, C++, Rust, or Go.

• test-automation

  Expert guide for implementing automated testing across the pyramid (Unit, Integration, E2E). Masters Jest, Pytest, Playwright, and Cypress. Use when designing test strategies, setting up CI quality gates, or building automated test suites.

• testing-and-quality

  Meta-orchestrator for testing and code quality. Routes to test automation, testing patterns, E2E, validation, code review, and plugin validation skills. Use when writing tests, setting up test automation, implementing E2E testing, analyzing test coverage, designing test pyramids, validating code qua

• testing-patterns

  Cross-language testing strategy guide covering framework selection, test pyramid design, CI/CD integration, and parallel execution for Python (pytest) and JavaScript/TypeScript (Jest/Vitest). Use when choosing testing frameworks, designing test architecture, or setting up test infrastructure across

• three-brain

  Route work between Claude, Codex, and Agy as live Herdr panes — either as a single one-shot second opinion, or as a persistent semi-automatic team that stays alive across a multi-round project. Use Route mode (default, one-shot) for second-opinion reviews of Claude's own work, high-risk code paths (

Slash commands (14)

• /dev-suite:code-review

  Code review — local uncommitted changes or GitHub PR (pass PR number/URL for PR mode). For a six-agent parallel PR review use /review-pr.

• /dev-suite:commit

  Intelligent git commit with automated analysis, quality validation, and atomic commit enforcement

• /dev-suite:docs

  Interactive workflow to generate, update, and sync project documentation (API specs, READMEs, Sphinx)

• /dev-suite:double-check

  Interactive validation workflow that runs automated testing, security scanning, and code review on specified work

• /dev-suite:eng-feature-dev

  Scientific feature development orchestrator. Coordinates science-suite and research-suite resources for numerical, ML, SciML, and simulation features. For general software features, use feature-dev:feature-dev with superpowers workflow skills.

• /dev-suite:fix-commit-errors

  Automatically analyzes GitHub Actions failures, identifies root causes, applies intelligent solutions, validates, and reruns workflows with adaptive learning.

• /dev-suite:git-branch

  Full branch lifecycle — finish a branch end-to-end (review, commit, push, merge direct or via PR/MR, sync, cleanup), sweep merged/stale branches, roll back to a prior revision, or manage worktrees

• /dev-suite:modernize

  Interactive workflow to migrate legacy code using Strangler Fig pattern with incremental assessment and component-by-component modernization

• /dev-suite:refactor-clean

  Analyze and refactor code to improve quality, maintainability, and SOLID principles

• /dev-suite:review-pr

  Parallel PR review by six specialized agents (comments, tests, errors, types, code, simplify). For a single-pass review use /code-review.

• /dev-suite:run-all-tests

  Iteratively run and fix all tests until zero failures with AI-driven RCA. To write new tests use /test-generate.

• /dev-suite:smart-debug

  Scientific computing debugger for NaN/inf propagation, JAX JIT trace failures, Julia dispatch ambiguities, shape mismatches, numerical instability. For general software bugs, use superpowers:systematic-debugging first.

• /dev-suite:test-generate

  Generate scientific test suites — numerical precision, property-based mathematical invariants, JAX vmap/jit correctness, Julia @inferred type-stability. For general TDD workflow, use superpowers:test-driven-development. Use --scientific flag for domain-specific tests.

• /dev-suite:workflow-automate

  Automated CI/CD workflow generation and management for GitHub Actions and GitLab CI.

Subagents (12)

• app-developer

  Use this agent when a user-facing app surface is being built or reworked, on web (React/Next.js) or mobile (Flutter, React Native, native Swift/Kotlin), covering screens and components, state management and data flow, performance, accessibility or bundle budgets, and offline or flaky-network behavio

• automation-engineer

  Use this agent when CI/CD, release, or git workflow automation is the work, such as authoring or debugging GitHub Actions or GitLab CI pipelines, branching and release strategy, slow build or test times, and progressive delivery such as canary or blue-green rollouts.

• code-reviewer

  Use this agent only as one of /review-pr's six fan-out passes (code-reviewer, comment-analyzer, pr-test-analyzer, silent-failure-hunter, type-design-analyzer, code-simplifier), never standalone — dev-suite's general-purpose review/audit agent is quality-specialist. Typical triggers include a PR diff

• code-simplifier

  Use this agent when simplifying code for clarity is the goal, either as one of /review-pr's six fan-out passes, via /refactor-clean, or standalone on recently modified code. Typical triggers include deeply nested logic that could use early returns, duplicated logic worth consolidating, and a direct

• comment-analyzer

  Use this agent only as one of /review-pr's six fan-out passes, never standalone, for comment accuracy and rot risk on a PR diff. Typical triggers include comments that no longer match refactored code, TODO/FIXME debt surfaced during /review-pr's aggregate pass, and comments that merely restate the c

• documentation-expert

  Use this agent when documentation structure or content is the deliverable, such as API reference, ADRs, tutorials and how-to guides, READMEs, changelogs and migration guides, or a docs-as-code pipeline.

• pr-test-analyzer

  Use this agent only as one of /review-pr's six fan-out passes, never standalone, for PR test coverage quality and completeness. Typical triggers include new code paths shipped without behavioral tests, assertions that only check "doesn't throw" instead of the real outcome, and coverage gaps needing

• quality-specialist

  Use this agent to review or audit existing code rather than author it, such as numerical-precision and JAX/JIT-safety audits, Julia type-stability review, reproducibility checks on scientific pipelines, security review, and test-strategy design. New JAX or Julia authoring goes to jax-pro or julia-pr

• silent-failure-hunter

  Use this agent only as one of /review-pr's six fan-out passes, never standalone, hunting for silent failures, swallowed errors, and bad fallbacks. Typical triggers include empty catch blocks, `.catch(() => [])`-style fallbacks that hide real failure, and error paths that drop context or stack traces

• software-architect

  Use this agent when system-level structure is at stake, before or instead of implementation code, such as service boundaries for a new or splitting system, REST vs GraphQL vs gRPC, cross-team technical standards, and AI/LLM integration design.

• sre-expert

  Use this agent when production reliability is the subject, such as instrumenting metrics, logs, or traces, defining SLOs and error budgets, running or writing up an incident and postmortem, and diagnosing latency or capacity problems under load.

• type-design-analyzer

  Use this agent only as one of /review-pr's six fan-out passes, never standalone, evaluating whether new or changed types make illegal states harder to represent. Typical triggers include a new domain type or interface added in the diff, an invariant checked at runtime instead of enforced by the type

Hooks (7)

• SessionStart

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/session_start.py"

• UserPromptSubmit

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/user_prompt_submit.py"

• PostToolUse

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_use.py"

• SubagentStop

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/subagent_stop.py"

• TaskCompleted

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/task_completed.py"

• SessionEnd

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/session_end.py"

• StopFailure

  python3 "${CLAUDE_PLUGIN_ROOT}/hooks/stop_failure.py"

Similar plugins