Agent skill

Helm Chart Builder

by alirezarezvani in alirezarezvani/claude-skills

Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening…

MITAuto-check passedDevOps & Cloud

Install Helm Chart Builder

skills CLI
$ npx skills add alirezarezvani/claude-skills --skill helm-chart-builder -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install alirezarezvani/claude-skills helm-chart-builder --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/alirezarezvani/claude-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/engineering/helm-chart-builder/skills/helm-chart-builder .claude/skills/helm-chart-builder && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
helm-chart-builder
GitHub stars
28k
Used in
1 other repo
Token cost
~3.8k tokens
SKILL.md length
846 words
Files
5 (incl. scripts, references)
Skills in repo
342
Repo updated
First seen
Licence
MIT

At a glance

Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening…

  • Works in 5 steps: Identify workload type → Scaffold chart structure → Apply Chart.yaml best practices → …
  • : user wants to create
  • SKILL.md covers Slash Commands, When This Skill Activates, Workflow and Tooling, plus 6 more sections
  • Runs Python scripts from its folder; calls python3, helm and git

What it does

Helm Chart Builder is an agent skill from alirezarezvani/claude-skills. Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening, and chart testing. Use when: user wants to create or improve Helm charts, design values.yaml files, implement template helpers, audit chart security (RBAC, network policies, pod security), manage subcharts, or run helm lint/test.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including scripts and reference files (for example `references/chart-patterns.md`, `references/values-design.md` and `scripts/chart_analyzer.py`).

It sits in DevOps & Cloud, covering Container orchestration. It works with Helm. The repository describes itself as: 380 Claude Code skills & agent skills & plugins (30+ Agents, 70+ custom commands, 380+ skills, customizable references, scripts)for Claude Code, Codex, Gemini CLI, Cursor, and 8… The licence is MIT.

When your agent uses it

  • : user wants to create
  • Improve Helm charts
  • Design values.yaml files
  • Implement template helpers

Example prompts

  • “/helm-chart-builder”

Requirements

  • Python 3

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Identify workload type
  2. Scaffold chart structure
  3. Apply Chart.yaml best practices
  4. Generate values.yaml with documentation
  5. Validate

What it can do on your machine

Read from SKILL.md and the folder at commit 19392f7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3
    • helm
    • git
    • gemini
    • cursor

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use helm and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Helm Chart Builder loads about 3.8k tokens when it runs, and up to ~9.1k if it reads all its reference files. Until then it costs about 111 tokens; SKILL.md has 846 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~111
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~9.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from alirezarezvani/claude-skills at commit 19392f7, republished under its MIT licence (© alirezarezvani). 846 words, ~3,757 tokens.

Download SKILL.mdSave it as .claude/skills/helm-chart-builder/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
helm-chart-builder
description
Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening, and chart testing. Use when: user wants to create or improve Helm charts, design values.yaml files, implement template helpers, audit chart security (RBAC, network policies, pod security), manage subcharts, or run helm lint/test.
license
MIT
metadata.version
1.0.0
metadata.author
Alireza Rezvani
metadata.category
engineering
metadata.updated
2026-03-15

Helm Chart Builder

Production-grade Helm charts. Sensible defaults. Secure by design. No cargo-culting.

Opinionated Helm workflow that turns ad-hoc Kubernetes manifests into maintainable, testable, reusable charts. Covers chart structure, values design, template patterns, dependency management, and security hardening.

Not a Helm tutorial — a set of concrete decisions about how to build charts that operators trust and developers don't fight.


Slash Commands

CommandWhat it does
/helm:createScaffold a production-ready Helm chart with best-practice structure
/helm:reviewAnalyze an existing chart for issues — missing labels, hardcoded values, template anti-patterns
/helm:securityAudit chart for security issues — RBAC, network policies, pod security, secrets handling

When This Skill Activates

