Start here — no command-line experience needed

This tutorial has two routes: follow the steps yourself, or let a local coding agent carry out the same steps and show its test results. Start with the short example before editing an entire episode.

The video announces that the full prompt, Markdown handoff and viewer kit will be posted soon. Until the creator publishes a download link, do not assume an unlisted URL exists. The files supplied with this package are the material prepared for that release.

What you are building

OBS records your screen, camera and voice. DroidCam can turn your phone into the camera. Codex helps plan the edit and run the supplied scripts. OpenShot holds the editable timeline. FFmpeg creates and checks the MP4. Your original recordings remain separate from the finished video.

The worked automated example was tested on Linux x86_64. OBS and OpenShot also offer native Windows and macOS downloads. Their native apps are not the same as the Linux AppImage runtime used by these scripts. On another platform, ask Codex to inspect compatibility and verify an adapted route; do not paste Linux installation commands into PowerShell or claim that another platform was already tested.

1. Get the applications from their official sites

OBS and the direct OpenShot downloads are free/open source. Codex model access follows your account's current terms. DroidCam has optional paid features. Do not purchase anything just to complete the included sample render; first check what is already installed and what feature you actually need. OpenShot's Windows Store route can be paid while the direct EXE is free; choose deliberately.

The exact recording settings and optional Source Clone / Background Removal plugin links are in OBS-SETUP.md. Install plugins for the OBS packaging you actually use. A native OBS plugin should not be copied into a Flatpak installation.

2. If you are starting in ChatGPT or Copilot

You can paste the starter prompt below into the assistant you already know. A chat without local file/terminal tools can explain the steps, but cannot prove that it installed programs or rendered a file on your computer.

I am a beginner. Help me set up the “How Codex Edits My Videos” workflow from The Sp_ceman Channel. First ask what operating system I use if you cannot inspect it. Explain how to open Codex with access to a NEW local video folder. I have the supplied viewer kit or standalone Markdown handoff. Walk me through account sign-in privately, choosing the folder, and attaching the handoff. Then have the local agent inspect dependencies, preserve existing OBS/display settings, build the practice project, export it and verify it. Explain each necessary click or command in plain language. Do not claim that anything ran unless a real result was observed.

In the ChatGPT desktop app, the current official instructions describe selecting Codex from the ChatGPT dropdown and choosing Local for work in the current project folder. Open/add the new video folder and attach the handoff or paste its full contents. Complete sign-in privately. A cloud-only task does not automatically have your local OBS devices or recordings. Official environments guide.

In VS Code, open the new folder using File → Open Folder, then use an agent interface with access to that folder and its terminal. Current VS Code supports multiple agent providers, including Codex where installed/available. Select the provider you intend to use; Copilot and Codex are not interchangeable product names. If you only have a chat view without execution tools, use it to guide you into the local Codex route. Official VS Code agent overview.

3. If you choose the terminal route

A terminal is an application where you type commands. On Linux, open your application launcher and search for Terminal. Some file managers also offer Open in Terminal when you right-click inside a folder.

Extract the viewer ZIP using your file manager. Open the resulting VIEWER-KIT folder, then open a terminal there. That is the folder containing README.md and tools.

• Paste one command at a time and press Enter.
• A command is not a sentence for the chatbot. Type shell commands in the terminal and instructions for Codex in its prompt box.
• Do not type a decorative $ prompt shown in a screenshot.
• Keep quotation marks around paths containing spaces.
• pwd shows the current folder; ls lists its files; cd changes folder.
• Password prompts may show no characters as you type. Enter passwords privately; never paste them into the tutorial or handoff.

If Codex is already installed, check it with codex --version; do not reinstall needlessly. Then type codex, sign in using the offered supported method, and give it prompts/SETUP-AND-TEST.md or the complete FULL-SETUP-HANDOFF.md.

For a new Ubuntu/Debian viewer machine, WORKFLOW.md gives the dependency commands. The sudo commands install software and can request your administrator password. These installation instructions are for your own new setup; they were not run to replace the creator's working software.

4. Tell Codex exactly where to work

Copy this instruction after attaching the handoff:

