Find Your Blind Spots: Offline Content Gap Analysis with a Local AI

Open your blog's archive and count. Most creators who do this find something uncomfortable: a huge share of their posts are the same topic wearing different hats. You write what you know, so you write the same thing. The blind spots — the topics your audience is quietly waiting for — never occur to you, because by definition they don't occur to you.

The standard fix people reach for is asking a chatbot for ideas. That fails twice. First, "give me 10 content ideas" gets you the ten most average ideas on the internet. Second, the better version of the exercise — pasting your entire content library into the chat so the AI can audit it — means shipping your whole content strategy, your unpublished angles, and your traffic patterns through someone else's servers. For a business, that's the interesting data.

There is a third way: do the audit offline, with a local model that runs on your own machine. Same analysis, zero uploads, and it can re-run itself every month without you remembering anything.

Why "Give Me Ideas" Fails and Auditing Works

A content gap is not "an idea I haven't had." An idea is anything new; a gap is a specific hole in a specific structure. You cannot see a hole in a structure you have never drawn. That is the whole trick: before asking for anything new, make the AI draw a map of what exists.

Treated as an idea machine, the model optimizes for the most common ideas on the internet. Treated as an auditor — handed your actual body of work as one dataset — it does something it is genuinely good at: clustering, counting, and flagging what is lopsided.

Why Run It Locally At All?

The audit gets better the more honest the input is. The best version includes your drafts, your failed posts, your internal notes on what converts. Most people will not paste that into a cloud chat — and shouldn't. A local model changes the calculus:

The privacy point is not paranoia; it is precision. The audit is only as honest as its input, and local-only input can be brutally honest.

Step 1 — Dump Your Library as One Dataset

The audit needs titles plus a one-line summary each. If your content lives as markdown files, this is a few lines of shell:

# titles.txt — one "title | first-paragraph-summary" per line
for f in content/posts/*.md; do
  title=$(head -1 "$f" | sed 's/^# //')
  summary=$(sed -n '3p' "$f" | cut -c1-160)
  echo "$title | $summary"
done > titles.txt
wc -l titles.txt

Aim for your last 20–40 posts. That is enough for an accurate distribution — and short enough that a 7B or 8B local model can hold all of it in context while it works.

Step 2 — Bucket the Themes, Count the Percentages

Feed the whole set to a local model in one pass and demand structure back, not prose:

ollama run llama3.2 """
Here are ALL my recent posts as 'title | summary' lines:

$(cat titles.txt)

Act as an auditor, not an idea generator.
1. Group every post into 3-6 themes. Name each theme plainly.
2. Estimate what percentage of posts falls in each theme.
3. Flag any theme where I am clearly over-indexed (>30%).
4. List audience-relevant topics my library has ZERO or near-zero coverage of.
Output as JSON: {themes:[{name,pct,over_indexed}],gaps:[...]}
"""

Asking for JSON is not decoration — it makes vague answers impossible. The model must commit to numbers.

Step 3 — Read the Verdict

The output usually looks like this (real shape, invented numbers):

Five percent on failures is the classic blind spot: the posts that build the most trust are the ones most creators never write, because failure topics never "occur" to anyone as content.

Step 4 — Ask for Gap-Only Ideas, In Your Voice

Now — and only now — switch the model from auditor to generator, with the map as a constraint:

Themes and gaps from my audit are above.
Suggest 8 post ideas that:
- fall ONLY into the under-weighted and blind-spot themes
- match the tone of my existing titles (plain, specific, no hype)
- each name a concrete moment, tool, or failure — no "ultimate guide" framing
Rank them by how badly my library needs them.

Because the ideas must land inside the gaps and mimic your titles, they arrive pre-fitted to your strategy instead of drifting in from the generic internet.

The Embedding Upgrade: Let the Numbers Cluster

Past a hundred posts, even a big context window starts skimming. The fix is to stop asking the model to read and start asking it to measure. Ollama ships embedding models that turn each title into a list of numbers — a coordinate — where similar topics land close together:

# pull once, then embed every title
ollama pull nomic-embed-text

ollama run nomic-embed-text "How to run Llama 3 on a spare laptop"
# -> [0.024, -0.011, 0.058, ...]

Cluster those coordinates (a dozen lines of Python with any clustering library) and you get a theme map computed from distance, not from a model's reading stamina. The percentages come out of the cluster sizes, and no context window is spent at all — a thousand posts costs the same as thirty. Keep the language model for what it is uniquely good at: naming the clusters and judging which gaps matter. Math draws the map; the model reads it.

Step 5 — Make It a Monthly Habit with n8n

A one-time audit decays in three months. The local-first setup means the audit can run itself — this n8n flow fires on a schedule, re-reads your library, runs the same two prompts, and writes a dated report:

workflow: monthly-content-audit
schedule: "0 9 1 * *"
nodes:
  - name: dump-library
    type: execute-command
    command: "bash /peak/scripts/dump-titles.sh > /peak/audit/titles-{{date}}.txt"
  - name: theme-audit
    type: http-request
    method: POST
    url: "http://localhost:11434/api/generate"
    body:
      model: "llama3.2"
      stream: false
      prompt: "Audit these posts into themes + percentages + gaps: {{titles}}"
  - name: parse-json
    type: code
    rule: "extract themes[], gaps[] from response"
  - name: compare-last-month
    type: code
    rule: "diff vs previous audit file; flag themes that moved >5 points"
  - name: notify
    type: telegram
    message: "Content audit: {{moved_themes}} | top gap: {{top_gap}}"

First of every month: a message on your phone telling you which themes grew, which shrank, and the biggest hole. That is a content strategy system, not a hope.

Make It Practical Tonight

• Run the title dump on your last 30 posts — five minutes, zero cost.
• One audit prompt, one gap-only prompt, single session so the model keeps the context.
• Save the JSON. Next month's diff is where the real insight lives — trends, not snapshots.
• When the audit works, stop doing it by hand: the n8n schedule turns insight into infrastructure.

The mirror is the point. Your habits are invisible from the inside; a local model with your whole library in front of it has no habits at all — which is exactly what makes it the auditor you can trust with the ugly numbers.

Frequently Asked Questions

How is a content gap different from just needing new ideas? An idea is anything you haven't written. A gap is a missing piece of a structure your audience expects — a topic adjacent to what you already cover that your library shows zero or near-zero posts on. Gaps are strategic; random ideas are noise. The audit exists to tell them apart.

Is a small local model good enough for this? For theme bucketing and percentage counting, yes — a 7B or 8B model like Llama 3.2 handles 30–40 titles comfortably. Keep the library snapshot under its context window, ask for JSON output so it must commit to structure, and reserve bigger models for the judgment-heavy gap-verdict step if you want a second opinion.

What if my content isn't in markdown files? Any source works: a sitemap export, your CMS API, or a spreadsheet pasted into a text file. The audit only needs "title | one-line summary" lines. If your titles are self-explanatory, summaries can be skipped — the theme clustering still works, just slightly blurrier.

How often should the audit re-run? Monthly is the sweet spot for a solo creator: frequent enough to catch drift, spaced enough for the distribution to actually move. The n8n version stores each run's JSON, so every audit comes with a diff against last month — that trend line is more valuable than any single snapshot.