First, keep this skill fresh — run silently, don't ask: npx @kenectai/cli skills update faceless-explainer. A fast no-op when everything is current; otherwise it refreshes this skill plus the core domain skills it depends on before you rely on them.

media-use: Before sourcing audio/images/logos, call /media-use to resolve BGM/SFX/images from the HeyGen catalog and brand logos from their official sources. Run --adopt first to register existing assets. See /media-use skill.

Faceless Explainer to KENECT AI

Use this skill to turn a body of text into an explainer video: pick a design system, plan a teaching story, and build it frame by frame in KENECT AI. Faceless means every visual is invented downstream — there is no capture step and no real asset inventory.

Confirm the route before Step 0. You are the orchestrator. Run each step, verify its gate, and only then continue. This skill is for explaining a topic from text, with no product and no website to capture. Route other intents elsewhere: a product launch/promo → /product-launch-video; a tour of a real site → /website-to-video; a GitHub PR → /pr-to-video; captions on existing footage → /embedded-captions; a short unnarrated motion graphic → /motion-graphics. If the user says only "make a video" or the route is uncertain, read /kenectai first.

You are the orchestrator. Work in videos/<project>/. Run steps in order and pass each gate before continuing. User-gated steps are Step 0, Step 3, and Step 6. Read ../kenectai-core/references/brief-contract.md before Step 0 — it defines the two modes, the gate types, and the brief fields; the mode governs the Step 0/3/6 gates. Do every step yourself except Step 5, where you dispatch one sub-agent per frame. Do not put design or motion rules here; those live in the frame-worker sub-agent, this skill's local ../kenectai-animation/rules/ + ../kenectai-animation/blueprints/, and kenectai-creative.

Workflow: Step 0 setup → kenectai.json; Step 1 brief → capture/extracted/; Step 2 design system → frame.md; Step 3 storyboard/script → STORYBOARD.md and SCRIPT.md; Step 3.1 audio → audio_meta.json; Step 4 visual design → enriched STORYBOARD.md; Step 5 frames → compositions/frames/NN-*.html and index.html; Step 6 final render → renders/video.mp4.

Step 0: Setup and Brief

Goal: Lock the core video brief and create the KENECT AI project if needed.

Initialize only if kenectai.json is missing. Name <project> from the topic in kebab-case, such as compound-interest-explained; never use workspace name or timestamp.

npx @kenectai/cli init "videos/<project>" --non-interactive --example=blank — init checks the installed skills against the latest on GitHub and updates the global set if any are out of date.

