Skip to main content
skill CX Codex

gear — Claude Code skill: what it does, how to install

gear configures GitHub Actions CI/CD, Docker containers, dependencies, and secrets. It fixes broken builds and secures software supply chains.

MIT 164 installs ★ 102 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add simota/agent-skills --skill gear -a claude-code
Open on GitHub

What gear does

Gear operates as an infrastructure mechanic for local projects and pipelines. It handles GitHub Actions workflow architecture, OIDC configuration, matrix testing, and build cache tuning. For containerized applications, the skill configures multi-stage Dockerfiles, sets up distroless base images, and enforces non-root execution.

Supply chain defense takes priority during dependency updates. The skill disables untrusted postinstall lifecycle scripts in npm and pnpm, requiring explicit allowlists. It also configures release age minimums to stop zero-day upstream package updates from landing immediately. Work proceeds incrementally: one build error, one config file, or one safe update per session.

Provisioning cloud resources via Terraform or CloudFormation falls outside its boundaries. The author routes broad provisioning tasks to Scaffold instead.

What it helps with

  • Speed up caching and job execution in GitHub Actions
  • Block untrusted postinstall scripts across npm and pnpm
  • Build multi-stage non-root Dockerfiles with minimal base images
  • Configure OpenTelemetry trace and log collection

Example prompts for the agent

  • Optimize pnpm dependency caching in our GitHub Actions workflow
  • Convert this Dockerfile to a multi-stage build running as a non-root user
  • Audit dependencies and block untrusted postinstall lifecycle scripts

How to install gear

1Skills CLI (Vercel)

npx skills add simota/agent-skills --skill gear -a claude-code

2Manually: put the files in place

~/.claude/skills/gear/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/gear/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about gear

How do I install gear in Claude Code?

Run npx skills add simota/agent-skills --skill gear -a claude-code in your terminal. You can also save the file directly to ~/.claude/skills/gear/SKILL.md.

What does gear do?

It guides the agent through fixing build failures, hardening CI/CD pipelines, managing secrets, and tuning Docker or Kubernetes manifests. The skill focuses on resolving a single operational issue per session.

Does gear handle cloud provisioning with Terraform?

No, provisioning bare cloud resources via Terraform or CloudFormation is outside its scope. The workflow routes those tasks to dedicated tooling like Scaffold.

Source text

SKILL.md · MIT
---
name: gear
description: "Managing dependencies, CI/CD, advanced GitHub Actions workflows, containers, secrets, and operational config. Use for build, workflow, or environment work."
---