Read FULL-SETUP-HANDOFF.md and follow it. Use a new folder called Codex-Video-Workflow in my Videos directory. Start by inspecting my OS, installed programs and available local tools. Explain any installation that is needed. Preserve existing recordings, projects, OBS scenes and monitor settings. Keep me involved for account sign-in, phone pairing and screen permissions. Run the supplied example all the way through native project creation, preview, HD export, full-file decode, source-preservation check and archive. Give me clickable output locations and the exact checks that passed. If a step fails, investigate its cause and repair it before continuing; do not label a partial result complete.

The creator reports using Codex with Astra Max. This is his reported chat selection; the saved default does not verify any per-chat override. Model and effort labels depend on your available product/account. Choose an available setting deliberately; a particular model is not a prerequisite for running the deterministic practice scripts. Official model-selection guidance.

5. Test OBS on your own hardware

Create a new OBS profile and a new scene collection if you are starting a separate setup. Follow OBS-SETUP.md for canvas, recording, audio, camera, clones and PIP. Select your own microphone, phone and captured screen; never copy another person's device IDs or tokens.

Make a short test recording. Switch from fullscreen camera to desktop plus camera, then desktop only. Open the saved file. Check a stable picture, one clean voice, no echo and no repeating tunnel. On Issiah's workstation OBS stays on the ThinkPad and captures the other screen; nothing about that working arrangement should be changed for this tutorial.

6. What a successful first run looks like

Your new episode contains a real .osp OpenShot project and a finished.mp4. The included practice edit is 302 frames, about 10.067 seconds, at 1920×1080 and 30 fps. Its report confirms full-file decode and unchanged source copies. Open the project and the MP4, and listen across the edit. Then give Codex your own recording and a clear editing brief.

A folder or a “done” message alone is not the test. The outcome is a playable checked file, an editable project, preserved originals and a useful report. Camera permissions, microphone quality and an adapted operating-system route must be checked on your machine.

Official pages checked during tutorial production on 23–24 September 2026. Use their current supported installers when following the guide; keep the automation's tested runtime version distinct from a new release.

Watch the same recording change.

A continuous 21-second excerpt contains a pause and an abandoned attempt. The edit keeps two complete portions, removes the restart, and adds a separate title layer.

Play one at a time to hear the difference. These are the actual media files, not a simulated preview.

New to command lines or Codex? Start with the beginner guide. Give FULL-SETUP-HANDOFF.md to Codex for the complete setup and production brief, or open TUTORIAL.html for the illustrated manual route. The Markdown contains the actual portable source code.

How Codex Edits My YouTube Videos

AI IS THE NEW NEWS · The Sp_ceman Channel · Issiah Hill

A practical Linux walkthrough: OBS recording, an organised episode folder, a readable edit plan, a native OpenShot project, an HD MP4 and measured verification.

Start with the illustrated tutorial, or use the command guide. The OBS guide documents the inspected setup, including picture-in-picture. Give this handoff to Codex to reproduce the demonstration in a new workspace.

Two routes to the same result

Do it yourself: follow the illustrated guide, create a new OBS profile/collection on your own machine, and run the individual commands below. Each step includes a result to check.

Ask Codex to set it up: give it prompts/SETUP-AND-TEST.md, your NEW workspace path and the OpenShot AppImage path. Codex audits dependencies, explains any required installation, prepares your isolated setup and runs the tests. Once dependencies are present, it can execute all sample stages with:

python3 tools/setup_viewer.py --root "$HOME/Videos/Codex-Tutorial-Demo" --episode Episode-001 --appimage "$HOME/Applications/OpenShot-v4.0.0-x86_64.AppImage"

Use a new episode name if that one already exists. Both routes end with the same native project, short MP4 and verification report. Account sign-in, phone permission/pairing, choosing your own capture screen and listening to your microphone remain explicit personal steps; the handoff tells Codex to guide and verify them, never pretend they happened.

The tested automated renderer targets Linux x86_64, Python 3.9+, OpenShot 4.0.0 AppImage, FFmpeg and a C compiler. OBS capture was inspected on Flatpak OBS 32.2.2. Other operating systems and OpenShot versions need separate verification; the renderer does not silently substitute a different runtime.

First working result

Open a terminal in this VIEWER-KIT directory. Use a NEW workspace path. Set VIDEO_APPIMAGE to the actual downloaded OpenShot file on your machine.

