Codex Skills Port

This repository contains native Codex-skill ports of three Claude Code plugins:

• claude-k8s-plugin
• claude-go-plugin
• product-demo-video

The goal of this repo is not to emulate Claude plugins exactly. Codex skills do not provide slash commands or automatic hooks in the same way, so these ports preserve the workflows, reusable scripts, templates, and guardrails in Codex-native form.

What Is In This Repo

All skills live under skills/.

Included skills:

Skill	Purpose
k8s-workflow	Guided Kubernetes operator workflow with kind, Kubebuilder, Tilt, and Kustomize
k8s-crd-design	CRD, webhook, reconcile-loop, and RBAC design patterns
k8s-quality-checklist	Review checklist for operator safety and readiness
k8s-templates	Starter Tilt, Makefile, Dockerfile, and Kustomize dev-overlay templates
go-development-loop	Fast feedback loop for Go development, linting, CI, security, coverage, and more
go-debug-breakpoints	Breakpoint-first Delve workflow for debugging failing Go tests
product-demo-video	Programmatic product demo video workflow using a bundled Remotion template

Each skill follows the Codex skill layout:

skills/<skill-name>/
├── SKILL.md
├── agents/openai.yaml
├── scripts/        # optional runnable helpers
├── references/     # optional documentation for the skill
└── assets/         # optional templates or bundled project files

How Codex Skills Work

A Codex skill is an instruction bundle that Codex can load when a task matches the skill description.

In practice:

• SKILL.md explains the workflow and the operating rules.
• agents/openai.yaml provides UI-facing metadata.
• scripts/ contains reusable local automation.
• references/ contains extra documentation that can be read only when needed.
• assets/ contains templates or files intended to be copied into target projects.

These skills are intended as source-controlled artifacts you can keep in this repo and install into your local Codex skills directory when needed.

Key Difference From Claude Plugins

The original repos used Claude plugin concepts such as:

• slash commands like /k8s:create-operator
• plugin manifests
• hook-based guardrails

These do not map 1:1 to Codex. In this port:

• slash commands became skill instructions plus reference docs
• hooks became explicit guardrails and portable scripts
• plugin templates became assets/ inside the corresponding skills

Example:

• original: /go:test-fast
• Codex port: use $go-development-loop and run scripts/test-fast.sh

Repo Layout

.
├── README.md
└── skills/
    ├── go-debug-breakpoints/
    ├── go-development-loop/
    ├── k8s-crd-design/
    ├── k8s-quality-checklist/
    ├── k8s-templates/
    ├── k8s-workflow/
    └── product-demo-video/

Installing The Skills

If you want Codex to discover these skills automatically in your local environment, copy or symlink them into your Codex skills directory.

Typical approach:

mkdir -p ~/.codex/skills
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/k8s-workflow" ~/.codex/skills/k8s-workflow
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/k8s-crd-design" ~/.codex/skills/k8s-crd-design
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/k8s-quality-checklist" ~/.codex/skills/k8s-quality-checklist
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/k8s-templates" ~/.codex/skills/k8s-templates
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/go-development-loop" ~/.codex/skills/go-development-loop
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/go-debug-breakpoints" ~/.codex/skills/go-debug-breakpoints
ln -s "/Users/trivedi/Documents/Projects/codex-skills/skills/product-demo-video" ~/.codex/skills/product-demo-video

If you prefer copying:

cp -R skills/* ~/.codex/skills/

How To Use The Skills

You can invoke a skill explicitly by naming it in your prompt.

Examples:

Use $k8s-workflow to scaffold a new Kubernetes operator for a Postgres backup CRD.

Use $go-development-loop to validate my Go changes and tighten the test loop.

Use $go-debug-breakpoints to debug this failing Go test with Delve.

Use $product-demo-video to turn this repo into a 60-second product demo video.

You can also combine them when the task spans multiple workflows:

Use $k8s-workflow and $k8s-crd-design to design and scaffold a namespaced operator with validating webhooks.

Skill Guide

k8s-workflow

Use this when building or iterating on a Kubernetes operator.

What it covers:

• prerequisite checks
• kind cluster creation
• Kubebuilder scaffold flow
• controller and webhook implementation order
• dev-loop guidance with Tilt
• deployment and verification flow
• kind-only safety posture

Useful files:

• skills/k8s-workflow/SKILL.md
• skills/k8s-workflow/scripts/prereqs.sh
• skills/k8s-workflow/scripts/setup-kind.sh
• skills/k8s-workflow/scripts/deploy-dev.sh
• skills/k8s-workflow/scripts/verify-dev.sh
• skills/k8s-workflow/references/command-mapping.md

Example prompts:

Use $k8s-workflow to scaffold a Kubernetes operator for a BackupSchedule CRD with validating webhooks.

Use $k8s-workflow to set up a kind-based dev loop for this Kubebuilder project and verify the manager and webhooks.

k8s-crd-design

Use this when the main problem is API and controller design rather than cluster setup.

What it covers:

• spec and status modeling
• kubebuilder validation/default markers
• webhook design
• reconcile-loop structure
• RBAC minimization
• testing expectations

Useful file:

• skills/k8s-crd-design/SKILL.md

Example prompts:

Use $k8s-crd-design to design the spec, status, validation rules, and RBAC for a namespaced Redis failover operator.

Use $k8s-crd-design to review whether this CRD schema and reconcile model are safe and idiomatic.

k8s-quality-checklist

Use this for review, audit, or pre-release validation of an operator.

What it covers:

• dev safety
• CRD correctness
• webhook correctness
• RBAC scope
• controller quality
• test and fast-loop readiness

Useful file:

• skills/k8s-quality-checklist/SKILL.md

Example prompts:

Use $k8s-quality-checklist to review this operator before I cut a release candidate.

Use $k8s-quality-checklist to audit the webhook, RBAC, and reconcile safety of this branch.

k8s-templates

Use this when you want starter files for the local operator workflow.

Bundled assets:

• skills/k8s-templates/assets/Makefile
• skills/k8s-templates/assets/Tiltfile
• skills/k8s-templates/assets/Dockerfile
• skills/k8s-templates/assets/config/dev/kustomization.yaml
• skills/k8s-templates/assets/config/dev/manager_dev_patch.yaml

Use this skill together with k8s-workflow.

Example prompts:

Use $k8s-templates to add a Tiltfile, dev overlay, and Make targets to this Kubebuilder repo.

Use $k8s-templates to generate starter local-dev files for an operator that runs in kind.

go-development-loop

Use this for day-to-day Go development and repo validation.

What it covers:

• targeted test loop
• lint and vet
• local CI
• security scans
• dependency checks and upgrades
• coverage checks
• benchmarks and profiling
• code generation
• migration helpers

Useful scripts:

• skills/go-development-loop/scripts/test-fast.sh
• skills/go-development-loop/scripts/lint.sh
• skills/go-development-loop/scripts/ci-local.sh
• skills/go-development-loop/scripts/security-scan.sh
• skills/go-development-loop/scripts/coverage-report.sh
• skills/go-development-loop/scripts/bench-run.sh

Example prompts:

Use $go-development-loop to validate the Go changes in this branch with the fast loop, lint, and local CI.

Use $go-development-loop to add reusable test, lint, coverage, and security scripts to this Go repo.

go-debug-breakpoints

Use this when a Go test is failing and static inspection is no longer enough.

What it covers:

• breakpoint planning
• Delve launch workflow
• runtime hypothesis loop
• failure log triage

Useful files:

• skills/go-debug-breakpoints/SKILL.md
• skills/go-debug-breakpoints/scripts/debug-test.sh
• skills/go-debug-breakpoints/scripts/triage-failure.sh
• skills/go-debug-breakpoints/references/delve-cheatsheet.md

Example prompts:

Use $go-debug-breakpoints to debug the failing test TestReconcile_Create in ./internal/controller.

Use $go-debug-breakpoints to inspect this race-condition failure with Delve and propose a minimal fix.

product-demo-video

Use this to create a polished, fully programmatic product demo video without screen recording.

What it covers:

• project scanning
• feature selection and storyboard planning
• narration generation
• storyboard.ts authoring
• preview and render flow with Remotion

Bundled template:

• skills/product-demo-video/assets/remotion-template/

That template includes:

• Remotion entrypoints
• reusable scene components
• starter src/storyboard.ts
• scripts/generate-narration.sh
• empty public/narration/ and public/screenshots/ directories

Typical workflow:

1. Copy the Remotion template into a working directory.
2. Run npm install.
3. Use the skill to scan the target product and draft a storyboard.
4. Generate narration audio.
5. Preview with npx remotion studio.
6. Render with npx remotion render DemoVideo output/demo.mp4.

Example prompts:

Use $product-demo-video to turn this developer tool into a 90-second demo video with a technical tone.

Use $product-demo-video to scan this SaaS app, draft a storyboard, and prepare a Remotion project for rendering.

Recommended Prompt Patterns

These prompts tend to trigger the skills cleanly:

Kubernetes

Use $k8s-workflow to create a Kubernetes operator for syncing GitHub teams into namespaces.

Use $k8s-crd-design to design the CRD schema, webhook validation, and RBAC for this operator.

Use $k8s-quality-checklist to review this operator before I demo it.

Go

Use $go-development-loop to validate the Go changes in this branch and tighten the feedback loop.

Use $go-debug-breakpoints to debug this failing test in ./internal/service with Delve.

Demo Video

Use $product-demo-video to create a 60-second developer-focused demo for this project.

Validation

These skills were validated after porting:

• every skill passed the Codex quick_validate.py validator
• bundled shell scripts passed bash -n
• the Remotion template under product-demo-video passed npm run build

Notes And Caveats

• The video template's dependency tree reported two high-severity vulnerabilities during npm install. The port preserved the upstream dependency set and did not upgrade it.
• The Kubernetes safety guard is explicit rather than automatic. Codex does not provide the same plugin hook model as Claude.
• Some workflows assume the user will either run the bundled scripts directly from this repo or copy them into the target project.

Source Lineage

These skills were ported from:

1. https://github.com/Sagart-cactus/claude-k8s-plugin
2. https://github.com/Sagart-cactus/product-demo-video
3. https://github.com/Sagart-cactus/claude-go-plugin

Future Improvements

Reasonable next steps if you want to extend this repo:

• add install scripts for ~/.codex/skills
• add repo-level tests for the copied shell scripts
• refresh the Remotion template dependencies
• add more concrete examples to each skill's references/
• split the video skill into planning vs rendering variants if usage grows