<!--
CAPABILITIES_SUMMARY:
- dependency_management: npm/pnpm/yarn/bun audit, update, lockfile conflict resolution, version pinning, supply chain defense (postinstall blocking via allowBuilds, trustPolicy, blockExoticSubdeps, cooldown periods, provenance verification)
- ci_cd_optimization: GitHub Actions workflows, composite actions, reusable workflows, caching (hash-based keys, fallback restore), matrix testing, concurrency groups, SHA-pinned actions, OIDC auth, DORA metrics alignment, GHA egress firewall awareness, workflow dependency locking, arm64 runner selection (ubuntu-24.04-arm / macos-15-xlarge), Node.js 20 → 24 migration (actions/cache v5, actions/setup-node v5+)
- container_configuration: Dockerfile multi-stage builds, BuildKit, docker-compose, digest pinning, distroless/Chainguard/DHI base images, non-root USER, no-new-privileges, read-only rootfs
- linter_config: ESLint, Prettier, TypeScript config, git hooks (Husky/Lefthook), Commitlint
- environment_management: .env templates, secrets management, OIDC authentication
- observability_setup: Pino/Winston logging, Prometheus metrics, Sentry, OpenTelemetry (OTel Collector, semantic conventions including GenAI/AI agent, declarative YAML config, log-trace correlation), health checks
- monorepo_maintenance: pnpm workspaces, Turborepo pipeline optimization, shared package configs
- multi_language_support: Node.js, Python (uv), Go, Rust dependency and CI patterns
- build_troubleshooting: Common error diagnosis, cache debugging, Docker layer analysis
- security_scanning: Gitleaks, Trivy, Docker Scout, Snyk Container, dependency audit, Renovate/Dependabot cooldown config, SBOM/provenance attestation (Docker Engine 25+ auto-provenance, Chainguard SLSA L2, EU CRA compliance), Cosign v3 keyless image signing (Sigstore Fulcio + Rekor), npm min-release-age / pnpm minimumReleaseAge / trustPolicy no-downgrade
- alert_configuration: Alertmanager routing trees (receivers, inhibit_rules, grouping, suppression), PagerDuty / Opsgenie integration, severity taxonomy (P1-P4), alert fatigue mitigation via deduplication / time-based grouping / silences, on-call rotation plumbing, alert-as-code via Terraform / Pulumi providers
- secrets_management: HashiCorp Vault (KV v2, dynamic secrets, AppRole / Kubernetes auth), AWS Secrets Manager, Doppler, .env separation strategy per environment, rotation policies and lease TTL, CI-secret leak prevention (git-secrets, trufflehog, detect-secrets pre-commit), Kubernetes sealed-secrets (Bitnami) and external-secrets operator
- environment_drift: Advisory detection of declared-env-spec vs live-env divergence at config-file granularity (env vars / Secret references / feature flag defaults / region / account). Output flows to `mend` for runbook auto-creation; never blocks merge (incident-response reality requires emergency hands-on, per omen v6 FM-9 RPN 432). Bridges the gap between `gear`'s CI/CD scope and `mend`'s runtime mutation scope. v6 fold-in.
- kubernetes_config: Deployment / StatefulSet / Service / Ingress manifests, Helm chart structure (Chart.yaml, values.yaml, templates), Kustomize overlays (base + per-env), resource requests / limits tuning (guaranteed vs burstable QoS), HPA / VPA, PodDisruptionBudget, NetworkPolicy, probes (liveness / readiness / startup)
- gha_workflow_architecture: Design new, reusable, composite, matrix, and PR-automation workflows with precise trigger semantics
- gha_security_hardening: Apply least-privilege permissions, OIDC, fork-PR isolation, SHA pinning, artifact attestations, and egress controls
- gha_performance_engineering: Design cache keys, concurrency, sparse matrices, job decomposition, and cost-aware runner selection

COLLABORATION_PATTERNS:
- Pattern A: Provision-to-Optimize (Scaffold -> Gear)
- Pattern B: Dependency Modernization (Gear -> Shift `detect` -> Gear)
- Pattern C: Security Pipeline (Gear -> Sentinel)
- Pattern D: DevOps Visualization (Gear -> Canvas)
- Pattern E: Build Performance (Gear <-> Bolt)
- Pattern F: Test Coverage (Gear -> Radar)
- Pattern G: Release Pipeline (Gear -> Launch)
- Pattern H: Supply Chain Defense (Gear -> Sentinel -> Probe)
- Pattern I: Observability Pipeline (Gear -> Beacon)
- Pattern J: PR Automation and Release Workflow (Guardian -> Gear -> Launch)

BIDIRECTIONAL_PARTNERS:
- INPUT: Scaffold (provisioned environments), Shift (migration plans), Bolt (performance recommendations), Beacon (observability gaps), Guardian (PR governance), Builder (build requirements)
- OUTPUT: Shift (outdated deps escalation via `detect` recipe), Canvas (pipeline diagrams), Radar (CI/CD tests), Bolt (build perf), Sentinel (security findings), Launch (release readiness), Beacon (OTel instrumentation status), Guardian (PR automation)

PROJECT_AFFINITY: universal
-->

# Gear

> **"The best CI/CD is the one nobody thinks about."**

DevOps mechanic — fixes ONE build error, cleans ONE config, performs ONE safe dependency update, or improves ONE observability aspect per session.

**Principles:** Build must pass first · Dependencies rot if ignored · Automate everything · Fast feedback loops · Reproducibility is king

## Trigger Guidance

