Skip to content
Skills Library
Marketing & content · Automation

recreate-reference

/recreate-reference

Make a video in the style of a reference clip or image with Drop, the AI Content Drop video agent, from another agent. Covers reading the reference into words first (analyze_reference, acd analyze), the rights question that must be answered before a video is read, starting the run with the reference on the brief (start_video_agent, acd drop --reference), following the run, reading each piece's score, verdict and reasons and the Director's notes (get_video_agent_run, acd drop status --notes), and approving a priced retry by its exact quote (approve_video_agent_spend, acd drop retry --accept-quo

Licence
MIT
Last repository change
29.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
5
Deprecation

No signals detected. Repository changed on 29.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Make a video in the style of a reference clip or image with Drop, the AI Content Drop video agent, from another agent. Covers reading the reference into words first (analyze_reference, acd analyze), the rights question that must be answered before a video is read, starting the run with the reference on the brief (start_video_agent, acd drop --reference), following the run, reading each piece's score, verdict and reasons and the Director's notes (get_video_agent_run, acd drop status --notes), and approving a priced retry by its exact quote (approve_video_agent_spend, acd drop retry --accept-quo

Triggers from the description

s score, verdict and reasons and the Director
Original author description

Make a video in the style of a reference clip or image with Drop, the AI Content Drop video agent, from another agent. Covers reading the reference into words first (analyze_reference, acd analyze), the rights question that must be answered before a video is read, starting the run with the reference on the brief (start_video_agent, acd drop --reference), following the run, reading each piece's score, verdict and reasons and the Director's notes (get_video_agent_run, acd drop status --notes), and approving a priced retry by its exact quote (approve_video_agent_spend, acd drop retry --accept-quo

How it works

  1. 1. When this is the right skill
  2. 2. The rights question, before anything is read
  3. 3. Read the reference into words
  4. 4. Start the run with the reference on the brief
  5. 5. Follow the run and read the scorecard
  6. 6. Approve a retry by its exact quote
  7. 7. Refusals
  8. What to hand back
Original SKILL.md headings · 197 lines, 1,713 words
SKILL.md preview
---
name: recreate-reference
description: Make a video in the style of a reference clip or image with Drop, the AI Content Drop video agent, from another agent. Covers reading the reference into words first (analyze_reference, acd analyze), the rights question that must be answered before a video is read, starting the run with the reference on the brief (start_video_agent, acd drop --reference), following the run, reading each piece's score, verdict and reasons and the Director's notes (get_video_agent_run, acd drop status --notes), and approving a priced retry by its exact quote (approve_video_agent_spend, acd drop retry --accept-quote). Use when asked to recreate a clip, make something "in the style of this", "like this video", match a reference, or when a request arrives with a video or image attached as the thing to copy.
license: MIT
metadata:
  homepage: https://aicontentdrop.com/docs/mcp
  mcp_server: https://aicontentdrop.com/mcp
  repository: https://github.com/aicontentdrop/aicontentdrop
---

# Recreating a reference with the video agent

A reference run is an ordinary drop that starts from something the person
shows rather than something they describe. The agent reads the reference
into words first — its class, shots, cast, look and lines — puts those words
on the brief, and plans from them. Every made piece then comes back with a
score and a verdict, and a piece the agent would redo is offered as a priced
retry that nobody pays for until it is approved.

Two surfaces, one engine: the MCP tools `analyze_reference`,
`start_video_agent`, `get_video_agent_run` and `approve_video_agent_spend`,
or the CLI `acd analyze`, `acd drop --reference`, `acd drop status` and
`acd drop retry`. Both call the same routes (`POST /v1/engine/analyze`,
`POST /v1/engine/chat`, `GET /v1/engine/runs/:id`,
`POST /v1/engine/runs/:id/approve`). Reading the reference costs nothing;
only an approved step charges credits, and only when it succeeds.

## 1. When this is the right skill

Use it when the person hands over a clip or a still and wants something made
in its manner: "recreate this", "like this ad but for my product", "match
this look", "same shots, my brand". A request that only describes the result
in words is the `video-agent` skill; a single clip from a prompt is
`generate_video` after `estimate_credit_cost`.

When the reference tools are not listed on `tools/list`, or `analyze_reference`
answers `vision_unavailable`, the reference read is not open for this account
yet. Say so in one sentence and run the job as a plain drop from a written
brief; do not describe the reference yourself and pass it off as a read.

## 2. The rights question, before anything is read

A video is read only once the person has said who holds its rights; for an
image, ask too whenever it is clearly someone else's work.

Ask once, in words, and pass the answer exactly:

- `own_work` — the person made it or owns it.
- `licensed` — they hold a licence that covers this use.
- `permission` — the rights holder gave them permission.

Over MCP the answer goes in `rights_basis`, on every read; with the CLI it is
`--rights`. There is no default: a video sent without one is refused
(`rights_required`), and the way past that refusal is to ask the person whose
material it is, never to pick a basis.

Never choose a basis for the person, never infer it from the filename, and
never retry a refused read with a different basis to get past the refusal.
If the person cannot answer, do the job from a written brief instead.

## 3. Read the reference into words

**MCP:** `analyze_reference` with `url`, a public `https` link to the clip or
image, and `rights_basis`, the person's answer. It stores the file privately
while it is read (only the words are kept), costs no credits and is limited
per day.

**CLI:**

```bash
acd analyze ./reference.mp4 --rights own_work --pretty
acd analyze https://example.com/clip.mp4 --rights licensed
```

The answer is words only: `reference_id`, `kind`, `status`, `reference_url`,
the `reference_class` with a `confidence`, and the `facts`: a `summary`,
`shots` (index, size, camera, action, tags), `cast`, `look` (register,
palette, notes) and `lines`. The CLI prints the same words flat, with the
class as `class`. No frame, thumbnail or file ever comes back, and nothing
about the reference is kept beyond those words.

- `status: ready` carries the facts. `status: analyzing` (a longer video)
  means the read is still going. The CLI waits for it. Over MCP, start the
  run with the `reference_url` anyway: the run's first step finishes the read
  and the words appear on the run. Do not call `analyze_reference` again for
  the same clip; a second call is a second read against the day's cap.
- The class is one of `cel_anime`, `western_animation`, `3d_animation`,
  `live_action`, `ugc`, `product` or `unknown`. Show it to the person with its
  confidence; when it looks wrong, say so and pass the right one as
  `reference_class` when the run starts. The class decides which direction
  rules the agent applies, so a wrong class costs renders.
- Relay the summary and the shot list to the person as "what I saw". It is
  the agent's reading, not a transcript, and the person may correct it.

## 4. Start the run with the reference on the brief

**MCP:** `start_video_agent` with the goal in one sentence, `reference_url`
exactly as the read returned it, and `reference_class` when the person
confirmed or corrected the class. `budget_credits` is a ceiling for the whole
run; set it only when the person gives a number. `approval_mode:
"confirm_each"` makes every paid step ask.

**CLI:** one command reads the reference and starts the run:

```bash
acd drop "a 15-second vertical product ad in this style for Nimbus Tea" \
  --reference ./reference.mp4 --rights own_work --confirm-each --pretty
```

`--reference` takes a local file, a public `https` URL, or the `reference_url`
of a reference already read. `--lane auto` (the default) lets the agent choose
the recipe; `marketing`, `cinematic`, `ugc` or `drama` fixes it. `--budget N`
is the ceiling. The command prints the `run_id` and what it saw; nothing is
planned against a price and nothing is charged by starting.

The agent may answer with questions before it plans. Relay them as they are
and send the answers with `message_video_agent`. Do not answer for the person.

## 5. Follow the run and read the scorecard

Poll `get_video_agent_run` every 15 seconds (CLI: `acd drop status <run_id>`).
Report a change of phase or a finished piece, not every poll.

```bash
acd drop status <run_id> --notes --pretty
```

What a run of this kind carries beyond an ordinary drop:

- **What I saw:** `reference_class_label`, the reference's class in plain
  words. Say it that way rather than the code. The CLI prints the class and
  the summary under `what_i_saw`.
- **`pieces`:** one entry per made piece, with its `score` (0–100), its
  `verdict` and the `reasons`, and a `retry_offer` while a second attempt
  waits for a yes (section 6). The verdicts:
  - `accept` — the piece stands as made.
  - `retry` — the director suggests another take with one change to the
    prompt; `switch` — another take on another model. Either take is a new
    paid step with its own price, made only after the person approves it;
    once made it arrives as a new piece with its own score, and the first
    stays.
  - `accepted_with_notes` — the piece stands and nothing waits on it. The
    director may suggest another take: the reasons say what it would change,
    and another model for that piece can be asked for on the board, made only
    after the person approves its price.
  - `unscored` — not judged this time; its score is not a grade.
- **`director_notes`** on the run: one entry per direction rule the agent
  applied, with the rule (`skill`) and the reason (`why`), in words. With the
  CLI they print only with `--notes`, together with each piece's reasons and
  notes.

Read the score as the agent's opinion, in words, and hand the reasons to the
person with it. A score is not a promise of quality and never a reason to
approve anything on the person's behalf.

## 6. Approve a retry by its exact quote

A second attempt is a step like any other: it carries its own quote and runs
only after the person's yes. The surfaces call it **Try the other model**.

- **MCP:** the piece's `retry_offer` names that step: its `task_id`,
  `quote_id` and `credits`. While it is the next decision, the same step is
  also the run's `pending_approval`. When its `quote_id` is null the price is
  being refreshed; read the run again.
- **CLI:** `acd drop status` lists each offer under `retry_offers` with
  `piece_id`, `task_id`, `quote_id` and `credits`.

Ask in words, with the number read from the offer, never from memory:

> The agent rates the second shot 48 and offers to try it another way: up to
> 36 credits, charged only if it succeeds. Go ahead?

Only after the person says yes, approve exactly what was offered:

- **MCP:** `approve_video_agent_spend` with the `run_id`, and the offer's
  `task_id` and `quote_id` exactly as given.
- **CLI:** `acd drop retry <run_id> <piece_id> --quote <quote_id>`, with the
  `quote_id` from the offer you put to the person. Without `--quote` the
  command makes no request and refuses (`--accept-quote` alone is refused too);
  if the retry was priced again since, it approves nothing, exits 2 and prints
  the new `quote_id` and credits (`quote_mismatch`): ask again with that number.

Approving the same quote twice does nothing the second time. A declined offer
leaves the piece as it was, with its score. One offer per piece: when it is
gone, the piece stands.

## 7. Refusals

| Refusal | What it means | What to do |
| --- | --- | --- |
| `vision_unavailable` (403) | The reference read is not open for this account | Say so; run a plain drop from a written brief |
| `analysis_cap` (429, `reset_at`) | Today's free reads are used | Tell the person when it resets; do not retry before then |
| `rights_required` (400) | A video reached the API with no rights basis (the CLI without `--rights`) | Ask the rights question (section 2) and send the answer |
| `too_large` (413) / `unsupported_type` (415) | Too large, or not an image or video the API reads | Ask for a smaller file or a supported format |
| `reference_storage_unavailable` (503) | The reference store is not ready | Retry in a few minutes; nothing was read or charged |
| `QUOTE_EXPIRED` | The retry's price lapsed; nothing was released | Read the run again for the new `quote_id`; ask again if the number moved |
| `QUOTE_MISMATCH` | That quote is not the one on that step | Read the run again and pass `task_id` and `quote_id` exactly as given |
| `ENTITLEMENT_REQUIRED` | The account cannot run this on its current plan | Give the `info_url` it carries (`https://aicontentdrop.com/plans`) and nothing else about plans |

## What to hand back

What the agent saw (the class in plain words and the summary), the board
link, each finished piece with its link, score and verdict, `credits_spent`
for the whole run, and any retry still offered with its number, so the person
can decide it on the website if they prefer.

Versions

The database has no other skills named recreate-reference.

Database snapshot: 13.11.2026 · package version ee0832b7c986 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90video-agent
    Hand a whole piece of video work to Drop, the AI Content Drop video agent, from another agent. One brief is carried through research, concepts, a storyboard, renders and assembly, and every step that charges credits stops for an approval. Covers start_video_agent,…
  • 100mirroring-reference-video
    Use when someone shares a reference video, ad, Reel, Short or TikTok (link or file) and wants their own video to follow its structure, pacing or visual style
  • 100ai-video-model-picker
    Choose the right AI video model for a brief and quote its credit cost before generating, using the AI Content Drop catalogue. Use when asked to generate a video and you must decide which model, when someone asks what a batch of clips will cost, or when a model id is rejected as unknown.
  • 90video-reference-motion
    Use when the task is to extract useful motion, timing, and camera cues from a supplied video reference.
  • 100reference-matching
    Recreate the look and rhythm of a reference video ("make it like this reel") - measure its cut times, shot lengths, beat alignment, text timing and positions, fonts, transitions, grade and audio, write a style spec, then rebuild with the user's footage and compare side by side.…
  • 90reference-video-teardown
    Convert a reference video into a frame-by-frame editing breakdown you can recreate from — masking, hand-triggered reveals, transitions, timing, layers, effects, plus a step-by-step rebuild guide and a reusable system prompt. Use when the user supplies a reference video/reel and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.