I got tired of teaching these in every new session. The fix was not a longer system prompt. It was a short patterns file that lives outside the chat, plus a rule that the assistant has to follow it or say it is uncertain.

1. The client is a request, not a source of truth

A RemoteEvent fired from the client can claim anything: "I bought this item," "I dealt 999 damage," "give me the reward." The server has to decide. Check that the player can actually afford it, that the item exists, that the cooldown has elapsed, that the character is in a state where the action is legal. Then apply the result on the server and replicate it back.

This is standard Creator Hub security guidance, and it is still the first pattern models drop when you ask for "a simple shop." I keep a one-line rule in the patterns file: client input is a request; the server validates and writes state. If a generated shop script awards currency on the client, it is not done.

2. ModuleScripts are not a shared database

A ModuleScript required on the server and required on the client is two separate copies. Mutating a table in one does not update the other. Shared state belongs in the DataModel — attributes, value objects, instances — or it is sent through remotes.

I have watched models "fix" a desync by stuffing more fields into a module that only one side can see. The bug looks like a timing issue. It is a memory-model issue. The patterns file says so in one paragraph, because I was tired of diagnosing it as if it were new.

3. Prefer the task library

Old Lua tutorials still teach wait(), spawn(), and delay(). In Luau, new code should use task.wait, task.spawn, and task.delay (and task.defer when the work should run after the current resumption). This is not a style preference. The deprecated globals are less predictable, especially under load, and they keep reappearing because training data is full of them.

My rule is mechanical: new code uses the task library; if you see wait(), replace it. I do not want a debate about it in the middle of a shop script.

4. Clean up connections

Characters respawn. Tools get unequipped. UI is destroyed and created again. A connection on Humanoid.Died or a RenderStepped loop that is never disconnected will pile up. The script may "still work" for five minutes and then stutter.

I ask the assistant to disconnect, or to use a Maid/Janitor-style helper, and to treat "this still runs after Destroy" as a bug. "I'll leave the connection, it is fine" is not an acceptable close to a task.

5. Do not invent APIs — and do not silently upgrade them

If a service method, property, or enum is not in a project note with a source and a date, the assistant must look it up or mark it uncertain. It may not invent MarketplaceService:PromptSomething(), and it may not "modernize" a working call because a 2019 blog post used a different name.

This rule alone cuts the paste-error-apologize loop. A confident paragraph about an API that does not exist looks identical to a verified one. The pattern is: cite, or say "uncertain" and how to check in Studio.

6. One module, one job — do not open a second shop

Before writing a new currency, inventory, or save path, the assistant reads the current project status and the code index. If a DataStore wrapper already exists, extend it. Duplicate systems are how a weekend project becomes two games in one folder.

This is the architectural twin of the invented API: not a wrong method name, but a second source of truth. Both come from a chat that has no memory of yesterday.

How I stopped re-explaining all of this

I keep a luau-patterns.md (the name does not matter) in a project vault, next to a short status.md for the game I am actually building. The patterns file holds the six rules above and a few snippets I have already run in Studio. The master prompt is short: read the patterns and the current status first; do not invent APIs or numbers; do not call a task done without a playtest; when uncertain, say so and how to check. After a session I add one line — exact error, cause, fix — even if the session was aborted.

I still have to playtest, including on a phone-sized viewport. A patterns file will not catch a jump that is unusable on touch. It just stops me from teaching the same six rules to a blank chat every morning.

If you want this structure ready-made

I packed this working method into a German-language kit called Roblox Second Brain: a copy-paste master prompt, a 292-page knowledge base (PDF and Markdown, dated 31 October 2026), setup notes, a Luau course, genre blueprints, and an Obsidian-friendly vault with the before/after routine above. It is 19 € once. There is no success claim, and it is not an official Roblox or Anthropic product.

A free sample — 12 patterns shared by many hit games, a second-by-second first-minute plan, and a 30-day zero-budget launch template — is here:

https://whop.com/kelvaro-creator-kits/leseprobe-roblox-second-brain

The full kit is here:

https://whop.com/kelvaro-creator-kits/roblox-second-brain

Launch offer: code LAUNCH40 = 40 % off, for the first 10 buyers only, until 16 November 2026.

Disclosure: the linked kit is my own paid product. The sample is free. I am not affiliated with Roblox Corporation or Anthropic.

This guide walks through a working path: extract audio, get word timestamps, turn them into an ASS file with a live-word highlight, and burn the result into a 9:16 clip. It is the caption stage only. Cutting, silence removal, and face framing are separate problems; I will point at them, not pretend they are solved here.

