Back Office · office.temerarii.xyz
One asset, all the way in — composition, the wireframe + storyboard, the output format stack, and the template, all read from the SAME content-index record. The expected output matches what /media surfaces for this post.
post longform-W49-Sunkind longformweek W49date 2026-12-06campaign longform-youtubepillar brandbeat asset videoduration 205.7sground redscenes 10

Checklist the per-video bar — engine/sim

100.0/100
plain languagevo coverageno dead airuniquenesscaption fitcompletenesscleanliness
quantitative quality · weights learn from your reviews (engine.sim.memory review longform-W49-Sun good|bad)
✓ all static checks pass — one-focal/scene · tier-by-beat · one-track caption · colorway · cast+shape correct · no banned/fabricated. (audio + visual tiers verify on the rendered finals — Phase 2)

Composition comp · template family · expected output

composition LongFormChaptersfamily / template LongFormChapters
9:16 Reelpending1:1 Squarepending16:9 Widepending9:16 4Kpending1:1 4Kpending16:9 4KpendingGIF (SMS)pending
render pending — silent master not yet on disk
expected output: 0/7 rendered — same matrix the /media preview surfaces for this asset.

Composition layer × scene 10 scenes · 205.7s · comp_id + rendered still + tier + the script

#Layer (comp_id · still · tier)BeatTimecodeMotionLogoAudioVO / on-screen / caption
1s1
matches intent
shared field
signature-3d
open0–24.1sspatial-parallaxicon·white-knockout♪ bed_in
This week the calendar says one thing: run it, secure it, see it, open it. That is the whole job of the operating layer. Today we open the first part, software development, and we build it in front of you. By the end you will know how The Big T-M writes custom tools without a big team. No theory. Just the moves you can copy tonight.
on-screen: Run it, secure it, see it
expected on screen: red ground · icosa hero in the shared Signal Field · Signum leads · node-graph · spatial-parallax · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual node-graphshape icosaground redtreatment white-knockoutmotion spatial-parallaxpower summoninstrument summon→Run it, secure it, see it
2s2
matches intent
NumberedList
template
teach24.1–46.400000000000006skinetic-buildicon·white-knockout♪ node_lock
The first move is to stop opening tabs. Open a terminal and start Claude Code as a coding agent. It reads your whole project at once, your files, your folders, your notes. Most people paste one file into a chat box and hope. Instead, point the agent at the actual repo on your disk so it works with the real thing.
on-screen: Start with the terminal
expected on screen: red ground · a NumberedList panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id NumberedListvisual node-graphshape icosaground redtreatment white-knockoutmotion kinetic-buildpower morphinstrument morph+laser→Start with the terminalcurate items, nodes
3s3
matches intent
ChecklistCard
template
teach46.4–66.6skinetic-buildicon·liquid-chrome♪ node_lock
The second move is to give the agent hands. You do that with MCP servers, small adapters that let one agent call other software. You wire in your database, your file storage, your calendar, whatever the tool needs. Now the agent does not guess. It calls the real tool and gets the real answer back.
on-screen: One brain, many tools
expected on screen: red ground · a ChecklistCard panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id ChecklistCardvisual node-graphshape icosaground redtreatment liquid-chromemotion kinetic-buildpower morphinstrument morph+laser→One brain, many toolscurate items, nodes
4s4
matches intent
StackTrace
template
teach66.6–88.6skinetic-buildicon·white-knockout♪ node_lock
The third move is boring and it is the one people skip. Before any code, write a short plan in plain words. What does this tool do, what goes in, what comes out. Hand that plan to the model. A clear plan turns a vague request into a list of small jobs the agent can finish one at a time.
on-screen: Write the spec first
expected on screen: red ground · a StackTrace panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id StackTracevisual node-graphshape icosaground redtreatment white-knockoutmotion kinetic-buildpower morphinstrument morph+laser→Write the spec firstcurate errMsg, errType, fix, frames, nodes
5s5
matches intent
ProcessFlow
template
teach88.6–109.1skinetic-buildicon·liquid-chrome♪ node_lock
The fourth move is to build one slice and run it. Do not ask for the whole app at once. Ask for the smallest thing that works, run it, watch it break, fix it. The agent holds the error and the fix in the same view, so each round gets you closer instead of burying you.
on-screen: Build in small slices
expected on screen: red ground · a ProcessFlow panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id ProcessFlowvisual node-graphshape icosaground redtreatment liquid-chromemotion kinetic-buildpower morphinstrument morph+laser→Build in small slicescurate nodes, steps
6s6
matches intent
JsonDiff
template
teach109.1–129.6skinetic-buildicon·white-knockout♪ node_lock
The fifth move is tests. Tell the agent to write a test for the slice it just built, then run that test. A test is just a tiny program that checks your program. When the test passes, you have proof the move worked, not a feeling. The agent can write these faster than you can ask.
on-screen: Make the agent test itself
expected on screen: red ground · a JsonDiff panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id JsonDiffvisual node-graphshape icosaground redtreatment white-knockoutmotion kinetic-buildpower morphinstrument morph+laser→Make the agent test itselfcurate fileName, lines, nodes
7s7
matches intent
DiffCard
template
teach129.6–148.7skinetic-buildicon·liquid-chrome♪ node_lock
The sixth move keeps you safe. Read what the agent wrote before you ship it. You do not need to write every line, but you must understand every line. If a piece looks strange, ask the agent why it chose that. The point is you stay the boss of your own software.
on-screen: Read the code, do not trust it
expected on screen: red ground · a DiffCard panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id DiffCardvisual node-graphshape icosaground redtreatment liquid-chromemotion kinetic-buildpower morphinstrument morph+laser→Read the code, do not trust itcurate lines, nodes
8s8
matches intent
SchematicCard
template
teach148.7–168.5skinetic-buildicon·white-knockout♪ node_lock
The seventh move is to put the tool somewhere it runs without you. Push it to a small server or a hosting service the agent can reach through its tools. Then write down how to run it again. A tool only counts when someone other than you can press the button and it works.
on-screen: Ship it, then keep it alive
expected on screen: red ground · a SchematicCard panel over a dimmed Signal Field · Signum leads · node-graph · kinetic-build · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id SchematicCardvisual node-graphshape icosaground redtreatment white-knockoutmotion kinetic-buildpower morphinstrument morph+laser→Ship it, then keep it alivecurate nodes
9s9
matches intent
RankList
template
proof168.5–187.3sreceipts-counticon·liquid-chrome♪ node_lock
Here is the honest part. We are not telling you a story we read somewhere. The whole studio you are watching was built with these exact moves, the terminal, the agent, the tools, the small slices. It runs in public. You can go look at it instead of taking our word.
on-screen: We built this studio this way
expected on screen: red ground · a RankList panel over a dimmed Signal Field · Signum leads · receipts · receipts-count · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id RankListvisual receiptsshape icosaground redtreatment liquid-chromemotion receipts-countpower receiptsinstrument spotlight→We built this studio this waycurate rows, statsLabels
10s10
matches intent
shared field
signature-3d
resolve187.3–205.70000000000002scoalescenceicon·white-knockout♪ bed_out
So that is software development, the spine of the week. Plain version: open a terminal, give the agent tools, write a short plan, build in slices, test, read, ship. Tomorrow we point the same idea at the website itself. Go see the live build at office.temerarii.xyz and steal what works.
on-screen: See it at office.temerarii.xyz
expected on screen: red ground · icosa hero in the shared Signal Field · Signum leads · coalescence · coalescence · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual coalescenceshape icosaground redtreatment white-knockoutmotion coalescencepower coalescenceinstrument coalescence→See it at office.temerarii.xyz

