Catalog
affaan-m/platform-factory

affaan-m

platform-factory

Build deterministic OCI images, SBOM/provenance evidence and hardened container or microVM runs from a compiled executable with the Platform Factory (pf) CLI, and keep its freeze lock in sync with a companion Claude Code hook. Use when a project contains .platform-factory/, when the user runs or asks about pf/platform-factory (detect, plan, freeze, build, verify, run, launch), or wants reproducible OCI builds without a Docker daemon.

v1.0LATEST
NewUpdated Nov 17, 2026

Platform Factory

Platform Factory (platform-factory, alias pf) is a single Go binary that turns a compiled executable into a deterministic OCI image, attaches native supply-chain evidence (SBOM, provenance, signatures, policy) and runs the result as a hardened container or a KVM/HVF microVM. No Docker daemon, BuildKit, syft or cosign is needed for the core path. It plugs into an existing stack; it does not replace Kubernetes, CI orchestrators or registries.

Full reference: the project's CLI guide. This skill covers the workflow an agent should follow and the guard hook that protects it.

When to Activate

  • The repository has a .platform-factory/ directory or freeze.lock.json.
  • The user runs, or asks about, pf / platform-factory commands.
  • The task is reproducible OCI image builds, SBOM/provenance evidence, or microVM execution of a legacy or dynamically linked binary.
  • You edit a dependency manifest (package-lock.json, go.sum, requirements.txt, Cargo.lock, pom.xml, ...) in a Platform Factory project.

Core Workflow

pf detect ./my-app        # native executable inspection; JSON output
# Directory detection runs loaded language-plugin inspection commands.
pf init --language node .    # create pf.yaml (language plugin must be loaded: pf plugin load node)
pf plan                   # project plan (platform-factory.dev/project-plan/v1)
pf project freeze         # pin dependencies -> .platform-factory/freeze.lock.json
pf build                  # deterministic OCI image
pf verify .platform-factory/image   # strict release gate: digests, diff_ids, platforms
pf run --runtime podman .platform-factory/image
pf diff                   # compare builds

pf launch --publish --yes freezes when required, builds, verifies, publishes to a registry and then starts the workload in one step, so it is an outward-facing action (see rule 7). pf sbom PATH... produces a reproducible SBOM natively.

Rules that matter

  1. Freeze before build. Any change to a dependency manifest makes .platform-factory/freeze.lock.json stale. Run pf project freeze, then pf build.
  2. Treat pf verify as the gate. A build is not done until verify passes.
  3. Inspect plugins before directory detection. Native executable classification does not run the target, but directory detection invokes loaded language plugins. Review those plugins and project commands as executable configuration before detect, plan, freeze, or build.
  4. Ambiguity is an error. pf detect exits with code 2 when a directory matches several ecosystems. Pass --accept-ambiguous only when the user confirmed the choice.
  5. Never add secrets to build inputs. Inputs end up in the image and its evidence.
  6. Callbacks are opt-in. pf hooks (CLI/MCP callbacks) only run when PLATFORM_FACTORY_HOOKS_CONFIG points to an explicit absolute file, so a cloned repository cannot activate executables.
  7. Keep execution within the user's authorization. Before publishing, deploying, launching, or running a workload, identify its target, image reference, and effects. Reuse explicit authorization already given for that scope; ask only when the action exceeds it. Use --dry-run where available before the authorized mutation. Do not add --yes to bypass an approval the user has not given.

Companion Claude Code Hook: freeze guard

The project ships a Claude Code plugin, platform-factory-guard, that runs next to ECC's own hooks:

Event Trigger Behavior
PostToolUse Edit/Write/MultiEdit on a dependency manifest Reminds you to run pf project freeze
PreToolUse Bash running pf build|publish|launch|deploy Warns when a manifest is newer than the freeze lock; denies if PF_GUARD_STRICT=1

It never executes pf, recognizes project configuration such as pf.yaml as well as .platform-factory/, ignores the per-user plugin directory as a project marker, and fails open. Disable with PF_GUARD=off.

Install it as a plugin (requires Node.js 18+):

/plugin marketplace add CYPT71/platform-factory
/plugin install platform-factory-guard@platform-factory

Anti-Patterns

# BAD: build right after changing dependencies
npm install left-pad && pf build