VIDEO_WORK="$HOME/Videos/Codex-Tutorial-Demo"
VIDEO_APPIMAGE="$HOME/Applications/OpenShot-v4.0.0-x86_64.AppImage"
python3 tools/doctor.py --appimage "$VIDEO_APPIMAGE"
python3 tools/workflow.py sample --root "$VIDEO_WORK" --episode Episode-001
python3 tools/workflow.py build --root "$VIDEO_WORK" --episode Episode-001 --appimage "$VIDEO_APPIMAGE"
python3 tools/workflow.py render --root "$VIDEO_WORK" --episode Episode-001 --appimage "$VIDEO_APPIMAGE"
python3 tools/workflow.py verify --root "$VIDEO_WORK" --episode Episode-001
python3 tools/workflow.py archive --root "$VIDEO_WORK" --episode Episode-001

Expected result: Episode-001/04-FINAL-EXPORT/finished.mp4, 1920×1080, 30 fps, 302 frames / about 10.067 seconds, with a title and two selected portions of the supplied 21-second recording. Its native project is Episode-001/02-EDITOR-PROJECT/episode.osp. The comparison is deliberately small enough to inspect completely before editing a whole episode.

The technical report intentionally says listening review NOT VERIFIED. Watch and listen yourself. A decode test cannot judge meaning or identify every background voice. Codec/library differences can change compressed file hashes between computers; verify the expected frame count, format and content, and compare source copies against their own intake hashes.

What the kit does

• Creates the episode folders without replacing existing notes.
• Copies finished recordings and verifies that the sources remain unchanged.
• Checks selected ranges, registered files, frame arithmetic and titles before rendering.
• Builds an editable native OpenShot timeline and renders it through libopenshot.
• Encodes H.264 High / AAC MP4 through FFmpeg and decodes the entire result for errors.
• Copies only used sources to an episode archive, preserving originals.

It does not automatically choose the best sentence, authenticate accounts, pair a phone, change displays, install programs, publish videos or guarantee channel growth. Codex helps author decisions and scripts; the scripts make those decisions reproducible. The creator reviews the result.

Sharing

Keep this directory together. Do not distribute .runtime, account configuration, cookies, raw OBS exports or private working logs. Font licensing is in sample/OFL.txt; other package permissions and third-party boundaries are in CREDITS.md.

From recording to a verified video

1. Know what each tool does

The benefit here is a reusable, inspectable build: the raw recording, decisions, editable project and finished output all remain available. An all-in-one editor can also make excellent videos; this approach is useful when you want Codex and scripts to repeat the mechanical work while you control the story.

Sources: OBS quick start, OpenShot download, Codex CLI, current OpenAI pricing, FFmpeg licensing, DroidCam OBS. Checked 23 September 2026; check versions again when installing.

2. Prepare a new viewer machine

On a Linux x86_64 computer, obtain OBS, FFmpeg, Python 3 and a C compiler from your distribution or the tools' official sources. Download the OpenShot 4.0.0 x86_64 AppImage from the official OpenShot site. Make that downloaded file executable using its Properties → Permissions dialog. This kit extracts it into its own .runtime directory; it does not edit your installed OpenShot or require a system Python package for libopenshot.

On Ubuntu/Debian, the following is a viewer installation example, not a command run against Issiah's existing setup:

sudo apt update
sudo apt install python3 ffmpeg build-essential flatpak curl
flatpak install flathub com.obsproject.Studio

If Flathub is not configured, follow its official distribution setup first. Review package versions and prompts. Do not mix plugins built for native OBS with Flatpak OBS. Plugin install examples and exact inspected versions are in the OBS guide. We inspected an existing installation; a clean operating-system install has not been certified by this tutorial.

Install Codex using the current official CLI instructions linked above. The official installer can be downloaded and inspected before running it, in a new viewer-owned directory:

curl -fsSLo codex-install.sh https://chatgpt.com/codex/install.sh
less codex-install.sh
sh codex-install.sh
codex --version

These are viewer installation instructions, not installation commands run on Issiah's existing host. If Codex is already installed, inspect its version and skip reinstalling it. Start it from the kit directory with codex and complete its account sign-in yourself. Do not place account files, API keys or login screens in your episode package. The original command demonstration used Codex CLI 0.153.4; the later narration-build environment reported 0.156.1. These are recorded versions, not required model-access versions. No model access is needed to run the small bundled demonstration once its dependencies are present.

