Inspiration At our startup, we ship thousands of lines of code every day. AI coding agents have made writing software dramatically faster, but understanding what changed has become the new bottleneck.
We would wake up to dozens of GitHub notifications, enormous pull requests, and commit messages like “small fixes” or “cleanup.” Every notification told us that something changed. Almost none explained what actually mattered.
That led to one question:
What if catching up on a codebase felt more like scrolling a story than reading a thousand-line diff?
Doomsday was created to protect human attention in an era where machines can generate code faster than people can review it.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
What it does Doomsday turns branches, pull requests, and repository activity into short, visual, brain-rot-style technical stories.
Instead of presenting another wall of code, Doomsday organizes related diff hunks into a narrative:
- What changed
- Why the developer likely changed it
- What improves
- What could break
- Which evidence supports the explanation
Each change becomes a scene containing the real diff, a contextually selected meme, and a concise explanation of the consequences.
On desktop, Doomsday uses a three-column experience:
• The actual diff on the left • The meme in the middle • The technical explanation on the right
On mobile, changes become a vertical feed. Users can swipe through the story, reveal the underlying code, and inspect the explanation without losing their place.
The result is a five-minute version of what your team did all night.
Your inbox deserves fewer notifications. You deserve better explanations.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
How we built it We built Doomsday as an AI-powered GitHub comprehension workflow.
The pipeline:
- Collects changes from a branch, pull request, or repository.
- Parses files, commits, and diff hunks.
- Groups related changes into meaningful technical events.
- Uses AI to infer the likely intent, impact, and tradeoffs.
- Keeps each claim connected to concrete evidence in the diff.
- Selects memes that match the meaning and emotional tone of each change.
- Produces a responsive, scrollable episode for mobile and desktop.
- Learns from whether users liked the meme or found the technical explanation useful.
We deliberately separated entertainment from evidence. The meme earns attention, but the real code keeps the story honest.
The interface was designed around intent-first comprehension. Rather than leading with file counts or generic review summaries, Doomsday starts by answering the question every engineer actually has:
“What did my team change, and why should I care?”
We also used HyperFrames to create a 45-second launch video that dramatizes the problem, introduces the Doomsday Protocol, and demonstrates the real product interface.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Challenges we ran into Turning a diff into a coherent story A pull request is organized by files, but humans understand changes through goals and consequences. We had to group hunks across multiple files without inventing relationships that the evidence did not support.
Balancing humor with technical accuracy Brain-rot culture had to be a genuine presentation mechanic, not a layer of random jokes. The memes needed to improve pacing and comprehension while ensuring that risks, tradeoffs, and code evidence remained visible.
Inferring intent responsibly Code rarely explains the author’s complete motivation. We designed the system to distinguish stated intent from inferred intent and to communicate uncertainty rather than presenting guesses as facts.
Designing for finite attention spans Large diffs can contain many individually important changes. We had to compress them without flattening every change into a vague summary. Each scene needed to be concise enough to scroll through but specific enough to help an engineer make decisions.
Supporting different screens The desktop experience benefits from simultaneous access to code, memes, and explanations. Mobile needs a focused, gesture-driven flow. Designing both without losing context required two different interaction models built around the same underlying story.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Accomplishments that we’re proud of We are proud that Doomsday does not hide the code behind an AI summary. It uses AI to create a path into the code.
The project combines:
• Real GitHub diff evidence • Intent and consequence analysis • Meme-driven storytelling • Risk and tradeoff communication • Responsive desktop and mobile experiences • Feedback signals for usefulness and humor • A reusable workflow that can generate future episodes automatically
We are also proud that the final experience feels playful without becoming a toy. A developer can laugh at the meme, inspect the exact lines that changed, understand the likely motivation, and identify what might require additional review.
Serious evidence. Unserious presentation.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
What we learned We learned that generating more summaries is not enough. Developers already have plenty of dashboards, notifications, and AI-generated paragraphs. The scarce resource is attention.
We also learned that humor can be functional. A relevant meme creates an emotional anchor that helps a technical change remain memorable. It can communicate “this is risky,” “this is a workaround,” or “this is surprisingly elegant” before the user reads the detailed explanation.
Most importantly, we learned that the future of code review is not simply faster diff reading. It is better information design.
AI writes code at 100 mph. Humans still have to read the receipts. Tools must help people understand intent, consequences, and uncertainty without pretending that automated analysis replaces engineering judgment.
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
What’s next for Doomsday Next, we want Doomsday to become an always-on repository storyteller.
Our roadmap includes:
• Scheduled daily and weekly repository episodes • Automatic pull request and branch monitoring • Personalized stories based on the files and systems a developer owns • Team-specific humor, pacing, and technical depth • Better change grouping across commits and repositories • Historical storylines that explain how a system evolved • Links from every claim to the exact supporting diff • Slack, email, and GitHub delivery • Shared team reactions and review checkpoints • Stronger detection of architectural risk and behavioral changes • Feedback-driven adaptation using separate “funny” and “useful” signals
As AI agents produce more code, understanding that code will become one of the most valuable engineering skills.
Doomsday makes sure humans can still keep up.
Doomscroll the diff before the diff dooms you.
Log in or sign up for Devpost to join the conversation.