I Rebuilt Eightify in 12 Minutes — Here's the Prompt

The tool we rebuilt

Eightify is a Chrome extension that adds AI summaries to YouTube videos. Click the extension's button on any video, get a structured summary with key points, takeaways, and timestamps in a few seconds. It's a useful tool — especially for tech tutorials, conference talks, and long-form interviews where the signal-to-noise ratio is variable.

The catch is the pricing. Eightify runs $20 per month for the standard tier, with caps on the number of summaries per month before the price scales. For most users that's reasonable, but only if you actually use it 30+ times monthly. For casual users, $20/month for occasional summaries means most of what you pay goes unused. For heavy users, the per-summary cost starts to feel inverted compared to what the underlying API actually costs — OpenAI's GPT-4 mini summarizes a typical YouTube transcript for around $0.02-0.05. Eightify pockets the spread.

The interesting question is whether the actual functionality is hard to replicate. Spoiler: it isn't. The hard part of Eightify isn't the AI — it's the polish (UI, caching, transcript extraction reliability). The AI itself is a single API call. If you don't need the polish, or you can accept some rough edges, you can rebuild the core in minutes.

So we did.

What I built

A Chrome extension that adds a "Summarize" button below every YouTube video. Clicking it extracts the transcript, sends it to OpenAI GPT-4, and displays a 3-bullet summary in a side panel that slides in from the right. Includes a copy button and a refresh button if you want a different angle.

The whole thing took 12 minutes from typing the prompt into PlugThis to having the working extension loaded in Chrome. About 8 of those minutes were Chrome being slow at reloading after manifest changes.

The output is a working Manifest V3 extension. Five files total: manifest.json, content.js (the button injection), content.css (the button styling), background.js (the API call), and popup.html (a minimal settings page for the OpenAI API key). About 200 lines of code combined.

I'm not claiming it's prettier than Eightify. Eightify has had time to polish the side panel, add language settings, build a slick onboarding flow, support custom prompts. Mine is functional and ugly. But functional was the whole point — to verify the question "can you actually rebuild a $20/month tool from a prompt" with a real answer.

The prompt I used

This is the exact text I pasted into PlugThis. No setup, no preamble.

Two things worth noting about this prompt:

It's specific about where the button goes ("next to the like/share buttons") and how it looks ("styled to match YouTube's existing button aesthetic"). Without that specificity, the first generation produced a floating button in the bottom-right corner of the page that didn't match YouTube's design language and looked janky.

It explicitly addresses transcript extraction, which is the hardest part. YouTube doesn't expose a clean transcript API to extensions — you have to either parse the captions endpoint manually or scrape the transcript panel from the DOM. The prompt tells PlugThis to use the DOM-scraping approach, which is the reliable path even if it's slightly slower.

How it works

The extension follows the classic three-room Chrome extension architecture (content script, background worker, popup).

Content script (content.js) runs on every youtube.com page. It uses a MutationObserver to detect when YouTube finishes loading the video page (single-page-app navigation means the script runs but the elements it needs don't exist yet — observer pattern handles this). Once the video controls are rendered, it injects the Summarize button as a sibling of the like/share buttons.

When the button is clicked, the content script:

1. Programmatically clicks YouTube's "..." menu → "Show transcript" to open the transcript panel (if it's not already open)
2. Waits for the panel to render
3. Scrapes the text content and timestamps from the transcript panel
4. Sends a message to the background service worker via chrome.runtime.sendMessage with the full transcript

Background worker (background.js) receives the message, reads the user's OpenAI API key from chrome.storage.local, and makes the API call:

const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: 'Summarize the following YouTube transcript in exactly 3 bullet points. Each bullet should include a timestamp reference (mm:ss) of where that point occurs in the video.'
      },
      { role: 'user', content: transcript }
    ]
  })
});

The response gets sent back to the content script, which injects the side panel into the page DOM and renders the summary.

Popup (popup.html) is a minimal settings page with one input field for the API key. On save, the key gets stored in chrome.storage.local where the background worker can read it.

That's the entire extension. About 200 lines of code, no external dependencies (no bundler, no framework, no build step), works on every YouTube video URL pattern.

Cost breakdown — the actual numbers

The interesting part is the math.

Two angles to read this.

If you're a moderate user (10-30 summaries per month): Eightify at $20/month vs PlugThis at $29/month + ~$1-2/month API costs = $30-31/month. PlugThis is a small premium for a tool you own and can modify.

If you're a heavy user (100+ summaries per month): Eightify at $20/month (with potential caps), API costs at full usage are still under $5/month. The total cost gap doesn't shift dramatically, but the value shifts substantially — you're not paying a subscription cap, you can summarize as many videos as you want, and you can extend the extension's behavior without waiting for Eightify's roadmap.

If you're a light user (5 or fewer summaries per month): Honestly, Eightify's free tier might be enough. Don't build this for the cost savings.

The interesting position is what you get beyond the price:

• The summary format is yours. Want bullet points, timestamps, action items, ELI5 mode, side-by-side comparison of two videos? Edit the system prompt in the background worker. No waiting for Eightify to add the feature.
• The model is yours. Eightify uses whatever model their backend picks. You can swap to Claude, Gemini, or a self-hosted model by changing one line.
• The data is yours. Summaries stay in your browser. Eightify's privacy policy is fine, but "fine" is different from "the data never leaves your machine."

Side-by-side feature comparison

The summary panel UI of PlugThis-generated extensions doesn't match Eightify's polish. If polish matters more than ownership, stay with Eightify. If ownership matters more, the rebuild is the better long-term position.

Customization ideas

The interesting part of owning the code is what you can change.

A few directions:

Different summary styles. Edit the system prompt to produce action items instead of summaries. Or ELI5 versions for technical content. Or "what's the controversy here" mode for debate videos. Each variation is a 30-second prompt change.

Different models. Swap GPT-4o-mini for Claude 3.7 Sonnet (better for long context) or Gemini 2.0 Flash (faster and cheaper). The change is one line in the background worker.

Multi-video comparisons. Save summaries to chrome.storage.local with the video URL. Add a "compare these two videos" mode that summarizes both transcripts together.

Timestamps as clickable links. Currently timestamps are text. Make each timestamp a clickable link that scrubs the YouTube player to that point. Single content script update.

Auto-summarize on page load. Remove the button entirely. When a YouTube page loads, auto-summarize in the background and show the summary in a sidebar that's always present.

Different language outputs. Add a settings dropdown for target language. The summarization prompt can target any language OpenAI supports.

Each of these is a 5-15 minute change. Once you have the code, you're not waiting for someone else's product roadmap.

Try it yourself

If you want the working extension, the prompt above produces it. Drop it into PlugThis, edit the OpenAI API key in the generated settings page, and load it into Chrome via chrome://extensions/ → Developer Mode → Load unpacked.

Or if you'd rather modify the prompt before generating — different summary length, different model, different layout — the prompt is yours to edit.

Related reading

• Eightify alternatives — full comparison — structured comparison of Eightify vs PlugThis-built equivalents
• I rebuilt Wordtune for $2/month — same approach applied to AI rewriting
• I rebuilt WriteSeed in 8 minutes — AI writing assistant rebuild
• The complete Chrome extension building guide — if you want to understand how the extension above works under the hood

Building Chrome extensions used to require a developer. AI builders changed that — and purpose-built ones like PlugThis make it specifically easy for Chrome extensions, which have an architecture (content scripts, service workers, message passing) that confuses general-purpose builders. The Eightify rebuild took 12 minutes. The next one took 8.