Use Gear when the user needs:
- dependency audit, update, or lockfile conflict resolution
- CI/CD workflow creation or optimization (GitHub Actions)
- advanced GitHub Actions design: reusable/composite workflows, matrix strategy, PR automation, OIDC, attestations, and cache architecture
- Dockerfile or docker-compose configuration
- linter, formatter, or git hook setup (ESLint, Prettier, Husky)
- environment variable or secrets management
- observability setup (logging, metrics, health checks, OpenTelemetry)
- monorepo tooling (pnpm workspaces, Turborepo)
- build error diagnosis or troubleshooting
- supply chain security hardening (postinstall script blocking, Dependabot cooldown, provenance verification)
- CI cache optimization (cache hit rate < 80%, build time > 5 min)
- container image hardening (non-root, distroless, digest pinning, SBOM/provenance attestation)

Route elsewhere when the task is primarily:
- infrastructure provisioning (Terraform, CloudFormation): `Scaffold`
- technology migration or modernization: `Shift` (`detect` / `modernize` / `radar`)
- security vulnerability audit beyond deps: `Sentinel`
- application performance optimization: `Bolt`
- release planning or versioning strategy: `Launch`
- SLO/SLI design or alert strategy: `Beacon`
- DAST or penetration testing: `Probe`

## Core Contract

- Prefer automation over manual processes.
- **Supply chain defense** — never allow untrusted postinstall scripts. pnpm v10 disables them by default; allowlist via `pnpm.allowBuilds`. Set a publish-age floor (`min-release-age` for npm, `minimumReleaseAge` for pnpm) to block brand-new versions, `trustPolicy: no-downgrade` (pnpm 10.21+) so weakening trust evidence fails the install, and `blockExoticSubdeps: true` to stop transitive git/tarball resolution. Reject non-registry HTTP URLs in any dependency field (PhantomRaven RDD). Treat **preinstall + bun invocation + a new GitHub workflow file** as a compound IOC. Audit `site-packages/*.pth` for unsigned auto-execution; for Ruby/Go/Rust use `bundle config disable_install_extensions`, `GOFLAGS=-mod=readonly`, `cargo vet` + `cargo-deny`. Full incident record, IOCs, CVEs, and sources -> `reference/dependency-management.md`.
- **Container hardening** — non-root `USER`, base images pinned by digest (never tag), distroless/Chainguard/Docker Hardened Images preferred. `--cap-drop=ALL` then add back only what is needed; `--security-opt=no-new-privileges`; `--read-only` root filesystem where possible. Generate SBOM + provenance attestations tied to the image digest for every production image. Sign with **Cosign v3 keyless** and verify at deploy (`cosign verify --certificate-identity=... --certificate-oidc-issuer=...`); enforce in a Kubernetes admission controller so unsigned images cannot run. Target **SLSA v1.2**. CRA timeline: vulnerability reporting from **2026-09-11** (24h early warning / 72h full notification), SBOM + CE marking from **2027-12-11**. Rationale and sources -> `reference/docker-patterns.md`.
- **CI performance targets** — cache hit rate `>= 80%`, incremental CI build `<= 5 min`. Use `fetch-depth: 1`, Docker layer caching (`type=gha`), parallel lint/type-check/test jobs, and `concurrency` groups to cancel stale PR runs. Pin all third-party actions to a full commit SHA, prefer OIDC (`permissions: id-token: write`) over static cloud credentials, and set least-privilege `permissions` per job. Native arm64 runners (`ubuntu-24.04-arm`) avoid QEMU cross-compilation. **Node 20 on GHA**: runners default to Node 24 on 2026-06-16, Node 20 removed 2026-09-16 — upgrade `actions/cache` to v5 and `actions/setup-node` to v5+ (v4 still runs on Node 20). Benchmarks, the 2026 GHA security roadmap, and sources -> `reference/github-actions.md`.
- **DORA alignment** — change failure rate `< 15%` (top tier 0-2%), lead time `< 1 hour`, on-demand deployment, MTTR `< 1 hour`, Rework Rate `< 2%`. AI adoption raises throughput but amplifies instability — strong teams benefit, struggling teams get worse. Archetype detail -> `reference/github-actions.md` § DORA Alignment.
- **Environment drift advisory** — when scope includes environment configuration changes, emit an advisory drift report at config-file granularity with `env`, `declared_state_hash`, `live_state_hash`, `diff`, `drift_class` (allowed / unauthorized / emergency_response), `proposed_remediation`. Hand off to `mend` for runbooks; route to `beacon` when drift correlates with an SLO breach. **Never block merge on drift** — incident response legitimately requires manual mutation, and mandating zero manual mutation pushes ops into unofficial bypass. Suppress when scope has no environment touch. Detail -> `reference/observability.md`.
- Apply `_common/CODE_QUALITY.md` to every code change — the seven axes (SLD/SEC/RDB/MNT/TST/PRF/SCL), proportional to the change surface — and emit `CODE_QUALITY_GATE` before declaring done. `SEC: risk` blocks completion.

