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-W27-Wedkind longformweek W27date 2026-07-08campaign longform-youtubepillar emerging_techbeat asset videoduration 160.3sground 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-W27-Wed 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 · 160.3s · comp_id + rendered still + tier + the script

#Layer (comp_id · still · tier)BeatTimecodeMotionLogoAudioVO / on-screen / caption
1s1
matches intent
shared field
signature-3d
open0–16.6sspatial-parallaxicon·liquid-chrome♪ bed_in
The hub is opening soon, and under every button is software somebody had to build. Today is only about software development. You will learn how a small team, or even one person, ships real working tools without drowning. These are the exact moves, given away.
on-screen: Software development, the honest way
expected on screen: black ground · cone hero in the shared Signal Field · Augur leads · node-graph · spatial-parallax · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual node-graphshape coneground blacktreatment liquid-chromemotion spatial-parallaxpower summoninstrument summon→Software development, the honest way
2s2
matches intent
ChecklistCard
template
teach16.6–37.900000000000006skinetic-buildicon·wireframe♪ node_lock
First move. Stop dreaming of one giant program. Build small functions instead. One function takes one thing in and gives one thing out. Take a name, return a greeting. Take a row, save it. Small functions are easy to test and hard to break. A big app is just many small ones holding hands. Build the hands first.
on-screen: Build small functions, not big apps
expected on screen: black ground · a ChecklistCard panel over a dimmed Signal Field · Augur leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id ChecklistCardvisual node-graphshape coneground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Build small functions, not big appscurate items, nodes
3s3
matches intent
NumberedList
template
teach37.9–60.2skinetic-buildicon·wireframe♪ node_lock
Second move. Use a coding agent in the terminal as your first drafter. You describe the function in plain English, it writes the code. But you do not trust it blind. You read it. The agent is fast and tireless. You are the one who knows what right looks like. That split, fast hands and careful eyes, is the whole trick.
on-screen: Let the agent write the draft
expected on screen: black ground · a NumberedList panel over a dimmed Signal Field · Augur leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id NumberedListvisual node-graphshape coneground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Let the agent write the draftcurate items, nodes
4s4
matches intent
SchematicCard
template
teach60.2–80.7skinetic-buildicon·wireframe♪ node_lock
Third move. For every function, write a tiny test. Give it a known input, check the output is what you expect. It takes two minutes and it saves you days. When you change code later, the tests tell you instantly if you broke something. Code without tests is a guess that you are paying interest on.
on-screen: Test before you trust
expected on screen: black ground · a SchematicCard panel over a dimmed Signal Field · Augur leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id SchematicCardvisual node-graphshape coneground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Test before you trustcurate nodes
5s5
matches intent
WireframeMock
template
teach80.7–101.6skinetic-buildicon·wireframe♪ node_lock
Fourth move. Every line lives in version control, like git. Every change is a small saved step with a note about why. If something breaks, you walk backward to the last good step instead of starting over. This is your undo button for the whole project. Skip it and one bad afternoon can cost you a week.
on-screen: Keep it all in version control
expected on screen: black ground · a WireframeMock panel over a dimmed Signal Field · Augur leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id WireframeMockvisual node-graphshape coneground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Keep it all in version controlcurate nodes
6s6
matches intent
JsonDiff
template
teach101.6–121.39999999999999skinetic-buildicon·wireframe♪ node_lock
The proof is the thing you are watching. The studio runs on exactly this. Small functions, an agent drafting, tests guarding, every change saved in git. The same machine builds the videos and the pages and the posts. We did not hire a department. We named the moves and let the agent run them.
on-screen: This studio is the codebase
expected on screen: black ground · a JsonDiff panel over a dimmed Signal Field · Augur leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id JsonDiffvisual node-graphshape coneground blacktreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→This studio is the codebasecurate fileName, lines, nodes
7s7
matches intent
StatScoreboard
template
proof121.4–139.4sreceipts-counticon·wireframe♪ node_lock
So that is software the honest way. Small functions, an agent for drafts, a test on each one, everything in version control. Your step is the smallest possible. Pick one annoying manual task and write a single function that does just that one thing. See the rest at office.temerarii.xyz.
on-screen: Write one function today
expected on screen: black ground · a StatScoreboard panel over a dimmed Signal Field · Augur leads · receipts · receipts-count · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id StatScoreboardvisual receiptsshape coneground blacktreatment wireframemotion receipts-countpower receiptsinstrument spotlight→Write one function todaycurate pillar, stats, statsLabels
8s8
matches intent
shared field
signature-3d
resolve139.4–160.3scoalescenceicon·liquid-chrome♪ bed_out
Last note. The goal is not clever code that only you understand. The goal is plain code that still makes sense in a year, to a stranger, or to a model reading it back. Boring and clear beats clever and fragile every time. The hub is built boring on purpose, and that is why it keeps running.
on-screen: Boring code outlives clever code
expected on screen: black ground · cone hero in the shared Signal Field · Augur leads · coalescence · coalescence · icon·liquid-chrome logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual coalescenceshape coneground blacktreatment liquid-chromemotion coalescencepower coalescenceinstrument coalescence→Boring code outlives clever code

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 the Honest Way: Small Functions, an Agent, Tests, Version Control Under every button is software somebody had to build. This walkthrough shows how a small team, or even one person, ships real working tools without drowning. The exact moves, given away. The method: - Build small functions, not big apps. One function takes one thing in and gives one thing out. Small functions are easy to test and hard to break. A big app is just many small ones holding hands. - Let a coding agent in the terminal write the first draft. You describe the function in plain English, it writes the code, you read it. The agent is fast and tireless, you are the one who knows what right looks like. Fast hands and careful eyes is the whole trick. - Test before you trust. For every function, write a tiny check with a known input and expected output. It takes two minutes and saves days. When you change code later, the tests tell you instantly if you broke something. - Keep it all in version control like git. Every change is a small saved step with a note about why. If something breaks, you walk backward to the last good step. The goal is not clever code only you understand. It is plain code that still makes sense in a year, to a stranger, or to a model reading it back. Boring and clear beats clever and fragile every time. Your step: pick one annoying manual task and write a single function that does just that one thing. See the rest at office.temerarii.xyz. Keywords: software development, coding agent, unit tests, version control, git, small functions, indie dev.

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