Built · not yet proven live AI Product Development 2026

Hoshi Cut

Video analysis, scoring and short-form editing from one upload

Upload one video. The application watches it, listens to it, measures every part of it, tells you where it goes wrong, and cuts the strongest moments into short-form clips — all from that one file, with nothing invented.

My role: Sole builder
Period: 2026
Category: AI Product Development

~100 s Analysis speed For 5 minutes at 2580x1080, on one workstation
6 Scoring scales Hook, pacing, picture, sound, emotion, short-form
6 Edit modes Plus a trailer and an arbitrary-length cut
-14 LUFS Loudness target Peaks held under -1.5 dBFS

In short

Watches and listens to one uploaded video, measures picture and sound across six scales, and scores it so the weakest part cannot hide behind the average.
Cuts short-form clips that begin and end where something actually begins and ends, reframed to 9:16 by following the action, with word-timed captions.
Every clip, note and voice-over line carries the timecode it came from. Nothing is invented to fill a quota.

Project overview

Hoshi Cut takes a single uploaded video and does four things with it: measures it, judges it, improves it, and cuts it into short-form clips.

The measuring pass covers the picture — exposure, contrast, detail, movement, where the cuts fall, where attention sits in the frame — and the sound, per audio track: level, silence, clipping, speech, music, transients. It also transcribes the speech with word-level timings.

The design rule underneath all of it is that the uploaded video is the only source of truth. Every clip, every note, every voice-over line comes from something measured or heard in that footage, and carries the timecode it came from so you can jump straight back and check it.

The problem being addressed

Editing software can cut anything but tells you nothing. It will not say that your first eight seconds are dead, that your voice is buried under the game audio, or that the best thirty seconds in a long recording start at 14:22.

The tools that do claim to help tend to invent. Asked for ten clips they return ten, whether or not there are ten good moments, and the reasoning behind each is unavailable. For someone deciding what to publish, a confident answer with no traceable basis is worse than no answer, because it is acted on.

The solution

Measure first, and make every judgement traceable to a measurement.

One analysis pass produces numbers for picture and sound. Those numbers feed six scales — hook, pacing, picture, sound, emotion and short-form suitability — each showing the measurements behind it. The final score is deliberately not an average: it is 40 per cent the mean and 60 per cent the weakest scale, so one bad dimension cannot be hidden by five good ones. A video with great picture and inaudible dialogue should not score well, and under a plain average it would.

Notes are actions rather than observations: where it goes dead, where a cut belongs, where to push in, where the voice is buried. Each carries its timecode.

Clip selection refuses to pad. Clips start and end where something starts and ends — never mid-sentence — and if the footage contains three good moments, you get three clips. The number is an output, not a target.

How it works

You give it one video file. It comes back with a score, a list of things to fix with timecodes, an edited cut, and a set of short-form clips. Every one of those is traceable to something it measured in your footage.

One pass, two senses

A single analysis pass measures the picture — exposure, contrast, detail, movement, where the cuts fall, where attention sits in the frame — and the sound on every audio track separately: level, silence, clipping, speech, music, transients. It also transcribes the speech with word-level timings. Five minutes of high-resolution footage takes roughly a hundred seconds.
Measurements become six scales

Those raw numbers feed six scores: hook, pacing, picture, sound, emotion and short-form suitability. Each one shows the measurements it came from, so a score you disagree with can be argued with rather than just accepted.
The weakest scale carries most of the weight

The final score is 40 per cent the average and 60 per cent the worst scale. This is deliberate. Under a plain average, a video with excellent picture and inaudible dialogue scores well — and a video nobody can hear is not a good video with one flaw.
Notes are actions, not observations

Not "pacing is weak" but where it goes dead, where a cut belongs, where to push in, where the voice is buried under the game. Each one carries the timecode, so you jump straight to it instead of hunting.
Clip boundaries come from speech and shots

Picking the highest-scoring windows produces clips that start mid-word. Boundaries are snapped to real speech and shot-change points from the transcript and the cut data instead — sometimes a slightly lower-scoring window, always a watchable one.
Reframe, caption, level

Clips are reframed to 9:16 by following the action rather than cropping the centre, captioned against the word timings, and the whole output normalised to a broadcast loudness target with peaks held down.

Technology stack

Application

Electron
Node.js
Local-first processing

Vision

Frame measurement
Shot-change detection
Attention estimation

Audio

Per-track analysis
Speech detection
Loudness and true-peak metering

Speech

Transcription with word timings
Local speech synthesis

Output

ffmpeg
9:16 reframing
Word-timed captions

System architecture

