N01 — The result first
This is a real recording mistake from one of my videos. I lose the line, pause, and try again. Now watch the corrected version. The unfinished attempt is gone, the complete sentence stays, and the title is in place. I want to show you the whole process that made that edit, so you can build a workflow like this for your own videos.
N02 — Welcome and the promise
Welcome to AI IS THE NEW NEWS on The Sp_ceman Channel. I'm Issiah Hill. Today we're going from a raw recording to an editable OpenShot project and a finished video, with Codex helping us do the work. You'll see the folders, the recording setup, the editing instructions, the commands, and the checks. Start with the small practice clip, then use the same approach for your own episode.
N03 — What Codex actually does
Codex helps me turn an editing brief into specific decisions and working scripts. OBS records the material. OpenShot supplies the timeline and the native editing engine. FFmpeg handles the final encoding and technical checks. Each tool has a clear job. The useful part is that we can keep the decisions and repeat the mechanical work, while still opening the project and changing the edit ourselves.
N04 — What you need
The demonstrated setup runs on Linux. OBS and OpenShot are free, open-source tools. The scripts in the tutorial are included, and the small practice build does not need a model call. Codex itself uses your account's current access and usage terms. My camera setup also uses DroidCam and a few OBS plugins. The guide lists the exact versions we inspected, so you don't have to guess which installation we used.
N05 — Get a small win first
Before we build an entire channel workflow, we're going to make one short edit work. The practice folder includes a continuous recording excerpt, the selected cuts, and a title. That gives you something small enough to check from beginning to end. If your computer can build and play that correctly, you have a much better starting point for a longer video.
N06 — The folder structure
Here's the folder structure I use. Raw footage has its own place. The editing project has its own place. Graphics and sound stay together, and the finished export goes somewhere separate. The upload information and thumbnail also have their own folders. The names are simple on purpose. When you return tomorrow, you should know where the original is, where the decisions are, and which file is the finished video.
N07 — Preserve the original
The intake step copies a finished recording. It does not remove my original. It also compares the copy with the source, so we can see that the content matches. If another file has the same name but different contents, the process stops instead of replacing it. That gives us room to make a mistake in the edit without losing the recording we started with.
N08 — My two-screen rule
One detail matters a lot in my recording setup. I keep OBS open on the ThinkPad. If I open it on the Samsung monitor, I get the repeating tunnel of windows. That's the captured screen showing its own preview again and again. My current arrangement already works, so we're documenting it, not changing it. On your system, keep the recording controls away from the screen you're capturing.
N09 — Canvas and recording quality
My saved OBS profile uses a nineteen-twenty by ten-eighty canvas and recording output, at thirty frames per second. In the recording section, the quality setting is High Quality, Medium File Size, using software encoding and Hybrid MP4. These are recording settings. Don't mistake a streaming bitrate somewhere else in the window for the quality of this recording. The screenshots and guide show the correct section.
N10 — One camera, several scenes
I don't rebuild the camera setup every time I change the shot. One camera source feeds separate clones. One gives me the fullscreen camera. Another gives me the small picture-in-picture view. Another has the background removed. That means I can move between a screen demonstration and direct explanation without rebuilding the scene in the middle of a recording.
N11 — Build the picture-in-picture
The screen capture sits underneath the camera inset. The inset uses a rounded rectangle mask, and the guide includes the exact saved position and size. One detail could be confusing: the filter's name says circle, but the actual mask is a rounded rectangle. We checked the file itself. When you follow along, use the actual mask and source dimensions instead of guessing from a label.
N12 — Add the background scene
For the presenter scene, the camera clone uses background removal, and a separate image sits behind it. The guide records the settings we found, including the filter that's disabled. That matters because turning on every filter you can see is not the same as reproducing a working setup. Use your own background image, check the edges around your face and shoulders, and make a short recording before committing to a full episode.
N13 — Get the audio right
Clear speech matters more than a complicated effect. My saved setup uses a separate microphone, and the phone-camera source is muted in OBS. The camera clones don't bring in another copy of the audio. For your setup, watch the meters and listen to a test recording. If the same voice is being captured twice, fix that routing before recording the whole tutorial.
N14 — Record in manageable sections
You do not need to read a whole script perfectly in one take. I record in short sections. If I lose a line, I pause and read the complete sentence again. That gives the edit a clean replacement to work with. Leave a little space at the beginning and end, and keep the corrected sentence complete. A clean twenty-second section is easier to repair than a rushed paragraph with no breathing room.
N15 — Open Codex in the right place
Now we open the terminal in the tutorial kit folder. That's where the instructions and scripts are. Codex needs a clear working context and a clear request. I tell it which episode we're editing, where the recordings are, what the viewer should learn, and what must stay unchanged. The guide includes a prompt you can copy and adapt without copying my personal account or device information.
N16 — Give it the actual brief
My editing brief asks for complete sentences, visible proof and a coherent story. It says to preserve the originals and keep the project editable. It also says which voices belong in the video and which interruptions must go. That is much more useful than simply asking for a professional video. The instructions describe the decisions that make it professional, and the final review checks whether those decisions worked.
N17 — Find the right take
Let's look at the recording again. There's a usable opening, then the abandoned attempt, and then the complete corrected reading. The edit keeps the useful portions and removes the restart between them. A transcript can help locate those words, but it cannot tell us everything about the sound or the meaning. We still inspect the actual clip and listen across the join.
N18 — Keep the edit decisions readable
These cuts are saved in a small edit-plan file. It tells the system which source to use, where each retained section starts and stops, and where the title belongs. The numbers are frames, so the timing is precise. That file is our bridge between the editorial decision and the rendered video. If a cut is wrong, we can find the decision that caused it and make a deliberate revision.
N19 — Check before rendering
Before rendering, the validator checks the plan against the actual footage. It looks for missing files, changed recordings, invalid ranges and titles that run beyond the end. This doesn't tell us whether the joke is funny or the explanation is clear. It catches the mechanical problems that would otherwise waste time or leave us with a broken export.
N20 — See the native OpenShot project
The build creates a real OpenShot project. The retained footage is on the timeline, and the title is on another layer. This is useful because we're not left with only a flattened video. We can open the project, scrub through the cut, and inspect how the result was assembled. If we make a manual revision, we save it separately and keep the edit plan in sync.
N21 — Add text that earns its place
The on-screen text should help you do the next step. Yellow marks an action or a checkpoint. Purple carries the main headings. Orange identifies the step, and dark blue holds the technical material. We keep the application screenshots looking like the real applications. The design gives you a consistent guide around them without hiding the setting or command you came here to see.
N22 — Preview before the full export
A short preview lets us catch a bad join or a title in the wrong place before we render the whole episode. In this small example, the finished selection is only about ten seconds long. For a long video, we also review important cuts and sections individually. That way, a mistake near the start doesn't get carried blindly into a fifteen-minute export.
N23 — Render the real timeline
Now the native OpenShot engine renders the timeline, and FFmpeg encodes the finished video. This is the actual command running, with its actual output. When I show a timing here, it refers to the render and encoding step, not every minute spent reviewing footage or planning the edit. Keeping that distinction clear makes the demonstration useful when you try it on your own computer.
N24 — Prove the export works
The checks read the finished file, confirm the format and frame count, and decode the whole video for errors. They also check that the original recordings remain unchanged. That's stronger than saying a file appeared in the export folder. But it still leaves an important job for us: watching and listening to what we actually made.
N25 — Compare before and after
Here are the two versions close together. Listen to the repeated attempt in the raw recording, then the complete sentence in the edited version. The point is not to pretend I never made the mistake. The point is to preserve what I meant to say and make it easier to follow. You can reproduce this small comparison before applying the same method to a longer recording.
N26 — The final human review
Before I call a video ready, it needs a full playback review. We check for clipped words, awkward cuts, unreadable text, unwanted voices and private details. If someone else speaks over an important line, a clean rerecording may be the best solution. A successful technical report is valuable evidence, but it is not a substitute for hearing the finished sentence.
N27 — Archive without losing the source
Once the edit is settled, the archive step copies the recordings that were actually used into an episode archive. The original recordings stay where they were. That makes the next day's intake easier to understand and gives us a clear record of what built this episode. I also want a separate backup, because another folder on the same drive cannot protect me if the drive fails.
N28 — Make the package match the video
The title, thumbnail and opening should make the same promise. For this tutorial, that promise is simple: see the real workflow and build the small example yourself. The chapters should take you to the right step, and the description should give you the useful links. I want someone who clicks to feel that their time was respected and that they leave with something they can use.
N29 — Connect it to SRR
This workflow fits the bigger idea behind my SRR work: do the task, inspect the result, and keep enough information to understand what happened. This particular video pipeline uses Codex and the tools we've shown. I'm not claiming SRR secretly performed the edit. The connection is the way we work: make the process visible, preserve the evidence, and improve the parts that don't hold up.
N30 — The next useful step
Start with the short practice edit. Get the folders, the native project and the finished file working on your machine. Then replace the sample with your own recording and give Codex a clear brief. If this helped you build something useful, subscribe for more real AI workflows, SRR development and practical tests. I'm Issiah Hill. Build it. Test it. Prove it. I'll see you in the next one.