I spend a few minutes recording a video. A pipeline does the rest: it cuts the best clips, captions them, scores them for virality, mixes in music, and posts them across every platform. Then it turns the same recording into a blog post, social threads, quote cards, and even audience-specific versions. The only manual step is hitting record.

I open-sourced the reference architecture here: https://github.com/levelsofself/content-engine

The problem

Making content is not the bottleneck. Cutting it, captioning it, formatting it per platform, posting it in five places, and then squeezing more assets out of it is the bottleneck. That work is mechanical, and mechanical work is automatable.

The pipeline

  record (1-10 min)
        |
        v
  cloud folder (Drive / Dropbox)
        |
   [1] auto-clip      -> best moments, vertical, subtitles, virality score
        |
   [2] auto-music     -> royalty-free bed, mood-matched, ducked under voice
        |
   [3] host + caption -> upload media, per-platform captions
        |
   [4] STAGE          -> human approves before anything goes live
        |
   [5] distribute     -> TikTok / Instagram / YouTube / Facebook / LinkedIn
        |
        +--> multiply (text): blog, threads, captions, quote cards, ebook outline
        +--> adapt (audience): same idea, re-expressed per audience and reading level

It is built in lanes so you can adopt one at a time: video first, then the written asset pack, then audience adaptation.

The stack

• Clipping + transcription: Vizard API (give it a cloud video URL, get back scored vertical clips and a transcript)
• Music: ffmpeg, a small mood-tagged royalty-free library, mixed low and ducked under the voice
• Hosting + multi-platform posting: PostPeer (one call posts everywhere, presigned upload for media)
• Orchestration: a small Python service (n8n works too)
• Text + asset generation: any LLM
• Runtime: a cheap Linux VPS with pm2

Every piece sits behind a thin wrapper, so the clipper, the poster, and the LLM are all swappable.

A peek at the glue

The music step is just ffmpeg with a sidechain compressor so the bed automatically ducks under your voice:

def add_music(in_mp4, music_mp3, out_mp4):
    subprocess.run([
        "ffmpeg", "-y", "-i", in_mp4, "-i", music_mp3,
        "-filter_complex",
        "[1:a]volume=0.25[m];[0:a][m]sidechaincompress=threshold=0.03:ratio=8[a]",
        "-map", "0:v", "-map", "[a]", "-c:v", "copy", "-shortest", out_mp4
    ])

The one rule that matters

Stage before publish. Nothing auto-posts. The engine writes a staged file and a human approves anything that goes public or earns money. If you run more than one brand, every asset is tagged to exactly one so the lines never cross.

Try it

The full reference, with the pipeline, a sanitized script, and an .env.example, is here: https://github.com/levelsofself/content-engine

Built while figuring out how to scale a personal brand without scaling the busywork. More on the thinking behind it at https://levelsofself.com