diff --git a/src/skill_seekers/cli/doc_scraper.py b/src/skill_seekers/cli/doc_scraper.py
index 963780d..f12448e 100755
--- a/src/skill_seekers/cli/doc_scraper.py
+++ b/src/skill_seekers/cli/doc_scraper.py
@@ -32,6 +32,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from skill_seekers.cli.llms_txt_detector import LlmsTxtDetector
 from skill_seekers.cli.llms_txt_parser import LlmsTxtParser
 from skill_seekers.cli.llms_txt_downloader import LlmsTxtDownloader
+from skill_seekers.cli.language_detector import LanguageDetector
 from skill_seekers.cli.constants import (
     DEFAULT_RATE_LIMIT,
     DEFAULT_MAX_PAGES,
@@ -111,6 +112,9 @@ class DocToSkillConverter:
         self.pages: List[Dict[str, Any]] = []
         self.pages_scraped = 0
 
+        # Language detection
+        self.language_detector = LanguageDetector(min_confidence=0.15)
+
         # Thread-safe lock for parallel scraping
         if self.workers > 1:
             import threading
@@ -278,81 +282,18 @@ class DocToSkillConverter:
 
         return page
 
-    def _extract_language_from_classes(self, classes):
-        """Extract language from class list
-
-        Supports multiple patterns:
-        - language-{lang} (e.g., "language-python")
-        - lang-{lang} (e.g., "lang-javascript")
-        - brush: {lang} (e.g., "brush: java")
-        - bare language name (e.g., "python", "java")
-
-        """
-        # Define common programming languages
-        known_languages = [
-            "javascript", "java", "xml", "html", "python", "bash", "cpp", "typescript",
-            "go", "rust", "php", "ruby", "swift", "kotlin", "csharp", "c", "sql",
-            "yaml", "json", "markdown", "css", "scss", "sass", "jsx", "tsx", "vue",
-            "shell", "powershell", "r", "scala", "dart", "perl", "lua", "elixir"
-        ]
-
-        for cls in classes:
-            # Clean special characters (except word chars and hyphens)
-            cls = re.sub(r'[^\w-]', '', cls)
-
-            if 'language-' in cls:
-                return cls.replace('language-', '')
-
-            if 'lang-' in cls:
-                return cls.replace('lang-', '')
-
-            # Check for brush: pattern (e.g., "brush: java")
-            if 'brush' in cls.lower():
-                lang = cls.lower().replace('brush', '').strip()
-                if lang in known_languages:
-                    return lang
-
-            # Check for bare language name
-            if cls in known_languages:
-                return cls
-
-        return None
-
     def detect_language(self, elem, code):
-        """Detect programming language from code block"""
+        """Detect programming language from code block
 
-        # Check element classes
-        lang = self._extract_language_from_classes(elem.get('class', []))
-        if lang:
-            return lang
+        UPDATED: Now uses confidence-based detection with 20+ languages
+        """
+        lang, confidence = self.language_detector.detect_from_html(elem, code)
 
-        # Check parent pre element
-        parent = elem.parent
-        if parent and parent.name == 'pre':
-            lang = self._extract_language_from_classes(parent.get('class', []))
-            if lang:
-                return lang
+        # Log low-confidence detections for debugging
+        if confidence < 0.5:
+            logger.debug(f"Low confidence language detection: {lang} ({confidence:.2f})")
 
-        # Heuristic detection
-        if 'import ' in code and 'from ' in code:
-            return 'python'
-        if 'const ' in code or 'let ' in code or '=>' in code:
-            return 'javascript'
-        if 'func ' in code and 'var ' in code:
-            return 'gdscript'
-        if 'def ' in code and ':' in code:
-            return 'python'
-        if '#include' in code or 'int main' in code:
-            return 'cpp'
-        # C# detection
-        if 'using System' in code or 'namespace ' in code:
-            return 'csharp'
-        if '{ get; set; }' in code:
-            return 'csharp'
-        if any(keyword in code for keyword in ['public class ', 'private class ', 'internal class ', 'public static void ']):
-            return 'csharp'
-
-        return 'unknown'
+        return lang  # Return string for backward compatibility
     
     def extract_patterns(self, main: Any, code_samples: List[Dict[str, Any]]) -> List[Dict[str, str]]:
         """Extract common coding patterns (NEW FEATURE)"""
diff --git a/src/skill_seekers/cli/language_detector.py b/src/skill_seekers/cli/language_detector.py
new file mode 100644
index 0000000..928a1fd
--- /dev/null
+++ b/src/skill_seekers/cli/language_detector.py
@@ -0,0 +1,554 @@
+#!/usr/bin/env python3
+"""
+Unified Language Detection for Code Blocks
+
+Provides confidence-based language detection for documentation scrapers.
+Supports 20+ programming languages with weighted pattern matching.
+
+Author: Skill Seekers Project
+"""
+
+import re
+from typing import Optional, Tuple, Dict, List
+
+
+# Comprehensive language patterns with weighted confidence scoring
+# Weight 5: Unique identifiers (highly specific)
+# Weight 4: Strong indicators
+# Weight 3: Common patterns
+# Weight 2: Moderate indicators
+# Weight 1: Weak indicators
+
+LANGUAGE_PATTERNS: Dict[str, List[Tuple[str, int]]] = {
+    # ===== PRIORITY 1: Unity C# (Critical - User's Primary Issue) =====
+    'csharp': [
+        # Unity-specific patterns (weight 4-5, CRITICAL)
+        (r'\busing\s+UnityEngine', 5),
+        (r'\bMonoBehaviour\b', 5),
+        (r'\bGameObject\b', 4),
+        (r'\bTransform\b', 4),
+        (r'\bVector[23]\b', 3),
+        (r'\bQuaternion\b', 3),
+        (r'\bvoid\s+Start\s*\(\)', 4),
+        (r'\bvoid\s+Update\s*\(\)', 4),
+        (r'\bvoid\s+Awake\s*\(\)', 4),
+        (r'\bvoid\s+OnEnable\s*\(\)', 3),
+        (r'\bvoid\s+OnDisable\s*\(\)', 3),
+        (r'\bvoid\s+FixedUpdate\s*\(\)', 4),
+        (r'\bvoid\s+LateUpdate\s*\(\)', 4),
+        (r'\bvoid\s+OnCollisionEnter', 4),
+        (r'\bvoid\s+OnTriggerEnter', 4),
+        (r'\bIEnumerator\b', 4),
+        (r'\bStartCoroutine\s*\(', 4),
+        (r'\byield\s+return\s+new\s+WaitForSeconds', 4),
+        (r'\byield\s+return\s+null', 3),
+        (r'\byield\s+return', 4),
+        (r'\[SerializeField\]', 4),
+        (r'\[RequireComponent', 4),
+        (r'\[Header\(', 3),
+        (r'\[Range\(', 3),
+        (r'\bTime\.deltaTime\b', 4),
+        (r'\bInput\.Get', 4),
+        (r'\bRigidbody\b', 3),
+        (r'\bCollider\b', 3),
+        (r'\bRenderer\b', 3),
+        (r'\bGetComponent<', 3),
+
+        # Basic C# patterns (weight 2-4)
+        (r'\bnamespace\s+\w+', 3),
+        (r'\busing\s+System', 3),
+        (r'\bConsole\.WriteLine', 4),  # C#-specific output
+        (r'\bConsole\.Write', 3),
+        (r'\bpublic\s+class\s+\w+', 4),  # Increased to match Java weight
+        (r'\bprivate\s+class\s+\w+', 3),
+        (r'\binternal\s+class\s+\w+', 4),  # C#-specific modifier
+        (r'\bstring\s+\w+\s*[;=]', 2),  # C#-specific lowercase string
+        (r'\bprivate\s+\w+\s+\w+\s*;', 2),  # Private fields (common in both C# and Java)
+        (r'\{\s*get;\s*set;\s*\}', 3),  # Auto properties
+        (r'\{\s*get;\s*private\s+set;\s*\}', 3),
+        (r'\{\s*get\s*=>\s*', 2),  # Expression properties
+        (r'\bpublic\s+static\s+void\s+', 2),
+
+        # Modern C# patterns (weight 2)
+        (r'\bfrom\s+\w+\s+in\s+', 2),  # LINQ
+        (r'\.Where\s*\(', 2),
+        (r'\.Select\s*\(', 2),
+        (r'\basync\s+Task', 2),
+        (r'\bawait\s+', 2),
+        (r'\bvar\s+\w+\s*=', 1),
+    ],
+
+    # ===== PRIORITY 2: Frontend Languages =====
+    'typescript': [
+        # TypeScript-specific (weight 4-5)
+        (r'\binterface\s+\w+\s*\{', 5),
+        (r'\btype\s+\w+\s*=', 4),
+        (r':\s*\w+\s*=', 3),  # Type annotation
+        (r':\s*\w+\[\]', 3),  # Array type
+        (r'<[\w,\s]+>', 2),  # Generic type
+        (r'\bas\s+\w+', 2),  # Type assertion
+        (r'\benum\s+\w+\s*\{', 4),
+        (r'\bimplements\s+\w+', 3),
+        (r'\bexport\s+interface', 4),
+        (r'\bexport\s+type', 4),
+
+        # Also has JS patterns (weight 1)
+        (r'\bconst\s+\w+\s*=', 1),
+        (r'\blet\s+\w+\s*=', 1),
+        (r'=>', 1),
+    ],
+
+    'javascript': [
+        (r'\bfunction\s+\w+\s*\(', 3),
+        (r'\bconst\s+\w+\s*=', 2),
+        (r'\blet\s+\w+\s*=', 2),
+        (r'=>', 2),  # Arrow function
+        (r'\bconsole\.log', 2),
+        (r'\bvar\s+\w+\s*=', 1),
+        (r'\.then\s*\(', 2),  # Promise
+        (r'\.catch\s*\(', 2),  # Promise
+        (r'\basync\s+function', 3),
+        (r'\bawait\s+', 2),
+        (r'require\s*\(', 2),  # CommonJS
+        (r'\bexport\s+default', 2),  # ES6
+        (r'\bexport\s+const', 2),
+    ],
+
+    'jsx': [
+        # JSX patterns (weight 4-5)
+        (r'<\w+\s+[^>]*>', 4),  # JSX tag with attributes
+        (r'<\w+\s*/>', 4),  # Self-closing tag
+        (r'className=', 3),  # React className
+        (r'onClick=', 3),  # React event
+        (r'\brender\s*\(\s*\)\s*\{', 4),  # React render
+        (r'\buseState\s*\(', 4),  # React hook
+        (r'\buseEffect\s*\(', 4),  # React hook
+        (r'\buseRef\s*\(', 3),
+        (r'\buseCallback\s*\(', 3),
+        (r'\buseMemo\s*\(', 3),
+
+        # Also has JS patterns
+        (r'\bconst\s+\w+\s*=', 1),
+        (r'=>', 1),
+    ],
+
+    'tsx': [
+        # TSX = TypeScript + JSX (weight 5)
+        (r'<\w+\s+[^>]*>', 3),  # JSX tag
+        (r':\s*React\.\w+', 5),  # React types
+        (r'interface\s+\w+Props', 5),  # Props interface
+        (r'\bFunctionComponent<', 4),
+        (r'\bReact\.FC<', 4),
+        (r'\buseState<', 4),  # Typed hook
+        (r'\buseRef<', 3),
+
+        # Also has TS patterns
+        (r'\binterface\s+\w+', 2),
+        (r'\btype\s+\w+\s*=', 2),
+    ],
+
+    'vue': [
+        # Vue SFC patterns (weight 4-5)
+        (r'<template>', 5),
+        (r'<script>', 3),
+        (r'<style\s+scoped>', 4),
+        (r'\bexport\s+default\s*\{', 3),
+        (r'\bdata\s*\(\s*\)\s*\{', 4),  # Vue 2
+        (r'\bcomputed\s*:', 3),
+        (r'\bmethods\s*:', 3),
+        (r'\bsetup\s*\(', 4),  # Vue 3 Composition
+        (r'\bref\s*\(', 4),  # Vue 3
+        (r'\breactive\s*\(', 4),  # Vue 3
+        (r'v-bind:', 3),
+        (r'v-for=', 3),
+        (r'v-if=', 3),
+        (r'v-model=', 3),
+    ],
+
+    # ===== PRIORITY 3: Backend Languages =====
+    'java': [
+        (r'\bpublic\s+class\s+\w+', 4),
+        (r'\bprivate\s+\w+\s+\w+', 2),
+        (r'\bSystem\.out\.println', 3),
+        (r'\bpublic\s+static\s+void\s+main', 4),
+        (r'\bpublic\s+\w+\s+\w+\s*\(', 2),
+        (r'@Override', 3),
+        (r'@Autowired', 3),  # Spring
+        (r'@Service', 3),  # Spring
+        (r'@RestController', 3),  # Spring
+        (r'@GetMapping', 3),  # Spring
+        (r'@PostMapping', 3),  # Spring
+        (r'\bimport\s+java\.', 2),
+        (r'\bextends\s+\w+', 2),
+    ],
+
+    'go': [
+        (r'\bfunc\s+\w+\s*\(', 3),
+        (r'\bpackage\s+\w+', 4),
+        (r':=', 3),  # Short declaration
+        (r'\bfmt\.Print', 2),
+        (r'\bfunc\s+\(.*\)\s+\w+\s*\(', 4),  # Method
+        (r'\bdefer\s+', 3),
+        (r'\bgo\s+\w+\s*\(', 3),  # Goroutine
+        (r'\bchan\s+', 3),  # Channel
+        (r'\binterface\{\}', 2),  # Empty interface
+        (r'\bfunc\s+main\s*\(\)', 4),
+    ],
+
+    'rust': [
+        (r'\bfn\s+\w+\s*\(', 4),
+        (r'\blet\s+mut\s+\w+', 3),
+        (r'\bprintln!', 3),
+        (r'\bimpl\s+\w+', 3),
+        (r'\buse\s+\w+::', 3),
+        (r'\bpub\s+fn\s+', 3),
+        (r'\bmatch\s+\w+\s*\{', 3),
+        (r'\bSome\(', 2),
+        (r'\bNone\b', 2),
+        (r'\bResult<', 3),
+        (r'\bOption<', 3),
+        (r'&str\b', 2),
+        (r'\bfn\s+main\s*\(\)', 4),
+    ],
+
+    'php': [
+        (r'<\?php', 5),
+        (r'\$\w+\s*=', 2),
+        (r'\bfunction\s+\w+\s*\(', 2),
+        (r'\bpublic\s+function', 3),
+        (r'\bprivate\s+function', 3),
+        (r'\bclass\s+\w+', 3),
+        (r'\bnamespace\s+\w+', 3),
+        (r'\buse\s+\w+\\', 2),
+        (r'->', 2),  # Object operator
+        (r'::', 1),  # Static operator
+    ],
+
+    # ===== PRIORITY 4: System/Data Languages =====
+    'python': [
+        (r'\bdef\s+\w+\s*\(', 3),
+        (r'\bimport\s+\w+', 2),
+        (r'\bclass\s+\w+:', 3),
+        (r'\bfrom\s+\w+\s+import', 2),
+        (r':\s*$', 1),  # Lines ending with :
+        (r'@\w+', 2),  # Decorator
+        (r'\bself\.\w+', 2),
+        (r'\b__init__\s*\(', 3),
+        (r'\basync\s+def\s+', 3),
+        (r'\bawait\s+', 2),
+        (r'\bprint\s*\(', 1),
+    ],
+
+    'r': [
+        (r'<-', 4),  # Assignment operator
+        (r'\bfunction\s*\(', 2),
+        (r'\blibrary\s*\(', 3),
+        (r'\bggplot\s*\(', 4),  # ggplot2
+        (r'\bdata\.frame\s*\(', 3),
+        (r'\%>\%', 4),  # Pipe operator
+        (r'\bsummary\s*\(', 2),
+        (r'\bread\.csv\s*\(', 3),
+    ],
+
+    'julia': [
+        (r'\bfunction\s+\w+\s*\(', 3),
+        (r'\bend\b', 2),
+        (r'\busing\s+\w+', 3),
+        (r'::', 2),  # Type annotation
+        (r'\bmodule\s+\w+', 3),
+        (r'\babstract\s+type', 3),
+        (r'\bstruct\s+\w+', 3),
+    ],
+
+    'sql': [
+        (r'\bSELECT\s+', 4),
+        (r'\bFROM\s+', 3),
+        (r'\bWHERE\s+', 2),
+        (r'\bINSERT\s+INTO', 4),
+        (r'\bCREATE\s+TABLE', 4),
+        (r'\bJOIN\s+', 3),
+        (r'\bGROUP\s+BY', 3),
+        (r'\bORDER\s+BY', 3),
+        (r'\bUPDATE\s+', 3),
+        (r'\bDELETE\s+FROM', 3),
+    ],
+
+    # ===== Additional Languages =====
+    'cpp': [
+        (r'#include\s*<', 4),
+        (r'\bstd::', 3),
+        (r'\bnamespace\s+\w+', 3),
+        (r'\bcout\s*<<', 3),
+        (r'\bvoid\s+\w+\s*\(', 2),
+        (r'\bint\s+main\s*\(', 4),
+        (r'->', 2),  # Pointer
+    ],
+
+    'c': [
+        (r'#include\s*<', 4),
+        (r'\bprintf\s*\(', 3),
+        (r'\bint\s+main\s*\(', 4),
+        (r'\bvoid\s+\w+\s*\(', 2),
+        (r'\bstruct\s+\w+', 3),
+    ],
+
+    'gdscript': [
+        (r'\bfunc\s+\w+\s*\(', 3),
+        (r'\bvar\s+\w+\s*=', 3),
+        (r'\bextends\s+\w+', 4),
+        (r'\b_ready\s*\(', 4),
+        (r'\b_process\s*\(', 4),
+    ],
+
+    # ===== Markup/Config Languages =====
+    'html': [
+        (r'<!DOCTYPE\s+html>', 5),
+        (r'<html', 4),
+        (r'<head>', 3),
+        (r'<body>', 3),
+        (r'<div', 2),
+        (r'<span', 2),
+        (r'<script', 2),
+    ],
+
+    'css': [
+        (r'\{\s*[\w-]+\s*:', 3),
+        (r'@media', 3),
+        (r'\.[\w-]+\s*\{', 2),
+        (r'#[\w-]+\s*\{', 2),
+        (r'@import', 2),
+    ],
+
+    'json': [
+        (r'^\s*\{', 3),
+        (r'^\s*\[', 3),
+        (r'"\w+"\s*:', 3),
+        (r':\s*["\d\[\{]', 2),
+    ],
+
+    'yaml': [
+        (r'^\w+:', 3),
+        (r'^\s+-\s+\w+', 2),
+        (r'---', 2),
+        (r'^\s+\w+:', 2),
+    ],
+
+    'xml': [
+        (r'<\?xml', 5),
+        (r'<\w+\s+\w+=', 2),
+        (r'<\w+>', 1),
+        (r'</\w+>', 1),
+    ],
+
+    'markdown': [
+        (r'^#+\s+', 3),
+        (r'^\*\*\w+\*\*', 2),
+        (r'^\s*[-*]\s+', 2),
+        (r'\[.*\]\(.*\)', 2),
+    ],
+
+    'bash': [
+        (r'#!/bin/bash', 5),
+        (r'#!/bin/sh', 5),
+        (r'\becho\s+', 2),
+        (r'\$\{?\w+\}?', 2),
+        (r'\bif\s+\[', 2),
+        (r'\bfor\s+\w+\s+in', 2),
+    ],
+
+    'shell': [
+        (r'#!/bin/bash', 5),
+        (r'#!/bin/sh', 5),
+        (r'\becho\s+', 2),
+        (r'\$\{?\w+\}?', 2),
+    ],
+
+    'powershell': [
+        (r'\$\w+\s*=', 2),
+        (r'Get-\w+', 3),
+        (r'Set-\w+', 3),
+        (r'\bWrite-Host\s+', 2),
+    ],
+}
+
+
+# Known language list for CSS class detection
+KNOWN_LANGUAGES = [
+    "javascript", "java", "xml", "html", "python", "bash", "cpp", "typescript",
+    "go", "rust", "php", "ruby", "swift", "kotlin", "csharp", "c", "sql",
+    "yaml", "json", "markdown", "css", "scss", "sass", "jsx", "tsx", "vue",
+    "shell", "powershell", "r", "scala", "dart", "perl", "lua", "elixir",
+    "julia", "gdscript",
+]
+
+
+class LanguageDetector:
+    """
+    Unified confidence-based language detection for code blocks.
+
+    Supports 20+ programming languages with weighted pattern matching.
+    Uses two-stage detection:
+    1. CSS class extraction (high confidence = 1.0)
+    2. Pattern-based heuristics with confidence scoring (0.0-1.0)
+
+    Example:
+        detector = LanguageDetector(min_confidence=0.3)
+        lang, confidence = detector.detect_from_html(elem, code)
+
+        if confidence >= 0.7:
+            print(f"High confidence: {lang}")
+        elif confidence >= 0.5:
+            print(f"Medium confidence: {lang}")
+        else:
+            print(f"Low confidence: {lang}")
+    """
+
+    def __init__(self, min_confidence: float = 0.15):
+        """
+        Initialize language detector.
+
+        Args:
+            min_confidence: Minimum confidence threshold (0-1)
+                          0.3 = low, 0.5 = medium, 0.7 = high
+        """
+        self.min_confidence = min_confidence
+        self._pattern_cache: Dict[str, List[Tuple[re.Pattern, int]]] = {}
+        self._compile_patterns()
+
+    def _compile_patterns(self) -> None:
+        """Compile regex patterns and cache them for performance"""
+        for lang, patterns in LANGUAGE_PATTERNS.items():
+            self._pattern_cache[lang] = [
+                (re.compile(pattern, re.IGNORECASE | re.MULTILINE), weight)
+                for pattern, weight in patterns
+            ]
+
+    def detect_from_html(self, elem, code: str) -> Tuple[str, float]:
+        """
+        Detect language from HTML element with CSS classes + code content.
+
+        Args:
+            elem: BeautifulSoup element with 'class' attribute
+            code: Code content string
+
+        Returns:
+            Tuple of (language, confidence) where confidence is 0.0-1.0
+        """
+        # Tier 1: CSS classes (confidence 1.0)
+        if elem:
+            css_lang = self.extract_language_from_classes(elem.get('class', []))
+            if css_lang:
+                return css_lang, 1.0
+
+            # Check parent pre element
+            parent = elem.parent
+            if parent and parent.name == 'pre':
+                css_lang = self.extract_language_from_classes(parent.get('class', []))
+                if css_lang:
+                    return css_lang, 1.0
+
+        # Tier 2: Pattern matching
+        return self.detect_from_code(code)
+
+    def detect_from_code(self, code: str) -> Tuple[str, float]:
+        """
+        Detect language from code content only (for PDFs, GitHub files).
+
+        Args:
+            code: Code content string
+
+        Returns:
+            Tuple of (language, confidence) where confidence is 0.0-1.0
+        """
+        # Edge case: code too short
+        if len(code.strip()) < 10:
+            return 'unknown', 0.0
+
+        # Calculate confidence scores for all languages
+        scores = self._calculate_confidence(code)
+
+        if not scores:
+            return 'unknown', 0.0
+
+        # Get language with highest score
+        best_lang = max(scores.items(), key=lambda x: x[1])
+        lang, confidence = best_lang
+
+        # Apply minimum confidence threshold
+        if confidence < self.min_confidence:
+            return 'unknown', 0.0
+
+        return lang, confidence
+
+    def extract_language_from_classes(self, classes: List[str]) -> Optional[str]:
+        """
+        Extract language from CSS class list.
+
+        Supports patterns:
+        - language-*  (e.g., language-python)
+        - lang-*      (e.g., lang-javascript)
+        - brush: *    (e.g., brush: java)
+        - Bare names  (e.g., python, java)
+
+        Args:
+            classes: List of CSS class names
+
+        Returns:
+            Language string or None if not found
+        """
+        if not classes:
+            return None
+
+        for cls in classes:
+            # Handle brush: pattern
+            if 'brush:' in cls:
+                parts = cls.split('brush:')
+                if len(parts) > 1:
+                    lang = parts[1].strip().lower()
+                    if lang in KNOWN_LANGUAGES:
+                        return lang
+
+            # Handle language- prefix
+            if cls.startswith('language-'):
+                lang = cls[9:].lower()
+                if lang in KNOWN_LANGUAGES:
+                    return lang
+
+            # Handle lang- prefix
+            if cls.startswith('lang-'):
+                lang = cls[5:].lower()
+                if lang in KNOWN_LANGUAGES:
+                    return lang
+
+            # Handle bare class name
+            if cls.lower() in KNOWN_LANGUAGES:
+                return cls.lower()
+
+        return None
+
+    def _calculate_confidence(self, code: str) -> Dict[str, float]:
+        """
+        Calculate weighted confidence scores for all languages.
+
+        Args:
+            code: Code content string
+
+        Returns:
+            Dictionary mapping language names to confidence scores (0.0-1.0)
+        """
+        scores: Dict[str, float] = {}
+
+        for lang, compiled_patterns in self._pattern_cache.items():
+            total_score = 0
+
+            for pattern, weight in compiled_patterns:
+                if pattern.search(code):
+                    total_score += weight
+
+            if total_score > 0:
+                # Normalize score to 0-1 range
+                # Score of 10+ = 1.0 confidence
+                confidence = min(total_score / 10.0, 1.0)
+                scores[lang] = confidence
+
+        return scores
diff --git a/src/skill_seekers/cli/pdf_extractor_poc.py b/src/skill_seekers/cli/pdf_extractor_poc.py
index f8c0fe8..75a8a89 100755
--- a/src/skill_seekers/cli/pdf_extractor_poc.py
+++ b/src/skill_seekers/cli/pdf_extractor_poc.py
@@ -55,6 +55,9 @@ import re
 import argparse
 from pathlib import Path
 
+# Import unified language detector
+from skill_seekers.cli.language_detector import LanguageDetector
+
 # Check if PyMuPDF is installed
 try:
     import fitz  # PyMuPDF
@@ -107,6 +110,9 @@ class PDFExtractor:
         self.extracted_images = []  # List of extracted image info (NEW in B1.5)
         self._cache = {}  # Cache for expensive operations (Priority 3)
 
+        # Language detection
+        self.language_detector = LanguageDetector(min_confidence=0.15)
+
     def log(self, message):
         """Print message if verbose mode enabled"""
         if self.verbose:
@@ -213,141 +219,11 @@ class PDFExtractor:
         Detect programming language from code content using patterns.
         Enhanced in B1.4 with confidence scoring.
 
+        UPDATED: Now uses shared LanguageDetector with 20+ languages
+
         Returns (language, confidence) tuple
         """
-        code_lower = code.lower()
-
-        # Language detection patterns with weights
-        patterns = {
-            'python': [
-                (r'\bdef\s+\w+\s*\(', 3),
-                (r'\bimport\s+\w+', 2),
-                (r'\bclass\s+\w+:', 3),
-                (r'\bfrom\s+\w+\s+import', 2),
-                (r':\s*$', 1),  # Lines ending with :
-                (r'^\s{4}|\t', 1),  # Indentation
-            ],
-            'javascript': [
-                (r'\bfunction\s+\w+\s*\(', 3),
-                (r'\bconst\s+\w+\s*=', 2),
-                (r'\blet\s+\w+\s*=', 2),
-                (r'=>', 2),
-                (r'\bconsole\.log', 2),
-                (r'\bvar\s+\w+\s*=', 1),
-            ],
-            'java': [
-                (r'\bpublic\s+class\s+\w+', 4),
-                (r'\bprivate\s+\w+\s+\w+', 2),
-                (r'\bSystem\.out\.println', 3),
-                (r'\bpublic\s+static\s+void', 3),
-            ],
-            'cpp': [
-                (r'#include\s*<', 3),
-                (r'\bstd::', 3),
-                (r'\bnamespace\s+\w+', 2),
-                (r'cout\s*<<', 3),
-                (r'\bvoid\s+\w+\s*\(', 1),
-            ],
-            'c': [
-                (r'#include\s+<\w+\.h>', 4),
-                (r'\bprintf\s*\(', 3),
-                (r'\bmain\s*\(', 2),
-                (r'\bstruct\s+\w+', 2),
-            ],
-            'csharp': [
-                (r'\bnamespace\s+\w+', 3),
-                (r'\bpublic\s+class\s+\w+', 3),
-                (r'\busing\s+System', 3),
-            ],
-            'go': [
-                (r'\bfunc\s+\w+\s*\(', 3),
-                (r'\bpackage\s+\w+', 4),
-                (r':=', 2),
-                (r'\bfmt\.Print', 2),
-            ],
-            'rust': [
-                (r'\bfn\s+\w+\s*\(', 4),
-                (r'\blet\s+mut\s+\w+', 3),
-                (r'\bprintln!', 3),
-                (r'\bimpl\s+\w+', 2),
-            ],
-            'php': [
-                (r'<\?php', 5),
-                (r'\$\w+\s*=', 2),
-                (r'\bfunction\s+\w+\s*\(', 1),
-            ],
-            'ruby': [
-                (r'\bdef\s+\w+', 3),
-                (r'\bend\b', 2),
-                (r'\brequire\s+[\'"]', 2),
-            ],
-            'swift': [
-                (r'\bfunc\s+\w+\s*\(', 3),
-                (r'\bvar\s+\w+:', 2),
-                (r'\blet\s+\w+:', 2),
-            ],
-            'kotlin': [
-                (r'\bfun\s+\w+\s*\(', 4),
-                (r'\bval\s+\w+\s*=', 2),
-                (r'\bvar\s+\w+\s*=', 2),
-            ],
-            'shell': [
-                (r'#!/bin/bash', 5),
-                (r'#!/bin/sh', 5),
-                (r'\becho\s+', 1),
-                (r'\$\{?\w+\}?', 1),
-            ],
-            'sql': [
-                (r'\bSELECT\s+', 4),
-                (r'\bFROM\s+', 3),
-                (r'\bWHERE\s+', 2),
-                (r'\bINSERT\s+INTO', 4),
-                (r'\bCREATE\s+TABLE', 4),
-            ],
-            'html': [
-                (r'<html', 4),
-                (r'<div', 2),
-                (r'<span', 2),
-                (r'<script', 2),
-            ],
-            'css': [
-                (r'\{\s*[\w-]+\s*:', 3),
-                (r'@media', 3),
-                (r'\.[\w-]+\s*\{', 2),
-            ],
-            'json': [
-                (r'^\s*\{', 2),
-                (r'^\s*\[', 2),
-                (r'"\w+"\s*:', 3),
-            ],
-            'yaml': [
-                (r'^\w+:', 2),
-                (r'^\s+-\s+\w+', 2),
-            ],
-            'xml': [
-                (r'<\?xml', 5),
-                (r'<\w+>', 1),
-            ],
-        }
-
-        # Calculate confidence scores for each language
-        scores = {}
-        for lang, lang_patterns in patterns.items():
-            score = 0
-            for pattern, weight in lang_patterns:
-                if re.search(pattern, code, re.IGNORECASE | re.MULTILINE):
-                    score += weight
-            if score > 0:
-                scores[lang] = score
-
-        if not scores:
-            return 'unknown', 0
-
-        # Get language with highest score
-        best_lang = max(scores, key=scores.get)
-        confidence = min(scores[best_lang] / 10.0, 1.0)  # Normalize to 0-1
-
-        return best_lang, confidence
+        return self.language_detector.detect_from_code(code)
 
     def validate_code_syntax(self, code, language):
         """
diff --git a/tests/test_language_detector.py b/tests/test_language_detector.py
new file mode 100644
index 0000000..c3753fe
--- /dev/null
+++ b/tests/test_language_detector.py
@@ -0,0 +1,708 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Test Suite for LanguageDetector
+
+Tests confidence-based language detection for 20+ programming languages.
+Includes Unity C# patterns, CSS class detection, and edge cases.
+
+Run with: pytest tests/test_language_detector.py -v
+"""
+
+import pytest
+from bs4 import BeautifulSoup
+from skill_seekers.cli.language_detector import LanguageDetector
+
+
+class TestCSSClassDetection:
+    """Test language detection from CSS classes"""
+
+    def test_language_prefix(self):
+        """Test language- prefix pattern"""
+        detector = LanguageDetector()
+
+        classes = ['language-python', 'highlight']
+        assert detector.extract_language_from_classes(classes) == 'python'
+
+        classes = ['language-javascript']
+        assert detector.extract_language_from_classes(classes) == 'javascript'
+
+    def test_lang_prefix(self):
+        """Test lang- prefix pattern"""
+        detector = LanguageDetector()
+
+        classes = ['lang-java', 'code']
+        assert detector.extract_language_from_classes(classes) == 'java'
+
+        classes = ['lang-typescript']
+        assert detector.extract_language_from_classes(classes) == 'typescript'
+
+    def test_brush_pattern(self):
+        """Test brush: pattern"""
+        detector = LanguageDetector()
+
+        classes = ['brush: php']
+        assert detector.extract_language_from_classes(classes) == 'php'
+
+        classes = ['brush: csharp']
+        assert detector.extract_language_from_classes(classes) == 'csharp'
+
+    def test_bare_class_name(self):
+        """Test bare language name as class"""
+        detector = LanguageDetector()
+
+        classes = ['python', 'highlight']
+        assert detector.extract_language_from_classes(classes) == 'python'
+
+        classes = ['rust']
+        assert detector.extract_language_from_classes(classes) == 'rust'
+
+    def test_unknown_language(self):
+        """Test unknown language class"""
+        detector = LanguageDetector()
+
+        classes = ['language-foobar']
+        assert detector.extract_language_from_classes(classes) is None
+
+        classes = ['highlight', 'code']
+        assert detector.extract_language_from_classes(classes) is None
+
+    def test_empty_classes(self):
+        """Test empty class list"""
+        detector = LanguageDetector()
+
+        assert detector.extract_language_from_classes([]) is None
+        assert detector.extract_language_from_classes(None) is None
+
+    def test_detect_from_html_with_css_class(self):
+        """Test HTML element with CSS class"""
+        detector = LanguageDetector()
+
+        # Create mock element
+        html = '<code class="language-python">print("hello")</code>'
+        soup = BeautifulSoup(html, 'html.parser')
+        elem = soup.find('code')
+
+        lang, confidence = detector.detect_from_html(elem, 'print("hello")')
+        assert lang == 'python'
+        assert confidence == 1.0  # CSS class = high confidence
+
+    def test_detect_from_html_with_parent_class(self):
+        """Test parent <pre> element with CSS class"""
+        detector = LanguageDetector()
+
+        # Parent has class, child doesn't
+        html = '<pre class="language-java"><code>System.out.println("hello");</code></pre>'
+        soup = BeautifulSoup(html, 'html.parser')
+        elem = soup.find('code')
+
+        lang, confidence = detector.detect_from_html(elem, 'System.out.println("hello");')
+        assert lang == 'java'
+        assert confidence == 1.0
+
+
+class TestUnityCSharpDetection:
+    """Test Unity C# specific patterns (CRITICAL - User's Primary Issue)"""
+
+    def test_unity_monobehaviour_detection(self):
+        """Test Unity MonoBehaviour class detection"""
+        detector = LanguageDetector()
+
+        code = """
+        using UnityEngine;
+
+        public class Player : MonoBehaviour
+        {
+            [SerializeField]
+            private float speed = 5.0f;
+
+            void Start() { }
+            void Update() { }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.9  # High confidence (Unity patterns)
+
+    def test_unity_lifecycle_methods(self):
+        """Test Unity lifecycle method detection"""
+        detector = LanguageDetector()
+
+        code = """
+        void Awake() { }
+        void Start() { }
+        void Update() { }
+        void FixedUpdate() { }
+        void LateUpdate() { }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.5
+
+    def test_unity_coroutine_detection(self):
+        """Test Unity coroutine detection"""
+        detector = LanguageDetector()
+
+        code = """
+        IEnumerator Wait()
+        {
+            yield return new WaitForSeconds(1);
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.4
+
+    def test_unity_serializefield_attribute(self):
+        """Test Unity attribute detection"""
+        detector = LanguageDetector()
+
+        code = """
+        [SerializeField]
+        private GameObject player;
+
+        [RequireComponent(typeof(Rigidbody))]
+        public class Test : MonoBehaviour { }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.7
+
+    def test_unity_types(self):
+        """Test Unity type detection (GameObject, Transform, etc.)"""
+        detector = LanguageDetector()
+
+        code = """
+        GameObject obj = new GameObject();
+        Transform transform = obj.transform;
+        Vector3 position = transform.position;
+        Rigidbody rb = obj.GetComponent<Rigidbody>();
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.3
+
+    def test_unity_namespace(self):
+        """Test Unity namespace detection"""
+        detector = LanguageDetector()
+
+        code = "using UnityEngine;"
+        lang, confidence = detector.detect_from_code(code)
+
+        # Short code, but very specific Unity pattern (19 chars)
+        # Now detects due to lowered min length threshold (10 chars)
+        assert lang == 'csharp'
+        assert confidence >= 0.5
+
+        # Longer version
+        code = """
+        using UnityEngine;
+        using System.Collections;
+        """
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.5
+
+    def test_generic_csharp_vs_unity(self):
+        """Test generic C# doesn't false-positive as Unity"""
+        detector = LanguageDetector()
+
+        # Generic C# code
+        code = """
+        using System;
+
+        public class Program
+        {
+            static void Main(string[] args)
+            {
+                Console.WriteLine("Hello");
+            }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        # Confidence should be high (contains multiple C# patterns)
+        # No Unity-specific patterns, but Console.WriteLine is strong indicator
+        assert 0.7 <= confidence <= 1.0
+
+    def test_unity_minimal_code(self):
+        """Test minimal Unity code (edge case)"""
+        detector = LanguageDetector()
+
+        code = "void Update() { Time.deltaTime; }"
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.3  # Low but detected
+
+    def test_unity_input_system(self):
+        """Test Unity Input system detection"""
+        detector = LanguageDetector()
+
+        code = """
+        float horizontal = Input.GetAxis("Horizontal");
+        if (Input.GetKeyDown(KeyCode.Space)) { }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.4
+
+    def test_unity_full_script(self):
+        """Test complete Unity script (high confidence expected)"""
+        detector = LanguageDetector()
+
+        code = """
+        using UnityEngine;
+        using System.Collections;
+
+        public class PlayerController : MonoBehaviour
+        {
+            [SerializeField]
+            private float speed = 5.0f;
+
+            [SerializeField]
+            private Rigidbody rb;
+
+            void Awake()
+            {
+                rb = GetComponent<Rigidbody>();
+            }
+
+            void Update()
+            {
+                float moveH = Input.GetAxis("Horizontal");
+                float moveV = Input.GetAxis("Vertical");
+
+                Vector3 movement = new Vector3(moveH, 0, moveV);
+                rb.AddForce(movement * speed);
+            }
+
+            IEnumerator DashCoroutine()
+            {
+                speed *= 2;
+                yield return new WaitForSeconds(0.5f);
+                speed /= 2;
+            }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'csharp'
+        assert confidence >= 0.9  # Very high confidence (many Unity patterns)
+
+
+class TestLanguageDetection:
+    """Test detection for major programming languages"""
+
+    def test_python_detection(self):
+        """Test Python code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        def calculate(x, y):
+            result = x + y
+            return result
+
+        class MyClass:
+            def __init__(self):
+                self.value = 0
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'python'
+        assert confidence >= 0.5
+
+    def test_javascript_detection(self):
+        """Test JavaScript code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        const add = (a, b) => a + b;
+
+        function calculate() {
+            let result = 0;
+            console.log(result);
+            return result;
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'javascript'
+        assert confidence >= 0.5
+
+    def test_typescript_detection(self):
+        """Test TypeScript code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        interface User {
+            name: string;
+            age: number;
+        }
+
+        type ID = string | number;
+
+        function getUser(): User {
+            return { name: "John", age: 30 };
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'typescript'
+        assert confidence >= 0.7
+
+    def test_java_detection(self):
+        """Test Java code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        public class Hello {
+            public static void main(String[] args) {
+                System.out.println("Hello World");
+            }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'java'
+        assert confidence >= 0.6
+
+    def test_go_detection(self):
+        """Test Go code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        package main
+
+        import "fmt"
+
+        func main() {
+            message := "Hello, World"
+            fmt.Println(message)
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'go'
+        assert confidence >= 0.6
+
+    def test_rust_detection(self):
+        """Test Rust code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        fn main() {
+            let mut x = 5;
+            println!("The value is: {}", x);
+
+            match x {
+                1 => println!("One"),
+                _ => println!("Other"),
+            }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'rust'
+        assert confidence >= 0.6
+
+    def test_php_detection(self):
+        """Test PHP code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        <?php
+        class User {
+            public function getName() {
+                return $this->name;
+            }
+        }
+        ?>
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'php'
+        assert confidence >= 0.7
+
+    def test_jsx_detection(self):
+        """Test JSX code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        const Button = () => {
+            const [count, setCount] = useState(0);
+
+            return (
+                <button onClick={() => setCount(count + 1)}>
+                    Click me: {count}
+                </button>
+            );
+        };
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'jsx'
+        assert confidence >= 0.5
+
+    def test_vue_detection(self):
+        """Test Vue SFC detection"""
+        detector = LanguageDetector()
+
+        code = """
+        <template>
+            <div>{{ message }}</div>
+        </template>
+
+        <script>
+        export default {
+            data() {
+                return { message: "Hello" };
+            }
+        }
+        </script>
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'vue'
+        assert confidence >= 0.7
+
+    def test_sql_detection(self):
+        """Test SQL code detection"""
+        detector = LanguageDetector()
+
+        code = """
+        SELECT users.name, orders.total
+        FROM users
+        JOIN orders ON users.id = orders.user_id
+        WHERE orders.status = 'completed'
+        ORDER BY orders.total DESC;
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'sql'
+        assert confidence >= 0.6
+
+
+class TestEdgeCases:
+    """Test edge cases and error handling"""
+
+    def test_short_code_snippet(self):
+        """Test code snippet too short for detection"""
+        detector = LanguageDetector()
+
+        code = "x = 5"
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'unknown'
+        assert confidence == 0.0
+
+    def test_empty_code(self):
+        """Test empty code string"""
+        detector = LanguageDetector()
+
+        lang, confidence = detector.detect_from_code("")
+        assert lang == 'unknown'
+        assert confidence == 0.0
+
+    def test_whitespace_only(self):
+        """Test whitespace-only code"""
+        detector = LanguageDetector()
+
+        code = "    \n    \n    "
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'unknown'
+        assert confidence == 0.0
+
+    def test_comments_only(self):
+        """Test code with only comments"""
+        detector = LanguageDetector()
+
+        code = """
+        // This is a comment
+        // Another comment
+        /* More comments */
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        # Should return unknown or very low confidence
+        assert confidence < 0.5
+
+    def test_mixed_languages(self):
+        """Test code with multiple language patterns"""
+        detector = LanguageDetector()
+
+        # HTML with embedded JavaScript
+        code = """
+        <script>
+        function test() {
+            console.log("test");
+        }
+        </script>
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        # Should detect strongest pattern
+        # Both html and javascript patterns present
+        assert lang in ['html', 'javascript']
+
+    def test_confidence_threshold(self):
+        """Test minimum confidence threshold"""
+        # Create detector with high threshold
+        detector = LanguageDetector(min_confidence=0.7)
+
+        # Code with weak patterns (low confidence)
+        code = "var x = 5; const y = 10;"
+
+        lang, confidence = detector.detect_from_code(code)
+
+        # If confidence < 0.7, should return unknown
+        if confidence < 0.7:
+            assert lang == 'unknown'
+
+    def test_html_with_embedded_css(self):
+        """Test HTML with embedded CSS"""
+        detector = LanguageDetector()
+
+        code = """
+        <style>
+        .container {
+            display: flex;
+            margin: 0 auto;
+        }
+        </style>
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang in ['html', 'css']
+
+    def test_case_insensitive_patterns(self):
+        """Test that patterns are case-insensitive"""
+        detector = LanguageDetector()
+
+        # SQL with different cases
+        code = """
+        select users.name
+        FROM users
+        where users.status = 'active'
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'sql'
+
+    def test_r_language_detection(self):
+        """Test R language detection (edge case: single letter)"""
+        detector = LanguageDetector()
+
+        code = """
+        library(ggplot2)
+        data <- read.csv("data.csv")
+        summary(data)
+
+        ggplot(data, aes(x = x, y = y)) +
+            geom_point()
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'r'
+        assert confidence >= 0.5
+
+    def test_julia_detection(self):
+        """Test Julia language detection"""
+        detector = LanguageDetector()
+
+        code = """
+        function calculate(x, y)
+            result = x + y
+            return result
+        end
+
+        using Statistics
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'julia'
+        assert confidence >= 0.3
+
+    def test_gdscript_detection(self):
+        """Test GDScript (Godot) detection"""
+        detector = LanguageDetector()
+
+        code = """
+        extends Node2D
+
+        var speed = 100
+
+        func _ready():
+            pass
+
+        func _process(delta):
+            position.x += speed * delta
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        assert lang == 'gdscript'
+        assert confidence >= 0.5
+
+    def test_multiple_confidence_scores(self):
+        """Test that multiple languages can have scores"""
+        detector = LanguageDetector()
+
+        # Code that matches both C# and Java patterns
+        code = """
+        public class Test {
+            public static void main() {
+                System.out.println("hello");
+            }
+        }
+        """
+
+        lang, confidence = detector.detect_from_code(code)
+        # Should detect the one with highest confidence
+        assert lang in ['csharp', 'java']
+        assert confidence > 0.0
+
+
+class TestIntegration:
+    """Integration tests with doc_scraper patterns"""
+
+    def test_detect_from_html_fallback_to_patterns(self):
+        """Test fallback from CSS classes to pattern matching"""
+        detector = LanguageDetector()
+
+        # Element without CSS classes
+        html = '<code>def test(): pass</code>'
+        soup = BeautifulSoup(html, 'html.parser')
+        elem = soup.find('code')
+
+        lang, confidence = detector.detect_from_html(elem, 'def test(): pass')
+        # Should fallback to pattern matching
+        # Now detects due to lowered min length threshold (10 chars)
+        assert lang == 'python'
+        assert confidence >= 0.2
+
+    def test_backward_compatibility_with_doc_scraper(self):
+        """Test that detector can be used as drop-in replacement"""
+        detector = LanguageDetector()
+
+        # Simulate doc_scraper.py usage
+        html = '<code class="language-python">import os\nprint("hello")</code>'
+        soup = BeautifulSoup(html, 'html.parser')
+        elem = soup.find('code')
+        code = elem.get_text()
+
+        # This is how doc_scraper.py would call it
+        lang, confidence = detector.detect_from_html(elem, code)
+
+        # Should work exactly as before (returning string)
+        assert isinstance(lang, str)
+        assert isinstance(confidence, float)
+        assert lang == 'python'
+        assert 0.0 <= confidence <= 1.0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/tests/test_pdf_extractor.py b/tests/test_pdf_extractor.py
index 5e8d243..d45a504 100644
--- a/tests/test_pdf_extractor.py
+++ b/tests/test_pdf_extractor.py
@@ -32,12 +32,16 @@ class TestLanguageDetection(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_detect_python_with_confidence(self):
         """Test Python detection returns language and confidence"""
         extractor = self.PDFExtractor.__new__(self.PDFExtractor)
+        # Initialize language_detector manually (since __init__ not called)
+        from skill_seekers.cli.language_detector import LanguageDetector
+        extractor.language_detector = LanguageDetector(min_confidence=0.15)
+
         code = "def hello():\n    print('world')\n    return True"
 
         language, confidence = extractor.detect_language_from_code(code)
@@ -49,6 +53,10 @@ class TestLanguageDetection(unittest.TestCase):
     def test_detect_javascript_with_confidence(self):
         """Test JavaScript detection"""
         extractor = self.PDFExtractor.__new__(self.PDFExtractor)
+        # Initialize language_detector manually (since __init__ not called)
+        from skill_seekers.cli.language_detector import LanguageDetector
+        extractor.language_detector = LanguageDetector(min_confidence=0.15)
+
         code = "const handleClick = () => {\n  console.log('clicked');\n};"
 
         language, confidence = extractor.detect_language_from_code(code)
@@ -59,6 +67,10 @@ class TestLanguageDetection(unittest.TestCase):
     def test_detect_cpp_with_confidence(self):
         """Test C++ detection"""
         extractor = self.PDFExtractor.__new__(self.PDFExtractor)
+        # Initialize language_detector manually (since __init__ not called)
+        from skill_seekers.cli.language_detector import LanguageDetector
+        extractor.language_detector = LanguageDetector(min_confidence=0.15)
+
         code = "#include <iostream>\nint main() {\n  std::cout << \"Hello\";\n}"
 
         language, confidence = extractor.detect_language_from_code(code)
@@ -69,6 +81,10 @@ class TestLanguageDetection(unittest.TestCase):
     def test_detect_unknown_low_confidence(self):
         """Test unknown language returns low confidence"""
         extractor = self.PDFExtractor.__new__(self.PDFExtractor)
+        # Initialize language_detector manually (since __init__ not called)
+        from skill_seekers.cli.language_detector import LanguageDetector
+        extractor.language_detector = LanguageDetector(min_confidence=0.15)
+
         code = "this is not code at all just plain text"
 
         language, confidence = extractor.detect_language_from_code(code)
@@ -79,6 +95,10 @@ class TestLanguageDetection(unittest.TestCase):
     def test_confidence_range(self):
         """Test confidence is always between 0 and 1"""
         extractor = self.PDFExtractor.__new__(self.PDFExtractor)
+        # Initialize language_detector manually (since __init__ not called)
+        from skill_seekers.cli.language_detector import LanguageDetector
+        extractor.language_detector = LanguageDetector(min_confidence=0.15)
+
         test_codes = [
             "def foo(): pass",
             "const x = 10;",
@@ -99,7 +119,7 @@ class TestSyntaxValidation(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_validate_python_valid(self):
@@ -159,7 +179,7 @@ class TestQualityScoring(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_quality_score_range(self):
@@ -216,7 +236,7 @@ class TestChapterDetection(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_detect_chapter_with_number(self):
@@ -275,7 +295,7 @@ class TestCodeBlockMerging(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_merge_continued_blocks(self):
@@ -340,7 +360,7 @@ class TestCodeDetectionMethods(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_pattern_based_detection(self):
@@ -373,7 +393,7 @@ class TestQualityFiltering(unittest.TestCase):
     def setUp(self):
         if not PYMUPDF_AVAILABLE:
             self.skipTest("PyMuPDF not installed")
-        from pdf_extractor_poc import PDFExtractor
+        from skill_seekers.cli.pdf_extractor_poc import PDFExtractor
         self.PDFExtractor = PDFExtractor
 
     def test_filter_by_min_quality(self):