We made an AI skill that interviews you before producing anything. It beats prompt-first agents on output quality. Here's the pattern.

Most video-generation tools take a prompt and emit a clip. You tweak the prompt; you re-emit; you iterate until the clip stops being wrong. The compute cost compounds. The user gives up around iteration 4.

We made a skill called scenario-to-video where the agent — named Peter — does the opposite. Peter interviews you first. Story, audience, tone, pacing, visual style, opening frame, closing frame, shot list. Each answer persisted immediately. Then he calls the video API.

The skill has been live for a few days. The pattern is more interesting than the video output: interview-first agents produce dramatically better artifacts than prompt-first agents, for a specific architectural reason.

The prompt-first failure mode

A prompt-first agent for video looks like this:

User → "make me a video of a cat dancing on the moon" → Agent → clip → 
User → "no, more energetic" → Agent → clip → 
User → "wrong colors" → Agent → clip → ...

Each iteration spends API credits + wall-clock time. The user's mental model of the desired output gets refined through the artifact. The artifact gets refined through trial and error. Both are inefficient because they share state through the slowest channel available — a 30-90 second video render per iteration.

The interview-first pattern

Peter inverts it. The interview is the cheap iteration loop; the video is the commit.

Peter: What's the story you want to tell?
User: A short clip about engineering clarity for startups.

Peter: Who's the audience? Founders, CTOs, engineers?
User: Series-A CTOs trying to scale their first team.

Peter: What feeling should the closing frame leave them with?
User: "I know what to do Monday morning."

Peter: Two-shot or three-shot? What's the start frame for shot 1?
[continues...]

Twelve to twenty answers. Each one stored in story.json immediately. The user's mental model is refined in text, not in compute-expensive artifacts. By the time Peter calls the video API, the prompt has already converged.

The skill's hard rule on this:

"Peter does the interviewing. Do not skip questions to 'save time'. The quality of the final video is a direct function of the depth of the interview."

The architecture

SKILL.md defines the skeleton:

---
name: scenario-to-video
description: >
  Turn a scenario into a finished video. A persona named Peter
  interviews the user (story, audience, tone, pacing, visual style,
  start frame, end frame, shot list), accepts multiple reference
  images, uploads them to A2E.ai R2 storage, then calls A2E's video
  generation API (Kling 3.0 by default) over curl and stitches the
  clips with ffmpeg into one deliverable.
---

Three load-bearing engineering decisions:

1. curl and ffmpeg, never SDKs. Every API call is a curl invocation; every assembly step is an ffmpeg invocation. No Python SDK to keep up to date with provider drift. No package versioning. The skill is shell-scripts-with-prompts. It runs anywhere curl and ffmpeg exist.

# the actual generation call — no abstraction
curl -X POST https://video.a2e.ai/api/v1/generate \
  -H "Authorization: Bearer $VIDEO_GENERATION_TOKEN" \
  -d @story.json \
  > clips/shot-01.json

2. Single auth env var. VIDEO_GENERATION_TOKEN. Not "configure a vault." Not "load from JSON." One env var. Missing → stop with how-to-set instructions. Never read keys from disk, never prompt for the secret.

3. Project workspace is a directory. ~/.config/agent-skills/scenario-to-video/{project-slug}/ holds story.json (interview state), inputs/ (user images), clips/ (downloaded MP4s), final/ (ffmpeg output), logs/ (raw curl request + response bodies for every call).

That last folder — logs/ — is the part most skill authors skip. Every API call's request and response body is on disk. When a video generation fails or comes back wrong, you have the receipts. The first thing Peter does on resume is read the logs to understand what happened last time.

What "resume" means in this pattern

If story.json exists for the slug, Peter picks up where he left off. Never restarts unless the user says "new video."

The implication: the interview state is the canonical user intent. The video clips are derived. Lose the clips, you re-render. Lose story.json, you start over. The persistence asymmetry is correct — text is what's expensive to recreate; the artifacts are cheap.

Why this generalizes beyond video

Any agent that produces an expensive artifact (a long document, a code refactor, a slide deck, a video, a multi-step workflow) is a candidate for the interview-first pattern. The signal that you should use it:

• The artifact takes >30 seconds to produce.
• The user's mental model of "what I want" is not fully formed at the start.
• Iteration cost on the artifact is non-trivial (API credits, GPU time, your patience).
• The first version is almost never the final version.

For coding agents shipping small fixes, prompt-first is fine — the artifact is cheap. For agents shipping anything that costs more than 30 seconds to redo, interview-first is structurally cheaper.

What we shipped

deemwar-products/scenario-to-video

install:
  ./install.sh   # symlinks the skill into ~/.agents/skills + ~/.claude/skills

trigger from Claude Code or Codex:
  "Peter make me a video about X"
  "scenario to video — using the images in /tmp/refs"
  "build a reel from this story"

Token: export VIDEO_GENERATION_TOKEN=... (from A2E).

Engines: curl for API, ffmpeg for assembly. Both shell-outs, both inspectable, both replaceable. No SDK lock-in.

Where the rest lives

The interview-first pattern applied to other artifact types — and where it doesn't work — at: 🔗 deemwar.com

— deemwar

References

• Yao et al. — ReAct: Synergizing Reasoning and Acting in Language Models (2022). arXiv:2210.03629
• Wei et al. — Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (2022). arXiv:2201.11903
• Press et al. — Measuring and Narrowing the Compositionality Gap in Language Models (Self-Ask) (2022). arXiv:2210.03350
• Yao et al. — Tree of Thoughts: Deliberate Problem Solving with Large Language Models (2023). arXiv:2305.10601
• Anthropic Engineering — Building Effective Agents (2024). anthropic.com