I Rebuilt WriteSeed in 8 Minutes — Here's the Prompt

The tool we rebuilt

WriteSeed is an AI writing assistant that helps people draft content faster — blog posts, marketing copy, social posts, emails. It's positioned somewhere between Notion AI and Jasper, with a Chrome extension that overlays writing assistance on any text field on the web.

The pitch is sensible: AI helps you generate, expand, rewrite, and refine your writing wherever you write it. The pricing — $19/month for the standard tier — is reasonable if you write for a living and use it constantly. It's hard to justify if you write occasionally and only need the assistance now and then.

The interesting question is what WriteSeed actually does at the technical layer. The answer: it detects text inputs on web pages, captures the surrounding context (what you've typed, what's on the page), and calls a language model API with a tailored prompt. There's no proprietary AI. There's no special model. The functionality is an OpenAI or Anthropic API call dressed up in a polished UI.

That's not a knock on WriteSeed. The polish is real value. But it's also rebuildable, and at lower cost.

What I built

A Chrome extension that adds an AI writing assistant to any text input on the web. When you focus a text field (textarea, contenteditable, or rich-text editor) and start typing, a small floating button appears. Click it to open a popup with three options:

• Continue writing — extends your current text
• Rewrite — paraphrases what you've written so far
• Generate paragraph — generates fresh content based on a prompt you provide

Each generates output via OpenAI GPT-4 and inserts it into the text field.

It took 8 minutes from typing the prompt into PlugThis to having the working extension loaded in Chrome. The build was quick because most of the complexity is invisible — text input detection, focus tracking, and clipboard-style text injection are well-trodden territory for AI builders that understand Chrome extensions.

Output is a working Manifest V3 extension with about 250 lines of code across four files. No frameworks, no bundler, no build step.

The prompt I used

The streaming part is what makes this feel real-time. Without streaming, the user clicks "Continue writing" and waits 3-5 seconds with no feedback. With streaming, the new text appears character-by-character as the model generates it — closer to the WriteSeed experience.

One thing the prompt doesn't try to do: detect what kind of content the user is writing. WriteSeed has heuristics for distinguishing between an email, a blog post, a tweet, a Slack message. Our rebuild doesn't — it just generates content matching the existing tone and continuing from where you left off. That's a feature gap. Closing it is a 5-minute prompt addition if you want it.

How it works

Three rooms doing their assigned jobs.

Content script runs on every webpage. It listens for focusin events on text-input elements (textarea, [contenteditable=true], input[type=text]). When detected, it injects a small floating button as a sibling of the focused element, positioned in the bottom-right corner using absolute positioning.

The button is hidden by default and shown only after the user has typed at least 20 characters (signal that they're actually composing, not just clicking around). The threshold is a small UX detail that meaningfully reduces noise — without it, the button appears the instant you click a search bar, which is annoying.

When the user clicks the button, the content script opens a small in-page popup with the three options. Each option triggers a different message to the background service worker.

Background service worker handles the AI calls. It reads the user's API key from chrome.storage.local, constructs the appropriate system prompt based on the action and the user's tone preference, then makes a streaming fetch to OpenAI:

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',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userMessage }
    ],
    stream: true
  })
});

const reader = response.body.getReader();
// ... stream chunks back to content script

Streaming responses from a service worker to a content script requires using chrome.runtime.connect ports rather than one-shot messages (the one-shot pattern can't keep a channel open for streaming). The extension opens a port from the content script before making the API call; the background worker pipes chunks through the port as they arrive.

Content script (continued) receives the streamed chunks and inserts each one at the cursor position in the focused text field. This uses document.execCommand('insertText', false, chunk) for contenteditable elements and direct value mutation for textarea/input elements.

Popup page is the settings page — single text input for the OpenAI API key, four radio buttons for tone preference, save button. Saves to chrome.storage.local. About 50 lines of HTML/CSS/JS.

That's the full extension. The interesting engineering is in two places: detecting "the user is actively writing" without being noisy, and streaming text insertion across the content-script-to-background boundary. Both are handled correctly in the PlugThis-generated output.

Cost breakdown — the actual numbers

The math:

For light users (writing occasionally, generating a few paragraphs a week), the PlugThis cost is dominated by the $29 subscription, not the API costs. Total around $30/month — slightly more than WriteSeed's $19.

For heavy users (writing daily, generating substantial volume), API costs scale linearly but are still small. A user generating 50,000 words per month via GPT-4o would spend roughly $5-8 in API costs. Total around $34-37/month vs WriteSeed's $19 with potential word caps.

The cost story isn't "much cheaper than WriteSeed" — it's roughly comparable. The reason to rebuild isn't pure cost. It's everything else:

• Customization — change the system prompts to match your voice exactly. The default WriteSeed voice is generic; yours doesn't have to be.
• Model freedom — swap GPT-4o for Claude Sonnet (better at long-form), Gemini Flash (cheaper for high volume), or even a self-hosted model.
• Privacy — text never goes through WriteSeed's servers. It goes directly from your browser to OpenAI (or whichever provider you pick).
• No caps — write as much as you want. The marginal cost is API tokens, not subscription tiers.

Side-by-side feature comparison

Honest assessment: WriteSeed's UI is more polished, the voice detection is more sophisticated, and the multi-platform support matters if you write outside the browser. If those are your primary needs, stay with WriteSeed. If your writing is all in browser-based tools (Gmail, Notion, Google Docs, Slack, Twitter), the rebuild covers 90% of the WriteSeed use case at comparable cost with full ownership.

Customization ideas

Custom system prompts. The biggest unlock from owning the code. The default "Continue writing" prompt is generic. You can replace it with: "Write in the voice of [your favorite author]" or "Match the tone of the surrounding text" or "Be deliberately funny" — anything you can describe.

Voice training from your past writing. Add a settings field where you paste 5-10 examples of your own writing. Include them in every system prompt as "this is how the user typically writes — match this voice." Substantially better than generic tone settings.

Domain-specific modes. Detect the URL of the current page. If it's Gmail, switch to email writing mode (shorter, action-oriented). If it's Notion, switch to documentation mode (structured, paragraph-based). If it's Twitter, switch to short-form mode.

Multi-language output. Add a language selector. The same system prompt with "respond in Spanish" gives you a writing assistant for Spanish content. Works for any language OpenAI supports.

Templates library. Add a "Templates" tab in the popup. Pre-defined prompts for common writing tasks: cold email template, blog intro, tweet thread, LinkedIn post. Each template is a saved system prompt.

Pricing-aware model selection. Use GPT-4o-mini for casual writing (cheap), GPT-4o for important content (good), Claude 3.7 Opus for high-stakes work (best). Add a quality slider in the popup.

Each is a small change. The infrastructure is already there.

Try it yourself

Drop the prompt above into PlugThis, provide your OpenAI API key in the generated settings page, and load it into Chrome. Total time from "I should try this" to "I have a working AI writing assistant" is around 10 minutes.

If you want to modify the prompt before generating — different action buttons, different default tone, different model — edit it before submission. The prompt is the source of truth.

Related reading

• WriteSeed alternatives — structured comparison — competitor analysis
• I rebuilt Wordtune for $2/month — similar approach for AI rewriting
• I rebuilt QuillBot's paraphraser — paraphrasing-focused rebuild
• The complete Chrome extension building guide — how Chrome extensions work under the hood

The pattern is the same across every AI writing tool. The functionality is one or two API calls behind a polished UI. The polish has real value, but rebuilds covering the core functionality run roughly the same cost as the subscription and give you complete ownership. WriteSeed took 8 minutes. The next one (Wordtune) took about the same.