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-W43-Tuekind longformweek W43date 2026-10-27campaign longform-youtubepillar it_devbeat asset videoduration 161.6sground blackscenes 8

Checklist the per-video bar — engine/sim

98.4/100
plain languagevo coverageno dead airuniquenesscaption fitcompletenesscleanliness
quantitative quality · weights learn from your reviews (engine.sim.memory review longform-W43-Tue good|bad)
⚠ 1 flag(s) — not yet ship-ready: copy_generic · see docs/strategy/VIDEO-CHECKLIST.md

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 8 scenes · 161.6s · comp_id + rendered still + tier + the script

#Layer (comp_id · still · tier)BeatTimecodeMotionLogoAudioVO / on-screen / caption
1s1
matches intent
shared field
signature-3d
open0–23.8sspatial-parallaxicon·white-knockout♪ bed_in
Today is photography, and we are not talking about owning a nicer camera. We are talking about making brand images you can repeat, on demand, that all look like they belong to the same company. The week is the plan behind the proof, and a photo is proof. So here is how The Big T-M plans an image instead of hoping for a good one.
on-screen: Photography you can repeat
expected on screen: black ground · box hero in the shared Signal Field · Faber leads · node-graph · spatial-parallax · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual node-graphshape boxground blacktreatment white-knockoutmotion spatial-parallaxpower summoninstrument summon→Photography you can repeat
2s2
matches intent
NumberedList
template
teach23.8–45.1skinetic-buildicon·wireframe♪ node_lock
The first move is to describe the shot in words before anything else exists. Subject, setting, light, mood, framing, in one plain sentence. We store that sentence in the plan. A photo that starts as a written brief can be remade, handed off, or generated, because the intent is on paper instead of locked in one person's head.
on-screen: Write the shot as a sentence
expected on screen: black ground · a NumberedList panel over a dimmed Signal Field · Faber leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id NumberedListvisual node-graphshape boxground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Write the shot as a sentencecurate items, nodes
3s3
matches intent
ChecklistCard
template
teach45.1–66.7skinetic-buildicon·wireframe♪ node_lock
Next, pull your brand colors and fonts into a small set of tokens, real values in a file. Red, black, white, the typeface, the spacing. Every image references the same tokens. When two photos sit side by side, they match, because they are both reading the same numbers. The brand look stops being a guess and becomes a setting.
on-screen: Lock the look in tokens
expected on screen: black ground · a ChecklistCard panel over a dimmed Signal Field · Faber leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id ChecklistCardvisual node-graphshape boxground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Lock the look in tokenscurate items, nodes
4s4
matches intent
SchematicCard
template
teach66.7–88.30000000000001skinetic-buildicon·wireframe♪ node_lock
Here is the concrete tool move. Use an image model with a locked reference, so the same character or product shows up the same way every time. You feed it the reference plus your written shot, and it returns a frame that fits the brand. You are not rolling dice. You are filling in a template you already designed.
on-screen: Generate from a reference sheet
expected on screen: black ground · a SchematicCard panel over a dimmed Signal Field · Faber leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id SchematicCardvisual node-graphshape boxground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Generate from a reference sheetcurate nodes
5s5
matches intent
LogStream
template
teach88.3–110.3skinetic-buildicon·wireframe♪ node_lock
Then check the output before you ship it. We run a quick visual pass that asks: do the colors match the tokens, is the brand mark used correctly, is the framing right. The model flags its own bad frames. You only look at the ones that passed, which is how you keep quality high without staring at every single image.
on-screen: Make the machine grade the frame
expected on screen: black ground · a LogStream panel over a dimmed Signal Field · Faber leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id LogStreamvisual node-graphshape boxground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Make the machine grade the framecurate nodes, rows
6s6
matches intent
ProcessFlow
template
teach110.3–130.8skinetic-buildicon·wireframe♪ node_lock
The proof is on our own office page. Every asset there shows a rendered still that was planned exactly this way, written first, locked to tokens, generated, then checked. Nothing was shot in a studio we are hiding. The images are built from the same file as the words, and you can inspect any of them.
on-screen: These stills came from the plan
expected on screen: black ground · a ProcessFlow panel over a dimmed Signal Field · Faber leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id ProcessFlowvisual node-graphshape boxground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→These stills came from the plancurate nodes, steps
7s7
matches intent
KpiGrid
template
proof130.8–152.8sreceipts-counticon·wireframe♪ node_lock
So photography as a system is four steps: write the shot, lock the look in tokens, generate from a reference, and let the machine grade the frame. Do that and your images stop being lucky and start being repeatable. See the whole set, planned in public, at office dot temerarii dot xyz, and copy the parts that fit your brand.
on-screen: Plan the photo, then make it
expected on screen: black ground · a KpiGrid panel over a dimmed Signal Field · Faber leads · receipts · receipts-count · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id KpiGridvisual receiptsshape boxground blacktreatment wireframemotion receipts-countpower receiptsinstrument spotlight→Plan the photo, then make itcurate kpis, statsLabels
8s8
matches intent
shared field
signature-3d
resolve152.8–161.60000000000002scoalescenceicon·white-knockout♪ bed_out
Chapter seven. Custom apps and dashboards: own the code and the IP. You keep the source, so the tool is yours to change.
on-screen: Chapter 7
expected on screen: black ground · box hero in the shared Signal Field · Faber leads · coalescence · coalescence · icon·white-knockout logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual coalescenceshape boxground blacktreatment white-knockoutmotion coalescencepower coalescenceinstrument coalescence→Chapter 7

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)

youtubeHow to own your operating layer instead of renting every tool Most businesses rent every tool they touch, and the rent never stops. This video shows how to build the operating layer yourself, with AI and code, so you own the move and the IP instead of leasing it. The method: Pick one workflow you do over and over, the dull repeating job that eats your week. That is the first thing to own, because the payoff is biggest where the pain repeats most. Write the job down as plain steps before any code. What goes in, what comes out, what the rule is at each step. A clear written job is a brief a coding agent can build against, and it keeps the tool from sprawling into something nobody understands. Have the agent build it in your repo. Run a coding agent in the terminal, hand it the steps and your brand tokens, and let it write the working version. You steer and review, the machine types. The code is yours, versioned, not trapped in a platform you do not control. Wire it to one source of truth so the tool reads the same data as everything else. One change updates every surface, because nothing has its own private copy of the truth. Keep the receipts in the open. Show what the tool actually does on real data, not a claimed result. The proof is the working thing, not a number you cannot back up. When you own the workflow as code, raising a vendor's price does not break you, and shutting down a service does not erase your work. The operating layer is yours. See how we run ours in public at office.temerarii.xyz. Keywords: automation, custom software, AI coding, Claude Code, own your tools, workflow, build vs buy.

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