Recognize these patterns from the user:

  • "Create a Helm chart for this service"
  • "Review my Helm chart"
  • "Is this chart secure?"
  • "Design a values.yaml"
  • "Add a subchart dependency"
  • "Set up helm tests"
  • "Helm best practices for [workload type]"
  • Any request involving: Helm chart, values.yaml, Chart.yaml, templates, helpers, _helpers.tpl, subcharts, helm lint, helm test

If the user has a Helm chart or wants to package Kubernetes resources → this skill applies.


Workflow

/helm:create — Chart Scaffolding
  1. Identify workload type

    • Web service (Deployment + Service + Ingress)
    • Worker (Deployment, no Service)
    • CronJob (CronJob + ServiceAccount)
    • Stateful service (StatefulSet + PVC + Headless Service)
    • Library chart (no templates, only helpers)
  2. Scaffold chart structure

    mychart/
    ├── Chart.yaml              # Chart metadata and dependencies
    ├── values.yaml             # Default configuration
    ├── values.schema.json      # Optional: JSON Schema for values validation
    ├── .helmignore             # Files to exclude from packaging
    ├── templates/
    │   ├── _helpers.tpl        # Named templates and helper functions
    │   ├── deployment.yaml     # Workload resource
    │   ├── service.yaml        # Service exposure
    │   ├── ingress.yaml        # Ingress (if applicable)
    │   ├── serviceaccount.yaml # ServiceAccount
    │   ├── hpa.yaml            # HorizontalPodAutoscaler
    │   ├── pdb.yaml            # PodDisruptionBudget
    │   ├── networkpolicy.yaml  # NetworkPolicy
    │   ├── configmap.yaml      # ConfigMap (if needed)
    │   ├── secret.yaml         # Secret (if needed)
    │   ├── NOTES.txt           # Post-install usage instructions
    │   └── tests/
    │       └── test-connection.yaml
    └── charts/                 # Subcharts (dependencies)
  3. Apply Chart.yaml best practices

    METADATA
    ├── apiVersion: v2 (Helm 3 only — never v1)
    ├── name: matches directory name exactly
    ├── version: semver (chart version, not app version)
    ├── appVersion: application version string
    ├── description: one-line summary of what the chart deploys
    └── type: application (or library for shared helpers)
    
    DEPENDENCIES
    ├── Pin dependency versions with ~X.Y.Z (patch-level float)
    ├── Use condition field to make subcharts optional
    ├── Use alias for multiple instances of same subchart
    └── Run helm dependency update after changes
  4. Generate values.yaml with documentation

    • Every value has an inline comment explaining purpose and type
    • Sensible defaults that work for development
    • Override-friendly structure (flat where possible, nested only when logical)
    • No hardcoded cluster-specific values (image registry, domain, storage class)
  5. Validate

    bash
    python3 scripts/chart_analyzer.py mychart/
    helm lint mychart/
    helm template mychart/ --debug