3. Understand the folder map

Your-Video-Workspace/
  obs-recordings/
    LIVE-AUTOMATION-BUILD/       finished recordings waiting for intake
    USED-VIDEO-ARCHIVE/
      Episode-001/media/        verified copies of sources actually used
  Episode-001/
    01-RAW-VIDEO/               preserved intake copies
    02-EDITOR-PROJECT/          edit-plan.json, episode.osp, project assets
    03-AUDIO-IMAGES-ASSETS/     titles, derived sound, verification
    04-FINAL-EXPORT/           preview.mp4, finished.mp4
    05-THUMBNAIL/              editable and upload artwork
    06-YOUTUBE-INFORMATION/    title, description, chapters, captions
    ASSETS/                    references you supplied
    BUILD-AUTOMATION/          brief, intake and archive manifests

From the kit directory, copy the commands in README in order. sample creates all folders, copies the supplied footage and installs its exact example edit plan. For your own episode, start with init, record into your intake location, stop OBS recording, then use intake:

python3 tools/workflow.py init --root "$VIDEO_WORK" --episode Episode-002
python3 tools/workflow.py intake --root "$VIDEO_WORK" --episode Episode-002 --source "$VIDEO_WORK/obs-recordings/LIVE-AUTOMATION-BUILD"
python3 tools/workflow.py inspect --root "$VIDEO_WORK" --episode Episode-002

Checkpoint: open BUILD-AUTOMATION/INTAKE.json. Every copied source has its original path, size, digest and media probe. Intake can be repeated for identical files. A same-name file with different content stops the copy instead of replacing the old file. Never intake a recording still being written.

Manual equivalent: create the directories in your file manager, copy rather than move footage, run sha256sum on original and copy, and inspect each file with ffprobe. The script performs these steps together and saves their results.

4. Record in short sections

Use the matching OBS scene, keep the script close to camera height, and record one idea at a time. Leave roughly two seconds of room at each end. If you stumble, pause and repeat the whole sentence, including its subject. Do not restart with half a word. Name recordings by section and take, such as N04-take02.mp4.

The later complete take is a candidate, not automatically the winner. Listen for clipped words, changed meaning, overlap and unexpected voices. Retain only Issiah and any explicitly wanted Codex voice. Remove unrelated speech or replace the affected line with a clean recording. If private text scrolls, a cover must remain over the entire affected region through the cuts. Soft blur is not a reliable way to remove sensitive text.

5. Give Codex a concrete editing brief

Use the supplied prompts/EDIT-AN-EPISODE.md. Tell it the topic, intended viewer, actual proof, style, people to keep, material to remove and final format. Require source ranges and reasons for cuts. Ask for missing narration rather than invented footage or fabricated results.

The real process used for the demonstration was: identify the false start, locate the complete rereading, write the two retained frame ranges, add a title, validate the plan, build the native timeline, render and verify. The sample plan is the actual input to that build; it is not a transcript claiming Codex autonomously chose every frame.

6. Read the edit plan

The kit uses 30 frames per second, with zero-based start-inclusive, end-exclusive ranges. Source frame 30 corresponds to one second. This example preserves 75 + 227 = 302 frames:

{
  "fps": 30,
  "width": 1920,
  "height": 1080,
  "segments": [
    {"id": "opening", "source": "01-RAW-VIDEO/raw-retake.mp4", "in_frame": 0, "out_frame": 75},
    {"id": "corrected-take", "source": "01-RAW-VIDEO/raw-retake.mp4", "in_frame": 356, "out_frame": 583}
  ],
  "overlays": [
    {"file": "03-AUDIO-IMAGES-ASSETS/after-title.svg", "start_frame": 0, "end_frame": 302}
  ]
}

The 21-second source is one continuous excerpt from an existing recording. It contains the repeated attempt and pause; the selected output is about 10.067 seconds. This is a real editorial cut, not a speed-up or AI-generated replacement performance. The supplied title stays on its own editable layer.

Before using recordings with another frame rate or variable timing, explicitly conform a derived copy and keep the original. This tested profile does not silently reinterpret 60 fps or 29.97 fps footage as 30 fps.

