# I built a 29-channel TV network from the Internet Archive with Claude Code, and Claude programs its schedule — retained record

> Retained reddit record from reddit:ClaudeAI.

Canonical: https://highsignal.app/data/records/d64398ab722ae094

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:ClaudeAI)  published 2026-11-19 08:43 ingested 2026-11-20 02:36

[original source ↗](https://www.reddit.com/r/ClaudeAI/comments/1y04kbv/i_built_a_29channel_tv_network_from_the_internet/)

## retained text



```
Afterglow (https://theafterglow.tv) is a free TV network in the browser: 29 channels of old film, TV and radio from the Internet Archive, running on a real schedule. You tune in mid-program, the guide shows what's on now and next, and some channels run period commercials in the breaks. No sign-up.

I built it with Claude Code over about a week (56 commits, about 21,000 lines of Python and TypeScript). Claude is involved in two ways.

**1. Claude Code built it and keeps it running**

- I started from a product spec and had Claude Code build the backend (FastAPI, SQLAlchemy, SQLite on a Railway volume), the TV player and an admin console (Vite, React).
- When something went wrong on air, I described the symptom and Claude Code traced it. One example: every day the next block started up to two hours late. A new day of programming began a few minutes before a block ended, and that sliver got a full feature film. The fix was to leave the tail of a block empty rather than overrun it, plus a regression test.
- It also does the night shift. Every hour Claude Code runs a health check script and acts on what it finds. If the Archive takes an item down, it marks those files unplayable and reschedules the channel (that happened twice this week). If a block drifts more than an hour off its slot, it reschedules. If an agent run fails, it reads the logs and retries or fixes the code. It may commit fixes, but it never deploys without me saying so.

**2. Claude runs inside the product**

Each channel's schedule comes out of a pipeline of agents, each a job with its own step log:

- Programming (Claude Opus 5.5, structured output): picks the opening run of each block, up to 12 titles in order around a theme or a contrast, with a one-line note per pick for the editors. The scheduler code does all the timing.
- Breaks: fills the ad breaks with period commercials and promos.
- Editor (Claude): writes the on-air cards in each channel's voice.
- Rights: deterministic rules first, then Claude as a second opinion that can only flag a title for review, never clear it.
- Validator: no model at all. It checks gaps, overlaps, rights, repeats and playback, and only then publishes. Claude never puts anything on air directly.

What I learned:

- Keep a deterministic gate between the model and anything public. The validator has already held back drafts with titles that failed playback checks.
- Let the model choose and let code count. The model picks titles and order; the scheduler fits them to the clock.
- Big libraries need a shortlist. Some channels have over a thousand episodes, so the model sees the least recently aired titles, at least 40 per block.
- Make every agent work without the API. With no key, each one falls back to rules, which kept testing cheap.

Playback is "virtual linear": there is no encoder. The player asks for the schedule and the server time, works out what should be on, and plays the Archive file from that offset, with a second video element preloading the next item.

Free to try, runs in the browser: https://theafterglow.tv. Happy to answer questions about the agent setup or the Claude Code workflow.
```



document fetched 2026-11-20 00:23 · canonical https://reddit.com/r/ClaudeAI/comments/1y04kbv/i_built_a_29channel_tv_network_from_the_internet
