Claude's Corner: Shortkit - The SDK Built by the Engineer Behind YouTube Shorts

Shortkit packages the full short-form video stack into a drop-in SDK so any consumer app can ship TikTok-quality feeds without a YouTube-sized engineering team. Founded by a former YouTube Shorts infrastructure engineer, it handles everything from transcoding to ML-driven buffer management.

Daniel Singer

Editor, StartupHub.ai

Aug 10 at 11:16 AM8 min read

Shortkit homepage screenshot with Claude's Corner badge

TL;DR

Shortkit is a drop-in SDK that gives any consumer app TikTok-grade short-form video. The founder spent six years at YouTube building the exact infrastructure they now sell. That background is the real differentiator, not the code.

7.0

Build difficulty

Contents(9)

Most companies discover too late how hard short-form video actually is. They integrate a generic video player, fire up Cloudflare Stream for transcoding, and wonder six months later why their video features get ignored while TikTok clips consume the same user's next three hours. The delta isn't the content. It's the 200 milliseconds between swipes, the buffer that anticipates the next video before the user decides to watch it, the codec negotiation that happens in the background so the first frame appears instantly even on a spotty LTE connection.

Shortkit's founders understand this gap from the inside. Michael Seleman spent six years at YouTube building the infrastructure behind YouTube Shorts. He didn't just use the stack - he built the parts that make short-form video feel fast and addictive at scale. His co-founder Neil Bhammar scaled a SaaS company from first employee through Series B at BusRight. The combination is infrastructure expertise paired with commercial execution, which is the pairing that actually ships products.

What Shortkit Does

Shortkit sells a drop-in SDK for short-form video. The pitch to potential customers is blunt: instead of spending six months and a team of engineers to build a feature that still won't perform like YouTube Shorts, plug in this SDK and ship something that does.

The product covers the entire stack:

Client SDKs for iOS (iOS 16+, distributed via Swift Package Manager), Android, React, and Web
Video pipeline: automatic upload, transcoding to adaptive bitrate HLS, global CDN delivery
Player mechanics: feed-aware pre-loading, ML-driven buffer management, device-aware codec selection that cuts delivered bytes by two to three times on capable hardware
Recommendation engine: baseline configurations for small catalogs, ML-driven feed ranking as content volume grows
Monetization: native ad integrations, first-party data collection hooks
Analytics: plays, swipes, completions, watch time curves, drop-off points, rebuffering rates
Admin layer: REST APIs, CMS connectors, AI captioning in 50+ languages, auto-moderation for user-generated content

The target customer is a company with content or inventory that wants a short-form surface without building the team to match. Media companies like the New York Times and ESPN are explicitly in scope; so are consumer platforms like TripAdvisor, Zillow, and Yelp, which all have large catalogs that could benefit from a vertical swipe interface.

Business Model

B2B SaaS with no public pricing - standard for infrastructure with per-customer usage variables. The likely structure is a combination of bandwidth delivered, video minutes processed, and seats. The native ad integration creates an interesting second revenue vector: once Shortkit manages your video surface and ad slots, the relationship becomes stickier. You are not just paying for infrastructure; they are part of your monetization stack.

How the Tech Stack Works

The foundational pipeline follows a well-established pattern. Video comes in via REST API or CMS connector, gets transcoded into multiple quality tiers on an adaptive bitrate HLS ladder, and lands in a global CDN. This part is infrastructure commodity. What Shortkit layers on top is where the differentiation sits.

Buffer management is the biggest technical claim. Generic video players use simple greedy buffering: grab as many seconds ahead as bandwidth allows. That works fine for long-form content where the user commits to watching. For short-form feeds, it wastes bandwidth on videos the user will swipe past in two seconds. Shortkit's ML model predicts swipe velocity and adjusts the pre-fetch budget accordingly. A user swiping fast gets lighter buffering on the current item and more items pre-loaded ahead. A user stopping to watch completions gets heavier buffering on the current video. The difference shows in rebuffering rates and in the physical feel of the scroll.

Codec selection runs automatically per device. A capable phone supporting AV1 gets the AV1-encoded stream, which delivers the same visual quality at 40 to 50 percent lower bitrate. HEVC on Apple devices. VP9 as the broad fallback. The result is fewer bytes delivered, faster loads, and lower CDN costs - without the developer doing anything.

Feed-aware player mechanics means the player knows its position in a swipe stack. Items one and two positions ahead start buffering before the user touches the screen. The handoff between items is designed to feel physical, not transactional. This is the piece most generic video SDKs skip entirely, and it is the piece that makes the feed feel like TikTok rather than a video website.

The recommendation engine starts with baseline collaborative filtering. As per-customer data accumulates, ML-driven ranking layers on top. The scope is constrained to each customer's own catalog - this is not a cross-platform network. A news publisher's feed ranks news videos; a marketplace's feed ranks property tours.

Difficulty Score Breakdown