What “good enough” captions look like on a Short

A useful default for a 9:16 talking-head:

• Two lines at most, roughly three to five words per line, centered in the lower third.
• The current word is a different colour or weight. The rest of the line stays readable.
• Leave a margin above the platform UI (the caption block often sits around 70–80% down the frame, not on the very bottom edge).
• Do not cover the mouth. If you already reframed the face into the upper two thirds, the lower third is free.
• Timing follows the word, not the sentence. A word that appears 400 ms late feels sluggish; one that appears early feels like a leak.

SRT can do the job if you only need sentences. Word-level highlight is much easier in ASS.

Step 1: extract a clean mono track

Whisper does not need a 48 kHz stereo mix. A 16 kHz mono WAV is smaller, faster, and honest enough for speech.

ffmpeg -y -i input.mp4 -vn -ac 1 -ar 16000 -c:a pcm_s16le audio.wav

If the source is already a clip you will publish, use that same file as input.mp4. If you caption a long podcast first and cut later, word times will still be correct for the long file; you will have to shift them when you cut. It is usually simpler to caption after you have the 20–60 second clip.

Step 2: transcribe with word timestamps

faster-whisper is the practical local choice: same word timings as Whisper, less RAM, good CPU performance with int8. A first script:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="auto", compute_type="int8")
segments, info = model.transcribe(
    "audio.wav",
    language="de",          # or "en"; omit to let it detect
    word_timestamps=True,
    vad_filter=False,
    beam_size=5,
)

words = []
for seg in segments:
    for w in seg.words:
        token = (w.word or "").strip()
        if not token:
            continue
        words.append({"start": w.start, "end": w.end, "text": token})

print(info.language, len(words), "words")

A few honest limits:

• small is a sensible default on a laptop. medium is cleaner on messy German audio and proper names; it is also slower. tiny will caption a demo, but it will miss names.
• Set language if you know it. Auto-detect on a short clip can flip to the wrong language after a loanword or a title in English.
• For files longer than a few minutes, transcribe in chunks of about 60 seconds and cut at a quiet spot, then stitch the word lists. A single pass on a long episode can drift.
• Do not treat the text as final. Whisper will invent a plausible name. Keep a small replacements file ("Müller", "Kelvaro", product names) and apply it before you render.

Times are in seconds, float, relative to the start of audio.wav.

Step 3: wrap words into lines, then into ASS events

Do not emit one event per word if you can avoid it. Build a line of three to five words, then, for each word in that line, write an ASS event that covers only that word’s time span and highlights just that word. The line stays on screen; the highlight moves.

A compact way to wrap: accumulate words until the next one would exceed about 24 characters or a five-word cap, and break before a new clause if you can (und, aber, weil, and, but). Avoid ending a line on a tiny function word if the next word is the payload.

ASS needs timestamps as H:MM:SS.cc (centiseconds). A highlight can be a colour override:

[Script Info]
ScriptType: v4.00+
PlayResX: 1080
PlayResY: 1920
WrapStyle: 0

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Word,Poppins ExtraBold,72,&H00FFFFFF,&H00000000,&H00101010,&H80000000,-1,0,0,0,100,100,0,0,1,6,0,2,80,80,280,1

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:01.20,0:00:01.55,Word,,0,0,0,,Clips {\c&H00E6C600&}automatisch{\c&H00FFFFFF&} schneiden

Notes that save pain later:

• In ASS, colours are &HBBGGRR&, not HTML. The example highlight is a yellow.
• Alignment=2 is bottom-centre. MarginV=280 on a 1920-tall frame lifts the block above typical UI chrome; tweak it on a real screenshot of YouTube Shorts or TikTok, not by taste alone.
• Use a font you actually ship (Poppins, Inter, or a bundled OFL font). A missing font silently falls back and changes the layout.
• Escape ASS special characters in the spoken text: {, }, and backslashes.

Generate the Dialogue lines in Python from your word list. Keep the full line visible in every event of that group; only the active word gets the \c override.

Step 4: burn the captions in with FFmpeg

Once you have captions.ass and a 9:16 clip.mp4:

ffmpeg -y -i clip.mp4 -vf "ass=captions.ass" -c:a copy captioned.mp4

If the clip is not 9:16 yet, do the scale/crop first, then caption, so the PlayResX/PlayResY of the ASS file match the frame you actually burn into. Mixing a 1920×1080 source with a 1080×1920 ASS style is the usual reason text lands in the wrong place.