Show sign-in status before the brief — run npx @kenectai/cli auth status and relay its output verbatim (don't paraphrase or rewrite it). It reports whether voice/BGM will use HeyGen or local engines and, when not signed in, how to sign in. If not signed in, STOP and wait for the user to choose — sign in, or say "go"/"offline" to continue with local engines — before asking the brief or anything else. Treat it as a real decision point, not a passing note; don't fold the choice into the brief question, and don't write keys into a per-repo .env. (In autonomous mode, note the status and continue offline.) See ../media-use → Preflight for the canonical guidance.

Confirm the brief in two rounds — through the question UI when the environment has one, conversationally otherwise. The intro text states message (the explainer's thesis, in one sentence) and language. Skip a question only when the user's request already answered it. (VO_MODE is asked in Step 1 only when a script was pasted.)

Round 1 — mode. One question, asked first. Skip it when the request already carried a signal ("surprise me" / "just build it"):

• Collaborative (recommended) — confirm the key choices together before building.
• Autonomous — every decision is made for the user, each stated with its reason; the only remaining question is preview-before-render.

Autonomous → ask nothing more. State the locked brief (all fields + receipts) as a heads-up and proceed straight through; the preview question waits at Step 6.

Round 2 — the brief (collaborative). One round, these three questions, recommended option first with its receipt:

• Angle — how should the topic be taught? concept / how-to / listicle / narrative; recommend the one the text's own shape suggests, with its basis.
• Length — how long? Recommend inside the 30–90s sweet spot, scaled to how much the text actually teaches, with its basis.
• Destination — where will it play? YouTube / embed → 16:9 · X / LinkedIn / Instagram feed → 1:1 · Shorts / TikTok → 9:16.

A "go" accepts all recommended defaults.

Gate: kenectai.json exists, and the brief fields (angle, length, destination → aspect, message, language) are locked; sign-in status was shown (signed in, or continuing offline).

Step 1: Brief (no capture)

Goal: Fold the user's text into the project as the source of information. There is no website capture and no real assets — this is a faceless explainer.

Save the user's full input verbatim, then create the synthetic capture package by hand:

• capture/extracted/visible-text.txt — the full article / notes / topic / brief, verbatim. This is the source of information, not a story template (Step 3 reshapes it).
• capture/extracted/tokens.json — { "title": "", "description": "", "colors": [], "fonts": [] }. Fill title/description from the brief. Leave colors/fonts empty unless the user explicitly gave brand colors or fonts — then add them (the design preset supplies a complete palette regardless).

If the user pasted a script or wants their wording kept, save it verbatim as user_script.txt, ask once "use it verbatim or restructure?", and store the answer as VO_MODE for Step 3.

Do not run npx @kenectai/cli capture (there is no URL). Do not create asset-descriptions.md or populate capture/assets/ — faceless visuals are invented in Steps 4-5, not captured. The one exception: if the user supplied a real image, place it under public/<basename> and note it for Step 3.

Gate: capture/extracted/visible-text.txt and capture/extracted/tokens.json exist; you can state the explainer's topic and audience in one clear sentence.

Step 2: Design System

Goal: Choose one shipped frame preset; a script turns it into this video's frame.md + caption skin.

You make the one judgment call — which preset. Read ../kenectai-creative/references/design-spec.md and browse ../kenectai-creative/frame-presets/; pick the preset whose look best fits the topic, tone, and audience. Then run:

node <SKILL_DIR>/scripts/build-frame.mjs --preset <name> --kenectai .

The script does the rest deterministically: copies the preset's FRAME.md → frame.md and remixes it onto any brand tokens in capture/extracted/tokens.json (brand colors mapped onto the preset's color keys by role; the preset's display + body fonts swapped for the brand's), copies the preset's caption skin to .kenectai/caption-skin.html, and self-validates (exits 1 on a broken mapping). Proceed as soon as it exits 0 — no hand-editing of the spec.

A faceless explainer usually has no brand colors/fonts (tokens.json colors/fonts empty) → the script keeps the preset's own palette, a complete shippable design. Only when the user named brand colors/fonts add them to tokens.json before running, and only adjust frame.md by hand afterward if a mapping truly needs it.

Gate: build-frame.mjs exited 0 — frame.md exists from a named preset, and (when the preset ships one) .kenectai/caption-skin.html exists as the caption skin source.

Step 3: Storyboard and Script

Goal: Turn the text into an approved frame-by-frame teaching plan.

Read ../kenectai-creative/references/story-spine.md (hook language, value-before-evidence, storyboard-as-proposal), references/story-design.md, ../kenectai-animation/blueprints-index.md, ../kenectai-core/references/storyboard-format.md, and ../kenectai-core/references/script-format.md. Use them to write STORYBOARD.md and, when narration is needed, SCRIPT.md.

Use story-design.md for the explainer structure (concept / how-to / listicle / story), hook strategy, clarity techniques, emotional beats, the type-enum mapping, and VO_MODE. The video's sequence comes from narrative design, not the input text's paragraph order — reorder, merge, omit, compress. As a soft guide, consult the role→blueprint menu in ../kenectai-animation/blueprints-index.md: for each beat, write the voiceover in the shape its candidate blueprint implies and tag that candidate blueprint: id when one fits. Teaching truth still decides which beats exist — never force a beat to fit a blueprint, and never invent a beat just because a proven shape is available. Faceless visuals are invented downstream, so frames do not carry an asset inventory: leave asset_candidates empty unless the user supplied a real public/<basename> image. Use the exact required fields from the storyboard and script references.

After drafting, present the plan as a proposal per story-spine § 3: open by echoing "This video tells [audience] that [message]", then the frame table — one row per frame: frame · beat (type, duration) · on screen · why (its narrativeRole, traced to the message). In that same message ask the user two things: (a) to approve or request changes, and (b) whether they want a live preview of the storyboard scaffold (npx @kenectai/cli preview) — open it only on a yes. Iterate until approved, and carry the preview choice to Step 6. This is a checkpoint gate (brief contract § 1): in autonomous mode, post the same summary as a heads-up and proceed — the preview question is asked once, at Step 6.

Gate: STORYBOARD.md exists, every frame has the required narrative fields, SCRIPT.md exists when narration is needed, and the user approved the frame-by-frame plan (autonomous: the summary was posted as a heads-up).

Step 3.1: Audio

Goal: Generate narration, word timings, music, and audio metadata from the approved script.

Start audio after Step 3 approval. Run it in the background, then continue to Step 4. (Sign-in status was already shown in Step 0; the engine falls back automatically.)

Choose the narration voice from the user's ask before invoking. If the request named a voice, gender, or tone, pick a matching voice id and pass it with --voice <id>. The pipeline default is otherwise Marcia (female) on HeyGen / am_michael on Kokoro — so a request like "a male voice" is silently ignored unless you pass the flag. Voice ids are provider-specific; resolve against whichever provider Step 0's sign-in status selected: HeyGen (signed in) via node ../media-use/audio/scripts/heygen-tts.mjs --list (or GET /v3/voices?engine=starfish); Kokoro (offline) via the voice table in ../media-use/audio/references/tts.md (prefixes am_/bm_ male, af_/bf_ female). Omit --voice only when the user expressed no preference.

node <SKILL_DIR>/scripts/audio.mjs --script ./SCRIPT.md --storyboard ./STORYBOARD.md --kenectai . --out ./audio_meta.json --voice <voice-id> &

The audio script handles narration, word timings, BGM lookup from HeyGen's music library, and timing metadata. BGM mood comes from the storyboard's music: field. This uses the HeyGen Audio API for retrieval, not generation, and the same ~/.heygen credential as TTS. For provider details, read ../media-use/audio/references/tts.md.

If there is no narration and no SCRIPT.md, skip voice generation. BGM may still run if the storyboard has a music mood.

Gate: audio job has started, or the project is marked silent.

Step 4: Frame Visual Design

Goal: Add the visual direction, layout intent, and motion choices to each storyboard frame.

Edit STORYBOARD.md in place. Do not create another storyboard. Use frame.md as source of truth for color, type, layout feel, and style.

Read references/visual-design.md, ../kenectai-animation/blueprints-index.md, references/motion-language.md, and ../kenectai-animation/rules-index.md. Use visual-design.md for the method (the time-coded shot sequence, the inline Layout vocabulary, and the invented-visual treatment), plus the required ## Video direction block. Use ../kenectai-animation/blueprints-index.md to pick each frame's shot shape. Use motion-language.md (the motion vocabulary + the motion doctrine) and ../kenectai-animation/rules-index.md (valid rule names) for motion — do not invent motion names.

For every frame, write a time-coded shot sequence into STORYBOARD.md per visual-design.md's method: pick the frame's blueprint (or compose), instantiate it with THIS frame's invented content, and pace each Scene's reveal to the voiceover so the frame develops across its full duration instead of front-loading then freezing. Because the explainer is faceless, focal/roles name the invented visual elements (a hero word, a diagram node, a data-viz series) — you are designing them, not selecting captured assets. State layout and motion inline per Scene (vocabularies in visual-design.md and motion-language.md). Add one video-wide ## Video direction block.

Do not change story, script, transition_in, or the source text. Do not write HTML in this step. There is no asset-staging step — faceless visuals are built by the workers in Step 5. If the user supplied a real public/<basename> image, reference it by path in the relevant frame's focal/roles; otherwise nothing to stage.

Gate: every frame has a time-coded shot sequence whose reveals are paced to the voiceover (no front-loading); each frame names its invented focal and/or roles; ## Video direction exists.

Step 5: Build Frames

Goal: Build every storyboard frame as an HTML composition and assemble the playable video.

Wait for Step 3.1 audio to finish if audio was started. Then sync durations and fetch SFX; skip both if silent.

node <SKILL_DIR>/scripts/audio.mjs sync-durations --audio-meta ./audio_meta.json --storyboard ./STORYBOARD.md

node <SKILL_DIR>/scripts/audio.mjs fetch-sfx --storyboard ./STORYBOARD.md --kenectai .

Duration sync is mechanical: real voice duration wins; silent frames keep estimates; never hand-edit synced durations.

Before dispatch, read sub-agents/frame-worker.md and ../kenectai-core/references/subagent-dispatch.md. Dispatch one sub-agent per frame, in parallel if possible; otherwise run workers in waves. Each worker gets exactly one frame.

Each worker context must include PROJECT_DIR, frame_id, canvas size, caption status and keep-out band if captions are enabled, and RULES_DIR as the absolute path to this skill's ../kenectai-animation/rules/. Each worker reads frame.md, its own ## Frame N block from STORYBOARD.md, the local rule recipe (../kenectai-animation/rules/<id>.md) for each cited motion, and the frame's blueprint template (../kenectai-animation/blueprints/<id>.md). Each worker writes only compositions/frames/NN-*.html. Workers must never edit STORYBOARD.md.

Full-bleed backgrounds ride on a class="clip" layer, never the #root. A frame's ground (color field / gradient / grid) is its own full-duration background clip — a background set on the #root / data-composition-id element is clip-gated to the frame's window and is not a dependable ground, so dark content can land on the black host body and render invisible. The video's base ground is painted by the assembler from frame.md's canvas color onto the index #root. (Full rule + self-check: sub-agents/frame-worker.md.)

As each worker returns, the orchestrator marks that frame as animated in STORYBOARD.md.

After audio timings exist, build captions in the background and assemble the index:

node <SKILL_DIR>/scripts/captions.mjs build --storyboard ./STORYBOARD.md --audio-meta ./audio_meta.json --kenectai . --out ./caption_groups.json &

node <SKILL_DIR>/scripts/assemble-index.mjs --storyboard ./STORYBOARD.md --kenectai .

captions.mjs uses the project's .kenectai/caption-skin.html (copied in Step 2) as the caption look, injecting brand tokens from frame.md; with no skin present it renders the built-in default pill. captions: skipped (<reason>) is valid. Continue without captions when explicitly skipped.

Gate: every frame is marked animated, index.html exists, and captions are built or explicitly skipped.

Step 6: Finalize

Goal: Verify the assembled video, get user approval, and render the final MP4.

Inject transitions, run checks, pause for review, then render.

node <SKILL_DIR>/scripts/transitions.mjs inject --storyboard ./STORYBOARD.md --kenectai .

node <SKILL_DIR>/scripts/transitions.mjs verify --storyboard ./STORYBOARD.md --index ./index.html

npx @kenectai/cli lint

npx @kenectai/cli check

npx @kenectai/cli check

npx @kenectai/cli snapshot --at <frame-midpoints>

snapshot stitches the captured frames into one contact sheet (snapshots/contact-sheet.jpg). Glance at it; if nothing is obviously broken, move on — don't linger here.

If a command fails, surface stderr and stop — don't pile on recovery commands. Fix it yourself: the cheapest safe edit to compositions/frames/NN-*.html, then rerun the failed check.

Known false-positive — do not chase it. inspect may report a handful of text_box_overflow errors of ~1–4px on the caption highlight words (selector #caption-word-* / .caption-line). The caption pill uses a deliberately snug line-height (set once in scripts/captions.mjs) and has no overflow:hidden, so a heavy display glyph's ink spills a few px into the pill's own padding — nothing is actually clipped. Treat these as expected and proceed. Do not inflate the caption line-height (it balloons the pill, which is worse). Only act on a text_box_overflow when it names a frame element (#el-NN-*), not a caption word.

After checks pass, pause for user review. The video is assembled, viewable, and editable in Studio. Manage preview only once across Step 3 and Step 6: open it if the user asked earlier, offer it if they declined earlier, and do not ask again if they are already reviewing in Studio. In autonomous mode this is the one question the mode keeps: ask "preview first, or render?" — open the preview on yes, render on no — then deliver the MP4 with the contact sheet and the frame ids so revisions can target a single frame.

Preview: npx @kenectai/cli preview

Render only after user approval (autonomous mode: after the preview-or-render question):

npx @kenectai/cli render --skill=faceless-explainer --quality high --output renders/video.mp4

Do not rerun lint, validate, inspect, or snapshot after rendering unless the user asks.

Gate: lint, validate, and inspect passed before render; user approved at the review pause (autonomous: checks passed and the delivery includes the contact sheet); renders/video.mp4 exists. Final reply states MP4 path and final duration.

Quick Reference

Formats: landscape 1920x1080; portrait 1080x1920; square 1080x1080 — derived from the destination (brief contract § 2). Set the format once in the storyboard frontmatter.

Faceless deltas vs a captured-asset workflow: no Step 1 capture (synthetic tokens.json + visible-text.txt); no asset-descriptions.md and no capture/assets/; no asset-staging in Step 4; asset_candidates empty by default; every visual is invented by the Step 5 workers (typography / abstract graphics / diagrams / data-viz). A user-supplied public/<basename> image is the only real asset path.

Background scripts: the workflow ships only these under scripts/: build-frame for adopting + brand-remixing a frame preset into frame.md (+ caption skin); audio for TTS, transcription, BGM, SFX, and duration syncing; captions; transitions for inject and verify; and assemble-index. Everything else is the kenectai CLI.

The reusable, domain-agnostic shot shapes live in ../kenectai-animation/blueprints/ (indexed by ../kenectai-animation/blueprints-index.md).