Building a Shortkit clone from scratch is harder than it looks. The individual components are known. Combining them into something that works at production quality across four platforms while maintaining the player feel is where complexity compounds.

ML / AI (7/10): The rec system is collaborative filtering with ML ranking on top. The buffer management prediction model is more interesting - a sequence model over user swipe patterns trained on per-customer data. Neither is research-level, but both require careful product instrumentation to train effectively.
Data (5/10): Per-customer analytics with no cross-customer flywheel. The data layer enables product improvement but doesn't create a compounding network effect between customers.
Backend (8/10): Video transcoding pipelines, adaptive bitrate generation, chunked transfer encoding for fast first-frame delivery, multi-region CDN. This is genuinely complex infrastructure with a lot of edge cases.
Frontend / SDKs (8/10): Four platform SDKs with buttery player mechanics, feed-aware pre-loading, and zero visible jank on swipe represents a large and ongoing engineering commitment. This is the most maintenance-heavy surface in the product.
DevOps (7/10): Global CDN, serverless auto-scaling to handle viral spikes, multi-region video delivery. Well-traveled territory with modern cloud providers, but operationally non-trivial.

The Moat

The technical moat is real but narrow. Every component Shortkit describes is buildable by a team with video infrastructure experience. FFmpeg for transcoding, HLS with multiple renditions, a CDN, a basic ML rec system. None of this is locked up behind patents or proprietary research.

What is not easily replicated is Michael Seleman's six years building YouTube Shorts specifically. YouTube invests enormous engineering time on player feel. Knowing what got optimized first, what broke at scale, what metrics predict retention versus what predict rebuffering - that institutional knowledge doesn't appear in technical papers and doesn't transfer in a job description.

StartupHub.ai data shows that among the media infrastructure companies in our database, Cloudinary (score: 83) is the closest parallel in terms of serving developers with managed media pipelines. But Cloudinary targets general image and video management; none of the companies we track address the short-form consumer SDK niche as a standalone product with player mechanics and feed ranking as first-class features.

The honest version of the moat: if a large media company decides to build this in-house with two senior video engineers and six months of runway, they can reach 80 percent feature parity. Shortkit's bet is that 80 percent takes too long, costs too much, and the remaining 20 percent - the feel - keeps customers once they ship. That is a reasonable bet for the next 12 to 18 months.

What Is Easy to Replicate

The video transcoding pipeline (FFmpeg, AWS MediaConvert, or Cloudflare Stream cover this)
Basic analytics (standard observability tooling)
The REST API layer and CMS connectors
Ad integration (most networks ship their own SDKs)

What Is Hard to Replicate

The player mechanics polish that comes from years of YouTube Shorts institutional knowledge
Cross-platform SDK maintenance across iOS, Android, React, and Web simultaneously
ML buffer management tuned for production traffic patterns
Customer trust in a category where one bad CDN day destroys a week of retention gains

Replicability Score: 45 / 100

Shortkit is infrastructure SaaS with a significant knowledge moat from its founders but no structural lock-in that compounds over time. A well-funded team with relevant video engineering experience could replicate the core product in 12 to 18 months. The score reflects genuine technical complexity in the SDK and infrastructure layers, offset by the fact that this is known engineering territory without novel research or proprietary data assets.

The Bottom Line

Shortkit is solving a real problem that most video infrastructure products ignore: the gap between having a video player and having a feed that feels like TikTok. The founder's YouTube Shorts background is the strongest possible credential for this specific problem. The business model is straightforward, the target customer is clear, and the go-to-market is not complicated - find companies with content catalogs that want short-form surfaces, show them the demo, let the product close.

The risk is the clock. Knowledge moats are not durable moats. The longer Shortkit takes to acquire customers and embed in publishing workflows, the more time a well-resourced competitor has to close the gap. If they get into three or four major media properties in the next 12 months, the reference customer list creates the real moat. If they move slowly, someone with a larger team and a bigger marketing budget catches up.

Watch the customer announcement cadence. That is the actual signal on whether this works.

© 2026 StartupHub.ai. All rights reserved. You may not republish this article in full without a license. Search engines and AI research tools may crawl and summarize for reference. Bulk reproduction or model training requires a license. See our terms.

Build This Startup with Claude Code

Complete replication guide, install as a slash command or rules file

# Build a Shortkit Clone with Claude Code

## Step 1: Database Schema
Create tables for `videos`, `feeds`, `feed_items`, `analytics_events`, `ad_slots`, and `customers`. Videos hold metadata (id, customer_id, cdn_url, duration, status, transcoding_job_id). Feed_items join videos to customer feeds with a position and score column for ranking. Analytics_events capture play, swipe, completion, and rebuffer events with timestamps and session_id.

```sql
CREATE TABLE videos (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  customer_id UUID NOT NULL,
  original_url TEXT,
  cdn_base_url TEXT,
  duration_seconds FLOAT,
  status TEXT DEFAULT 'processing',
  transcoding_job_id TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);
```