The subtitles= filter can also read ASS, but it goes through a slightly different font-config path. If a font you installed does not appear, ass= plus an explicit fonts directory (FFmpeg’s fontsdir option on the filter) is the more predictable route.

A short quality checklist

Watch the file once, with sound off, then once with sound on.

• Names, numbers, and product words: fix them in the word list, do not “paint over” in a timeline.
• Words that start mid-breath: shift the start forward a little rather than letting a caption flash on a pause.
• Lines that sit on the face or on a hook title: drop MarginV or reserve the top of the frame for the title (about the first 2.5 seconds).
• German compounds and capitalization: Whisper sometimes splits or lowercases them. A replacements file is faster than a second model.

And the non-technical constraint: only caption recordings you or your client have the rights to. Running the model locally does not change copyright.

Where this stops

This path captions a clip you already have. It does not pick the six best moments in a 20-minute talk, drop silences, or keep a face in the middle of a 9:16 crop. Those are earlier stages, and they are worth automating only after the captions look right — because a wrong word, highlighted, is more visible than a slightly late cut.

If you want that full local pipeline instead of wiring only the caption stage, I packaged it as a pay-once kit (the Auto-Clipping-System): Python source, a German step-by-step guide, word-level captions (including German), silence removal, face framing, hook titles, and optional zooms or B-roll. It is 29 € once, no subscription. Windows is the tested baseline. Preview every file before you post. The kit is here: https://whop.com/kelvaro-creator-kits/auto-clipping-system

Disclosure: that kit is my own paid product. No guarantee of views or revenue.

This is not mainly because the model is “bad at coding.” It is because a chat window is a terrible place to keep a Roblox project.

Why the model guesses

A general assistant has three gaps at once.

First, Roblox is not generic Lua. The language is Luau, the APIs live in Studio services, and the official documentation changes. Training data mixes old forum posts, deprecated patterns, and generic Lua. When the model is unsure, it completes the sentence anyway.

Second, each new chat starts almost empty. It does not remember that you already decided to store data in one DataService, that a RemoteEvent failed last night with a specific message, or that your game must work on touch, mouse, and gamepad. So it cheerfully opens a second shop, a second currency, or a second save path.

Third, nothing in a default chat forces the model to mark uncertainty. A confident paragraph about MarketplaceService:PromptSomething() looks the same as a verified one.

The result is familiar: you paste the script, Studio errors, you paste the error back, the model apologizes and invents a slightly different API. A typical twin of that failure is architectural: the next session forgets that a DataStore wrapper already exists and generates a second one “just to be safe.” Both bugs come from missing memory, not from a lack of adjectives in the prompt.

What a project knowledge vault actually is

A vault, in this sense, is not a pile of bookmarks. It is a source of truth outside the chat, in three layers:

1. Rules. What the assistant must always do and must never do: answer in your language, keep code and API names in English, do not invent APIs or numbers, do not call a task “done” without a playtest, prefer official Roblox documentation over old tutorials.
2. Knowledge. Sourced facts with a date: how a service works, a Luau pattern you have already tested, how you think about the first minute of a game. The model is not allowed to silently overwrite this layer because a new chat had “a better idea.”
3. Memory. What this project has learned: one-line lessons, “exact error → cause → fix,” a short status.md with open tasks and decisions, an index of modules you already tested.

Without layer 3, you repeat yesterday’s bug. Without layer 2, the model hallucinates. Without layer 1, every session has a different standard of “finished.”

A practical folder looks like this: an index the model reads first, a copy-paste master prompt for the project instructions, a 01-Wissen folder for stable notes, a code library with a short index, and 05-Projekte/<Game>/status.md. That status file can be short: current stage, the core loop in one sentence, open tasks, dated decisions, one next step, and a launch checklist. Obsidian is useful because the links work, but a plain folder is enough.

The routine that makes the vault work

The structure only helps if you use it the same way every time.

Before a task: open the index, then only the notes you need — lessons, preferences, the current status.md, the code index. If an error appears, check the error log first. Reuse tested modules. Do not reread the entire vault.

After a task, including an aborted one: add one new lesson as a single line, record solved errors in the “message → cause → fix” form, put tested snippets in the library, and update status.md plus a dated changelog line. Extend existing notes; do not duplicate them. Change sourced knowledge only when you have a source. If the assistant cannot write files itself, have it emit a short “learning update” block that you paste in.

