Seedance Sequence logo

Seedance Sequence

CommunityPopular
Emily2040
seedance-sequence

This skill should be used when a Seedance 2.0 request is a long story, connected set of clips, multi-generation scene, campaign sequence, dense storyboard, continuation-ready plan, or any idea that must be divided into stateful clips.

Overview

PublisherEmily2040
Repositoryseedance-2.0
Skill nameseedance-sequence
Stars
7.4K
Forks
1.1K
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by Emily2040 on GitHub. Read the source before you install it.

Installation

Install the Seedance Sequence AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/Emily2040/seedance-2.0.git /tmp/seedance-2.0
mkdir -p .claude/skills
cp -r /tmp/seedance-2.0/skills/seedance-sequence .claude/skills/seedance-sequence
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Seedance Sequence in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Seedance Sequence on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Seedance Sequence is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

seedance-sequence

Before producing prompt text, a prompt-ready block, a rewrite, an example, or a compiled clip, load the Director's Read, classify the brief, and complete its canonical narrative or non-narrative record. Translate that record into visible or audible carriers and keep its internal labels out of final generation prose.

Use this when the user's idea is larger than one reliable generation, when connected clips are requested, or when the user says continue, extend, next part, part two, next scene, or make it longer. Plan globally, generate locally: the skill plans the whole story, but compiles only the next unresolved clip.

Load the Director's Read, sequence-project-state, continuation-handoff, prompt-compiler, surface-prompt-profiles, event-density, and continuity-qc. Load reference-transfer-contract when references are present and dense-storyboard-mode when the request contains many shots or animation panels. Load directing-engine to set one directorial voice for the whole story and plan the long-form spine so the look is authored by one hand across every clip. For a user's first multi-clip project, sequence-worked-trace walks the whole loop once - plan, deviation, reconciliation, chain cap, re-anchor, resume.

Intent

The user is trying to make a film, not a pile of prompts. This skill protects the thread of action across generations: what already happened, what is happening now, what must not happen yet, and what the accepted footage actually shows. The plan is global; the prompt is local.

Sequence Classifier

Classify as sequence_project when the story exceeds the verified active-surface duration, asks for multiple connected clips, contains several narrative beats, is a film scene, ad, campaign, music sequence, action scene, dialogue scene, or uses continue/extend/next-part language. Otherwise classify as standalone_clip and return to the concise prompt path.

For every request also classify:

  • generation input mode: T2V, I2V, V2V, R2V, FLF2V, edit, native extend when verified for the active surface, or troubleshoot;
  • sequence relation: standalone, sequence_first_clip, seamless_continuation, intentional_next_shot, bridge_between_known_states, repair_tail, or reanchor_after_drift;
  • shot structure: compact_single_take, phased_single_take, dense_multishot, first_last_frame_transition, or video_edit_contract;
  • medium grammar: live_action, 3d_animation, 2d_animation, product_or_object, or another supported medium;
  • surface profile: exact reference-tag convention, verified duration range, prompt budget, supported reference roles, timeline syntax, edit/extension availability, audio behavior, and constraints.

If the surface is unknown, use a conservative generic profile. Do not invent a duration, prompt limit, reference count, or tag syntax.

Scene Architecture

Plan scenes before clips. A scene is the re-anchor unit: one location and time envelope whose clips may chain from each other's accepted footage.

  • Seamless continuation is legal only inside a scene. A scene boundary is an intentional cut that opens from canonical references and resets extension_depth to 0.
  • Cap consecutive output-sourced generations at the scene's max_chain_depth (default 2, hard ceiling 3). Schedule re-anchors in the plan; identity decays with chained generations, so a scheduled reset is routine and a drift repair is expensive.
  • Map the arc to scenes: each scene carries one arc_position and its clips inherit it.
  • Cuts are the cheapest continuity tool. The audience expects frame continuity only inside a chained shot, not across an editorial cut. A five-minute story usually resolves to several scenes of two to five clips, not one long extension chain.
  • Audio: clips carry ambience, sync SFX, and on-camera dialogue; unify music and score in post because audio is not continuous across separate generations.