Hoshi Cut analysis and editing pipeline — One measurement pass over picture and sound feeds everything downstream. Scores, notes and clips all carry the timecode of the measurement they came from, so no judgement exists without evidence in the footage.

My responsibilities

Designed the measurement pass and what it had to produce to make every later step traceable.
Designed the six scoring scales and the weighting that stops a weak dimension being averaged away.
Built the clip selection so that boundaries land on real speech and action boundaries.
Built the editing modes, the loudness normalisation and the 9:16 reframing.
Built the voice-over feature, including the constraint that it measures a delivery and never clones a voice.

Development process

Decide what counts as evidence first

Before any scoring existed, the rule was set: a judgement that cannot point at a measurement and a timecode does not ship. That single constraint determined most of the architecture.
Score in a way that cannot be gamed by an average

The 40/60 weighting toward the weakest scale came from testing against real footage where a plain average rated an unwatchable video highly because five of six dimensions were fine.
Let the output count be an output

Clip count is whatever the footage supports. Making it a target is exactly how these tools start inventing, and inventing is the failure this application exists to avoid.

Challenges encountered

A score that flattered bad video

The first scoring model averaged the six scales. A recording with good exposure, good framing, reasonable pacing and almost inaudible speech scored well, because one catastrophic dimension was diluted by five acceptable ones. That is precisely backwards: a video nobody can hear is not a good video with one flaw, it is unusable.

Weighting the final score 60 per cent toward the weakest scale fixed it. The general point is that an aggregate is a choice about what you are willing to hide, and the default choice — the mean — hides exactly the thing you most need to know.

Clips that cut people off mid-word

Choosing clip boundaries by score alone produces clips that start halfway through a sentence and end halfway through another. Technically those are the highest-scoring windows; they are also unwatchable. Boundaries are now snapped to real speech and action boundaries from the transcript and the shot-change data, which sometimes means a slightly lower-scoring window — and a clip somebody can actually watch.

It measures, it does not understand

This is the honest limit of the application and it is worth stating plainly. It measures light, movement, cuts, levels and speech. It does not know what is happening in the footage. It can tell you a moment is loud, fast and visually busy; it cannot tell you the moment is funny. For commentary work this is the gap that matters most, and it is unresolved rather than solved.

It does not package

The application runs, but the distributable build fails and there is no application icon. It is therefore something I can run and demonstrate, not something a stranger can install — which is the difference between a working program and a released product, and why its status here says built rather than released.

Testing and validation

Run against real footage, not samples

Scoring was developed against actual long-form recordings, which is how the averaging flaw surfaced. Synthetic test clips would not have exposed it.

Output levels verified by measurement

Delivered cuts are checked against the loudness and true-peak targets rather than judged by ear.

Boundary checking on clips

Clip starts and ends are validated against transcript word timings, so a clip cutting into a word is a detectable failure.

Traceability spot-checks

Notes and clips are checked by following their timecodes back into the source, which is the only way to confirm the no-invention rule actually holds.

Evidence and demonstrations

There is no public URL for this project, and there are no screenshots on this page. That is deliberate: a screenshot is trivial to fabricate and I would rather show you a description of the real architecture than an image you have no way to verify. The diagram above is authored from the actual system.

Source code is not currently published. Publishing this portfolio repository and making my work reviewable is step 2 on my roadmap, and it is a hiring problem before it is a technical one. I am happy to walk through any of this code in a screen share.

Current development status

Built, tested and in use

Single-pass analysis of picture and sound, with per-track audio measurement and a word-timed transcript.
Six scoring scales with the measurements behind each, and weighting that surfaces the weakest.
Actionable notes with timecodes back to the source.
Six editing modes, a trailer mode and an arbitrary-length cut.
Short-form clips with real boundaries, 9:16 reframing that follows the action, and word-timed captions.
Voice-over that measures a delivery style without copying anyone.

Not built, or not proven

It does not package. The distributable build fails and there is no application icon, so it cannot be installed by anyone else. That is why its status is built rather than released.
It measures but does not comprehend. It cannot tell you why a moment is good, only that it is loud, fast or visually busy.
No automated regression suite for the scoring model, so a change to the weighting is validated by hand against known footage.

Future improvements

Fix packaging and ship an installable build, which is the only thing between this and being a released product.
Add scene understanding so the notes can say why a moment works, not only that it measures well.
Build a regression set of scored footage so changes to the scoring model are checked automatically.

Hoshi Cut

Project overview

The problem being addressed

The solution

How it works

One pass, two senses

Measurements become six scales

The weakest scale carries most of the weight

Notes are actions, not observations

Clip boundaries come from speech and shots

Reframe, caption, level