System Requirements Document for youtube-shorts

1. Introduction

Product intent. youtube-shorts is an AI YouTube Shorts generator. A user supplies an idea or topic, and the tool produces a complete Short package: the script, the captions, the visuals, and the voiceover. The generated package is durable — it can be revisited, reviewed, adjusted, and regenerated before it is used.

Audience. The tool serves two audiences: solo creators, who need volume and want the full Shorts package produced without a production team, and marketing team members, who produce short-form video at scale for brand channels on a recurring content cadence. Both audiences use the same generation workflow and both are self-starting users with no invitation or provisioning boundary.

Scope of this document. This SRD defines the current, first-party web product: an anonymous public entry, self-service enrollment and returning verification, a generator workspace, a revisitable collection of generated Short packages, and a focused editor for reviewing, adjusting, and regenerating a package. Publishing to YouTube is the successful outcome the product serves; the product itself ends at a ready-to-publish Short.

2. System Overview

youtube-shorts is a first-party web application with application-owned identity and custom UI. The current delivery consists of six destinations:

Actors. Two accepted human personas — Solo Creator and Marketing Team Member — both of whom may enter anonymously, enroll, verify, generate, revisit, and adjust. The generation pipeline (script, captions, visuals, voiceover synthesis) is a system process that supports the human-facing work; it is not a destination and has no human interaction of its own.

Accepted behavior. Idea/topic submission; generation of script, captions, visuals, and voiceover as one package; durable storage of generated packages; revisiting a package from the collection; reviewing, adjusting, and regenerating a package in the editor; self-service enrollment; returning verification.

Narrow exclusions. The product does not publish to YouTube on the user's behalf — publishing is the user's own downstream action on YouTube, and the product's completion point is a ready-to-publish Short. The product does not provide team administration, shared workspaces, role-based permissions, or differentiated visibility over shared state; both personas have identical access to their own generated packages. No invitation, provisioning, or deployment-bootstrap enrollment path exists.

2a. Product Interpretation and Delivery Boundary

Delivery ownership. All six destinations are first-party custom pages owned by the application. The generation pipeline that produces script, captions, visuals, and voiceover is backend work invoked by the application; it has no separate user-facing surface. YouTube itself is an external destination the user goes to after the product has delivered a ready-to-publish Short — the product does not own, embed, or automate that step.

Access ownership. The Landing page is the anonymous public entry. Sign Up and Login are anonymous access surfaces: a protected destination cannot own the interaction that establishes access to itself, so enrollment and returning verification are reachable without identity, while Shorts, Generator, and Short Editor require a verified identity so that durable, actor-specific Short packages remain bound to the correct participant.

Current vs. future. Everything described in this document is current. No future-horizon requirements were accepted in the authoritative thread; nothing in this document is deferred.

2b. Source Content Inventory

Not applicable. No reference directive in this project declares content_source authority, so no source content inventory is produced.

2c. Page Content and Component Coverage

Landing

• Information and state. Anonymous public entry. Explains what the AI YouTube Shorts generator does, the complete generation workflow (idea → script → captions → visuals → voiceover), and who it serves (solo creators and marketing teams). No user-specific state is shown.
• Primary action. Enter the product: proceed to Sign Up to enroll, or to Login to continue existing work.
• Supporting actions. Read the workflow explanation; read the audience explanation; move between the workflow, audience, and entry sections.
• Domain entities. None owned. The page describes the Short package concept (script, captions, visuals, voiceover) without holding any package state.
• Component responsibilities. Hero headline and entry CTA; workflow explanation presenting the four generated outputs as an ordered pipeline; audience explanation distinguishing solo creators from marketing teams; entry controls routing to Sign Up and Login.
• States. Loading: static content, no data fetch required. Empty: not applicable — content is fixed. Success: the visitor understands the workflow and chooses an entry path. Error: not applicable to page content; if a downstream entry route is unavailable, the entry control reports the failure and the visitor can retry. Recovery: the visitor can re-read the page and choose the other entry path.

Sign Up

