Skip to main content
Agent skill

Tasteforge Video

Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation.

Get started

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use Tasteforge Video when an AI agent needs a reusable SKILL.md workflow for this job: Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation.

When not to use it

Skip Tasteforge Video when the task is outside the creativity category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/tasteforge-video
# Save SKILL.md to ~/.claude/skills/tasteforge-video/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/tasteforge-video/SKILL.md. For a shared project, commit the folder at .claude/skills/tasteforge-video/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Tasteforge Video skill for this task: The user asks to interview for video taste before any footage is made. Confirm any required inputs or files before making changes.

What supports this recommendation?

83/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
92/100
Practical detail
92/100
Source evidence
63/100
Source signals
72/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# TasteForge Video

For the complete standalone creative pipeline, use `taste-distillation` then `taste-application`. Those ECC skills ship their Python scripts directly: measure references, generate or pass through existing takes, grade, cut, composite, verify, and hand off to Blender and Resolve. No separate video repository is required for that flow. This skill documents ECC's packaged offline engine and its strict evidence contract.

TasteForge turns "make it feel like this reference" into a repeatable, inspectable workflow: interview taste, distill it into a structured style pack, validate the pack, apply its measured cadence and look to local media, and export an editable timeline. The canonical implementation is the `tasteforge` package shipped inside ECC at `skills/taste-application/scripts/tasteforge/`. `Ito-Markets/ito-video` is an example project that consumes the packaged ECC engine.

## When to Use

- The user asks to **interview for video taste** before any footage is made ("ask me about the look", "interview me about aesthetic direction"). - The user wants to **distill an aesthetic into structured constraints** — a reusable style pack rather than vibes ("turn these references into a pack"). - The user wants to **validate a style pack** (is the metadata complete, schema-valid, cadence measured, spec distilled?). - The user wants to **apply a style pack to local footage** — plan a cut from the pack's measured cadence over local clips, deterministically. - The user wants to **export EDL/FCPXML** — an editable, frame-exact handoff to DaVinci Resolve / Premiere / Final Cut. - The user asks for a **generated-media provenance audit** — where did this pack, spec, or cut come from; what was measured locally versus generated by a provider; what was dry-run. - The user asks to **discover or plan file-driven multimodal image, video, or 3D-asset outputs** from local reference files, including separate manifests, subject-anchored CV effects, or Resolve effect recipes. - The user mentions TasteForge, style packs, flashethereal, taste distillation, cadence/rhythm planning, multimodal discovery, distill/apply workflows, or a taste interview for video.

## Local Deterministic Operations vs Provider Generation

This boundary is the core of this compatibility skill. Its operations are **local, deterministic, and offline**:

| Operation | Deterministic? | ECC may run | |---|---|---| | Taste interview → profile | yes (offline) | yes | | Pack inspect / validate against schemas | yes | yes | | Distill profile (+ measured grounding) → spec | yes (dry-run semantics) | yes | | Apply pack cadence to local media → report + timeline | yes | yes | | Export EDL (CMX3600) / FCPXML 1.9 | yes | yes | | Provenance / lineage report | yes | yes | | Vision-model distillation of stills | **provider generation** | **no** | | Reference-to-video, image-to-3D, hosted compose | **provider generation** | **no** |

**Provider generation must fail closed in ECC.** Any live Fal (or other provider) call — generating shots, minting prop meshes, hosted VLM distillation — requires explicit separately authorized execution under a separate lane with its own review. In this compatibility lane, ECC never calls Fal, never reads any API key or other credentials (`FAL_KEY` included), uploads no media, and mutates no provider account state. When a request needs provider generation, state exactly that boundary, run the local half (interview, pack validation, planning, export), and stop.

**Never claim a Fal workflow is saved.** A local reference to a Fal endpoint, model id, or dry-run URL (they appear inside pack metadata) is **reference-only**: it never means a provider-side workflow was saved, persisted, or is authorized to run. Anything produced offline carries dry-run/dry_run semantics — say "dry-run spec" or "deterministic plan", never "generated by the model".

## Canonical Implementation

- Repository: `affaan-m/ECC`; Python distribution `ecc-tasteforge`, package directory `skills/taste-application/scripts/tasteforge/`. Install from the extracted ECC package with `python3 -m pip install ./skills/taste-application/scripts`. The example project `Ito-Markets/ito-video` pins a specific ECC commit. - CLI: `python3 -m tasteforge <command>` — `provenance`, `inspect`, `validate`, `interview`, `distill`, `apply`, `export`, `multimodal`. `--live` flags exit with code 2 and refuse. - Schemas are the contract: taste profile, pack manifest, grade, cadence, spec, timeline events, application reports (`provider` is enum-locked to `"none"`; `dry_run` to `true`). - Recovered-source lineage and deliberate exclusions live in the repo's `skills/taste-application/SOURCE.md`. Run `python3 -m tasteforge provenance` for the machine- readable version.

