I Cleaned Up My LinkedIn Feed with a Free Open Source AI Spam Filter — Here's How to Actually Set It Up

Zero-Trust Feed Sanitization: Implementing Local ML Filters for Browser-Based Social Clients

Current Situation Analysis

Professional social networks have undergone a structural shift in content distribution. The algorithmic incentive model now prioritizes high-velocity engagement signals over domain relevance, resulting in a feed composition dominated by synthetic text, engagement-bait loops, and repetitive motivational templates. For technical professionals, this creates a severe signal-to-noise ratio degradation.

The prevailing mitigation strategy—manual curation via unfollowing or hiding—is fundamentally flawed. The network graph expands the surface area of exposure; removing a single low-signal node often triggers the algorithm to surface adjacent nodes within the extended network that exhibit identical behavioral patterns. The volume of pattern-based spam scales exponentially relative to manual intervention capacity.

Furthermore, the privacy implications of third-party feed management tools are frequently underestimated. Extensions that route feed data through external APIs for classification introduce a trust boundary violation. These tools gain access to session cookies, private messaging metadata, and connection graphs. In a zero-trust architecture, any extension processing sensitive session data must operate entirely within the client boundary, with verifiable code and zero outbound telemetry.

The viable solution space is restricted to open-source, client-side content scripts that perform inference locally. These tools must handle dynamic DOM injection (infinite scroll), maintain resilience against frontend selector drift, and provide configurable thresholds to minimize false positives on legitimate technical content.

WOW Moment: Key Findings

The following comparison demonstrates why local client-side inference is the only architecture that satisfies the constraints of privacy, latency, and cost for feed sanitization.

Approach	Inference Latency	Privacy Risk Profile	Maintenance Overhead	Total Cost of Ownership
Manual Curation	High (User Time)	None	Infinite	Free (Time-expensive)
Cloud API Filter	~150ms - 400ms	Critical (Session Data Exfiltration)	Low	Subscription + Privacy Debt
Local ML Extension	<5ms	Zero (Air-gapped Inference)	Medium (Selector Drift)	Free (Dev Time Only)

Why this matters: Local inference eliminates the network round-trip, allowing real-time filtering before the DOM paints. This prevents visual flicker and ensures that low-signal content never enters the user's viewport. The privacy profile is mathematically superior: the model weights reside in the extension bundle, and no payload leaves the browser process. The trade-off is selector maintenance, which is manageable through community-driven updates and fallback strategies.

Core Solution

The implementation relies on a browser extension architecture comprising three components: a content script for DOM interaction, a local inference engine, and a configuration layer.

Architecture Decisions

1. Content Script Injection: The script executes at document_idle to avoid blocking the initial page load. It attaches to the feed container and monitors for mutations.
2. MutationObserver Strategy: LinkedIn and similar platforms use lazy loading. A static query selector is insufficient. A MutationObserver watches for added nodes, triggering classification only on new content. This ensures performance scales with feed velocity, not total feed size.
3. Local Model Inference: The classifier uses a compact JSON weight file (~180KB) embedded in the extension. This file contains signal weights for pattern matching (e.g., hedging phrases, formatting anomalies, engagement bait). Inference is synchronous and deterministic.
4. Selector Resilience: Frontend frameworks frequently obfuscate or rename class names. The solution employs a fallback chain of selectors and validates node structure rather than relying on a single hardcoded class.

Implementation

The following TypeScript implementation demonstrates the core sanitization logic. This example uses distinct interfaces and class structures from common open-source variants to illustrate the pattern.

Feed Sanitizer Controller

// FeedSanitizer.ts
import { PatternMatcher } from './PatternMatcher';
import { FilterConfig } from './types';

export class FeedSanitizer {
  private observer: MutationObserver;
  private matcher: PatternMatcher;
  private config: FilterConfig;

  constructor(config: FilterConfig, modelWeights: Record<string, number>) {
    this.config = config;
    this.matcher = new PatternMatcher(modelWeights);
    this.observer = new MutationObserver(this.handleMutations.bind(this));
  }

  public activate(rootElement: HTMLElement): void {
    this.observer.observe(rootElement, {
      childList: true,
      subtree: true,
    });
  }

  public deactivate(): void {
    this.observer.disconnect();
  }

  private handleMutations(mutations: MutationRecord[]): void {
    // Batch processing to reduce layout thrashing
    const nodesToEvaluate: HTMLElement[] = [];

    for (const mutation of mutations) {
      for (const node of mutation.addedNodes) {
        if (node instanceof HTMLElement && this.isTargetNode(node)) {
          nodesToEvaluate.push(node);
        }
      }
    }

    if (nodesToEvaluate.length > 0) {
      this.processBatch(nodesToEvaluate);
    }
  }