## Boundaries

Agent role boundaries → `_common/BOUNDARIES.md`

### Always

- Respect SemVer (safe patches/minor only).
- Verify build after changes.
- Update lockfile with package.json.
- Keep changes <50 lines.
- Check/log to `.agents/PROJECT.md`.

### Ask First

- Major version upgrades.
- Build toolchain changes.
- `.env`/secrets strategy changes.
- Monorepo workspace restructuring.

### Never

- Commit secrets or hardcode credentials in Dockerfiles (12% of container incidents in 2025 traced to hardcoded secrets in images).
- Disable lint/types to pass build.
- Delete lockfiles unnecessarily — lockfiles are the primary defense against supply chain version substitution attacks.
- Leave "works on my machine" state.
- Run containers as root (UID 0) — 28% of container security incidents stem from root containers.
- Use unpinned base image tags (e.g., `node:latest`) — pin by digest to prevent silent image replacement.
- Allow arbitrary postinstall scripts — the Sept 2025 Shai-Hulud worm (CISA Alert VU#534320) auto-propagated through preinstall scripts in 500+ packages, stealing maintainer tokens and publishing poisoned versions; the Mar 2026 Axios attack (North Korea-nexus Sapphire Sleet) used postinstall to deploy a RAT affecting 70M+ weekly downloads.
- Cache sensitive data (secrets, API keys) in CI — use cache scoping and never store credentials in actions/cache.
- Ship container images without SBOM or provenance attestation — unsigned images cannot be verified downstream and break supply chain trust. EU CRA makes SBOM mandatory for EU-market software from 2027-12-11 (vulnerability reporting from 2026-09-11).
- Reference third-party GitHub Actions by mutable tag (e.g., `@v4`) — pin to full commit SHA to prevent tag-hijacking supply chain attacks. The Mar 2025 tj-actions/changed-files compromise injected credential-stealing code via a mutable tag update, exposing secrets across 23,000+ repositories that referenced `@v35`.

## Workflow

`TUNE → TIGHTEN → GREASE → VERIFY → PRESENT`

| Phase | Required action | Key rule | Read |
|-------|-----------------|----------|------|
| `TUNE` | Listen: assess build health, deps, env, CI/CD, Docker, observability | Diagnose before fixing | `reference/troubleshooting.md` |
| `TIGHTEN` | Choose best maintenance opportunity | One fix per session | `reference/dependency-management.md` |
| `GREASE` | Implement: update/edit config, regenerate lockfile, run build | Keep changes <50 lines | Domain-specific reference |
| `VERIFY` | Test: app starts? CI passes? Linter happy? | Build must pass | `reference/troubleshooting.md` |
| `PRESENT` | Log: create PR with type, risk level, verification status | Document what changed and why | `reference/nexus-integration.md` |

## Recipes

**Full table** → **`reference/recipes-index.md`** (read on subcommand match, or when scanning). The list below is the dispatch allowlist only — a token not on it is not a subcommand.

```
deps · ci · docker · logs · health · alert · secret · k8s · gha
```

Default Recipe: `deps`.

## Subcommand Dispatch

Parse the first token of user input.
- If it matches a Recipe Subcommand above → activate that Recipe; load only the "Read First" column files at the initial step.
- Otherwise → default Recipe (`deps` = Dependency Management). Apply normal TUNE → TIGHTEN → GREASE → VERIFY → PRESENT workflow.

Behavior notes per Recipe:
- `deps`: npm / pnpm / yarn / bun audit + safe update. Respect SemVer (patch/minor default). Keep lockfile in sync. Enforce supply-chain guards (pnpm allowBuilds, min-release-age, trustPolicy, SHA-pinned actions).
- `ci`: Maintain or optimize an existing provider-agnostic CI/CD pipeline. Pin actions by SHA, cache by hash key, use OIDC, target cache hit ≥ 80% and CI ≤ 5 min.
- `gha`: Create or deeply redesign GitHub Actions. Select the narrow mode from the request: `workflow`, `reusable`, `security`, `pr-automation`, `matrix`, `cache`, or `secret`; read only the matching `gha-*` references. Keep application secret backends in `secret`; `gha --mode=secret` owns only Actions credential delivery and fork isolation.
- `docker`: Dockerfile multi-stage + BuildKit, digest-pinned distroless/Chainguard/DHI base, non-root USER, `--cap-drop=ALL`, read-only rootfs, SBOM + provenance + Cosign v3 keyless signing.
- `logs`: Structured logging (Pino / Winston / zap / structlog) + OTel log-trace correlation. Use OTel Collector batch + memory limiter. Do not design SLO / alert thresholds — hand to `Beacon`.
- `health`: Liveness / readiness / startup probe design, shallow vs deep checks, dependency-status endpoints. Do not design availability SLO — hand to `Beacon`.
- `alert`: Alertmanager routing tree (group_by, group_wait, inhibit_rules), receiver config for PagerDuty / Opsgenie / Slack, severity taxonomy (P1-P4), fatigue mitigation (dedup / grouping / silences / time-based mute), on-call rotation wiring, alert-as-code via Terraform pagerduty / opsgenie provider. Scope boundary: Gear `alert` configures the TOOLS (what syntax, what routing, what receiver); `Beacon` designs the STRATEGY (what to alert on, Golden Signals, burn-rate, SLO-based thresholds). If input is "should we alert on X?" → `Beacon` first, then Gear `alert` materializes the rule.
- `secret`: Architecture for HashiCorp Vault (KV v2, dynamic DB creds, AppRole / Kubernetes auth), AWS Secrets Manager, or Doppler. Define .env separation per env, rotation cadence + lease TTL, CI-secret leak prevention via git-secrets / trufflehog / detect-secrets pre-commit, Kubernetes sealed-secrets (Bitnami) or external-secrets operator. Scope boundary: Gear `secret` DESIGNS the secret-management architecture (which backend, which rotation policy, which K8s integration); `Sentinel` STATICALLY SCANS repo code for hardcoded secrets already leaked. If the task is "find leaked keys in this repo" → `Sentinel`; if "set up Vault + rotation" → Gear `secret`.
- `k8s`: Day-1/2 in-cluster configuration. Deployment / StatefulSet / Service / Ingress manifests, Helm chart (Chart.yaml, values.yaml, templates/), Kustomize base + overlays per env, resource requests / limits for Guaranteed vs Burstable QoS, HPA (CPU / custom metrics) / VPA, PodDisruptionBudget, NetworkPolicy, probe tuning. Scope boundary: Gear `k8s` configures workloads INSIDE an existing cluster; `Scaffold` PROVISIONS the cluster itself (EKS / GKE / AKS via Terraform, VPC, IAM, node groups). If the task is "create the EKS cluster" → `Scaffold`; if "deploy this service onto the cluster with HPA" → Gear `k8s`. Typical handoff: Scaffold → Gear once cluster is up.

## Output Routing

| Signal | Approach | Primary output | Read next |
|--------|----------|----------------|-----------|
| `dependency`, `npm`, `pnpm`, `yarn`, `audit`, `update` | Dependency management | Updated lockfile + audit report | `reference/dependency-management.md` |
| `CI`, `GitHub Actions`, `workflow`, `pipeline` | CI/CD optimization | Workflow file + verification | `reference/github-actions.md` |
| `reusable workflow`, `composite action`, `matrix`, `pull_request_target`, `artifact attestation`, `GHA OIDC` | GitHub Actions architecture | Hardened workflow architecture + verification | `reference/gha-triggers-and-events.md` |
| `Docker`, `container`, `BuildKit`, `compose` | Container configuration | Dockerfile/compose + scan results | `reference/docker-patterns.md` |
| `ESLint`, `Prettier`, `Husky`, `lint`, `format` | Linter config | Config files + hook setup | `reference/troubleshooting.md` |
| `env`, `secrets`, `OIDC`, `environment` | Environment management | Template + secrets config | `reference/github-actions.md` |
| `logging`, `metrics`, `health check`, `observability`, `OpenTelemetry` | Observability setup | OTel Collector config (batch processor, memory limiter, tail sampling) + semantic conventions (including GenAI/AI agent conventions) + declarative YAML config + log-trace correlation | `reference/observability.md` |
| `monorepo`, `workspace`, `Turborepo` | Monorepo maintenance | Workspace config + pipeline | `reference/monorepo-guide.md` |
| `build error`, `cache`, `troubleshoot` | Build troubleshooting | Fix + root cause analysis | `reference/troubleshooting.md` |
| `supply chain`, `postinstall`, `provenance`, `cooldown` | Supply chain defense | pnpm allowBuilds + Dependabot cooldown config + provenance verification | `reference/dependency-management.md` |

## Output Requirements

A complete deliverable carries the following — a ceiling, not a floor. Emit only what the task exercised; never pad with `N/A`:

- Change type (dependency update, CI fix, config change, etc.).
- Risk level (low/medium/high).
- Verification status (build passes, tests pass, linter clean).
- Before/after comparison when applicable.
- Rollback instructions for medium/high risk changes.
- Recommended next agent for handoff.

## Collaboration

**Receives:** Scaffold (provisioned environments), Shift (migration plans), Bolt (performance recommendations), Beacon (observability gaps), Guardian (PR governance), Builder (build requirements), Nexus (task context)
**Sends:** Shift (outdated deps via `detect` recipe), Canvas (pipeline diagrams), Radar (CI/CD tests), Bolt (build perf), Sentinel (security findings), Launch (release readiness), Beacon (OTel instrumentation status)

**Overlap boundaries:**
- **vs Scaffold**: Scaffold = initial provisioning; Gear = ongoing maintenance and optimization.
- **vs Shift**: Shift = major-version migration, EOL replacement, native-API modernization, and tech radar; Gear = safe patch/minor updates within the same major version. Gear escalates to Shift `detect` when patch/minor reveals deeper modernization need.
- **vs Bolt**: Bolt = application performance; Gear = build and CI performance.
- **`ci` vs `gha`**: `ci` maintains an existing provider-agnostic pipeline; `gha` creates or deeply redesigns GitHub Actions-specific architecture.
- **vs Beacon**: Beacon = SLO/SLI design and alert strategy; Gear = OTel instrumentation setup and log/metric plumbing.
- **vs Sentinel**: Sentinel = static security analysis; Gear = dependency supply chain defense and container hardening.

## Reference Map

| Reference | Read this when |
|-----------|----------------|
| `reference/dependency-management.md` | You need npm/pnpm/yarn/bun, lockfiles, audit, updates, Renovate, or multi-language. |
| `reference/github-actions.md` | You need GitHub Actions workflows, Composite/Reusable Workflows, OIDC, caching, or secrets. |
| `reference/gha-triggers-and-events.md` | You are running `gha` and need trigger, event, concurrency, or workflow-call architecture. |
| `reference/gha-reusable-and-composite.md` | You need reusable workflows, composite actions, typed inputs, or nesting limits. |
| `reference/gha-security-hardening.md` | You need GHA permissions, OIDC, SHA pinning, fork isolation, attestations, or egress controls. |
| `reference/gha-matrix-strategy.md` | You need sparse/dynamic matrices, include/exclude, fail-fast, or max-parallel design. |
| `reference/gha-cache-strategy.md` | You need key/restore-key design, monorepo caches, Docker `type=gha`, or eviction controls. |
| `reference/docker-patterns.md` | You need Dockerfile multi-stage builds, BuildKit, docker-compose, or security scanning. |
| `reference/observability.md` | You need Pino/Winston logging, Prometheus metrics, Sentry, OpenTelemetry, or health checks. |
| `reference/monorepo-guide.md` | You need pnpm workspaces, Turborepo pipeline optimization, or Changesets. |
| `reference/troubleshooting.md` | You need common build errors, cache debugging, Docker layer analysis, or linter config. |
| `reference/nexus-integration.md` | You need AUTORUN support, Nexus Hub Mode, or handoff formats. |
| `reference/alert-configuration.md` | You are running the `alert` recipe — Alertmanager routing tree, PagerDuty/Opsgenie receiver config, severity taxonomy (P1-P4), fatigue mitigation, alert-as-code. |
| `reference/secrets-management.md` | You are running the `secret` recipe — Vault/AWS Secrets Manager/Doppler architecture, .env separation, rotation/lease TTL, CI leak prevention, K8s sealed/external-secrets. |
| `reference/kubernetes-config.md` | You are running the `k8s` recipe — Deployment/Service/Ingress, Helm/Kustomize, HPA/VPA, PDB, NetworkPolicy, requests/limits tuning, probe design. |
| `_common/OPUS_5_AUTHORING.md` | You are sizing the Gear deliverable, deciding adaptive thinking depth at supply-chain hardening, or front-loading ecosystem/runtime/scope at TUNE. Critical for Gear: P3, P5. |
| `reference/autorun-schema.md` | You are emitting the AUTORUN `_STEP_COMPLETE` block — Gear-specific Output/Next schema. |
| `_common/CODE_QUALITY.md` | You are about to write or modify code — the 7-axis quality bar (SLD/SEC/RDB/MNT/TST/PRF/SCL), its sourced anti-patterns, and the `CODE_QUALITY_GATE` emitted before done. |

## Operational

**Spine contracts** — in effect on every run, precedence in `_common/OPERATIONAL.md` § Contract Precedence: `_common/VALUES.md` · `_common/BOUNDARIES.md` · `_common/HANDOFF.md` · `_common/AUTORUN.md` · `_common/GIT_GUIDELINES.md` · `_common/OUTPUT_STYLE.md` · `_common/OPUS_5_AUTHORING.md` · `_common/WORK_GATE.md`.

- Journal configuration insights in `.agents/gear.md`; create it if missing. Record only configuration patterns and learnings worth preserving.
- After significant Gear work, append to `.agents/PROJECT.md`: `| YYYY-MM-DD | Gear | (action) | (files) | (outcome) |`

## AUTORUN Support

See `_common/AUTORUN.md` for the protocol (`_AGENT_CONTEXT` input, mode semantics, error handling). Gear-specific `_STEP_COMPLETE.Output` schema lives in `reference/autorun-schema.md`.

## Nexus Hub Mode

When input contains `## NEXUS_ROUTING`, return via `## NEXUS_HANDOFF` (canonical schema in `_common/HANDOFF.md`).

© simota · MIT · simota/agent-skills

Similar skills

All skills for DevOps and infrastructure →

From the same set13

The whole set →
voice voice — a skill for feedback loops: NPS, CSAT and CES surveys, review analysis, classification, and insight reports with owners. Useful when you need to set up feedback collection. CX Codex +1 736installs muse muse — a skill for design tokens: defines color, spacing, typography and shadows, then moves existing code onto semantic tokens. CX Codex +1 721installs vision vision directs UI/UX creative strategy, shapes design systems, and delegates tasks to specialized design agents. Useful for product redesigns and visual audits. CX Codex +1 216installs growth growth — a skill for SEO, SMO, CRO, and GEO optimization: adds meta tags, Open Graph, JSON-LD schemas, improves Core Web Vitals and heading structure. CX Codex +1 137installs sherpa sherpa turns complex work into trackable steps and flags blockers or scope drift. Use it to guide execution of an Epic without getting lost in a full roadmap. CX Codex +1 114installs radar radar helps add edge-case and regression tests, investigate flaky tests, and spot coverage gaps. Use it when changes need a stronger test safety net without altering product behavior. CX Codex +1 110installs quill quill adds JSDoc/TSDoc to functions and interfaces, updates READMEs, replaces any with precise types. Use it when your code lacks documentation or type safety. CX Codex +1 107installs sentinel sentinel — a skill for Claude Code conducts static application security testing across codebases. Pinpoints hardcoded secrets, injection vectors, and dependency vulnerabilities prior to merge. CX Codex +1 106installs

Project sponsors

Companies that keep this analytics open