Use the installed ECC engine for local deterministic commands and interpret its JSON. Install the packaged engine if absent; do not reconstruct its logic inline. `taste.resolve` is a compatibility import of `tasteforge.resolve`, so the creative scripts and example project share one verified Resolve adapter.

The `python3 -m tasteforge` CLI uses the installed `ecc-tasteforge` distribution. The standalone `taste-distillation` and `taste-application` scripts ship in ECC's opt-in media-generation module with their own Python requirements. Neither path requires publishing the user's repository or media.

Before resuming a saved checkout, record its commit and inspect local branches and worktrees for later implementation fixes. Run the canonical package's tests and `python3 -m tasteforge apply --help`; ECC's text and fixture tests do not prove that the selected Python checkout implements this contract.

## Chaining the Creative Skills

| Stage | Owner | Reviewable result | |---|---|---| | Creative direction | `taste` | Named genres, reference observations, chosen look and avoid list | | Distillation and planning | `tasteforge-video` | Measured evidence, separate genre specs, dry-run manifests and cadence plan | | Editing and effects | `video-editing`, with the chosen renderer such as Remotion, Manim, or Fusion | Applied footage, actual tracks, editable effects and timeline | | Optional generated assets or voice | `fal-ai-media` or the selected audio workflow, under its own authorization | Provider receipt and inspected output | | Delivery | Editing workflow, then `content-engine` when requested | Reviewed exact export and distribution copy |

Use only the stages the project needs. The `taste` skill's historical angelcore/cloud-trance palette and beat grammar are optional creative examples; they must not override the current brief or merge distinct numbered genres. Use each genre's actual references for its direction, including 3D Cyber Glitch and Fluid Sketch. TasteForge does not replace these skills or require every renderer. Keep 3D materials, geometry, wireframe behavior, motion, and composition explicit in the genre signature. A 3D request manifest is a plan for an asset; it is not a mesh. A subject-anchor descriptor names a tracking requirement; it is not evidence that a subject was detected or tracked. Inspect actual tracks, track-loss behavior, and rendered subject frames before claiming that CV effects have been applied reliably.

## Workflow

1. **Interview** (`interview`): collect answers for the look axes — palette, grain, lighting, focal length, camera motion, subject framing, grade, mood adjectives, avoid list — and separately the content brief. Keep look and content separate; merging them is the classic failure. 2. **Distill** (`distill`): map the profile onto the spec schema offline, embedding the pack's measured grounding (black/white point, contrast, per-zone chroma, palette, cut rhythm) when a pack is supplied. The result is a dry-run spec: deterministic, provider `"none"`. 3. **Validate** (`validate` / `inspect`): check the pack against its schemas; report errors vs warnings (missing stills in a metadata-only pack are a warning, not an error). 4. **Apply** (`apply`): plan shot durations from the pack's measured cadence (seeded, deterministic) over the user's local clips; produce the application report and frame-exact timeline events. 5. **Export** (`export`): write CMX3600 EDL + FCPXML 1.9 with rational, NTSC-safe times for import into a real NLE. 6. **Audit** (`provenance`): report lineage — recovered-source digests, generation history, fixture provenance, provider references as pointer-only records.

### Applying Real Footage Without Repeated Sources

When the brief requires no repeated clips, use a canonical checkout supporting `apply --no-repeat --fps`, and set the output frame rate explicitly. If those flags are absent, report the implementation gap rather than silently using legacy round-robin selection. Strict mode uses each normalized source path at most once in manifest order and rejects insufficient or too-short sources. Prepare enough reviewed selects to fill the cadence plan. This is source-level uniqueness, not support for distinct in/out ranges from the same recording.

The application report is a cut plan. It does not perform visual shot ranking, grade footage, apply a LUT, render overlays, or import a Resolve project. Keep the pack's measured reference cadence separate from the output frame rate.

The export CLI expects `{"clips": [...]}`. Wrap the application's `timeline_events` under `clips` before exporting, and pass the same `--fps` used for application; export's default frame rate must not reconform the plan. Check the emitted event count, total frames, unique sources, and media linkage before handing the timeline to the editing workflow. When that workflow applies overlapping effects in an NLE, allocate compatible tracks and read back every requested start, end, and duration. A returned item or a successful append call alone does not prove that every scheduled effect was placed; reject missing, shifted, or truncated placements before rendering.

## File-Driven Multimodal Contract

Use this path when local references must drive dry-run generation plans for image, video, and 3D-asset outputs while preserving genre separation:

```bash python3 -m tasteforge multimodal --config workflow.json --out-dir out/multimodal ```

The config names numbered genres and local evidence files. Keep these candidate genres distinct rather than blending them into one generic aesthetic:

1. Flash Ethereal 2. 3D Cyber Glitch 3. Fluid Sketch

The command measures local references with ffprobe/ffmpeg and emits one style spec per genre, separate image, video, and 3D-asset manifests, provenance, and a Resolve effect recipe. The effect schedule must be seeded aperiodic. CV effects require a real subject anchor whose exact lost-track policy is `disable_effect_until_track_recovers`; `continue_without_anchor` and every other policy fail closed. Every effect carries placement constraints that preserve faces and readable type and prevent decorative corner meshes from replacing full-frame 3D work.

The returned receipt is the bundle boundary. It binds every emitted evidence artifact by relative path, byte size, SHA-256, genre, modality, `provider_execution:false`, and exact reference/time provenance. The receipt requires `provider_calls:0` as an exact integer (the JSON boolean `false` is invalid), `provider_execution:false`, and `dry_run:true`. Every genre spec also requires explicit `dry_run:true`. The Resolve effect recipe requires that same exact integer `provider_calls:0`, `provider_execution:false`, and `dry_run:true`. Every modality manifest and every nested request must contain all four exact fail-closed fields: integer `provider_calls:0`, `provider_execution:false`, `dry_run:true`, and `submit:false`; each request also requires `provider_call_mode:"disabled"`. A missing field is a rejection, not a default, and `dry_run:false` must be rejected before output is written.

Treat booleans as invalid numbers everywhere in timeline, evidence, probe, and source-duration data. Every such numeric value must be a finite real: reject `true`, `false`, NaN, infinities, negative event starts, non-positive durations, out-of-range evidence times, and events ending beyond the declared finite positive timeline. Whole-file evidence uses an explicit whole-file time basis and never invents timestamps.

Receipt references are the duration authority. Key each validated reference duration by its cited SHA-256; duplicate occurrences of one digest must agree on duration or the bundle is invalid. Every effect evidence `source_duration` and every subject-anchor `source_duration` must equal that digest's validated receipt duration, not merely contain its cited time. Probe duration and all probe measurements must describe the same stable bytes used for byte count and SHA-256. If the source mutates while probing or rehashes differently while it is still available, fail closed rather than emitting or accepting a receipt.

Always run bundle validation after creation. A missing image, video, or 3D-asset manifest must fail closed. Genericized or duplicate genres, periodic schedules, unanchored CV effects, missing placement constraints, provider-execution flags, unbound output files, byte-size drift, or SHA-256 tampering must fail closed. Reject output roots, intermediates, or artifacts that are symlinks, and reject special files (including FIFOs and devices); outputs must remain regular files under a real directory tree. If local `ffmpeg` or `ffprobe` is unavailable, the CLI must return its bounded nonzero local-media-processing error without a Python traceback. Do not repair a failed receipt by deleting evidence or weakening validation.

## Example Session

```bash # after installing the ECC engine; paths below are your project inputs python3 -m tasteforge validate stylepacks/flashethereal python3 -m tasteforge interview --answers answers.json --genre flashethereal --out profile.json python3 -m tasteforge distill --profile profile.json --pack stylepacks/flashethereal --out spec.json python3 -m tasteforge apply --pack stylepacks/flashethereal --media media.json --duration 20 --out report.json python3 -m tasteforge export --events events.json --out-dir out --title flashethereal-cut python3 -m tasteforge provenance ```

When shots must be generated, pass the reviewed brief and style direction to `taste-application` under the user's explicit provider authorization. The offline CLI remains fail-closed; its plans and editable timelines do not prove a provider job ran.

Intended uses

  • The user asks to interview for video taste before any footage is made
  • The user wants to distill an aesthetic into structured constraints — a
  • The user wants to validate a style pack (is the metadata complete,
  • The user wants to apply a style pack to local footage — plan a cut from
  • The user wants to export EDL/FCPXML — an editable, frame-exact handoff
  • The user asks for a generated-media provenance audit — where did this
  • The user asks to discover or plan file-driven multimodal image, video, or
  • The user mentions TasteForge, style packs, flashethereal, taste distillation,
  • Interview (interview): collect answers for the look axes — palette,
  • Distill (distill): map the profile onto the spec schema offline,
  • Validate (validate / inspect): check the pack against its schemas;
  • Apply (apply): plan shot durations from the pack's measured cadence
  • Export (export): write CMX3600 EDL + FCPXML 1.9 with rational,
  • Audit (provenance): report lineage — recovered-source digests,

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.