Helm Chart Generator Skill

Helm Chart Generator

Overview

Generate production-ready Helm charts with deterministic scaffolding, standard helpers, reusable templates, and validation loops.

Official Documentation:

Helm Docs - Main documentation
Chart Best Practices - Official best practices guide
Template Functions - Built-in functions
Sprig Functions - Extended function library

When to Use This Skill

| Use helm-generator | Use OTHER skill | |-------------------|-----------------| | Create new Helm charts | helm-validator: Validate/lint existing charts | | Generate Helm templates | k8s-yaml-generator: Raw K8s YAML (no Helm) | | Convert K8s manifests to Helm | k8s-debug: Debug deployed resources | | Implement CRDs in Helm | k8s-yaml-validator: Validate K8s manifests |

Trigger Phrases

Use this skill when prompts include phrases like:

"create Helm chart"
"scaffold Helm chart"
"generate Helm templates"
"convert manifests to Helm chart"
"build chart with Deployment/Service/Ingress"

Execution Flow

Follow these stages in order. Do not skip required stages.

Stage 1: Gather Requirements (Required)

Collect:

Scope: full chart, specific templates, or conversion from manifests
Workload: deployment, statefulset, or daemonset
Image reference: repository, optional tag, or digest
Ports: service port and container target port (separate values)
Runtime settings: resources, probes, autoscaling, ingress, storage
Security: service account, security contexts, optional RBAC/network policies

Use request_user_input when critical fields are missing.

If request_user_input is unavailable, ask in normal chat and continue with explicit assumptions.

| Missing Information | Question to Ask | |---------------------|-----------------| | Image repository/tag | "What container image should be used? (e.g., nginx:1.25)" | | Service port | "What service port should be exposed?" | | Container target port | "What container port should traffic be forwarded to?" | | Resource limits | "What CPU/memory limits should be set? (e.g., 500m CPU, 512Mi memory)" | | Probe endpoints | "What health check endpoints does the app expose? (e.g., /health, /ready)" | | Scaling requirements | "Should autoscaling be enabled? If yes, min/max replicas and target CPU%?" | | Workload type | "What workload type: Deployment, StatefulSet, or DaemonSet?" | | Storage requirements | "Does the application need persistent storage? Size and access mode?" |

Do not silently assume critical settings.

Stage 2: Lookup CRD Documentation (Only if CRDs Are In Scope)

Try Context7 first:
- mcp__context7__resolve-library-id
- mcp__context7__query-docs
Fallback chain if Context7 is unavailable or incomplete:
- Operator official docs (preferred)
- General web search

Also consult references/crd_patterns.md for example patterns.

Stage 3: Scaffold Chart Structure (Required)

Run:

bash scripts/generate_chart_structure.sh <chart-name> <output-directory> [options]

Options:

--image <repo> - Supports repo-only, tagged image, registry ports, and digest refs
--port <number> - Service port (default: 80)
--target-port <number> - Container target port (default: 8080)
--type <type> - Workload type: deployment, statefulset, daemonset (default: deployment)
--with-templates - Generate resource templates (deployment.yaml, service.yaml, etc.)
--with-ingress - Include ingress template
--with-hpa - Include HPA template
--force - Overwrite existing chart without prompting

Image parsing behavior:

--image nginx:1.27 -> repository nginx, tag 1.27
--image registry.local:5000/team/app -> repository kept intact
--image ghcr.io/org/app@sha256:... -> digest mode (no tag concatenation)
--tag cannot be combined with digest image references

Idempotency and overwrite behavior:

generate_chart_structure.sh: prompts before overwrite; --force overwrites non-interactively.
generate_standard_helpers.sh: prompts before replacing templates/_helpers.tpl; --force bypasses prompt.

Expected scaffold shape:

mychart/
  Chart.yaml
  values.yaml
  templates/
    _helpers.tpl
    NOTES.txt
    serviceaccount.yaml
    service.yaml
    configmap.yaml
    secret.yaml
    deployment.yaml|statefulset.yaml|daemonset.yaml
    ingress.yaml (optional)
    hpa.yaml (optional)
  .helmignore

Stage 4: Generate Standard Helpers

Run:

bash scripts/generate_standard_helpers.sh <chart-name> <chart-directory>

Required helpers: name, fullname, chart, labels, selectorLabels, serviceAccountName.

Fallback:

If script execution is blocked, copy assets/_helpers-template.tpl and replace CHARTNAME with the chart name.

Stage 5: Consult References and Generate Templates (Required)

Consult relevant references once at this stage:

references/resource_templates.md for the resource patterns being generated
references/helm_template_functions.md for templating function usage
references/crd_patterns.md only when CRDs are in scope

Example file-open commands:

sed -n '1,220p' references/resource_templates.md
sed -n '1,220p' references/helm_template_functions.md

Resource coverage from references/resource_templates.md:

Workloads: Deployment, StatefulSet, DaemonSet, Job, CronJob
Services: Service, Ingress
Config: ConfigMap, Secret
RBAC: ServiceAccount, Role, RoleBinding, ClusterRole, ClusterRoleBinding
Network: NetworkPolicy
Autoscaling: HPA, PodDisruptionBudget

Required template patterns:

metadata:
  name: {{ include "mychart.fullname" . }}
  labels: {{- include "mychart.labels" . | nindent 4 }}

{{- with .Values.nodeSelector }}
nodeSelector: {{- toYaml . | nindent 2 }}
{{- end }}

annotations:
  {{- if and .Values.configMap .Values.configMap.enabled }}
  checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
  {{- end }}

Checksum annotations are required for workloads, but must be conditional and only reference generated templates (configmap.yaml, secret.yaml).

Stage 6: Create values.yaml

Structure guidelines:

Group related settings logically
Document every value with # -- comments
Provide sensible defaults
Include security contexts, resource limits, probes
Keep service.port and service.targetPort separate and explicit
Keep configMap.enabled / secret.enabled aligned with generated templates

See assets/values-schema-template.json for JSON Schema validation.

Stage 7: Validate

Preferred path: run the helm-validator skill.

If skill invocation is unavailable, run local commands directly:

helm lint <chart-dir>
helm template test <chart-dir>

If helm is unavailable, report the block clearly and perform partial checks:

bash -n scripts/generate_chart_structure.sh
bash -n scripts/generate_standard_helpers.sh
Verify generated files and key fields manually

Re-run validation after any fixes.

Template Functions Quick Reference

See references/helm_template_functions.md for complete guide.

| Function | Purpose | Example | |----------|---------|---------| | required | Enforce required values | {{ required "msg" .Values.x }} | | default | Fallback value | {{ .Values.x \| default 1 }} | | quote | Quote strings | {{ .Values.x \| quote }} | | include | Use helpers | {{ include "name" . \| nindent 4 }} | | toYaml | Convert to YAML | {{ toYaml .Values.x \| nindent 2 }} | | tpl | Render as template | {{ tpl .Values.config . }} | | nindent | Newline + indent | {{- include "x" . \| nindent 4 }} |

Working with CRDs

See references/crd_patterns.md for complete examples.

Key points:

CRDs you ship -> crds/ directory (not templated, not deleted on uninstall)
CR instances -> templates/ directory (fully templated)
Always look up documentation for CRD spec requirements
Document operator dependencies in Chart.yaml annotations

Converting Manifests to Helm

Parameterize: Names -> helpers, values -> values.yaml
Apply patterns: Labels, conditionals, toYaml for complex objects
Add helpers: Create _helpers.tpl with standard helpers
Validate: Run helm-validator (or local lint/template fallback), then test with different values

Error Handling

| Issue | Solution | |-------|----------| | Template syntax errors | helm template test <chart-dir> --debug --show-only templates/<file>.yaml | | Undefined values | helm lint <chart-dir> --strict and add default/required | | Checksum include errors | Ensure templates/configmap.yaml and templates/secret.yaml exist and configMap.enabled / secret.enabled are set correctly | | Port mismatch (Service vs container) | Set both service.port and service.targetPort, then re-run helm template test <chart-dir> | | CRD validation fails | Verify apiVersion/spec fields with Context7 or operator docs, then re-render | | Script argument failures | Run bash scripts/generate_chart_structure.sh --help and pass required values for option flags |

Example Flows

Full scaffold with templates, ingress, HPA, and explicit port mapping:

bash scripts/generate_chart_structure.sh webapp ./charts \
  --image ghcr.io/acme/webapp:2.3.1 \
  --port 80 \
  --target-port 8080 \
  --type deployment \
  --with-templates \
  --with-ingress \
  --with-hpa

Digest-based image scaffold:

bash scripts/generate_chart_structure.sh api ./charts \
  --image ghcr.io/acme/api@sha256:0123456789abcdef \
  --with-templates

Minimal scaffold without templates:

bash scripts/generate_chart_structure.sh starter ./charts

Scaffold Success Criteria

Mark complete only when all checks pass:

[ ] Chart.yaml, values.yaml, .helmignore, templates/NOTES.txt, and templates/_helpers.tpl exist
[ ] values.yaml contains explicit service.port and service.targetPort
[ ] If --with-templates was used, serviceaccount.yaml, service.yaml, configmap.yaml, secret.yaml, and one workload template exist
[ ] Generated workload template uses conditional checksum annotations for config/secret
[ ] Image rendering logic supports tag and digest modes
[ ] Validation completed (helm-validator skill or local fallback commands) and outcomes reported

Resources

Scripts

| Script | Usage | |--------|-------| | scripts/generate_chart_structure.sh | bash scripts/generate_chart_structure.sh <chart-name> <output-dir> [options] | | scripts/generate_standard_helpers.sh | bash scripts/generate_standard_helpers.sh <chart-name> <chart-dir> [--force] |

References

| File | Content | |------|---------| | references/helm_template_functions.md | Complete template function guide | | references/resource_templates.md | All K8s resource templates | | references/crd_patterns.md | CRD patterns (cert-manager, Prometheus, Istio, ArgoCD) |

Assets

| File | Purpose | |------|---------| | assets/_helpers-template.tpl | Standard helpers template | | assets/values-schema-template.json | JSON Schema for values validation |

Integration with helm-validator

After generating charts, invoke helm-validator and close the loop:

Generate chart/templates
Run helm-validator (or local fallback commands)
Fix identified issues
Re-validate until passing

Agent Skills: Helm Chart Generator

Install this agent skill to your local

Skill Files