Format stack 1 aspects · same scenes[], re-cropped

16:9
1920×1080
X/Twitter · YouTube · LinkedIn video

Channels 2 destinations

YouTubeBlog

Social captions supplemental published copy · per channel (comp_id level)

youtubeSoftware development with an AI agent: the seven moves, start to ship This is how we write custom tools without a big team. No theory, just the seven moves you can copy tonight, walked end to end in plain language. The moves: - Start in the terminal. Stop opening tabs. Open a terminal and start Claude Code as a coding agent. It reads your whole project at once: your files, folders, and notes. Point it at the real repo on your disk so it works with the real thing, not one pasted file. - Give the agent hands with MCP servers. These are small adapters that let one agent call other software. Wire in your database, your file storage, your calendar. Now the agent calls the real tool and gets the real answer back instead of guessing. - Write the spec first. Before any code, write a short plan in plain words: what the tool does, what goes in, what comes out. A clear plan turns a vague request into a list of small jobs the agent can finish one at a time. - Build in small slices. Ask for the smallest thing that works, run it, watch it break, fix it. The agent holds the error and the fix in the same view, so each round gets you closer instead of burying you. - Make the agent test itself. Tell it to write a test for the slice it just built, then run it. A test is a tiny program that checks your program. When the test passes, you have proof the move worked, not a feeling. - Read the code, do not trust it. You do not need to write every line, but you must understand every line. If a piece looks strange, ask the agent why it chose that. You stay the boss of your own software. - Ship it, then keep it alive. Push the tool to a small server or hosting service the agent can reach, then write down how to run it again. A tool only counts when someone other than you can press the button and it works. The honest part: the whole studio you are watching was built with these exact moves. It runs in public, so you can go look instead of taking our word. See the live build at office.temerarii.xyz and steal what works. Keywords: AI software development, Claude Code, MCP servers, spec-first coding, test-driven, ship to production, build internal tools

Cross-links every lens is a view on this one record