/helm:review — Chart Analysis
  1. Check chart structure

    CheckSeverityFix
    Missing _helpers.tplHighCreate helpers for common labels and selectors
    No NOTES.txtMediumAdd post-install instructions
    No .helmignoreLowCreate one to exclude .git, CI files, tests
    Missing Chart.yaml fieldsMediumAdd description, appVersion, maintainers
    Hardcoded values in templatesHighExtract to values.yaml with defaults
  2. Check template quality

    CheckSeverityFix
    Missing standard labelsHighUse app.kubernetes.io/* labels via _helpers.tpl
    No resource requests/limitsCriticalAdd resources section with defaults in values.yaml
    Hardcoded image tagHighUse {{ .Values.image.repository }}:{{ .Values.image.tag }}
    No imagePullPolicyMediumDefault to IfNotPresent, overridable
    Missing liveness/readiness probesHighAdd probes with configurable paths and ports
    No pod anti-affinityMediumAdd preferred anti-affinity for HA
    Duplicate template codeMediumExtract into named templates in _helpers.tpl
  3. Check values.yaml quality

    bash
    python3 scripts/values_validator.py mychart/values.yaml
  4. Generate review report

    HELM CHART REVIEW — [chart name]
    Date: [timestamp]
    
    CRITICAL: [count]
    HIGH:     [count]
    MEDIUM:   [count]
    LOW:      [count]
    
    [Detailed findings with fix recommendations]
Show full SKILL.md (476 more words)Show less
/helm:security — Security Audit
  1. Pod security audit

    CheckSeverityFix
    No securityContextCriticalAdd runAsNonRoot, readOnlyRootFilesystem
    Running as rootCriticalSet runAsNonRoot: true, runAsUser: 1000
    Writable root filesystemHighSet readOnlyRootFilesystem: true + emptyDir for tmp
    All capabilities retainedHighDrop ALL, add only specific needed caps
    Privileged containerCriticalSet privileged: false, use specific capabilities
    No seccomp profileMediumSet seccompProfile.type: RuntimeDefault
    allowPrivilegeEscalation trueHighSet allowPrivilegeEscalation: false
  2. RBAC audit

    CheckSeverityFix
    No ServiceAccountMediumCreate dedicated SA, don't use default
    automountServiceAccountToken trueMediumSet to false unless pod needs K8s API access
    ClusterRole instead of RoleMediumUse namespace-scoped Role unless cluster-wide needed
    Wildcard permissionsCriticalUse specific resource names and verbs
    No RBAC at allLowAcceptable if pod doesn't need K8s API access
  3. Network and secrets audit

    CheckSeverityFix
    No NetworkPolicyMediumAdd default-deny ingress + explicit allow rules
    Secrets in values.yamlCriticalUse external secrets operator or sealed-secrets
    No PodDisruptionBudgetMediumAdd PDB with minAvailable for HA workloads
    hostNetwork: trueHighRemove unless absolutely required (e.g., CNI plugin)
    hostPID or hostIPCCriticalNever use in application charts
  4. Generate security report

    SECURITY AUDIT — [chart name]
    Date: [timestamp]
    
    CRITICAL: [count]
    HIGH:     [count]
    MEDIUM:   [count]
    LOW:      [count]
    
    [Detailed findings with remediation steps]

Tooling

scripts/chart_analyzer.py

CLI utility for static analysis of Helm chart directories.

Features:

  • Chart structure validation (required files, directory layout)
  • Template anti-pattern detection (hardcoded values, missing labels, no resource limits)
  • Chart.yaml metadata checks
  • Standard labels verification (app.kubernetes.io/*)
  • Security baseline checks
  • JSON and text output

Usage:

bash
# Analyze a chart directory
python3 scripts/chart_analyzer.py mychart/

# JSON output
python3 scripts/chart_analyzer.py mychart/ --output json

# Security-focused analysis
python3 scripts/chart_analyzer.py mychart/ --security
scripts/values_validator.py

CLI utility for validating values.yaml against best practices.

Features:

  • Documentation coverage (inline comments)
  • Type consistency checks
  • Hardcoded secrets detection
  • Default value quality analysis
  • Structure depth analysis
  • Naming convention validation
  • JSON and text output

Usage:

bash
# Validate values.yaml
python3 scripts/values_validator.py values.yaml

# JSON output
python3 scripts/values_validator.py values.yaml --output json

# Strict mode (fail on warnings)
python3 scripts/values_validator.py values.yaml --strict

Template Patterns

Pattern 1: Standard Labels (_helpers.tpl)
yaml
{{/*
Common labels for all resources.
*/}}
{{- define "mychart.labels" -}}
helm.sh/chart: {{ include "mychart.chart" . }}
app.kubernetes.io/name: {{ include "mychart.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end }}

{{/*
Selector labels (subset of common labels — must be immutable).
*/}}
{{- define "mychart.selectorLabels" -}}
app.kubernetes.io/name: {{ include "mychart.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
{{- end }}
Pattern 2: Conditional Resources
yaml
{{- if .Values.ingress.enabled -}}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: {{ include "mychart.fullname" . }}
  labels:
    {{- include "mychart.labels" . | nindent 4 }}
  {{- with .Values.ingress.annotations }}
  annotations:
    {{- toYaml . | nindent 4 }}
  {{- end }}
spec:
  {{- if .Values.ingress.tls }}
  tls:
    {{- range .Values.ingress.tls }}
    - hosts:
        {{- range .hosts }}
        - {{ . | quote }}
        {{- end }}
      secretName: {{ .secretName }}
    {{- end }}
  {{- end }}
  rules:
    {{- range .Values.ingress.hosts }}
    - host: {{ .host | quote }}
      http:
        paths:
          {{- range .paths }}
          - path: {{ .path }}
            pathType: {{ .pathType }}
            backend:
              service:
                name: {{ include "mychart.fullname" $ }}
                port:
                  number: {{ $.Values.service.port }}
          {{- end }}
    {{- end }}
{{- end }}
Pattern 3: Security-Hardened Pod Spec
yaml
spec:
  serviceAccountName: {{ include "mychart.serviceAccountName" . }}
  automountServiceAccountToken: false
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 1000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: {{ .Chart.Name }}
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL
      image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
      imagePullPolicy: {{ .Values.image.pullPolicy }}
      resources:
        {{- toYaml .Values.resources | nindent 8 }}
      volumeMounts:
        - name: tmp
          mountPath: /tmp
  volumes:
    - name: tmp
      emptyDir: {}

Values Design Principles

STRUCTURE
├── Flat over nested (image.tag > container.spec.image.tag)
├── Group by resource (service.*, ingress.*, resources.*)
├── Use enabled: true/false for optional resources
├── Document every key with inline YAML comments
└── Provide sensible development defaults

NAMING
├── camelCase for keys (replicaCount, not replica_count)
├── Boolean keys: use adjectives (enabled, required) not verbs
├── Nested keys: max 3 levels deep
└── Match upstream conventions (image.repository, image.tag, image.pullPolicy)

ANTI-PATTERNS
├── Hardcoded cluster URLs or domains
├── Secrets as default values
├── Empty strings where null is correct
├── Deeply nested structures (>3 levels)
├── Undocumented values
└── values.yaml that doesn't work without overrides

Dependency Management

SUBCHARTS
├── Use Chart.yaml dependencies (not requirements.yaml — Helm 3)
├── Pin versions: version: ~15.x.x (patch float)
├── Use condition: to make optional: condition: postgresql.enabled
├── Use alias: for multiple instances of same chart
├── Override subchart values under subchart name key in values.yaml
└── Run helm dependency update before packaging

LIBRARY CHARTS
├── type: library in Chart.yaml — no templates directory
├── Export named templates only — no rendered resources
├── Use for shared labels, annotations, security contexts
└── Version independently from application charts

Proactive Triggers

Flag these without being asked:

  • No _helpers.tpl → Create one. Every chart needs standard labels and fullname helpers.
  • Hardcoded image tag in template → Extract to values.yaml. Tags must be overridable.
  • No resource requests/limits → Add them. Pods without limits can starve the node.
  • Running as root → Add securityContext. No exceptions for production charts.
  • No NOTES.txt → Create one. Users need post-install instructions.
  • Secrets in values.yaml defaults → Remove them. Use placeholders with comments explaining how to provide secrets.
  • No liveness/readiness probes → Add them. Kubernetes needs to know if the pod is healthy.
  • Missing app.kubernetes.io labels → Add via _helpers.tpl. Required for proper resource tracking.

Installation

One-liner (any tool)
bash
git clone https://github.com/alirezarezvani/claude-skills.git
cp -r claude-skills/engineering/helm-chart-builder ~/.claude/skills/
Multi-tool install
bash
./scripts/convert.sh --skill helm-chart-builder --tool codex|gemini|cursor|windsurf|openclaw
OpenClaw
bash
clawhub install cs-helm-chart-builder

  • senior-devops — Broader DevOps scope (CI/CD, IaC, monitoring). Complementary — use helm-chart-builder for chart-specific work, senior-devops for pipeline and infrastructure.
  • docker-development — Container building. Complementary — docker-development builds the images, helm-chart-builder deploys them to Kubernetes.
  • ci-cd-pipeline-builder — Pipeline construction. Complementary — helm-chart-builder defines the deployment artifact, ci-cd-pipeline-builder automates its delivery.
  • senior-security — Application security. Complementary — helm-chart-builder covers Kubernetes-level security (RBAC, pod security), senior-security covers application-level threats.

© alirezarezvani, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (scripts, references) in engineering/helm-chart-builder/skills/helm-chart-builder of alirezarezvani/claude-skills.

  • SKILL.md
  • references/chart-patterns.md
  • references/values-design.md
  • scripts/chart_analyzer.py
  • scripts/values_validator.py

Open the folder on GitHubat commit 19392f7

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in alirezarezvani/claude-skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Helm Chart Builder next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Helm Chart Builder compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Helm Chart Builder this skillalirezarezvani/claude-skills28k1 repos~3.8kAutomated safety check: PassMIT
Kubeshark Installerkubeshark/kubeshark12k—~3.6kAutomated safety check: NotesApache-2.0
Sim Helmsimstudioai/sim30k—~2.2kAutomated safety check: PassApache-2.0
Helm Chart ScaffoldingCybereason-Public/owLSM28013 repos~381Automated safety check: PassGPL-2.0
NGINX Ingress Controller Feature Checklistsnginx/kubernetes-ingress5.1k—~1.4kAutomated safety check: PassApache-2.0
Kubernetes SpecialistJeffallan/claude-skills12k1 repos~2.1kAutomated safety check: PassMIT

Similar skills

  • Kubeshark Installer

    kubeshark/kubeshark

    Installs and configures Kubeshark on a Kubernetes cluster, choosing between the quick CLI path and a Helm install with custom values.

    12k GitHub stars~3.6k tokensUpdated today
    DevOps & CloudAuto-check: notes
  • Sim Helm

    simstudioai/sim

    Install, upgrade, and operate the Sim Helm chart on Kubernetes.

    30k GitHub stars~2.2k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Helm Chart Scaffolding

    Cybereason-Public/owLSM

    Comprehensive guidance for creating, organizing, and managing Helm charts for packaging and deploying Kubernetes applications.

    280 GitHub starsUsed in 13 repos~381 tokens
    DevOps & CloudAuto-check passed
  • Gives step-by-step checklists for adding Ingress annotations, VirtualServer fields and Helm values to the NGINX Kubernetes Ingress Controller, with common gotchas.

    5.1k GitHub stars~1.4k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Kubernetes Specialist

    Jeffallan/claude-skills

    Creates and checks Kubernetes manifests, Helm charts, RBAC and network policies, and helps debug pod problems, with kubectl checks and rollback steps.

    12k GitHub starsUsed in 1 repo~2.1k tokens
    DevOps & CloudAuto-check passed
  • KubeShark for Kubernetes

    LukasNiessen/kubernetes-skill

    Keeps Kubernetes manifests, Helm charts and policies grounded by diagnosing six failure modes, such as insecure defaults and API drift, and loading only matching references.

    444 GitHub stars~1.2k tokensUpdated 24 days ago
    DevOps & CloudAuto-check passed

More from alirezarezvani/claude-skills

All 342 skills in this repo
  • Agile Product Owner

    alirezarezvani/claude-skills

    Writes INVEST-checked user stories with acceptance criteria, splits epics, plans sprints from velocity and ranks the backlog with a weighted score.

    28k GitHub starsUsed in 3 repos~3.2k tokens
    Auto-check passed
  • Product Strategist

    alirezarezvani/claude-skills

    OKR cascade toolkit for product leaders: generates aligned company-to-team OKRs from five strategy types and scores how well they line up.

    28k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed
  • App Store Optimization

    alirezarezvani/claude-skills

    App Store Optimization (ASO) toolkit for researching keywords, analyzing competitor rankings, generating metadata suggestions, and improving app visibility on Apple App Store and Google Play Store.

    28k GitHub starsUsed in 1 repo~4.2k tokens
    Auto-check passed
  • AWS Solution Architect

    alirezarezvani/claude-skills

    Design AWS architectures for startups using serverless patterns and IaC templates.

    28k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed
  • Campaign Analytics

    alirezarezvani/claude-skills

    Calculates attribution, funnel and ROI figures for marketing campaigns with three Python scripts that need only the standard library.

    28k GitHub starsUsed in 1 repo~2.1k tokens
    Auto-check passed
  • Code to PRD

    alirezarezvani/claude-skills

    Reverse-engineers a frontend, backend or fullstack codebase into a product requirements document with per-page docs, an enum dictionary and an API inventory.

    28k GitHub starsUsed in 1 repo~4.9k tokens
    Auto-check passed

Works with

Categories

Questions about Helm Chart Builder

What does Helm Chart Builder do?

Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening…. Helm Chart Builder is an agent skill from alirezarezvani/claude-skills. Helm chart development agent skill and plugin for Claude Code, Codex, Gemini CLI, Cursor, OpenClaw — chart scaffolding, values design, template patterns, dependency management, security hardening, and chart testing.

When should I use Helm Chart Builder?

Helm Chart Builder fits situations like: : user wants to create; improve Helm charts; design values.yaml files; implement template helpers.

How do I install Helm Chart Builder in Claude Code?

Run `npx skills add alirezarezvani/claude-skills --skill helm-chart-builder -a claude-code`. Or copy the skill folder (engineering/helm-chart-builder/skills/helm-chart-builder in alirezarezvani/claude-skills) into .claude/skills/helm-chart-builder in your project. Claude Code loads it when a task matches its description.

How do I install Helm Chart Builder in Codex?

Run `npx skills add alirezarezvani/claude-skills --skill helm-chart-builder -a codex`. Or copy the skill folder (engineering/helm-chart-builder/skills/helm-chart-builder in alirezarezvani/claude-skills) into .agents/skills/helm-chart-builder in your project. Codex loads it when a task matches its description.

Can I use Helm Chart Builder in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add alirezarezvani/claude-skills --skill helm-chart-builder -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/helm-chart-builder, .gemini/skills/helm-chart-builder, .github/skills/helm-chart-builder and .opencode/skills/helm-chart-builder in your project.

What does Helm Chart Builder need to run?

Going by SKILL.md and its folder, Helm Chart Builder needs Python for the scripts in its folder and the command-line tools its instructions call (python3, helm, git, gemini and cursor). Our summary lists: Python 3.

Does Helm Chart Builder access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Helm Chart Builder safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Helm Chart Builder use?

Helm Chart Builder is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Helm Chart Builder use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.4k tokens, read only when the agent opens those files.

What are the alternatives to Helm Chart Builder?

Skills that share tags, products or a category with Helm Chart Builder: Kubeshark Installer (kubeshark/kubeshark, 12k stars), Sim Helm (simstudioai/sim, 30k stars), Helm Chart Scaffolding (Cybereason-Public/owLSM, 280 stars) and NGINX Ingress Controller Feature Checklists (nginx/kubernetes-ingress, 5.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Helm Chart Builder?

alirezarezvani (a GitHub user) maintains it in alirezarezvani/claude-skills, which has 27,829 GitHub stars. The repository holds 342 skills in this directory. The repository was last updated on August 30, 2026.

Source: alirezarezvani/claude-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.