python3 tools/workflow.py validate --root "$VIDEO_WORK" --episode Episode-001

Checkpoint: VALID, 302 frames, about 10.067 seconds. Missing files, altered source hashes, duplicate segment IDs, overlapping base positions and out-of-range titles are errors to resolve before building.

7. Build and inspect the native project

Run build from README. Open Episode-001/02-EDITOR-PROJECT/episode.osp with OpenShot 4.0.0. The file panel contains the source and title image; the timeline contains two retained clips and an overlay layer. Scrub across the join and listen to the sentence. Use File → Save Project As for a manual revision.

In a fully manual edit, import the raw clip, select the 1080p30 profile, split at the selected times, remove the unwanted interval, close the gap and place the title on a higher track. Match the same source ranges and compare the result. The script automates those timeline operations; it does not remove your ability to adjust them in OpenShot.

Do not regenerate a project after making GUI edits without reconciling them into the edit plan. The builder detects a changed project hash and stops rather than erasing your manual work. Keep a revision folder for a changed final export.

8. Preview, export and prove the result

python3 tools/workflow.py preview --root "$VIDEO_WORK" --episode Episode-001 --appimage "$VIDEO_APPIMAGE" --seconds 5
python3 tools/workflow.py render --root "$VIDEO_WORK" --episode Episode-001 --appimage "$VIDEO_APPIMAGE"
python3 tools/workflow.py verify --root "$VIDEO_WORK" --episode Episode-001

Do not run render again over an existing finished.mp4; the tool preserves it. Choose a new episode/revision for a changed cut. In OpenShot's GUI the comparable export target is Web → YouTube HD → 1920×1080 → High. The supplied deterministic renderer uses native OpenShot frames and audio, FFmpeg H.264 High at CRF 18, 30 fps, AAC 256 kb/s, 48 kHz stereo, and fast-start MP4. These are the script's explicit settings, not a claim that every GUI preset has identical encoder parameters.

Checkpoint: 03-AUDIO-IMAGES-ASSETS/verification/VERIFY.json reports the dimensions, frame count, digest and whole-file decode. The demonstration's initial native rendering and mux took approximately 16.51 seconds on this machine. That timing excludes setup, model work and editorial review; it is not the total time needed to produce a video.

Watch the entire export, with headphones and once on a smaller screen. Check sentence continuity, screen readability, title collisions, private text, sound levels and the first/last frames of covers. Do not mark publish-ready until this review is recorded.

9. Archive and package

Run archive from README. It copies only registered EDL-used recordings into USED-VIDEO-ARCHIVE/Episode-001/media, verifies their hashes and leaves originals where they were. Back up this workspace separately; a second folder on the same disk is not protection against disk failure.

Write the title, description and thumbnail around the same specific outcome. Add accurate chapters after the final timeline is locked. Preserve the GoFundMe link alongside the other project links. Upload only when the owner explicitly requests publishing.

10. Troubleshoot the failing step

Real settings, with the important fields visible.

These OBS screenshots show public saved values in an isolated inspection copy. Phone and microphone devices are disconnected in that copy. They do not show a new live hardware test.

OBS: the inspected Sp_ceman recording setup

Read-only inspection of saved settings, 23 September 2026. This documents the existing setup; it is not permission to reconfigure Issiah's system. Phone pairing and a new live audio/camera test have not been performed for this tutorial.

Preserve the working two-screen arrangement

Issiah confirms that opening OBS on the Samsung monitor produces infinite windows. He opens OBS only on the ThinkPad, where picture-in-picture works correctly. Keep that arrangement. Do not alter GNOME screen assignment, primary display, resolution, scaling, layout or refresh rate, and do not reselect the existing capture source.

For someone setting up their own computer: place OBS on a screen that is not being captured, and choose the intended demonstration screen in the system's capture chooser. If OBS itself is visible in that capture, the preview captures its own preview repeatedly. This is screen recursion, not a reason to change a working monitor configuration.

The actual installed combination

Launch the same installation with flatpak run com.obsproject.Studio. A separate native OBS installation exists on the production machine; do not accidentally configure that one instead. The settings inspected here belong to the Flatpak installation.