# GOOD: refresh the lock first
npm install left-pad && pf project freeze && pf build && pf verify .platform-factory/image
  • Skipping pf verify and shipping the image.
  • Passing --accept-ambiguous to silence exit code 2 without checking which ecosystem is intended.
  • Editing .platform-factory/freeze.lock.json by hand instead of re-running pf project freeze.
  • Running pf with a PLATFORM_FACTORY_HOOKS_CONFIG file you did not review.

Best Practices

  • Build the executable statically when possible (CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags='-s -w') so the image is small and reproducible.
  • Select a container or microVM from the workload's isolation requirements and available host support. This external CLI guide does not certify an ECC sandbox tier or replace ECC capability/evidence policy.
  • Use pf extensions list / pf extensions analyze for offline policy checks (AI, data, gateway, Kubernetes, supply-chain analyzers).
  • In CI, run pf verify as a required step and archive the SBOM and provenance.
  • docker-patterns - container conventions when a Dockerfile is still involved
  • deployment-patterns - rollout and release strategies
  • kubernetes-patterns - running the produced image on a cluster
  • security-review - reviewing supply-chain and secret handling
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

83/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

82

Quality

84

Clarity

85

Completeness

78

Summary

Platform Factory is a skill for building deterministic OCI images from compiled executables using the pf CLI tool, which produces supply-chain evidence (SBOM, provenance) and runs hardened containers or microVMs. The skill documents the core workflow, guard rules, and integration with a companion Claude Code hook that enforces freeze-lock synchronization.

Detected Capabilities

CLI tool execution (pf commands)file read (project detection)file write (freeze.lock.json, pf.yaml)dependency manifest inspection (package-lock.json, go.sum, etc.)plugin loading and executioncontainer/microVM runtime executionregistry publication

Trigger Keywords

Phrases that agents use to match this skill to user intent.

platform factory buildspf detect classifydeterministic oci imagessbom provenance evidencefreeze lock syncreproducible container buildsmicrovm execution

Risk Signals

WARNING

pf launch --publish --yes publishes to registry and starts workload in one command; instruction requires explicit user authorization scope before this action

Core Workflow section and Rule 7
WARNING

Directory detection with pf detect invokes loaded language plugins as executable configuration; guard rule requires plugin review before execution

Rules that matter, section 3
INFO

PLATFORM_FACTORY_HOOKS_CONFIG environment variable enables hook execution; guard rules state this requires explicit absolute file path and user review

Rules that matter, section 6
INFO

pf project freeze modifies freeze.lock.json and must be run after any dependency manifest change; anti-pattern explicitly warns against building without refreshing lock

Anti-Patterns section

Referenced Domains

External domains referenced in skill content, detected by static analysis.

github.com

Use Cases

  • Build reproducible OCI images from compiled binaries without Docker daemon
  • Generate SBOM and provenance evidence for supply-chain security
  • Detect and classify project dependencies before deterministic builds
  • Synchronize dependency manifests with freeze-lock files via guard hooks
  • Run workloads as hardened containers or microVMs with verified images
  • Compare successive builds for reproducibility and integrity verification

Quality Notes

  • Strength: Clear activation criteria tied to concrete project signals (.platform-factory/ directory, specific CLI commands, manifest changes)
  • Strength: Seven numbered rules establish explicit guardrails, particularly Rule 7 on user authorization for publish/deploy/launch actions
  • Strength: Well-defined workflow with inline commands showing each stage (detect → init → plan → freeze → build → verify → run)
  • Strength: Anti-patterns section contrasts incorrect and correct sequences, improving clarity on freeze-first discipline
  • Strength: Guard hook described with event triggers, behavior, and installation instructions; acknowledges hook activation requires explicit environment variable
  • Strength: Integration point with Claude Code plugin reduces manual oversight; PostToolUse and PreToolUse hooks enforce freeze-lock discipline
  • Minor: Related Skills section references docker-patterns, deployment-patterns, kubernetes-patterns, and security-review without links or expansion; could benefit from one-sentence descriptions of how each relates
  • Minor: 'Best Practices' section mixes infrastructure choices (static builds, container vs microVM selection) with CI/CD patterns; could be more tightly scoped to pf-specific decisions
Model: claude-haiku-4-5-20251001Analyzed: Nov 17, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use affaan-m/platform-factory in your dev environment

Command Palette

Search for a command to run...