Two rules keep the system honest. Uncertain APIs, asset IDs, or numbers get looked up or tested in Studio; otherwise the answer says “uncertain” and how to check. And “done” requires a playtest. A short report should separate what is finished from what is still open.

Studio can be connected, but the vault still matters without it

The cleanest loop today is Claude Desktop talking to Roblox Studio through Roblox’s official Studio MCP interface: list the open Studio session, build, run a playtest, read the console, take a screenshot, then fix what actually failed. That is optional. ChatGPT and Gemini work well as a knowledge base plus a fixed prompt; you stay in copy-paste mode, with complete scripts, a setup path, and a test checklist. The vault is what stops both setups from drifting.

What this does not do

A vault will not invent a good game idea, pass the Device Simulator for you, or guarantee players. Market numbers go stale; if they have no source and date, they do not belong in 01-Wissen. An oversized vault that nobody updates is just slower chaos. A few notes that you actually read beat a 200-file archive.

What it does do is reduce invented APIs, duplicate systems, and the feeling that every morning is a new project.

If you do not want to assemble this from scratch

I put this structure into a German-language kit called Roblox Second Brain: a copy-paste master prompt, a 292-page knowledge base (PDF and Markdown, dated 31 October 2026), setup from zero for Windows and macOS, a Luau course, genre blueprints, 101 game briefs, a CSV catalog of 2,174 experiences (Roblox API snapshot from the same date), a code library, Blender scripts for your own low-poly models, and the Obsidian-friendly vault with the before/after routine above. It is 19 € once. There is no success claim, and it is not an official Roblox or Anthropic product.

A free sample — 12 patterns shared by many hit games, a second-by-second first-minute plan, and a 30-day zero-budget launch template — is here:

https://whop.com/kelvaro-creator-kits/leseprobe-roblox-second-brain

The full kit is here:

https://whop.com/kelvaro-creator-kits/roblox-second-brain

Disclosure: the linked kit is my own paid product. The sample is free.

This article walks through a local Python pipeline that does that. No cloud editor, no monthly seat. The blocks are ordinary: faster-whisper for a word-timed transcript, a small scorer (or an LLM that only sees text) to pick clips, OpenCV to track a face, and FFmpeg to render. I will be honest about what this replaces and what it does not.

What the pipeline should emit

A useful default is six clips, each 20–60 seconds (30–45 is the sweet spot), already in 9:16, with silence trimmed, a vertical frame, word-by-word captions, a hook title in the first couple of seconds, light zooms, optional B-roll and sound effects, a progress bar, and a clean end that can loop.

Support two inputs, because the media is different:

• talk — one long file (podcast, interview, vlog). Find the best moments and cut each as its own Short.
• lifestyle — a folder of raw clips with little speech. Edit the folder to a beat: speed ramps, flash or whip transitions, kinetic type, a lower third, a simple grade.

The rest of this article is talk mode. Lifestyle is a second renderer on the same command, not a second architecture.

A hard rule: only process video you or your client have the rights to. yt-dlp can fetch a URL, but downloading someone else's upload and reposting it breaks copyright and platform rules, automation or not.

The command shape

Keep one entry point:

# heuristic selection, then render six Shorts
python clip.py podcast.mp4 --lang en

# German audio, more accurate captions (slower)
python clip.py interview.mp4 --lang de --model medium

# export a transcript for an LLM to pick clips, then render that file
python clip.py podcast.mp4 --analyze
python clip.py podcast.mp4 --clips work/podcast/clips.json --only 2 5

Useful flags: --fast (FFmpeg veryfast), --no-sfx, --no-broll, --music default for a quiet bed with ducking, and --crop for a full-bleed vertical crop. Cropping is fashionable; it also chops hands and slides. A safer default is to fit the whole landscape frame onto 9:16 and use a blurred copy of the same frame as background.

You need Python 3.12, FFmpeg and ffprobe on PATH, faster-whisper, OpenCV, NumPy, Pillow, SciPy, soundfile, and librosa. A GPU helps Whisper, but a CPU-only run with --model base and --fast is enough for a first pass.

Step 1: a transcript with word timestamps

Captions and clip boundaries both need word times, not paragraph times. faster-whisper (the CTranslate2 port of Whisper) writes {word, start, end} locally, including German with --lang de. From that list you can group sentences on punctuation, treat long gaps as silence, and later highlight the active caption word.

Write work files into work/<slug>/. A replayable transcript lets you re-render clip 3 without transcribing again.

Step 2: find stretches that work as Shorts