For a NEW viewer installation with Flathub already configured, the relevant plugin commands are:

flatpak install flathub com.obsproject.Studio.Plugin.DroidCam
flatpak install flathub com.obsproject.Studio.Plugin.SourceClone
flatpak install flathub com.obsproject.Studio.Plugin.BackgroundRemoval

Confirm available versions and compatibility before accepting installation. Move Transition is not required to reproduce the saved Fade transition. See DroidCam, Source Clone and Background Removal.

Profile and scene collection are different

The active saved profile and collection were both named Untitled. Profiles carry recording/output settings; scene collections carry scenes, sources and associated audio sources. A viewer should create a new profile and a new scene collection before building their version. Never import over an existing working collection.

The public OBS-SETTINGS-INSPECTED.json is a descriptive audit, not an OBS import file. Phone addresses, device IDs, stream credentials and desktop-portal tokens are deliberately omitted. A raw OBS scene export is not a safe public tutorial download.

Reference: OBS scene collections.

Recording settings: where to click and what to enter

In a new viewer profile, open Settings → Video:

Open Settings → Output, choose Simple, then the Recording section:

Choose your own intake folder as the recording path. The screenshot's isolated copy uses a different path; it is not an instruction to record in Issiah's home folder. The Streaming section's 6000 kb/s field is not the recording bitrate for this separate recording-quality mode.

Open Settings → Audio: 48 kHz, Stereo. The owner has one Mic/Aux PulseAudio input selected, unmuted at 0 dB, no saved source filters, zero sync offset and monitoring off. Device identity is machine-specific and omitted. Select your own microphone in a new setup, speak a test sentence and listen to a short local recording.

The inspection screenshot deliberately has physical audio devices disconnected. Do not copy its disabled Mic/Aux selector as the owner's real microphone setup.

Build the base camera once

1. On your phone, install the DroidCam app appropriate to your device and grant camera permission.
2. On the new OBS collection, add the DroidCam source. Pair your own device using the plugin's supported USB or local network procedure.
3. The source in Issiah's setup is named DroidCam OBS Iphone 11 Plus, with 1280×720 camera resolution. A different phone can supply the camera; its name and connection details must be yours.
4. The plugin's audio option is enabled in the saved source, but the OBS source is muted. All three camera clones below have cloned audio disabled. The separate microphone supplies narration; do not accidentally record the same voice twice.
5. Establish a stable camera picture before making clones. A saved transform is not proof that a disconnected camera is delivering frames.

The scenes and source order

In OBS's Sources list, the upper source is drawn over lower sources. For a NEW collection build these scenes:

Choose the existing screen source when reusing it within your NEW collection instead of opening another capture connection. The desktop-only and main desktop scenes fit that screen to the 1920×1080 canvas. The saved transition is Fade, 300 ms; no scene-switch hotkeys were present in the inspected scene list.

Reference: OBS sources.

Exact picture-in-picture geometry

Create a Source Clone referencing the base camera. The main PIP clone is active, video only, with cloning filters allowed. Add Filters → Effect Filters → Image Mask/Blend. Select the provided rounded rectangle mask and Alpha Mask (Alpha Channel). The saved filter is called HEAD SHOT CIRCLE MASK, but the actual supplied PNG is a rounded rectangle, not a circle.

Mask: sample/OBS_Rectangle_Mask_1024.png, 1024×1024 RGBA. It has a transparent outer area and opaque rounded inner area. Preserve the file itself.

Select the PIP in 1 - Desktop + Me, then Transform → Edit Transform. These are the saved values:

The main PIP reaches X=1950, which is 30 pixels beyond the right edge of the 1920-wide canvas. That is the inspected layout. It has not been moved or “corrected.” A viewer should reproduce these values only with the same input dimensions, or deliberately choose their own inset position.

The fullscreen clone references the same camera, uses no source filters, disables cloned audio, and scales 1280×720 by 1.5 to fill 1920×1080 at 0,0.

Presenter with background removal

Sp_ceman Camera Clone references the same base camera, with filters allowed and cloned audio off. Its enabled Sp_ceman Background Removal filter uses:

The separate filter on the Helper scene itself is disabled. Do not enable a second remover simply because it exists in the saved file. Put your own background image beneath the Helper scene in 4 - Me + Background.