  private isTargetNode(element: HTMLElement): boolean {
    // Fallback selector chain to mitigate DOM drift
    const selectors = [
      '[data-test-id="post-container"]',
      '.feed-update-v2',
      '.update-components-update'
    ];
    return selectors.some(selector => element.matches(selector));
  }

  private processBatch(elements: HTMLElement[]): void {
    elements.forEach(element => {
      const textContent = element.innerText;
      const result = this.matcher.analyze(textContent);

      if (result.score >= this.config.threshold) {
        this.applyAction(element, result.category);
      }
    });
  }

  private applyAction(element: HTMLElement, category: string): void {
    if (this.config.actions[category] === 'collapse') {
      element.style.maxHeight = '0';
      element.style.overflow = 'hidden';
      element.style.transition = 'max-height 0.2s ease';
    } else {
      element.remove();
    }
  }
}

Local Pattern Matcher

// PatternMatcher.ts
export interface AnalysisResult {
  score: number;
  category: string;
  signals: string[];
}

export class PatternMatcher {
  private weights: Record<string, number>;

  constructor(weights: Record<string, number>) {
    this.weights = weights;
  }

  public analyze(text: string): AnalysisResult {
    const signals: string[] = [];
    
    // Signal extraction
    if (this.detectHedgingStructure(text)) signals.push('hedging_pattern');
    if (this.detectEngagementBait(text)) signals.push('engagement_bait');
    if (this.detectFormattingAnomaly(text)) signals.push('formatting_anomaly');
    if (this.detectSyntheticVulnerability(text)) signals.push('synthetic_vulnerability');

    const totalScore = signals.reduce((acc, signal) => acc + (this.weights[signal] || 0), 0);
    
    return {
      score: totalScore,
      category: this.dominantCategory(signals),
      signals
    };
  }

  private detectHedgingStructure(text: string): boolean {
    // Matches patterns like "It's not about X, it's about Y"
    const hedgingRegex = /it'?s\s+not\s+about\s+.+,\s*it'?s\s+about\s+/gi;
    return hedgingRegex.test(text);
  }

  private detectEngagementBait(text: string): boolean {
    // Matches explicit CTAs at the end of posts
    const baitRegex = /(comment\s+(yes|agree)|save\s+this|tag\s+a\s+friend)/gi;
    return baitRegex.test(text);
  }

  private detectFormattingAnomaly(text: string): boolean {
    // Detects excessive single-sentence paragraphs typical of AI padding
    const paragraphs = text.split('\n').filter(p => p.trim().length > 0);
    if (paragraphs.length < 6) return false;
    
    const singleSentenceCount = paragraphs.filter(p => {
      const sentences = p.split(/[.!?]+/).filter(s => s.trim().length > 0);
      return sentences.length === 1;
    }).length;

    return (singleSentenceCount / paragraphs.length) > 0.8;
  }

  private detectSyntheticVulnerability(text: string): boolean {
    // Matches "I almost quit" or "I failed" without substance
    const vulnRegex = /(almost\s+quit|failed\s+at|struggled\s+with).{0,50}(but\s+then|however)/gi;
    return vulnRegex.test(text);
  }

  private dominantCategory(signals: string[]): string {
    if (signals.includes('engagement_bait')) return 'bait';
    if (signals.includes('hedging_pattern')) return 'ai_generated';
    return 'spam';
  }
}

Rationale

• Batch Processing: The handleMutations method collects nodes before processing. This prevents repeated DOM reads and reduces layout thrashing, which is critical when the feed loads multiple posts simultaneously.
• Selector Fallback: The isTargetNode method checks multiple selectors. If LinkedIn updates the primary class, the extension remains functional until the selector chain is updated.
• Synchronous Inference: The PatternMatcher runs synchronously. Since the model is a simple weighted sum of regex checks, execution time is negligible (<2ms per post), avoiding the need for Web Workers and simplifying the architecture.
• Action Abstraction: The applyAction method supports both removal and collapse. Collapse is useful for preserving feed continuity while hiding content, reducing the "jump" effect when posts are removed.

Pitfall Guide

1. DOM Selector Drift

Explanation: Social platforms frequently refactor their frontend code, renaming class names and data attributes. Extensions relying on a single hardcoded selector will break silently, failing to filter content. Fix: Implement a selector fallback chain. Monitor the repository's issue tracker for reports of breakage. Prefer selectors based on semantic attributes (e.g., data-test-id) over CSS classes, as these are more stable.

