How I gained 1000 followers in a week with two vibe-coded scripts and Loopi.

Write a single Python file transfer.py — a local WiFi file transfer server (desktop ↔ phone on same network).

Run: python3 transfer.py [port] (default 8080). Detect LAN IP via UDP socket to 8.8.8.8:80 (fallback 127.0.0.1). On startup, print the URL in an ASCII box and a terminal QR code (qrcode lib, inverted ASCII). Gracefully exit with install hints if flask or qrcode are missing.

Server: Flask, host=0.0.0.0, threaded, MAX_CONTENT_LENGTH=4GB. Auto-create ./received/ (uploads) and ./shared/ (downloads) next to the script.

Routes:
- GET / — serve a single self-contained HTML page (inline string).
- POST /upload — accept multiple files (request.files.getlist("files")), sanitize names with werkzeug.secure_filename, append _1, _2... on collision, return {"saved":[...]}.
- GET /files — JSON list of files in ./shared/ (skip dotfiles, sorted), each {name, size}.
- GET /download/<path:filename> — send as attachment; block path traversal by resolving and checking it stays inside SHARED_DIR; 403/404 as appropriate.

Frontend (inline, mobile-friendly dark theme):
- Two cards: Send (drop-zone + tap-to-pick <input type=file multiple>, drag-and-drop, upload queue with per-file progress bars using XMLHttpRequest progress events) and Browse (lists /files, each row has filename, human size, and a download button, plus a refresh button).
- JS helpers for human-readable sizes and emoji file icons by extension.

Keep it one file, no external assets.

# Build: cut_and_caption.py — single-file Python CLI

Concatenates talking-head video clips from inputs/ into one cut, then burns captions onto it. Splits cut-building from caption-rendering so caption styling can be re-tuned without re-doing the merge + transcription.

## Dependencies
System:
    ffmpeg, ffprobe   (must be on PATH)
    whisper CLI       (`pip install openai-whisper`; uses GPU if available)
Python:
    stdlib only — no API keys, no third-party Python deps beyond whisper.

## Layout (script creates dirs as needed)
    inputs/                     user drops clips here (and optional order.txt)
    transcoded/                 per-clip normalized h264 mp4 (cache)
    intermediate/cut.mp4        merged cut, NO captions
    intermediate/cut.transcript.json   whisper segment-level transcript of cut.mp4
    outputs/final.mp4           cut.mp4 with captions burned in

## CLI
    python cut_and_caption.py                # full run: build cut + caption
    python cut_and_caption.py --recaption    # only re-burn captions
    --position {top,middle,bottom}  default top
    --margin INT                    default 400
    --font-size INT                 default 42
    --opacity FLOAT (0-1)           default 0.3

## Pipeline
1. Discover clips. Look in inputs/ for *.{mp4,mov,mkv,avi,webm,m4v,mts,ts}. If inputs/order.txt exists, use it as the order (one filename per line; blank lines and `#` comments ignored; may be a subset to skip bad takes; error fast if it references a missing file). Otherwise sort by filename.

2. Transcode each clip → transcoded/{stem}.mp4 with libx264 -crf 18 -preset fast, **-g 1 (all-intra)** so concat-demux can stream-copy cleanly, aac 128k, +faststart. Skip if cached output exists.

3. Concat-demux all transcoded mp4s in order → intermediate/cut.mp4. Stream copy (no re-encode) since codecs match. Rebuild if cut.mp4 is missing or older than order.txt.

4. Transcribe intermediate/cut.mp4 with whisper CLI (model "medium", output_format json) → intermediate/cut.transcript.json. Segment-level is enough — captions don't need word timestamps. Skip if cached.

5. Caption: read cut.transcript.json segments, build an ASS subtitle file, burn it onto cut.mp4 with ffmpeg `-vf subtitles=...` -c:v libx264 -crf 20 -c:a copy -movflags +faststart → outputs/final.mp4.

## --recaption mode
Skips steps 1–4. Errors clearly if intermediate/cut.mp4 or cut.transcript.json is missing.

## Functions
    get_dimensions(video) -> (w, h)         # ffprobe
    transcode(src, dst)                      # ffmpeg normalize
    resolve_order() -> list[Path]            # order.txt or filename sort
    concat(clips, dst)                       # ffmpeg concat-demux
    transcribe(video, dst_json)              # whisper CLI
    build_ass(segments, w, h, position, margin, font_size, opacity) -> str
    burn_captions(video, ass_text, dst)      # ffmpeg subtitles filter
    build_cut()                              # steps 1–4
    recaption(position, margin, font_size, opacity)  # step 5
    main()                                   # argparse + orchestration

## ASS styling
Font Arial, font_size from CLI. Alignment 8/5/2 = top/middle/bottom. MarginV from CLI. Apply opacity to fill + outline alpha (alpha = round((1-opacity)*255) as 2-digit hex; ASS alpha is inverted — 00=opaque, FF=transparent). PlayResX/Y from ffprobe of cut.mp4.

## Constraints
Single file. No README, no extra docs, no comments beyond the module docstring. Cache by existence (and order.txt mtime for cut.mp4). Fail fast with readable errors when ffmpeg/whisper aren't on PATH or order.txt is malformed.

I just rendered 14 short-form videos to ./outputs/ — talking-head
clips, 30-60 seconds each, captions already burned in.

Schedule them across TikTok, Instagram Reels, and YouTube Shorts:
- Cadence: 2 posts a day for the next 7 days
- Times: 9 AM and 11 AM in America/New_York
- For each video, use Loopi's transcript to compose platform-
  appropriate captions — TikTok with a hook in the first two lines
  + 3-5 hashtags; Instagram with line breaks and 5-8 tags; YouTube
  Shorts with a searchable title and a 1-2 line description.

Upload everything in batches, then show me the full proposed
schedule — per-platform captions, dates, times — and wait for my
approval before you actually schedule any of it. I'll review and
either tell you to ship it or call out what to revise.

Stop hand-scheduling. Vibe-code the boring parts once, run them every week.

The two scripts are one-shot prompts. The third step — multi-platform scheduling, captions, analytics — is what Loopi exists for. Connect your agent and start running it.