A Short has to survive without the rest of the episode. Score seven checks from 0–10 and skip anything with a mean under 6:

1. Hook in the first two seconds. A question, a hard claim, a number, a contradiction. Not "so, yeah…"
2. Self-contained. No dangling "he" or "as I said."
3. One thought. Setup, example, payoff.
4. Payoff at the end, and a cut on the payoff, not after it trails off.
5. Energy. A laugh, a pace spike, a personal story.
6. Something to comment on. A take, a myth, a surprise.
7. Length. Prefer 30–45 s; allow 20–60 s. Short and sharp beats long and soft.

Start on the first word of the hook sentence. End on the last word of the payoff (keep the laugh if it comes right after). Do not let clips overlap.

A first version does not need an LLM. Slide a sentence window across the 20–60 s range. Boost hook words in the first sentence, questions, and emotion or controversy terms (English and German). Penalize openings that start mid-thought (And, So, Und, Also). Prefer a clean sentence end and a duration near 38 s. Measure RMS energy with FFmpeg (f32le mono at 8 kHz) and reward variance, plus a mild words-per-second bonus. Sort by score and greedily keep non-overlapping winners.

That already beats "cut every 45 seconds from the start." It still misses quiet jokes and can over-rank a segment that merely contains the word "secret."

The better, still cheap path is --analyze: export a timestamped sentence list plus a short briefing, and let Claude or ChatGPT apply the seven checks and write a clips.json (start, end, a hook title of at most six words, keywords to highlight, optional speaker name, optional B-roll search terms). The model never sees the pixels, only text. A 20-minute episode is roughly 5,000–8,000 tokens. Then render exactly that file.

Step 3: reframe to 9:16 without a jumpy crop

For each output frame, detect the face (OpenCV's YuNet model is small and MIT-licensed), aim a 9:16 window at it, and smooth the window over time. Without a low-pass, every head nod becomes a camera bump.

Two framing policies:

• fit (default): letterbox the full frame onto 9:16, blur and scale the same frame as background. Nothing important is shaved off.
• crop: fill the frame and follow the face. Better for a tight talking-head; worse when two people share the shot or the speaker holds up a notebook.

If two faces are in frame, prefer a window where one person is clearly speaking, or start from a file that is already vertical.

Step 4: render in one FFmpeg pass

Once you have (start, end) and the word list, the renderer is bookkeeping: cut the source, drop pauses above a threshold (around 0.35 s works), overlay word-by-word captions with the current word emphasized, show a hook title for about 2.5 seconds, punch-in zoom on three to eight keywords, optionally lay B-roll on those hits, add light SFX, duck a music bed, and draw a progress bar with a last-frame hold so the clip can loop.

For B-roll, a local folder named by keyword is the cleanest option. If you fall back to a stock API, write a credits file and put required CC BY attribution in the description.

Generating ASS or title/drawtext filters from the word timestamps is more reliable than typography frame-by-frame in Python, except for motion-graphics layers you pre-render with Pillow.

Watch every file before you post. The pipeline will caption a mis-heard name, start a cut on a breath, or zoom on the wrong word. A two-minute review saves a bad upload.

Lifestyle mode, briefly: skip Whisper, detect the beat with librosa, lay clips on the downbeats, and add ramps plus flash, glitch, zoom, or whip-pan transitions. This will not beat a careful CapCut or After Effects pass on tracking and music feel. Treat it as a rough cut.

Rights, cost, and an honest ceiling

Use client-cleared or your own recordings. Running locally means no subscription for the core path. Optional API keys (Pexels, Pixabay, or an LLM) are extras. Budget about fifteen minutes on Windows for Python, FFmpeg, a venv, and pip install. Linux and macOS should work with Python 3.12 and FFmpeg; I have only treated Windows as the tested baseline.

A pipeline like this can take over something like 70–80% of the repetitive cutting. It does not replace a good editor, and it will not invent a hook that is not in the tape. The win is that you spend your time on selection and a last pass, not on clicking the same five effects in a timeline.

I packaged this exact flow as a paid kit (the Auto-Clipping-System): the Python source, a German step-by-step guide, a Windows installer script, the clip-scoring rules, prompts for Claude, bundled CC0 sounds, OFL fonts, and demo clips. It is 29 € once, no subscription. If you want the boxed version instead of wiring the stages yourself, it is here: https://whop.com/kelvaro-creator-kits/auto-clipping-system

Disclosure: that kit is my own paid product. No guarantee of views or revenue. Please preview every clip before you publish it.