2. False Positives on Technical Content

Explanation: Technical posts often use structured formatting, bullet points, and concise sentences. Naive classifiers may flag these as "AI-generated" due to formatting overlap. Fix: Maintain a per-author allowlist. Adjust the weight of the formatting_anomaly signal if your feed contains many engineers. Implement a heuristic to detect code blocks or technical jargon and lower the score for those posts.

3. Firefox Persistence Limitations

Explanation: Firefox treats unpacked extensions as temporary add-ons that do not persist across browser restarts. Users must reload the extension manually after every restart. Fix: Use web-ext for development. For production use, consider self-signing the extension via Mozilla's developer portal, or use a profile-specific configuration that auto-loads the extension.

4. Build Artifact Mismatch

Explanation: Loading the source directory instead of the compiled output results in missing assets and broken functionality. Some repositories commit the /dist folder; others require a build step. Fix: Always check the README for build instructions. Verify the existence of the output directory (/dist or /build) before loading. Ensure node --version returns 18.0.0 or higher, as the build toolchain requires modern ES module support.

5. Performance Degradation on Large Feeds

Explanation: Running heavy regex operations on every mutation can block the main thread, causing UI lag. Fix: Optimize regex patterns to fail fast. Use innerText instead of traversing the DOM tree for text extraction. Implement a debounce mechanism if the mutation rate exceeds a threshold.

6. Privacy Illusion in "Free" Tools

Explanation: Users may assume open-source tools are safe without verification. Some projects may include obfuscated code or hidden API calls. Fix: Audit the manifest.json for permissions. Check the Network tab in DevTools for outbound requests. Verify that the model weights are local JSON files and not fetched from a remote endpoint.

7. Node Version Incompatibility

Explanation: The build process often relies on features introduced in Node.js 18, such as native fetch and improved ES module handling. Older versions will fail during npm install or npm run build. Fix: Run node --version before cloning. Use a version manager like nvm to switch to Node 18+ if necessary.

Production Bundle

Action Checklist

• Audit Network Traffic: Open DevTools, navigate to the Network tab, and verify zero outbound requests while browsing the feed.
• Verify Node Environment: Ensure Node.js version is 18.0.0 or higher using node --version.
• Build Artifacts: Clone the repository, run npm install, and execute npm run build. Confirm the output directory exists.
• Load Extension: Enable Developer Mode in Chrome (chrome://extensions) and load the unpacked extension from the output directory.
• Configure Thresholds: Adjust the filter threshold and category weights based on your feed composition.
• Establish Allowlist: Identify legitimate authors flagged by the filter and add them to the allowlist.
• Monitor Selector Health: Subscribe to the repository's release notifications to stay ahead of DOM changes.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Individual Developer	Local Open-Source Extension	Zero cost, full privacy, immediate value.	Free
Enterprise Compliance	Forked & Audited Extension	Data sovereignty, custom policy enforcement.	Dev Time
Rapid Prototyping	Userscript with Tampermonkey	Fast iteration, no build step required.	Free
Team Standardization	Internal Extension Store	Centralized config, version control.	Infrastructure

Configuration Template

{
  "threshold": 0.75,
  "actions": {
    "bait": "remove",
    "ai_generated": "collapse",
    "spam": "remove"
  },
  "weights": {
    "hedging_pattern": 0.3,
    "engagement_bait": 0.4,
    "formatting_anomaly": 0.2,
    "synthetic_vulnerability": 0.35
  },
  "allowlist": [
    "author_id_1",
    "author_id_2"
  ],
  "selectors": [
    "[data-test-id=\"post-container\"]",
    ".feed-update-v2"
  ]
}

Quick Start Guide

1. Clone Repository:

   git clone https://github.com/[author]/[repo-name].git
   cd [repo-name]
   

2. Install Dependencies:

   npm install
   

3. Build Output:

   npm run build
   

4. Load in Browser:
   • Chrome: Navigate to chrome://extensions, enable Developer Mode, click "Load unpacked," and select the /dist folder.
   • Firefox: Navigate to about:debugging, click "This Firefox," click "Load Temporary Add-on," and select manifest.json.
5. Pin Extension: Click the puzzle piece icon in the toolbar and pin the extension for easy access to controls.

This architecture provides a robust, privacy-preserving mechanism for feed sanitization. By leveraging local inference and resilient DOM handling, developers can maintain signal quality in professional networks without compromising session security or incurring subscription costs. Regular maintenance of selectors and weights is required to adapt to platform changes, but the operational benefits outweigh the overhead.