How to Build a Full AI TikTok Slideshow Workflow in Ghostfeed

Most slideshow workflows are a prompt, a folder, and hope.

The actual Ghostfeed workflow is much more direct:

Choose the correct starting door

• Use From Social to remix a TikTok Photo Mode post or image-only Instagram carousel. Ghostfeed keeps the reference’s slide count and beat logic, then writes fresh copy and casts fresh images.
• Use From Prompt when you know the audience and angle. Type @ to attach products, image collections, or approved avatars; if no slide count is specified, the Director chooses a length that fits the story.
• Use From Scratch when the script is already approved or an agent will art-direct every slide through MCP. The dashboard starts with three editable slides; the MCP operation can create the exact deck length requested.

Step 1: start with one angle and one audience

Use reviews, support tickets, search language, or founder knowledge to identify a specific tension. The first slide should make that tension recognizable; the remaining slides should pay it off.

Write the arc before touching images:

1. hook;
2. deepen the situation;
3. name the mechanism;
4. give evidence or steps;
5. handle the obvious objection;
6. close with one next action.

Step 2: create the editable base

For the MCP-driven scratch route, Ghostfeed's create_blank_slideshow operation creates the saved slideshow and the number of slides you want to art-direct. You can add, remove, or reorder slides later, up to the product limit.

This is not a flattened image export. Each slide remains editable.

Step 3: cast every background

For each slide, search for a scene rather than a topic.

"Tired parent checking a phone in a dark nursery" produces a more native background than "sleep tracking infographic."

Ghostfeed can cast from:

• Pinterest search results;
• workspace collections;
• linked product collections;
• approved avatar image libraries;
• an uploaded or external image URL.

The tool rejects undersized images, and the chosen Pinterest query is saved so the editor can reopen or shuffle that search later.

Step 4: place the text as a separate layer

Use set_slide_texts with a role and placement for each text block. Ghostfeed maps headings, body copy, and CTAs into mobile-safe positions.

Keep copy out of the generated background. When a line changes, you should edit the line—not regenerate the scene.

01

02

03

04

Step 5: caption and review the whole sequence

Set the post caption, then call get_slideshow to read back every slide, text box, background source, and variant.

Review the sequence for:

• hook payoff;
• repeated scenes;
• visual continuity;
• text density;
• unsupported claims;
• product appearing too late;
• CTA fit.

Step 6: build a real variant

In the dashboard, choose a ready base and open Generate variants. Write the direction or let Ghostfeed suggest distinct hooks, choose the count, and generate.

Each hook becomes the topical truth for its own deck. Ghostfeed keeps the base slide count and text geometry, writes fresh copy, and changes backgrounds according to source: recast Pinterest slides, rotate collections and avatar pools, preserve uploads and standalone AI images.

Do not call a resized export a new variant. A variant should change a hypothesis: hook, scene language, proof order, or CTA.

Claude builds a Ghostfeed photo-mode deck through MCP: blank deck, sourced backgrounds, editable text, and saved review state.

Step 7: export and learn

The MCP surface builds and reviews the deck. Final downloading and platform posting remain deliberate user actions. After publishing, log results against the angle and variant so the next deck inherits an actual learning.

That is the full creative loop.

That works until you need to:

• regenerate slide four without changing the character;
• trace an unsupported claim;
• publish five aspect-ratio variants;
• understand why a post worked;
• stop an automation from shipping broken text.

The structured contract below is how you keep that Ghostfeed workflow intact when you automate larger batches. It is supporting detail, not the article's main idea.

This is the slideshow pipeline I would build for an app team.

Start with the unit of work

One slideshow should be one structured object.

That object survives every stage:

Do not pass the work between stages as prose pasted into Slack.

Define each slide explicitly

The important fields are not the exact names. The important idea is that copy, visual intent, continuity, evidence, and status are separate.

When the overlay is baked into the image prompt, a copy edit forces an image regeneration. Keep text as a render layer unless the native aesthetic specifically needs photographed text.

Give every slide one job

A useful nine-slide structure:

Slide two should make sense if someone lands there, but it does not need a fake “second hook.” It needs to advance the argument.

Build the brief from evidence

The creative brief should cite inputs:

• customer interview excerpts;
• support-ticket themes;
• product behavior;
• ad comments;
• sales objections;
• approved product claims;
• previous creative results.

Example:

This prevents a language model from filling gaps with plausible nonsense.

Lock continuity before generating images

Continuity is a small production bible:

Use only people and likenesses you have permission to use. “AI generated” does not erase publicity, contract, endorsement, or platform obligations.

Generate candidates, not final assets

For each visual:

1. generate a small candidate set;
2. reject structural failures;
3. compare continuity against adjacent slides;
4. choose one;
5. regenerate only the failed slot.

Do not blindly generate eight variants for every slide. Spend more candidates on high-risk frames:

• hands interacting with products;
• readable interfaces;
• recurring characters;
• unusual camera angles;
• product packaging.

Spend fewer on simple objects and environments.

Validate before human review

Cheap deterministic checks should run first:

Then add visual checks:

• face and hand integrity;
• product/logo correctness;
• character continuity;
• text contrast;
• duplicated artifacts;
• accidental watermarks;
• implausible physics.

Automation should remove boring mistakes before a human sees the batch.

Add approval gates where errors get expensive

I would use three:

Gate 1: brief

Approve the audience, claim, evidence, angle, and product role.

Gate 2: source frame

Approve the creator, setting, wardrobe, and visual language before generating the sequence.

Gate 3: final post

Approve copy, sequence, render, CTA, rights, and publishing metadata.

One video. Hundreds of posts only works when the approved decisions are reusable.

Render from a template

Keep layout tokens separate from content:

Then render platform-specific variants without rewriting the creative.

01

02

03

04

Publish through supported paths

Use platform-supported publishing integrations and preserve:

• destination account;
• scheduled time;
• caption;
• audio choice;
• disclosure state;
• post ID;
• exact rendered asset hash.

Do not build device farms, proxy choreography, or fake-human behavior. That is evasion infrastructure, not marketing leverage.

Close the feedback loop

Store performance against the exact creative object:

Use a consistent window. Do not compare a three-hour post with a seven-day post.

More importantly, do not optimize only for views if the objective is qualified trials.

A concrete iteration

Version A:

I fixed my sleep with this app.

It is broad, outcome-heavy, and barely says anything.

Version B:

My sleep score looked fine. This graph showed why I still felt wrecked.

The second version creates a specific information gap and naturally introduces a real product screen.

The next test should change one meaningful variable:

• hook specificity;
• evidence type;
• creator;
• visual setting;
• objection;
• CTA.

Do not change all six and call the result learning.

The operating rule

A slideshow system is not “30 scripts in one prompt.”

It is:

That is the difference between content generation and a production system.

Ghostfeed is built around the same idea: no filming, no editing, no prompting as the operating model—but with the briefs, source frames, approvals, variants, and publishing state kept visible.

The output is not merely more slides.

It is a system you can inspect, improve, and trust.