## Step 2: Video Ingestion API
Build a REST endpoint POST /v1/videos that accepts a file upload or source URL. Use pre-signed S3 URLs for direct browser-to-storage upload. On upload completion, enqueue a transcoding job via SQS or a job queue. Return a video_id immediately so the client can poll status.

```bash
curl -X POST https://api.yourapp.com/v1/videos \
  -H 'Authorization: Bearer sk_...' \
  -F 'source_url=https://example.com/video.mp4'
```

## Step 3: Transcoding Pipeline
Run FFmpeg on AWS Batch or Lambda containers. Generate an adaptive bitrate HLS ladder: 360p, 540p, 720p, 1080p variants. Use AV1 for VP9-capable devices, HEVC for Apple, H.264 as baseline. Generate thumbnail at 0.1s, 1s, and midpoint. Upload all renditions to S3 behind a CloudFront CDN. Update the video row with cdn_base_url pointing to the HLS master playlist.

```bash
ffmpeg -i input.mp4 \
  -map 0:v -map 0:a -b:v:0 800k -s:v:0 540x960 \
  -map 0:v -map 0:a -b:v:1 2500k -s:v:1 1080x1920 \
  -f hls -hls_time 2 -hls_list_size 0 \
  -master_pl_name master.m3u8 output/%v/stream.m3u8
```

## Step 4: iOS SDK
Create a Swift Package with a ShortFeedView SwiftUI component. The feed is a vertical UIScrollView with paged scrolling. Pre-load the AVPlayerItem for positions N+1 and N+2 using AVPlayerItemGroup. Use NotificationCenter to detect when the visible item changes and adjust buffer strategy: set preferredForwardBufferDuration to 3s for fast-swipers (detected by swipe velocity in the UIScrollViewDelegate) and 15s for engaged watchers. Publish via Swift Package Manager.

```swift
public struct ShortFeedView: View {
    @StateObject var viewModel: FeedViewModel
    public var body: some View {
        TabView(selection: $viewModel.currentIndex) {
            ForEach(viewModel.items.indices, id: \.self) { i in
                VideoPlayerView(item: viewModel.items[i])
                    .tag(i)
                    .onAppear { viewModel.preload(around: i) }
            }
        }.tabViewStyle(.page(indexDisplayMode: .never))
    }
}
```

## Step 5: Recommendation Engine
Start with a simple popularity-weighted random ranking per customer catalog. Implement collaborative filtering using implicit feedback (play, swipe, completion signals). Use a two-tower model (user embedding + video embedding) trained on per-customer events. Serve rankings via a lightweight inference endpoint. Re-rank daily for small catalogs, near-real-time for large ones. Use Redis to cache ranked feed slices per user.

```python
# Two-tower scoring at serve time
user_emb = user_tower(user_features)  # (D,)
video_embs = video_tower(video_features)  # (N, D)
scores = (user_emb @ video_embs.T)  # (N,)
ranked_ids = video_ids[scores.argsort()[::-1]]
```

## Step 6: ML Buffer Management
Train a sequence model (lightweight LSTM or Transformer) on historical swipe sessions to predict dwell time on the next N items given the last K swipes. Use predicted dwell time to set AVPlayer buffer targets. A predicted dwell under 2s means the user is browsing fast: pre-load three items ahead at low quality. Predicted dwell over 5s means engaged: buffer full quality on the current item. Retrain weekly per customer once session volume crosses 10k/day.

```python
class DwellPredictor(nn.Module):
    def __init__(self, d_model=64, nhead=4, num_layers=2):
        super().__init__()
        self.embed = nn.Embedding(MAX_VIDEOS, d_model)
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model, nhead), num_layers
        )
        self.head = nn.Linear(d_model, 1)
    def forward(self, video_ids):
        x = self.embed(video_ids)  # (B, T, D)
        x = self.transformer(x.permute(1,0,2))
        return self.head(x[-1])  # predict next dwell
```

## Step 7: Deployment
Deploy the API on Railway or Fly.io with auto-scaling. Use Cloudflare R2 for video storage with CloudFront or Cloudflare CDN for delivery. Run transcoding jobs on AWS Batch (spot instances for cost). Deploy the recommendation inference server as a FastAPI app on a GPU instance (A10G spot). Set up Grafana dashboards tracking rebuffer rate, P50/P95 play start time, completion rate, and swipe-per-session as the four core product health metrics. Use Terraform to manage all infra so environment parity stays tight between staging and production.

Install for:

claude-code-skills.md

#YC W2026 #Video Infrastructure #Developer Tools #Short-Form Video #SDK #Media Tech #Consumer Apps

Written by

Daniel Singer

Editor, StartupHub.ai

Daniel Singer is the editor of StartupHub.ai, a technology expert and thought leader on AI and its applications across sectors, from fintech and healthcare to developer tooling and consumer software. He writes and tests the tools covered here thoroughly and regularly, and built StartupHub.ai to give founders, operators and buyers a clearer read on what they are actually being sold.