Andrej Karpathy says a roughly two-hour Claude Code session produced HackerTube, a YouTube-style recommendation site built from videos mentioned on Hacker News. In his October 31, 2026 announcement, he describes filtering 43 million comments into about 40,000 recommendation comments, yielding 6,454 videos across 150 topics.
The project puts a concrete product behind the agentic-coding pitch. Karpathy says Anthropic’s models handled the data work, built the interface, and deployed the application. He created a Google Cloud API key, started a virtual private server, and bought the domain.
HackerTube also offers something useful beyond the demonstration: a downloadable data export intended to help other people build their own versions. The accompanying Hacker News discussion reached 2,856 points and 633 comments in the opened snapshot, giving the project substantial visibility among that community.
The most interesting part is the combination of an existing recommendation source, a bounded product idea, and an agent given responsibility for several connected jobs. That combination helps explain the build without turning one person’s account into a general promise about AI development.
What the Two-Hour Build Actually Included
Karpathy says he used the Claude Code desktop app for Mac, with Opus 5.5 at Medium effort as his default model configuration. His account also names Sonnet as part of a workflow used to process the comments. These were different roles within the project, not evidence that one model independently performed every step.
His description spans work that usually crosses several development boundaries:
- Downloading and filtering a large comment collection.
- Identifying YouTube recommendations and removing spam.
- Retrieving video metadata through a Google Cloud API credential.
- Building a YouTube-style interface.
- Deploying the application to a VPS.
- Performing the requested security, hardening, and optimization work.
Karpathy summarizes the elapsed effort with a short claim: “This takes ~2 hours now.” He also says he no longer reads or writes code or runs terminal commands for this kind of work, instead directing Claude through conversation. Those are statements about his process, not measurements of what every developer should expect from the same tools. His post supplies the account, but no independent timing or security assessment.
The three manual tasks established the project’s external connections. The API key enabled access to YouTube metadata. The VPS supplied a deployment destination. The domain supplied the public address.
They do not, however, justify treating the two-hour figure as agent-only work with additional setup time necessarily added afterward. Karpathy explicitly says he handled those tasks while Claude was working. The account describes overlapping human and agent activity; it does not provide a precise breakdown of their individual durations.
My reading is that this is a useful example of human orchestration. Karpathy supplied the goal, credentials, infrastructure, and decisions, while delegating the implementation. That is a more specific claim than saying an agent independently launched a business.
It also gives a concrete counterpart to the broader argument explored in Zeniteq’s coverage of Proton’s “programming is dead” manifesto: writing less code can still leave someone responsible for deciding what to build and what resources it can access.
From Millions of Comments to a Bounded Video Catalog
HackerTube’s pipeline starts with an existing body of human discussion. Karpathy describes Claude downloading Hacker News comments, filtering them, and running Sonnet over the material through a Claude Code workflow to identify recommendations and remove spam.
The published outputs are more specific than the rounded headline number:
| Stage | Reported result |
|---|---|
| Source material | Hacker News comments covering 2007–2026 |
| Selected recommendation comments | About 40,000; the HN submission specifies 39,834 |
| Resulting video catalog | 6,454 YouTube videos |
| Topic organization | 150 topics |
The rounded and precise comment counts are consistent with each other. The announcement uses roughly 40,000, while the Hacker News submission gives 39,834.
The consequential design choice is using recommendations as the input signal. HackerTube does not begin with the task of deciding which videos across all of YouTube deserve attention. It begins with videos people have already brought into a particular discussion community.
That narrows the discovery problem before the interface is built. The models still have to distinguish recommendations from incidental links, organize the results, and deal with unwanted material. But the corpus already contains a reason each candidate might be interesting.
I would treat that choice as one of the most reusable parts of the project. A focused archive of human recommendations gives an agent a clearer job than an instruction to build a universally good discovery engine.
It also introduces a selection bias. A catalog drawn from Hacker News reflects what people posted there, across the years represented in the collection. Its usefulness to a reader depends partly on whether that community’s interests overlap with theirs. The scale of the input alone cannot settle that question.
The published account does not include the exact filtering prompts, acceptance criteria, or an accuracy evaluation. The workflow is understandable at a high level, but its extraction decisions cannot be reconstructed from those totals.
A YouTube-Style Interface Is a Smaller Product Boundary
HackerTube assembles a catalog around existing YouTube videos. Karpathy’s description is of a recommendation and browsing product, not a replacement for YouTube’s video-uploading, hosting, or creator infrastructure.
That boundary helps explain why the project is a useful agentic-building case study. The agent was connecting available components around a defined experience, while relying on an existing video platform for the underlying content.
Several product choices make the result more distinctive than a plain list of links. According to Karpathy’s announcement, HackerTube includes:
- A personalized For You experience without requiring an account.
- Browser-local state, which he describes as stored in the local browser session.
- Keyboard shortcuts for navigating the interface.
- Alternative thumbnails, using what he calls the “50% thumbnail” instead of the uploaded thumbnail.
- A downloadable data export for building other versions.
The thumbnail choice addresses one of his stated complaints about YouTube: exaggerated preview images. Changing the image-selection rule is a concrete intervention in how the catalog presents itself. It does not by itself establish that the underlying recommendations are better.
The login-free design is similarly practical. It removes account creation from the path between opening the site and browsing. Browser-local state also avoids making a centralized user profile a requirement for that experience.
The tradeoff is portability. Without a documented synchronization mechanism, readers should not assume that their state follows them between browsers or devices. Local storage describes where state lives; it is not a complete privacy guarantee about every request the application makes.
For a small recommendation product, I think this is a sensible scope choice. Cross-device accounts would add authentication, recovery, synchronization, and account-management work before improving the central task of finding something worth watching.
The Data Export Is the Reusable Artifact
Karpathy presents the export as material readers can give to their own agents to create another version. That distinction matters: the release described in his post is a data release, not a source-code release.
The two artifacts support different kinds of reuse.
Frequently Asked Questions
3 questions
1Which Claude Models Did Karpathy Use?
Karpathy says he used Claude Code for Mac with Opus 5.5 at Medium effort, plus a Sonnet workflow for processing comments.
