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-W48-Tuekind longformweek W48date 2026-12-01campaign longform-youtubepillar multimediabeat asset videoduration 171.7sground whitescenes 7

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-W48-Tue 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 7 scenes · 171.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·wireframe♪ bed_in
The operating layer needs custom tools, the small programs no one sells you because they only fit your business. Today is software development, and the surprise is you do not need a room full of engineers. You need one clear request and an agent that writes, runs, and fixes its own code. You will learn the loop that turns a plain ask into a working tool.
on-screen: Custom software, no big team
expected on screen: white ground · octa hero in the shared Signal Field · Lumen leads · node-graph · spatial-parallax · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual node-graphshape octaground whitetreatment wireframemotion spatial-parallaxpower summoninstrument summon→Custom software, no big team
2s2
matches intent
NumberedList
template
teach24.1–50.0skinetic-buildicon·wireframe♪ node_lock
Start by telling Claude Code, in the terminal, exactly what you want in one plain sentence. A script that takes a folder of invoices and adds up the totals by month. That is it. The agent writes the first version of the code itself. You are not typing syntax. You are the person who knows what the business needs, and that is the part a machine still cannot do for you.
on-screen: Describe the tool in one sentence
expected on screen: white ground · a NumberedList panel over a dimmed Signal Field · Lumen leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id NumberedListvisual node-graphshape octaground whitetreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Describe the tool in one sentencecurate items, nodes
3s3
matches intent
ChecklistCard
template
teach50.0–75.2skinetic-buildicon·wireframe♪ node_lock
Here is the move that matters. Let the agent run the code it just wrote, in the same terminal, and read its own error messages. Code almost never works the first time. A human would copy the error and search for it. The agent reads the error, understands what broke, and rewrites the line that failed. It loops on its own until the script runs clean. You just watch.
on-screen: Make it run the code and read
expected on screen: white ground · a ChecklistCard panel over a dimmed Signal Field · Lumen leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id ChecklistCardvisual node-graphshape octaground whitetreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Make it run the code and read errorscurate items, nodes
4s4
matches intent
AnnotatedDiagram
template
teach75.2–100.0skinetic-buildicon·wireframe♪ node_lock
Before you trust the tool, tell the agent to write tests, small checks that prove the code does what you asked on fake data you control. Feed it three invoices you already know the answer for. If the test passes, the math is right. The big T-M never ships a tool without these checks, because a calculator that is confidently wrong is worse than no calculator at all.
on-screen: Make it write tests for itself
expected on screen: white ground · a AnnotatedDiagram panel over a dimmed Signal Field · Lumen leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id AnnotatedDiagramvisual node-graphshape octaground whitetreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Make it write tests for itselfcurate callouts, nodes
5s5
matches intent
WireframeMock
template
teach100.0–123.8skinetic-buildicon·wireframe♪ node_lock
Put the tool in git, the system that saves every version of your code. Tell the agent to commit each working change. Now if a new edit breaks something, you roll back to yesterday in one command. Nothing is lost, ever. This is the safety net that lets you and the agent move fast: you can always undo, so you are never afraid to try.
on-screen: Keep every version in git
expected on screen: white ground · a WireframeMock panel over a dimmed Signal Field · Lumen leads · node-graph · kinetic-build · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id WireframeMockvisual node-graphshape octaground whitetreatment wireframemotion kinetic-buildpower morphinstrument morph+laser→Keep every version in gitcurate nodes
6s6
matches intent
TerminalRun
template
proof123.8–147.9sreceipts-counticon·wireframe♪ node_lock
Our proof is the engine behind this whole calendar. It is custom software, built exactly this way, an agent writing code, running it, reading its own errors, fixing them, and committing each good version. We did not hire a squad to build it. We described what we needed and stayed in the loop. The tool exists because the steps are small and the machine is patient.
on-screen: Our engine is one of these tools
expected on screen: white ground · a TerminalRun panel over a dimmed Signal Field · Lumen leads · receipts · receipts-count · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id TerminalRunvisual receiptsshape octaground whitetreatment wireframemotion receipts-countpower receiptsinstrument spotlight→Our engine is one of these toolscurate statsLabels
7s7
matches intent
shared field
signature-3d
resolve147.9–171.70000000000002scoalescenceicon·wireframe♪ bed_out
So custom software is no longer out of reach. Say what you need in one sentence. Let the agent write it, run it, read its own errors, and fix them. Make it test itself, keep every version in git. Build the one small tool that would save your team an hour a day. See what we built this way at office dot temerarii dot xyz.
on-screen: See the tools at office.temerarii.xyz
expected on screen: white ground · octa hero in the shared Signal Field · Lumen leads · coalescence · coalescence · icon·wireframe logo · caption bottom-left
spec (the prompt): comp_id shared Signal Fieldvisual coalescenceshape octaground whitetreatment wireframemotion coalescencepower coalescenceinstrument coalescence→See the tools 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)

youtubeBuild custom software with an AI coding agent, no engineering team Most businesses think custom tools need a room full of engineers. They do not. You need one clear request and a coding agent that writes, runs, and fixes its own code. This video walks the whole loop, in plain language, so you can copy it tonight. What you will learn: - Describe the tool in one sentence. Tell Claude Code in the terminal exactly what you want, like a script that reads a folder of invoices and adds the totals by month. The agent writes the first version. You bring the part a machine still cannot: knowing what the business needs. - Let the agent run its own code and read its own errors. Code rarely works the first try. Instead of you copying the error into a search box, the agent reads the error, understands what broke, and rewrites the failing line. It loops on its own until the script runs clean. - Make it write tests before you trust it. Feed it three invoices you already know the answer for. If the test passes, the math is right. A calculator that is confidently wrong is worse than no calculator at all. - Keep every version in git. Tell the agent to commit each working change. If a new edit breaks something, you roll back to yesterday in one command. Nothing is ever lost, so you are never afraid to try. The honest proof: the engine behind our whole content calendar is custom software built exactly this way. An agent writing code, running it, reading its own errors, fixing them, committing each good version. No squad. We described what we needed and stayed in the loop. The one move to take: build the single small tool that would save your team an hour a day. Say what you need in one sentence and let the agent do the typing. See what we built this way at office.temerarii.xyz Keywords: AI coding agent, Claude Code, custom software without engineers, build internal tools, git version control, automated testing for non-developers

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