The inspected owner's studio image uses scale 1.333333373, crop left/right 4, top 108, bottom 168. These values are tied to that particular image and are not a universal crop recipe. The owner's background image is not included as a general licensed asset; use an image you own.

Reference: OBS filters.

Test your new setup before recording a whole episode

Record a short local test: one sentence on fullscreen camera, a move to desktop plus PIP, and a move to desktop only. Keep OBS off the captured display. Open the saved file outside OBS. Confirm a stable inset, readable screen, one clean voice, no echo, no screen recursion and no private notifications. Check frame size, frame rate and audio with ffprobe.

This hardware test must happen on the viewer's machine. Codex can create folders, inspect settings, build titles, run media checks and report exact failures; it cannot silently grant phone permissions, choose a private screen on the owner's behalf or prove microphone quality from a settings file.

Copy this into Codex after adding the viewer kit

Build my video workflow using FULL-SETUP-HANDOFF.md and the files in this kit. I am a beginner. Explain each new tool in plain language and give me the next action in small steps.

Use a NEW folder in my Videos directory. First inspect my operating system, CPU architecture, free disk space, installed OBS, OpenShot, Python, FFmpeg and compiler. Identify the exact application/package variants. Do not reinstall working software or touch existing OBS scenes, camera sources, audio routing or display settings. If installation is needed, show the official source and specific changes before requesting the permissions needed to perform them.

Keep account sign-in, camera pairing, screen capture permissions and microphone selection under my control. Do not put credentials, phone addresses, device IDs, account files or private screen contents into the handoff, logs or public video. A chat without local tools must hand me these instructions rather than pretend it changed my machine.

For Linux x86_64, use the supplied native OpenShot 4.0.0 AppImage route. If my OS or runtime is different, assess and implement an equivalent native route only when you can test it here. Do not claim the Linux build proves Windows, macOS or phone capture works. A fallback explanation is not a completed installation.

Run the bundled 21-second example through sample intake, plan validation, native project build, preview, full render, full-file decode, source preservation and archive. Verify the expected 302 retained frames at 1920×1080, 30 fps, with audio. Open the project and the result for inspection. For a Markdown-only kit, first create the clearly labelled synthetic setup fixture; do not describe it as the creator's real before/after recording.

Then help me create a NEW OBS profile and scene collection if I need a new recording setup. Follow the documented screen, camera, clone, mask and audio routing. Use my actual hardware and a background I own. Record a short local hardware test, switch fullscreen camera → desktop/PIP → desktop only, and verify the saved recording. Stop at any screen permission or account action that only I can provide.

For my real episode, ask for the topic, intended viewer, recordings, voices to retain, style and final purpose if those details are missing. Create the standard episode folders. Copy and hash originals; do not move or delete them. Review the footage, locate full retakes, retain useful personal additions, remove false starts and unrelated voices, and document exact source ranges. Never manufacture a statement, a result, a model conversation, or a before/after proof. If overlapping speech prevents a clean edit, identify the line that needs rerecording.

Keep the native OpenShot project editable. Use diagrams and clear text when they teach something, genuine application captures when demonstrating settings, and actual tool output when proving a build. Use a strong honest opening followed by setup, action, a result and a useful next step. Do not pad the running time. Do not promise algorithmic reach or monetization.

Prepare original dialogue with modest cleanup and consistent levels; preserve voice, meaning and lip sync. Keep music optional and unobtrusive. Use yellow for actions, purple for headings, orange for step numbers and dark blue for technical material when following this channel's design. The creator identifies the production model selection as Codex with Astra Max; do not imply that a specific model is required for the deterministic scripts.

Preview critical joins and graphics, then export MP4 H.264/AAC, 1920×1080, 30 fps. Verify frame count, whole-file decode, dimensions, original hashes, export hash, audible dialogue, title placement, unwanted voices and privacy. Keep technical checks separate from human listening/meaning review. Never certify a review you could not perform.

Save title, description, accurate chapters, captions, thumbnail and the reproduction report. Copy used originals to the episode archive and explain that a separate-device backup is still needed. Preserve previous exports and manual GUI revisions. Do not upload or send anything without my request. Report the actual artifact locations, completed checks, exact remaining issues and next action.