• Information and state. Anonymous enrollment surface. Collects the minimum identity information needed to establish a first-time account. No protected state is visible here.
• Primary action. Create the account and become a verified user.
• Supporting actions. Move to Login if the visitor already has an account; correct invalid input and resubmit.
• Domain entities. Account identity (the enrolling user's own credentials and identifying information).
• Component responsibilities. Enrollment form with input validation; submit control; link to Login; inline error reporting.
• States. Loading: submit control shows in-progress state while the account is created. Empty: the form is presented blank on first arrival. Success: the account is created and the user proceeds into the product as a verified user. Error: invalid or incomplete input is reported inline against the offending field; an already-registered identity is reported and the user is directed to Login. Recovery: the user corrects the input and resubmits, or switches to Login, without losing the rest of the form.

Login

• Information and state. Anonymous returning-verification surface. Collects the returning user's credentials. No protected state is visible here.
• Primary action. Verify identity and resume work on the user's own generated Short packages.
• Supporting actions. Move to Sign Up if the visitor has no account; correct invalid input and resubmit.
• Domain entities. Account identity (the returning user's own credentials).
• Component responsibilities. Verification form; submit control; link to Sign Up; inline error reporting.
• States. Loading: submit control shows in-progress state while verification runs. Empty: the form is presented blank on first arrival. Success: identity is verified and the user lands in the product with access to their own Shorts, Generator, and Short Editor. Error: incorrect credentials are reported without revealing which part was wrong; the user may retry. Recovery: the user re-enters credentials and resubmits, or switches to Sign Up.

Shorts

• Information and state. The verified user's collection of previously generated Short packages. Each entry shows the package's identifying information (its idea or topic and its generated state) so the user can recognize and choose one. Scoped to the signed-in user's own packages.
• Primary action. Open a Short package to review and adjust it in the Short Editor.
• Supporting actions. Start a new Short from the Generator; scan and identify a package by its idea or topic.
• Domain entities. Short package (idea/topic, script, captions, visuals, voiceover, generated state).
• Component responsibilities. Package list or grid; per-package identifying metadata; entry point to the Generator for a new Short; empty-state guidance.
• States. Loading: the collection is being retrieved; a loading indication occupies the list region. Empty: no packages exist yet; the page explains that no Shorts have been generated and offers the path to the Generator. Success: the user's packages are listed and selectable. Error: retrieval failure is reported with a retry action; the page does not silently show an empty collection in place of a failed load. Recovery: retry the retrieval; if the failure persists, the user can still start a new Short from the Generator.

Generator

• Information and state. The workspace where a new Short package is produced. Holds the user's submitted idea or topic and the generation state of the resulting package (not yet started, generating, complete, or failed). Scoped to the signed-in user.
• Primary action. Submit an idea or topic and generate the Short package — script, captions, visuals, and voiceover together.
• Supporting actions. Edit the idea or topic before generating; observe generation progress; open the completed package in the Short Editor; retry a failed generation.
• Domain entities. Idea/topic input; Short package (script, captions, visuals, voiceover); generation state.
• Component responsibilities. Idea/topic input field; generate control; generation progress indication covering all four outputs; result handoff into the Short Editor; failure reporting with retry.
• States. Loading: generation is in progress; progress is visible and the generate control does not accept a duplicate submission for the same run. Empty: no idea or topic has been submitted yet; the input is presented ready for entry. Success: the package is complete with script, captions, visuals, and voiceover, and the user can open it in the Short Editor. Error: generation fails; the failure is reported against the run and the submitted idea or topic is preserved so the user does not have to retype it. Recovery: retry generation with the preserved input, or edit the idea or topic and generate again.

Short Editor

• Information and state. The focused workspace for one generated Short package. Shows the package's script, captions, visuals, and voiceover together with its current generated state, so the user can judge the whole Short before using it. Scoped to the signed-in user's own package.
• Primary action. Adjust the package and regenerate it so the result is ready to publish.
• Supporting actions. Review each of the four outputs (script, captions, visuals, voiceover); change the package's inputs or content; trigger regeneration; return to the Shorts collection.
• Domain entities. Short package (script, captions, visuals, voiceover); the user's adjustments to that package; regeneration state.
• Component responsibilities. Review surface presenting script, captions, visuals, and voiceover; adjustment controls; regenerate control; regeneration progress and result; failure reporting with retry; navigation back to the collection.
• States. Loading: the package is being retrieved; a loading indication occupies the workspace. Empty: not applicable — the editor always operates on an existing package; if the package cannot be found, the user is returned to the collection with an explanation. Success: adjustments are applied and the regenerated package reflects them, ready to publish. Error: retrieval or regeneration fails; the failure is reported and the user's adjustments are preserved. Recovery: retry retrieval or regeneration; the user can return to the collection and reopen the package without losing the stored package.

3. Functional Requirements

FR-1 — Generate a complete Short package from an idea or topic. As a Solo Creator or Marketing Team Member, I should submit an idea or topic and receive a generated Short package containing script, captions, visuals, and voiceover, so that I have a finished Short without a production team.

• Provenance: explicit (build an AI YouTube Shorts generator; generate the script and captions; generate the visuals and voiceover).
• Actor: Solo Creator / Marketing Team Member. Trigger: submitting an idea or topic in the Generator.
• Observable result: a Short package exists containing all four outputs — script, captions, visuals, and voiceover — and is available to open in the Short Editor.
• Access state: requires a verified identity.
• Failure/recovery: if generation fails, the failure is reported and the submitted idea or topic is preserved so the user can retry or edit and generate again.
• Continuation: the user opens the completed package in the Short Editor, or returns to the Generator to start another Short.

FR-2 — Generate the script and captions for the Short. As a Solo Creator or Marketing Team Member, I should receive a generated script and generated captions as part of my Short package, so that the spoken content and the on-screen text are both written for me.

• Provenance: explicit.
• Actor: Solo Creator / Marketing Team Member. Trigger: the generation run started from the Generator.
• Observable result: the package's script and captions are present and reviewable in the Short Editor.
• Access state: requires a verified identity.
• Failure/recovery: if script or caption generation fails, the run is reported as failed and can be retried with the preserved input.
• Continuation: the user reviews the script and captions in the Short Editor and adjusts them if needed.

FR-3 — Generate the visuals and voiceover for the video. As a Solo Creator or Marketing Team Member, I should receive generated visuals and a generated voiceover as part of my Short package, so that the video has both its imagery and its audio produced for me.

• Provenance: explicit.
• Actor: Solo Creator / Marketing Team Member. Trigger: the generation run started from the Generator.
• Observable result: the package's visuals and voiceover are present and reviewable in the Short Editor.
• Access state: requires a verified identity.
• Failure/recovery: if visual or voiceover generation fails, the run is reported as failed and can be retried with the preserved input.
• Continuation: the user reviews the visuals and voiceover in the Short Editor and adjusts them if needed.

FR-4 — Serve both solo creators and marketing teams. As a Solo Creator or as a Marketing Team Member, I should be able to use the same generation workflow for my own production context, so that the tool works whether I am producing alone or for a brand channel.

• Provenance: explicit.
• Actor: Solo Creator / Marketing Team Member. Trigger: entering the product.
• Observable result: both personas can enroll, verify, generate, revisit, and adjust Short packages through the same workflow, with no invitation, provisioning, or team-administration step required.
• Access state: anonymous entry, then verified identity for protected work.
• Failure/recovery: not applicable to the shared-workflow guarantee itself; individual capability failures are handled by their own requirements.
• Continuation: each persona proceeds through the same generation lifecycle.

FR-5 — Self-service enrollment for first-time users. As a first-time Solo Creator or Marketing Team Member, I should be able to enroll myself without an invitation or provisioning step, so that I can start generating Shorts immediately.

• Provenance: required_inference (required to make the accepted current journey executable; no invitation or provisioning boundary exists in the source).
• Actor: first-time visitor. Trigger: choosing to enroll from the Landing page.
• Observable result: an account is created and the user becomes a verified user with access to their own Shorts, Generator, and Short Editor.
• Access state: the enrollment interaction itself is anonymous; protected state remains unavailable until enrollment completes.
• Failure/recovery: invalid or incomplete input is reported inline; an already-registered identity is reported and the user is directed to Login; the user corrects and resubmits without losing the rest of the form.
• Continuation: the newly enrolled user proceeds into the Generator to create their first Short.

FR-6 — Returning verification for users continuing work. As a returning Solo Creator or Marketing Team Member, I should verify my identity so that I can continue work on my own generated Short packages.

• Provenance: required_inference (required so durable packages remain bound to the correct participant).
• Actor: returning user. Trigger: choosing to log in from the Landing page.
• Observable result: identity is verified and the user reaches their own Shorts collection, Generator, and Short Editor.
• Access state: the verification interaction itself is anonymous; protected state remains unavailable until verification succeeds.
• Failure/recovery: incorrect credentials are reported without revealing which part was wrong; the user retries or switches to Sign Up.
• Continuation: the verified user opens an existing package from Shorts or starts a new Short in the Generator.

FR-7 — Durable storage of generated Short packages. As a Solo Creator or Marketing Team Member, I should have my generated Short packages stored durably, so that I can revisit and adjust them later.

• Provenance: required_inference (required so accepted revisit-and-adjust work is executable).
• Actor: Solo Creator / Marketing Team Member. Trigger: a generation run completing.
• Observable result: the package persists and appears in the user's Shorts collection, scoped to that user, and can be reopened in the Short Editor.
• Access state: requires a verified identity; packages are bound to the user who generated them.
• Failure/recovery: if the collection cannot be retrieved, the failure is reported with a retry action rather than being shown as an empty collection.
• Continuation: the user opens the stored package in the Short Editor to review and adjust it.

FR-8 — Revisit previously generated Short packages. As a Solo Creator or Marketing Team Member, I should browse my previously generated Short packages and open one, so that I can return to work I have already started.

• Provenance: required_inference (the revisit half of the accepted durable-storage and adjust journey).
• Actor: Solo Creator / Marketing Team Member. Trigger: opening the Shorts collection.
• Observable result: the user's packages are listed with identifying information and one can be opened in the Short Editor.
• Access state: requires a verified identity.
• Failure/recovery: retrieval failure is reported with retry; the user can still start a new Short from the Generator.
• Continuation: the selected package opens in the Short Editor.

FR-9 — Review, adjust, and regenerate a Short package. As a Solo Creator or Marketing Team Member, I should review the script, captions, visuals, and voiceover of a generated package, adjust it, and regenerate it, so that the finished Short is ready to publish.

• Provenance: required_inference (the adjust half of the accepted durable-storage and adjust journey).
• Actor: Solo Creator / Marketing Team Member. Trigger: opening a package in the Short Editor and making an adjustment.
• Observable result: the regenerated package reflects the user's adjustments across script, captions, visuals, and voiceover, and is ready to publish.
• Access state: requires a verified identity; the package is the user's own.
• Failure/recovery: if retrieval or regeneration fails, the failure is reported and the user's adjustments are preserved; the user can retry or return to the collection and reopen the package.
• Continuation: the user takes the ready-to-publish Short to YouTube, or returns to the collection to work on another package.

4. User Personas

Solo Creator

Product context. An individual short-form video creator who needs volume. They work alone, without a production team, and the value of the tool is that it produces the entire Shorts package — script, captions, visuals, and voiceover — in one pass instead of requiring separate writing, captioning, visual, and voice work.

Primary goal. Turn an idea into a finished, ready-to-publish Short quickly enough to sustain a posting cadence, and publish it to YouTube.

Distinct accepted responsibilities. The Solo Creator initiates generation from their own idea or topic, reviews the resulting package, adjusts it, and regenerates it until it is ready to publish. They own the whole lifecycle end to end: there is no handoff to a colleague and no approval step between generation and use.

Relevant inputs and decisions. The idea or topic they submit; the judgment of whether the generated script, captions, visuals, and voiceover are good enough to publish; the decision to adjust and regenerate rather than accept the first result.

Interactions with other accepted participants. None inside the product. The Solo Creator is the sole human participant in their own generation lifecycle. Their downstream counterpart is YouTube, an external destination they act on themselves after the product has delivered a ready-to-publish Short.

Observable success. A Short package that contains script, captions, visuals, and voiceover, that reflects their adjustments, and that they can take to YouTube and publish.

Marketing Team Member

Product context. A member of a marketing team producing short-form video at scale for brand channels. They rely on the same generation workflow as the Solo Creator, but their production context is a recurring content cadence rather than a single creator's posting rhythm.

Primary goal. Deliver a ready-to-publish Short on a recurring content cadence for a brand channel.

Distinct accepted responsibilities. Like the Solo Creator, the Marketing Team Member submits the idea or topic, reviews the generated package, adjusts it, and regenerates it. Their distinguishing work is cadence-driven: they return repeatedly to the collection to revisit and continue packages, and they treat the generator as a repeatable production step rather than a one-off.

Relevant inputs and decisions. The brand-channel idea or topic; the judgment of whether the generated script, captions, visuals, and voiceover meet the channel's standard; the decision to adjust and regenerate before the Short goes out.

Interactions with other accepted participants. None inside the product. The product provides no shared workspace, team administration, or approval routing between team members; each Marketing Team Member works with their own generated packages exactly as the Solo Creator does. Their downstream counterpart is the brand channel on YouTube, which they act on themselves.

Observable success. A ready-to-publish Short delivered on schedule, produced through the same generation workflow the Solo Creator uses.

5. Core User Flows

Flow A — First-time user enrolls and generates a first Short (Solo Creator or Marketing Team Member)

1. Starting context. The visitor is anonymous and has no account. They arrive at the Landing page.
2. On Landing, the visitor reads what the generator produces — script, captions, visuals, and voiceover — and who it serves. They choose the enrollment path.
3. On Sign Up, the visitor enters the identity information required to create an account and submits.
4. Observable result. The account is created and the visitor becomes a verified user. If the input is invalid or incomplete, the error is reported inline against the offending field and the visitor corrects it and resubmits; if the identity is already registered, they are directed to Login instead.
5. Continuation. The verified user proceeds to the Generator.
6. On Generator, the user enters an idea or topic and triggers generation.
7. Observable result. Generation runs and produces the Short package: script, captions, visuals, and voiceover. Progress is visible while it runs. If generation fails, the failure is reported and the submitted idea or topic is preserved so the user can retry or edit it and generate again.
8. Continuation. The user opens the completed package in the Short Editor (Flow C), or starts another Short from the Generator.

Flow B — Returning user verifies and reopens an existing Short package (Solo Creator or Marketing Team Member)

1. Starting context. The user has previously generated at least one Short package and is currently anonymous. They arrive at the Landing page.
2. On Landing, the user chooses the returning path.
3. On Login, the user enters their credentials and submits.
4. Observable result. Identity is verified and the user reaches their own protected work. If the credentials are incorrect, the error is reported without revealing which part was wrong, and the user retries or switches to Sign Up.
5. Continuation. The verified user opens the Shorts collection.
6. On Shorts, the user scans their previously generated packages, identified by their idea or topic and generated state, and selects one.
7. Observable result. The selected package opens in the Short Editor. If the collection cannot be retrieved, the failure is reported with a retry action rather than being shown as an empty collection; the user can retry or start a new Short from the Generator.
8. Continuation. The user reviews and adjusts the package (Flow C).

Flow C — User reviews, adjusts, and regenerates a Short package (Solo Creator or Marketing Team Member)

1. Starting context. The user is verified and has opened a generated package in the Short Editor, either from the Shorts collection or directly after generation.
2. On Short Editor, the user reviews the package's four outputs together: the script, the captions, the visuals, and the voiceover.
3. The user makes an adjustment to the package and triggers regeneration.
4. Observable result. Regeneration runs with visible progress, and the regenerated package reflects the user's adjustment across script, captions, visuals, and voiceover. If retrieval or regeneration fails, the failure is reported and the user's adjustments are preserved.
5. Recovery. The user retries regeneration with the adjustments intact, or returns to the Shorts collection and reopens the package without losing the stored package.
6. Completion. The package is ready to publish. The user takes the finished Short to YouTube and publishes it there — the product's responsibility ends at the ready-to-publish Short.
7. Continuation. The user returns to the Shorts collection to work on another package, or to the Generator to start a new Short.

Flow D — Marketing Team Member produces on a recurring cadence

1. Starting context. A verified Marketing Team Member is producing for a brand channel on a recurring schedule and has existing packages in their Shorts collection.
2. The team member opens the Generator and submits the next brand-channel idea or topic.
3. Observable result. A new Short package is generated with script, captions, visuals, and voiceover, and is stored durably alongside their previous packages.
4. The team member opens the new package in the Short Editor, reviews all four outputs against the channel's standard, adjusts what needs changing, and regenerates.
5. Observable result. The regenerated package reflects the adjustments and is ready to publish.
6. Continuation. The team member publishes the Short to the brand channel on YouTube and returns to the Shorts collection, where the package remains available for later revisit and adjustment.

6. Visuals, Colors, and Theme

Muse and headline direction. The visual language is Yugo Nakamura — interaction as delight. The product's promise is turning a one-line idea into a living, moving Short, so the interface itself behaves like the medium: kinetic type, cursor-reactive physics, and generative graphics. The register is playful creative energy, not a sober admin shell.

Mode. Dark mode.

Color tokens (exact hex, by role).

Proportion. Approximately 70% void, 20% surface, 7% primary, 3% accent. Color is a live event, not a surface treatment.

Typography. Headings and body both use Space Grotesk. Display sizes are set enormous — clamp(56px, 10vw, 144px) — with tight tracking of -0.03em, mixed case, and occasional all-caps micro-labels at 11px with 0.18em letterspacing. Headlines are treated as kinetic objects: individual words sit in their own spans so they can translate, skew, and reveal on scroll and cursor proximity. Weight 700 for display, 400 for body, 500 for UI labels.

Type scale. 1.333 modular — 144 / 108 / 72 / 40 / 24 / 17 / 13 / 11, with display sizes as clamp() ranges (mobile 56px → desktop 144px; section heads 36px → 72px).

Shape language. Hard-edged rectangles and 1px hairline rules; no soft radii on structural elements (0–4px maximum). The only curves are the cursor trail, the pulsing generation ring, and the 9999px pill on the single primary CTA — so the one circular gesture reads as an event. Grid lines are visible and generative: a 12-column field of 1px #00E0B8 at 8% opacity that subtly warps toward the pointer.

Spacing rhythm. Full-bleed horizontal hairline rules separate sections instead of cards or shadows, keeping the page a continuous field. Sections breathe generously against the void; the generator workspace uses a compact, keyboard-first control column against a large preview region.

Imagery style. Motion replaces imagery — no stock photography, no gradient blobs, no 3D mascots, no decorative illustration. Visual interest comes from generative and procedural graphics: the warping grid field, the cursor trail, and animated 9:16 preview frames showing the actual generated Short layout (caption bars, script text, a waveform for the voiceover). Where a still is needed, it is a schematic diagram of the generation pipeline (idea → script → captions → visuals → voiceover) drawn as thin mint strokes. Library tiles show real 9:16 frames with tabular-numeral metadata.

Layout. A full-viewport playground rather than a stacked marketing page. The landing hero occupies 100vh with the headline as the dominant element, breaking the 12-column grid asymmetrically (headline spans columns 1–9, offset upward). The generator workspace is a two-pane split: left is the prompt field and controls, right is a live 9:16 preview frame with caption/script/voiceover tabs stacked as a vertical strip. The Shorts library is a dense editorial grid of 9:16 tiles with tabular numerals for durations and view counts. Every layout collapses to a single column at 375px, with the preview frame full-width and controls beneath.

Forbidden. Any blue–indigo primary (#0057FF, #2563EB, #4F46E5, #7C3AED) on white; gradient-blob heroes or soft violet→pink washes; grids of identical hover-lift cards with soft shadows; Inter, Roboto, Arial, Helvetica, Open Sans, Lato, Poppins, or system-ui for headings or body; a centred headline + subtext + button SaaS hero; stock photography, 3D character mascots, or decorative illustration; bouncy elastic easing on every element; pure #FFFFFF text or pure #000000 ground.

Readability guarantee. Headlines, wordmarks, labels, numbers, card text, and controls stay entirely inside the viewport and their container at 375px, 768px, and 1280px, wrapping or scaling to fit, with no other element covering any part of them. Imagery, decoration, and motion may be cropped, bled off an edge, rotated, overlapped, or cut as the direction asks, provided they cover no readable text or control.

7. Signature Design Concept

The live generation field. The public entry is a full-bleed near-black viewport (#0B0B0F) carrying a 12-column field of 1px electric-mint grid lines at 8% opacity that warp gently toward the cursor — the background is an interactive instrument, not a texture. The dominant element is an oversized Space Grotesk headline, "Turn one idea into a finished Short", set at clamp(56px, 10vw, 144px), weight 700, tracking -0.03em, left-aligned and spanning columns 1–9, with each word in its own span so words drift 6–14px toward the pointer. Beneath it, a single 9999px pill CTA in hot red #FF3B2F — "Generate a Short" — sits left-aligned, with a small 11px letterspaced uppercase micro-label above it reading "SCRIPT · CAPTIONS · VISUALS · VOICEOVER". To the right, bleeding off the right edge of the viewport, a 9:16 preview frame at roughly 70vh height rotates subtly with the cursor and shows a live Short being assembled: caption bars sliding in, a script line typing, a mint waveform pulsing. No centred stack, no gradient blob, no blue button. On mobile the preview frame drops below the headline full-width, and the grid field stays while the trail is disabled.

The concept recomposes only accepted content and controls: the headline states the accepted generation promise, the micro-label names the four accepted outputs, the CTA is the accepted entry action, and the preview frame depicts the accepted Short package format. It introduces no new behavior, page, or destination.

8. Interaction Model & Motion Direction

Interaction Model: Animated Motion Tempo: cinematic Hero Dimensionality: layered_2d

Landing Hero Motion Brief.

• Focal subject. The oversized kinetic headline "Turn one idea into a finished Short" and the 9:16 preview frame bleeding off the right edge, both sitting on the warping mint grid field.
• Input → transformation → outcome thesis. Pointer movement across the hero is the input; headline words translate 6–14px toward the cursor with a soft lag, a red #FF3B2F trail follows the pointer at a slight lag, and the grid lines ripple outward from the pointer position; the outcome is a first screen that behaves like the moving medium the product produces. On scroll, headline words stagger-reveal upward with a 40ms per-word offset and full-bleed section rules draw left-to-right.
• Motion vocabulary. Cursor-reactive physics with soft lag; word-level translation on proximity; grid ripple propagation; staggered upward word reveals; self-drawing horizontal rules; the generation pulse — pressing "Generate a Short" fires an expanding mint ring from the button that resolves into the 9:16 preview frame filling with script, caption bars, and a waveform.
• Composed first frame. Near-black viewport, mint grid at 8% opacity, headline occupying columns 1–9 offset upward with all words whole and legible, the red pill CTA left-aligned beneath it with its uppercase micro-label, and the 9:16 preview frame partially off the right edge showing caption bars, a typing script line, and a pulsing waveform.
• Reduced-motion state. Under prefers-reduced-motion, the cursor trail is disabled, headline words appear whole without translation or stagger, the grid is static, and the generation pulse becomes a simple opacity fade. All text and controls remain whole and fully readable at 375px, 768px, and 1280px.

9. Non-Functional Requirements

NFR-1 — Durable package persistence. Generated Short packages must persist so that a verified user can revisit and adjust them across sessions. Provenance: required_inference — the accepted revisit-and-adjust journey is not executable without durable storage. Rationale: packages are the product's output and the object of the editor's work.

NFR-2 — Actor-scoped package ownership. Each generated Short package must remain bound to the user who generated it, so that returning verification restores access to the correct participant's own work. Provenance: required_inference — required by the accepted returning-verification and durable-storage requirements. Rationale: without binding, a returning user could not reliably resume their own packages.

NFR-3 — Protected destinations require verified identity. Shorts, Generator, and Short Editor must not expose a user's package state before identity is verified; Landing, Sign Up, and Login must remain reachable anonymously. Provenance: required_inference — a protected destination cannot own the interaction that establishes access to itself. Rationale: keeps enrollment and verification executable while protecting durable actor-specific state.

NFR-4 — Generation progress and failure visibility. A generation or regeneration run must expose visible progress and must report failure explicitly, preserving the user's submitted idea or topic and their adjustments so that retry does not require re-entry. Provenance: required_inference — required for the accepted generation and regeneration lifecycles to be usable. Rationale: generation is the product's core action and its failure must be recoverable.

NFR-5 — Readable text and controls at every viewport. Headlines, labels, numbers, card text, and controls must remain entirely inside the viewport and their container at 375px, 768px, and 1280px, wrapping or scaling to fit, with no element covering any part of them. Provenance: explicit (creative direction readability guarantee). Rationale: the direction's motion and bleed must never compromise legibility or control access.

NFR-6 — Reduced-motion support. All motion must respect prefers-reduced-motion: the cursor trail is disabled, headline words appear whole, the grid is static, and the generation pulse becomes a simple opacity fade. Provenance: explicit (creative direction). Rationale: accessibility of the motion-led interface.

NFR-7 — No differentiated permissions. The product must not introduce role-based visibility, permission controls, or shared-state administration between the two personas; both personas have identical access to their own generated packages. Provenance: explicit (the source establishes no differentiated control or visibility over shared product state). Rationale: prevents inventing team-administration scope the source did not accept.

10. Tech Stack

• Frontend: React — a first-party custom web UI with the six accepted destinations. [Default — not specified by user]
• Backend: Python / FastAPI — serves the application's API, including the generation pipeline that produces script, captions, visuals, and voiceover, and the durable storage of Short packages. [Default — not specified by user]
• Storage: A persistent datastore for user identity and durable Short packages (script, captions, visuals, voiceover, and generated state), scoped per user. [Default — not specified by user]
• Containerization: Docker with docker-compose for local and single-host deployment. [Default — not specified by user]
• Orchestration: Kubernetes is not required for the current scope; the accepted product is a single first-party web application with one backend service and one datastore. [Default — not specified by user]

No source-specified technology choices were provided in the authoritative thread; the above are labeled defaults and do not alter product behavior.

11. Assumptions and Constraints

Assumptions.

• A-1. Both personas are self-starting users with no invitation, provisioning, or deployment-bootstrap boundary, so enrollment is self-service. Provenance: required_inference, consistent with the accepted persona descriptions.
• A-2. A user's generated Short packages are private to that user; the source establishes no sharing, team workspace, or cross-user visibility. Provenance: required_inference, consistent with the absence of any accepted sharing capability.
• A-3. Generation produces all four outputs — script, captions, visuals, and voiceover — as one package per run, since the source states them together as the tool's output. Provenance: explicit.
• A-4. The product's completion point is a ready-to-publish Short; publishing to YouTube is the user's own downstream action. Provenance: explicit (publishing to YouTube is described as the successful outcome, not as a product capability).

Constraints.

• C-1. No blue–indigo primary on white, no gradient-blob heroes, no soft-shadow hover-lift card grids, no Inter/Roboto/Arial/Helvetica/Open Sans/Lato/Poppins/system-ui for headings or body, no centred SaaS hero, no stock photography or 3D mascots, no bouncy elastic easing, and no pure #FFFFFF text or pure #000000 ground. Provenance: explicit (creative direction).
• C-2. Readable text and controls must stay whole and uncovered at 375px, 768px, and 1280px; where a direction asks readable text or a control to be cropped, clipped, covered, or run off an edge, the text and control stay whole and the gesture is carried by imagery or decoration instead. Provenance: explicit (creative direction).
• C-3. Motion must respect prefers-reduced-motion as specified in NFR-6. Provenance: explicit (creative direction).
• C-4. No team administration, shared workspaces, role-based permissions, or differentiated visibility over shared state. Provenance: explicit (no such capability is accepted in the source).
• C-5. No invitation, provisioning, or deployment-bootstrap enrollment path. Provenance: explicit (the source presents both personas as self-starting users with no such boundary).
• C-6. The product does not publish to YouTube on the user's behalf. Provenance: explicit (publishing is the user's downstream action; the product delivers a ready-to-publish Short).

12. Glossary

• Short package — The complete generated output for one idea or topic: the script, the captions, the visuals, and the voiceover, held together as one durable unit that can be revisited, adjusted, and regenerated.
• Script — The generated spoken/written content of the Short.
• Captions — The generated on-screen text for the Short.
• Visuals — The generated imagery for the Short.
• Voiceover — The generated audio narration for the Short.
• Generator — The workspace where a user submits an idea or topic and generates a Short package.
• Short Editor — The focused workspace where a user reviews, adjusts, and regenerates one generated Short package.
• Shorts — The verified user's revisitable collection of previously generated Short packages.
• Solo Creator — An individual short-form video creator who produces the full Shorts package without a production team.
• Marketing Team Member — A member of a marketing team producing short-form video at scale for brand channels on a recurring content cadence.
• Ready-to-publish Short — A Short package that has been reviewed and adjusted to the user's satisfaction; the product's completion point, after which the user publishes to YouTube themselves.
• Verified user — A user whose identity has been established through self-service enrollment or returning verification, granting access to their own Shorts, Generator, and Short Editor.