Design & Development2025–2026Mac App · Electron · AI Workflows

TinySlate

A Mac app I designed and built for video editors — AI-powered footage search with your own model or Apple's on-device AI, storyboards, and export to Final Cut, Premiere, or Resolve.

TinySlate library view with AI-tagged video clips in a dark-themed grid

Context

TinySlate is a Mac desktop app for editors who sit on hours of unorganized footage. Point it at a watch folder, and it uses vision AI to tag every clip — title, summary, keywords, mood, location, spoken words, and on-screen text — then lets you search, map, storyboard, and export straight into Final Cut Pro, Premiere, or DaVinci Resolve.

I designed and built the whole thing: product UX, React UI, Electron shell, a native Swift helper for Apple’s on-device AI, SQLite data layer, ffmpeg pipeline, and Gumroad licensing. Most of the core app came together through sustained Cursor sessions; a structured release prep pass in mid-2026 tightened licensing, AI provider setup, and the marketing site before ship.

TinySlate library grid showing AI-tagged video clips
The main library — searchable grid of analyzed clips with mood, keyword, and rating filters in the sidebar.

The problem

If you shoot a lot — drone, travel, documentary — your drives fill up with clips you can’t find later. Scrubbing through folders doesn’t scale. Cloud tagging services exist, but editors often want local files, their own AI provider, and a clean handoff to the NLE they already use.

TinySlate sits in that gap: watch folders locally, analyze with the AI you already use — or with Apple’s on-device models and no API key at all — search instantly, then build a rough sequence before opening an editor. No subscription: footage stays on your Mac, and you pay once.

TinySlate clip detail view with AI analysis results
Clip detail panel — AI-generated title, summary, keywords, and technical metadata pulled from ffmpeg.

What I designed

Three-panel library. Collapsible filter sidebar, clip grid, and a 320px detail drawer. Arrow keys move between clips; Escape closes the panel. Keeps browsing fast when you’re hunting for one shot.

Bring your own brain. First launch walks through provider choice — featured cards for Claude, OpenAI, Gemini, Ollama, Apple Vision, and Apple On-Device, not a generic API key field — then a connection check and a live model list. OpenRouter, Grok, Groq, Mistral, and other OpenAI-compatible endpoints sit one step further in. Users stay in control of cost and privacy, and can switch providers without touching their library.

Search that matches how editors think. Plain-language search across titles, summaries, keywords, what was said, and what’s written on screen — “the take where she says launch day” or “the shot with the trailhead sign” — plus sidebar filters for mood, location, capture device, time of day, rating, and favorites.

Storyboards inside the app. Drag clips into lanes, trim and reorder, then generate a rough-cut proxy to preview the sequence. Two AI modes: pick from your library or draft from a written concept.

Export without re-building. One menu sends FCPXML, Premiere XML, or Resolve EDL — plus a distribute package when clips span multiple drives.

TinySlate search results filtered by keyword
Keyword search across the full library — results update as filters stack in the sidebar.
TinySlate storyboard editor with clip lanes
Storyboard lanes with drag-and-drop clips, trim handles, and rough-cut generation.

Features worth calling out

Map view for GPS-tagged clips — useful for travel and drone libraries where location is how you remember a shot.

Asset library for LUTs, overlays, transitions, and sound. Creative recommendations suggest grade and sound pairings per clip, matched against what you actually own.

Metadata write-back via XMP sidecars or embedded tags, so titles and keywords travel with the file into Premiere, Final Cut, Lightroom, and Bridge.

AI optional. Each watch folder can read the titles and tags already in your files, or import filenames only, with no model and no cost.

iCloud library sync keeps the library in step across every Mac you edit on, under one personal license.

TinySlate map view showing GPS-tagged clip locations
Clips with GPS data plotted on a dark-themed map — click a marker to open clip detail.
TinySlate export options for professional NLEs
Export menu — Final Cut Pro, Premiere, Resolve, or a distribute package for mixed online/offline drives.

How it was built

Stack: Electron, React 19, TypeScript, Tailwind, Zustand, SQLite (better-sqlite3), ffmpeg for frame extraction and proxy generation, and provider SDKs for Claude, OpenAI, Gemini, Ollama, and OpenAI-compatible endpoints. A bundled native Swift helper brings in Apple’s Foundation Models, Vision, and Speech frameworks.

Architecture: Main process handles file watching, analysis queue, licensing, and export. Renderer is a standard React SPA with a typed preload bridge. Analysis runs in a background queue with rate limiting and clear progress in the header. For on-device analysis, the main process hands frames and audio to the Swift helper, which returns titles, summaries, scene labels, transcripts, and on-screen text without a cloud call — and API keys live in the macOS Keychain.

Cursor’s role: I used Cursor throughout — for feature work, refactors, and a spec-driven release prep pass (licensing wire-up, dynamic model picker, multi-provider recommendations, landing page refresh). Having structured task briefs and review checkpoints kept agent-assisted work from turning into spaghetti.

TinySlate AI provider and model selection settings
Settings — choose a cloud provider, local Ollama, or Apple Vision and Apple On-Device, verify the connection, then pick a model.

Outcome

TinySlate ships as a commercial Mac app for Apple Silicon and Intel — $45 once, with future updates included — and a free trial of 7 days or 50 analyzed clips. It launched on Product Hunt in September 2026. The landing page at tinyslate.app uses real app screenshots — the same ones in this case study.

For me, the project is the clearest example of what I mean by sitting between design and code: every interaction decision had to survive contact with ffmpeg paths, queue states, and offline drive edge cases. AI helped me move faster, but the product only works because the UX was designed around how editors actually work.