Build Process

  1. Establish the story promise and final outcome before Clip 01.
  2. Classify every clip with the Director's Read and record its explicit directors_read_lane as narrative or non_narrative; never infer psychology from story.medium. This per-clip lane lets utility inserts coexist with performed beats in one sequence. Before a clip classified in the narrative lane is compiled, complete its ten-field internal record, including one non-transferable detail and one stock-solution refusal. For observation/performance without a dramatic story turn or for utility, use the non_narrative lane and record the two-line intent and refusal; do not invent drama or suppress the requested expression. Then use directing-engine to set one directorial voice for the whole project when the sequence needs it and plan the long-form spine - how shot scale, camera movement, light contrast, and sound should progress from open to climax to release, and which single clip breaks the pattern to mark the turn.
  3. Extract ordered beats and assign each beat a status: planned, current, completed, omitted, or replaced.
  4. Group beats into scenes: assign each scene one location and time envelope, one arc_position, canonical anchor_source references, max_chain_depth (default 2), and an audio plan.
  5. Divide each scene into generation-sized clips using the active surface budget or conservative assumption; chain clips from accepted footage only inside a scene, and open every scene from canonical references.
  6. Give every clip one narrative job, one felt_intent - a single line naming what the viewer should feel or notice, the directing engine's intention made persistent in state - and one completed endpoint.
  7. Persist the complete lane record in authoring_state. A narrative clip keeps every canonical field, labels the non-transferable detail source_bound only with an exact source locator or authored_choice with a null source, adds genuinely unequal value before/after, and stores exact visible or audible prompt_carriers. Its value_before must equal the nearest narrative ancestor's value_after, walking across utility inserts. A non_narrative clip stores exactly utility_intent and non_narrative_refusal; it never fabricates psychology.
  8. Define planned opening state, planned ending state, continuity locks, allowed changes, and extension-friendly handoff requirements.
  9. Store later clips as provisional intent cards, not final prompts.
  10. Compile only the first unresolved clip prompt from the current clip contract. Emit prompt_carriers, never the internal labels or explanations.
  11. After generation, require the clip or final frame, record observed start/end state, reconcile physical and dramatic handoffs, and only then compile the next prompt.

Use beginner-friendly language. It is valid to say: "This idea needs three connected generations. I will plan the complete story now, but finalize one prompt at a time so each new prompt matches what Seedance actually produced."

Sequence Map Fields

Each clip card must include clip_id, scene_id, sequence_index, parent_clip_id, narrative_job, felt_intent, directors_read_lane, lane-complete authoring_state, target_duration_sec, generation_mode, shot_structure, already_happened, this_clip_only, reserved_for_later, planned_start_state, planned_end_state, transition_in, transition_out, continuity_locks, allowed_changes, arc_position, and status. The arc_position (open, rising, turn, climax, or release) is inherited from the clip's scene and records where it sits on the directorial spine so its scale, movement, light, and sound trends inherit the project voice.

Each scene card must include scene_id, scene_index, narrative_function, arc_position, location, time_of_day, anchor_source, max_chain_depth, audio_plan, assigned_clip_ids, transition_out, and status.

Clip 01 can plan "exit terminal and reach open car door" with the endpoint "subject beside the open rear door" while reserving "entering the car" and "vehicle departure" for later clips. Do not paste all planned clips into one generation prompt.

Output Contract

For a new sequence, return:

  1. Project summary.
  2. Story spine.
  3. Final outcome.
  4. World and continuity bible, including the chosen directorial voice and the long-form look spine (how scale, movement, light, and sound progress, and which clip breaks the pattern).
  5. Scene map and sequence map.
  6. Clip 01 contract, including the Director's Read-derived internal authoring handoff and its visible or audible prompt carriers when the clip lane is narrative.
  7. Intent echo: one line - "this clip exists so the viewer feels X" - confirmed before generation spends money.
  8. Clip 01 final Seedance prompt in natural language.
  9. Provisional intent cards for future clips.
  10. Instruction to return the generated clip or final frame before Clip 02 is finalized.
  11. Project State Capsule.

Do not output internal JSON unless the user asks for it. The readable capsule is the cross-session handoff.

Frequently asked questions

What does the Seedance Sequence AI skill do?

This skill should be used when a Seedance 2.0 request is a long story, connected set of clips, multi-generation scene, campaign sequence, dense storyboard, continuation-ready plan, or any idea that must be divided into stateful clips.

Why use Seedance Sequence on TypingMind?

Because you install it once and use it with any model. Seedance Sequence is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Seedance Sequence in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Emily2040/seedance-2.0/tree/main/skills/seedance-sequence. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Seedance Sequence?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Seedance Sequence?

As many as you like. As long as a model supports skills, you can use Seedance Sequence with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Seedance Sequence AI skill free?

Yes. It is published on GitHub by Emily2040 under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