diff --git a/src/__tests__/collection.patternFlyApi.test.ts b/src/__tests__/collection.patternFlyApi.test.ts
index b4683ff0..fa584500 100644
--- a/src/__tests__/collection.patternFlyApi.test.ts
+++ b/src/__tests__/collection.patternFlyApi.test.ts
@@ -179,6 +179,24 @@ describe('parsePayload', () => {
   it('parses numeric payloads as non-empty', () => {
     expect(parsePayload('42').isEmpty).toBe(false);
   });
+
+  it.each([
+    {
+      description: 'length',
+      payload: 'A'.repeat(200),
+      expected: 1
+    },
+    {
+      description: 'code fence',
+      payload: '```ts file="./ButtonBasic.tsx"\n```',
+      expected: 0.95
+    }
+  ])('should calculate qualityScore during payload parsing, $description', ({ payload, expected }) => {
+    // See collection.patternFlyApi.test.ts for quality scoring tests
+    const parsed = parsePayload(payload);
+
+    expect(parsed.qualityScore).toBeLessThanOrEqual(expected);
+  });
 });
 
 describe('crawler', () => {
diff --git a/src/__tests__/collection.patternFlyApiHelpers.test.ts b/src/__tests__/collection.patternFlyApiHelpers.test.ts
index 0a6ae48f..1671cd00 100644
--- a/src/__tests__/collection.patternFlyApiHelpers.test.ts
+++ b/src/__tests__/collection.patternFlyApiHelpers.test.ts
@@ -6,8 +6,11 @@ import {
   formatSlugToTitle,
   getApiFallbackDescription,
   getLiveExampleCount,
+  getRawImportCount,
+  getTemplateCount,
+  isContentAggregator,
+  isSubstantialGuide,
   hasEmptyFileCodeFence,
-  hasLiveExample,
   isRawImport,
   normalizeSlug
 } from '../collection.patternFlyApiHelpers';
@@ -79,50 +82,141 @@ describe('isRawImport', () => {
   });
 });
 
-describe('hasLiveExample', () => {
+describe('getRawImportCount', () => {
   it.each([
     {
-      description: 'self-closing LiveExample tag',
-      input: '<LiveExample src="./Button.tsx" />',
+      description: 'plain text with no import',
+      input: 'const a = "./Button.tsx";',
+      expected: 0
+    },
+    {
+      description: 'single raw import',
+      input: "import ButtonRaw from './Button.tsx?raw';",
+      expected: 1
+    },
+    {
+      description: 'multiple raw imports across multiple lines',
+      input: "import Btn1 from './Btn1.tsx?raw';\nimport Btn2 from './Btn2.tsx?raw';\nimport Btn3 from './Btn3.tsx?raw';",
+      expected: 3
+    },
+    {
+      description: 'multiline raw import statement',
+      input: "import {\n  Button,\n  Card\n} from './components?raw';",
+      expected: 1
+    },
+    {
+      description: 'mixed raw imports and standard imports',
+      input: "import React from 'react';\nimport ExampleRaw from './Example?raw';\nimport { Card } from './Card';",
+      expected: 1
+    }
+  ])('should count raw imports, $description', ({ input, expected }) => {
+    expect(getRawImportCount(input)).toBe(expected);
+  });
+});
+
+describe('getTemplateCount', () => {
+  it.each([
+    {
+      description: 'content with no templates, raw imports',
+      input: 'Pure documentation content without any examples.',
+      expected: { pairedCount: 0, orphanCount: 0, totalUnits: 0 }
+    },
+    {
+      description: 'live example, raw import',
+      input: "import Example from './Example?raw';\n<LiveExample src=\"./Example\" />",
+      expected: { pairedCount: 1, orphanCount: 0, totalUnits: 1 }
+    },
+    {
+      description: 'orphaned raw import, no live examples',
+      input: "import Example1 from './Example1?raw';\nimport Example2 from './Example2?raw';",
+      expected: { pairedCount: 0, orphanCount: 2, totalUnits: 2 }
+    },
+    {
+      description: 'orphaned live examples, no raw imports',
+      input: '<LiveExample src="1" />\n<LiveExample src="2" />',
+      expected: { pairedCount: 0, orphanCount: 2, totalUnits: 2 }
+    },
+    {
+      description: 'multiple live examples and a single raw import',
+      input: "import Ex1 from './Ex1?raw';\n<LiveExample src=\"1\" />\n<LiveExample src=\"2\" />\n<LiveExample src=\"3\" />",
+      expected: { pairedCount: 1, orphanCount: 2, totalUnits: 3 }
+    }
+  ])('should calculate template counts and pairings, $description', ({ input, expected }) => {
+    expect(getTemplateCount(input)).toEqual(expected);
+  });
+});
+
+describe('isContentAggregator', () => {
+  it.each([
+    {
+      description: 'multiple templates without inlined code blocks',
+      input: '<LiveExample src="1" />\n<LiveExample src="2" />',
       expected: true
     },
     {
-      description: 'opening LiveExample tag with attributes',
-      input: '<LiveExample id="example-1">',
+      description: 'multiple templates where total units is greater than inlinedCodeCount',
+      input: '<LiveExample src="1" />\n<LiveExample src="2" />\n<LiveExample src="3" />\n```tsx\nconst a = \'single block that exceeds 20 characters\';\n```',
       expected: true
     },
     {
-      description: 'case-insensitive liveexample tag',
-      input: '<liveexample src="demo" />',
+      description: 'template tag present, lacks prose paragraphs and no inlined code',
+      input: '<LiveExample src="1" />\nShort line',
       expected: true
     },
     {
-      description: 'LiveExample tag with multiline attributes',
-      input: '<LiveExample\n  src="./Demo.tsx"\n/>',
+      description: 'multiple paragraphs and inlined code, content is not an aggregator',
+      input: '<LiveExample src="Ex" />\n\nThis is the first substantive paragraph detailing how to implement this pattern.\n\nThis is the second substantive paragraph detailing accessibility guidelines and props.\n\n```tsx\nimport React from \'react\';\nexport const Sample = () => <Button>Click</Button>;\n```',
+      expected: false
+    },
+    {
+      description: 'non-markdown/html, content is not an aggregator',
+      input: '{"template": "<LiveExample />", "raw": "import x from \'x?raw\'"}',
+      expected: false
+    },
+    {
+      description: 'no templates, content is not an aggregator',
+      input: '# Documentation\n\nThis is a standard document with no template references.',
+      expected: false
+    }
+  ])('should determine if content is an aggregator, $description', ({ input, expected }) => {
+    expect(isContentAggregator(input)).toBe(expected);
+  });
+});
+
+describe('isSubstantialGuide', () => {
+  it.each([
+    {
+      description: 'markdown with templates and multiple paragraphs',
+      input: 'This is paragraph one explaining how to configure the component in depth.\n\nThis is paragraph two explaining proper event handling and keyboard navigation.\n\n<LiveExample src="Ex" />',
       expected: true
     },
     {
-      description: 'LiveExample tag without attributes',
-      input: '<LiveExample/>',
+      description: 'markdown with templates and an inlined code block',
+      input: '```tsx\nimport React from \'react\';\nexport const App = () => <Card>Content</Card>;\n```\n<LiveExample src="Ex" />',
       expected: true
     },
     {
-      description: 'text without LiveExample tag',
-      input: '<div>Regular HTML component</div>',
+      description: 'markdown with templates and minimum number of words',
+      input: `${'word '.repeat(105)}\n\n<LiveExample src="Ex" />`,
+      expected: true
+    },
+    {
+      description: 'aggregator stub with templates but no paragraphs, words < 100, and no inlined code',
+      input: "import Ex1 from './Ex1?raw';\nimport Ex2 from './Ex2?raw';\n<LiveExample src=\"1\" />\n<LiveExample src=\"2\" />",
       expected: false
     },
     {
-      description: 'extended component name without word boundary match',
-      input: '<LiveExampleExtended />',
+      description: 'substantial document without template units',
+      input: "This is paragraph one explaining how to configure the component in depth.\n\nThis is paragraph two explaining proper event handling and keyboard navigation.\n\n```tsx\nimport React from 'react';\nexport const App = () => <Card>Content</Card>;\n```",
       expected: false
     },
     {
-      description: 'empty string',
-      input: '',
+      description: 'non-markdown content type',
+      input: '{"paragraphs": 5, "template": "<LiveExample />"}',
       expected: false
     }
-  ])('should detect LiveExample tags, $description', ({ input, expected }) => {
-    expect(hasLiveExample(input)).toBe(expected);
+  ])('should determine if content is a substantial guide, $description', ({ input, expected }) => {
+    expect(isSubstantialGuide(input)).toBe(expected);
   });
 });
 
@@ -152,6 +246,31 @@ describe('getLiveExampleCount', () => {
       description: 'empty string',
       input: '',
       expected: 0
+    },
+    {
+      description: 'opening LiveExample tag with attributes',
+      input: '<LiveExample id="example-1">',
+      expected: 1
+    },
+    {
+      description: 'LiveExample tag with multiline attributes',
+      input: '<LiveExample\n  src="./Demo.tsx"\n/>',
+      expected: 1
+    },
+    {
+      description: 'LiveExample tag without attributes',
+      input: '<LiveExample/>',
+      expected: 1
+    },
+    {
+      description: 'text without LiveExample tag',
+      input: '<div>Regular HTML component</div>',
+      expected: 0
+    },
+    {
+      description: 'extended component name without word boundary match',
+      input: '<LiveExampleExtended />',
+      expected: 0
     }
   ])('should count LiveExample occurrences, $description', ({ input, expected }) => {
     expect(getLiveExampleCount(input)).toBe(expected);
@@ -335,6 +454,57 @@ describe('calculateContentQualityScore', () => {
   ])('should calculate quality score, $description', ({ content, options, expected }: any) => {
     expect(calculateContentQualityScore(content, options)).toBe(expected);
   });
+
+  it.each([
+    {
+      description: 'multiple paragraphs multiple live examples',
+      content: [
+        'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+        '\n',
+        'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+        '\n',
+        '<LiveExample src="./first.tsx" />',
+        '<LiveExample src="./second.tsx" />'
+      ].join('\n'),
+      expected: 0.94
+    },
+    {
+      description: 'single paragraph',
+      content: [
+        'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+        '\n',
+        '<LiveExample src="./first.tsx" />',
+        '<LiveExample src="./second.tsx" />'
+      ].join('\n'),
+      expected: 0.94
+    },
+    {
+      description: 'no paragraphs',
+      content: [
+        'Lorem ipsum dolor sit amet.',
+        '<LiveExample src="./first.tsx" />',
+        '<LiveExample src="./second.tsx" />'
+      ].join('\n'),
+      expected: 0.91
+    },
+    {
+      description: 'no paragraphs single example',
+      content: [
+        'Lorem ipsum dolor sit amet.',
+        '<LiveExample src="./first.tsx" />'
+      ].join('\n'),
+      expected: 0.91
+    },
+    {
+      description: 'single example',
+      content: [
+        '<LiveExample src="./first.tsx" />'
+      ].join('\n'),
+      expected: 0.91
+    }
+  ])('should cap "LiveExample" penalities for wordy documents, $description', ({ content, expected }) => {
+    expect(calculateContentQualityScore(content)).toBe(expected);
+  });
 });
 
 describe('normalizeSlug', () => {
@@ -662,7 +832,7 @@ describe('getApiFallbackDescription', () => {
       description: 'examples category',
       displayName: 'Button',
       category: 'examples',
-      expected: 'PatternFly Button examples and demos.'
+      expected: 'PatternFly examples and demos for Button.'
     },
     {
       description: 'doc category',
@@ -680,7 +850,7 @@ describe('getApiFallbackDescription', () => {
       description: 'default arguments without parameters',
       displayName: undefined,
       category: undefined,
-      expected: 'PatternFly documentation and guidelines for .'
+      expected: 'PatternFly documentation and guidelines.'
     }
   ])('should provide fallback description, $description', ({ displayName, category, expected }: any) => {
     expect(getApiFallbackDescription(displayName, category)).toBe(expected);
@@ -705,7 +875,7 @@ describe('extractApiDescription', () => {
       description: 'detailType equals examples returns fallback',
       content: '# Title\nValid paragraph line exceeding twenty characters in length.',
       context: { displayName: 'Button', detailType: 'examples' },
-      expected: 'PatternFly Button examples and demos.'
+      expected: 'PatternFly examples and demos for Button.'
     },
     {
       description: 'markdown content uses first valid paragraph',
@@ -749,6 +919,24 @@ describe('extractApiDescription', () => {
       context: { displayName: 'Card', category: 'doc' },
       expected: 'PatternFly documentation and guidelines for Card.'
     },
+    {
+      description: 'content with purposeful script injections',
+      content: "import React from 'react';\n# Heading\nShort line <<script>script>console.warn('lorem ipsum')</script>",
+      context: { displayName: 'Card', category: 'doc' },
+      expected: 'PatternFly documentation and guidelines for Card.'
+    },
+    {
+      description: 'content with purposeful nested script injections',
+      content: "import React from 'react';\n# Heading\nShort line <scr<script>ipt> console.warn('lorem ipsum')",
+      context: { displayName: 'Card', category: 'doc' },
+      expected: 'PatternFly documentation and guidelines for Card.'
+    },
+    {
+      description: 'content with purposeful unclosed script injections',
+      content: "import React from 'react';\n# Heading\nShort line <script console.warn('lorem ipsum')",
+      context: { displayName: 'Card', category: 'doc' },
+      expected: 'PatternFly documentation and guidelines for Card.'
+    },
     {
       description: 'undefined content uses fallback',
       content: undefined,
@@ -759,13 +947,13 @@ describe('extractApiDescription', () => {
       description: 'undefined content and undefined context returns fallback',
       content: undefined,
       context: undefined,
-      expected: 'PatternFly documentation and guidelines for .'
+      expected: 'PatternFly documentation and guidelines.'
     },
     {
       description: 'null context explicitly passed returns fallback',
       content: undefined,
       context: null as any,
-      expected: 'PatternFly documentation and guidelines for .'
+      expected: 'PatternFly documentation and guidelines.'
     }
   ])('should extract API description, $description', ({ content, context, expected }: any) => {
     expect(extractApiDescription(content, context)).toBe(expected);
diff --git a/src/__tests__/resource.helpers.test.ts b/src/__tests__/resource.helpers.test.ts
index 3e0e77ff..9bdd0497 100644
--- a/src/__tests__/resource.helpers.test.ts
+++ b/src/__tests__/resource.helpers.test.ts
@@ -1,6 +1,8 @@
 import {
+  breakdownProse,
   contentType,
   formatContentForMarkdown,
+  getInlinedCodeBlockCount,
   isCssLike,
   isJavaLike,
   isJsLike,
@@ -29,6 +31,97 @@ jest.mock('../patternFly.helpers', () => ({
 const MockFilter = filterPatternFly.memo as jest.MockedFunction<typeof filterPatternFly.memo>;
 const MockNormalizeVersion = normalizeEnumeratedPatternFlyVersion.memo as jest.MockedFunction<typeof normalizeEnumeratedPatternFlyVersion.memo>;
 
+describe('getInlinedCodeBlockCount', () => {
+  it.each([
+    {
+      description: 'markdown without code blocks',
+      input: 'Just regular markdown prose text.',
+      expected: 0
+    },
+    {
+      description: 'code block meeting default minBlockLength threshold (>=20)',
+      input: '```tsx\nimport React from "react";\nexport const App = () => <div />;\n```',
+      expected: 1
+    },
+    {
+      description: 'code block below minBlockLength threshold',
+      input: '```js\nconst a = 1;\n```',
+      expected: 0
+    },
+    {
+      description: 'code block with custom minBlockLength threshold',
+      input: '```js\nconst a = 1;\n```',
+      minBlockLength: 5,
+      expected: 1
+    },
+    {
+      description: 'ignored code block starting with file= external reference',
+      input: '```tsx\nfile="./examples/ButtonBasic.tsx"\n```',
+      expected: 0
+    },
+    {
+      description: 'multiple code blocks mixed inline and file= references',
+      input: '```tsx\nfile="./examples/ButtonBasic.tsx"\n```\n\n```tsx\nimport React from "react";\nexport const Comp = () => <Button>Click</Button>;\n```\n\n```html\n<button class="pf-v6-c-button pf-m-primary">Click</button>\n```',
+      expected: 2
+    },
+    {
+      description: 'empty code block',
+      input: '```ts\n\n```',
+      expected: 0
+    }
+  ])('should count inlined code blocks, $description', ({ input, minBlockLength, expected }) => {
+    expect(getInlinedCodeBlockCount(input, minBlockLength)).toBe(expected);
+  });
+});
+
+describe('breakdownProse', () => {
+  it.each([
+    {
+      description: 'non-markdown returns zero paragraph, word counts',
+      input: '{"key": "value", "items": [1, 2, 3]}',
+      expected: {
+        type: 'json',
+        paragraphs: 0,
+        wordCount: 0
+      }
+    },
+    {
+      description: 'typescript returns zero paragraph, word counts',
+      input: 'import React from "react";\nexport const Button = () => {\n  return <button>Click</button>;\n};',
+      expected: {
+        type: 'javascript',
+        paragraphs: 0,
+        wordCount: 0
+      }
+    },
+    {
+      description: 'multi-paragraph markdown',
+      input: 'This is the first paragraph describing the component and its general capabilities.\n\nThis is the second paragraph providing accessibility notes and usage recommendations.',
+      expected: {
+        type: '',
+        paragraphs: 2,
+        wordCount: 23
+      }
+    },
+    {
+      description: 'markdown stripped code blocks, JSX tags, and imports',
+      input: "import Button from './Button';\n\n# Button Component\n\nButtons allow users to perform actions and choose options with a single tap.\n\n<LiveExample src=\"ButtonBasic\" />\n\n```tsx\nconst App = () => <Button>Submit</Button>;\n```\n\nAlways use descriptive labels so users know what action will be performed.",
+      expected: {
+        type: 'markdown',
+        paragraphs: 2,
+        wordCount: 28
+      }
+    }
+  ])('should breakdown prose content, $description', ({ input, expected }) => {
+    const result = breakdownProse(input);
+
+    expect(result.type).toBe(expected.type);
+    expect(result.paragraphs).toBe(expected.paragraphs);
+    expect(result.wordCount).toBe(expected.wordCount);
+    expect(result.content).toBe(input);
+  });
+});
+
 describe('isCssLike', () => {
   it.each([
     {
diff --git a/src/collection.patternFlyApi.ts b/src/collection.patternFlyApi.ts
index fb194209..a2b279ea 100644
--- a/src/collection.patternFlyApi.ts
+++ b/src/collection.patternFlyApi.ts
@@ -66,11 +66,13 @@ interface ApiContent {
  * @property content - Content retrieved from the API.
  * @property path - Initial or relative path used to fetch the content.
  * @property resolvedPath - Absolute or resolved path after processing the initial path.
+ * @property qualityScore - Content quality score.
  */
 interface ApiCrawler {
   content: string;
   path: string;
   resolvedPath: string;
+  qualityScore: number;
 }
 
 /**
@@ -85,10 +87,12 @@ type ParsePayloadApi = string | number | boolean | null | string[] | Record<stri
  *
  * @property isEmpty - Whether the parsed payload is considered empty.
  * @property {ParsePayloadApi} payload - Parsed version of the input payload.
+ * @property qualityScore - Content quality score.
  */
 interface ParsePayload {
   isEmpty: boolean;
   payload: ParsePayloadApi;
+  qualityScore: number;
 }
 
 /**
@@ -140,6 +144,7 @@ const parsePayload = (payload: unknown): ParsePayload => {
     updatedPayload = payload;
   }
 
+  const qualityScore = calculateContentQualityScore(updatedPayload);
   let isEmpty: boolean;
   let parsedPayload: ParsePayloadApi;
 
@@ -158,7 +163,7 @@ const parsePayload = (payload: unknown): ParsePayload => {
     isEmpty = updatedPayload.length === 0;
   }
 
-  return { isEmpty, payload: parsedPayload };
+  return { isEmpty, payload: parsedPayload, qualityScore };
 };
 
 /**
@@ -243,13 +248,13 @@ const crawler = async (
       continue;
     }
 
-    const { isEmpty, payload } = parsePayload.memo(res.content);
+    const { isEmpty, payload, qualityScore } = parsePayload.memo(res.content);
 
     if (Array.isArray(payload)) {
       // Terminal Data Arrays (props, css, etc)
       if (componentPaths.some(componentPath => res?.path?.endsWith(`/${componentPath}`))) {
         if (!isEmpty) {
-          content.push({ ...res });
+          content.push({ ...res, qualityScore });
         }
         continue;
       }
@@ -285,7 +290,7 @@ const crawler = async (
 
     // String Payloads (Markdown, HTML, .tsx source code)
     if (!isEmpty) {
-      content.push({ ...res });
+      content.push({ ...res, qualityScore });
     }
 
     // Probe Traversal Paths on Facet Endpoints (e.g. /react -> /react/examples)
@@ -389,7 +394,7 @@ const apiSpider = async (options = getOptions()): Promise<ApiCrawler[]> => {
  * @returns The process metadata entry.
  */
 const contentMetadata = (crawlerResponse: ApiCrawler, options = getOptions()): ApiContent => {
-  const { content, resolvedPath } = crawlerResponse;
+  const { content, resolvedPath, qualityScore } = crawlerResponse;
   const { base } = options.patternflyOptions.api;
 
   // Relative path after '/api/'
@@ -424,7 +429,7 @@ const contentMetadata = (crawlerResponse: ApiCrawler, options = getOptions()): A
   const displayName = extractApiDisplayName(content, { slug: normalizedItem, category: normalizedCategory, section: normalizedSection });
   const description = extractApiDescription(content, { displayName, category: normalizedCategory, detailType: normalizedDetailType });
 
-  const isLowQuality = calculateContentQualityScore(content, { category: normalizedCategory }) < MIN_API_QUALITY_THRESHOLD;
+  const isLowQuality = qualityScore < MIN_API_QUALITY_THRESHOLD;
   const isDeferred = DEFERRED_API_CATEGORIES.has(normalizedCategory);
 
   return {
diff --git a/src/collection.patternFlyApiHelpers.ts b/src/collection.patternFlyApiHelpers.ts
index 53052cb3..51c5aeef 100644
--- a/src/collection.patternFlyApiHelpers.ts
+++ b/src/collection.patternFlyApiHelpers.ts
@@ -1,4 +1,10 @@
-import { isJson, isJsonLike } from './resource.helpers';
+import {
+  breakdownProse,
+  contentType,
+  getInlinedCodeBlockCount,
+  isJson,
+  isJsonLike
+} from './resource.helpers';
 
 /**
  * Detect imports that use the `?raw` query param.
@@ -9,11 +15,13 @@ const isRawImport = (str: string) =>
   /import\s+[\w*\s{},]+\s+from\s+['"][^'"]+\?raw['"]/i.test(str);
 
 /**
- * Detect a `<LiveExample … />` tag.
+ * Count the number of raw imports in a given string.
  *
- * @param str
+ * @param str - Input string.
+ * @returns Number of raw imports found in the input string.
  */
-const hasLiveExample = (str: string) => /<LiveExample\b[^>]*\/?>/i.test(str);
+const getRawImportCount = (str: string): number =>
+  (str.match(/import\s+[\w*\s{},]+\s+from\s+['"][^'"]+\?raw['"]/gi) || []).length;
 
 /**
  * Count the number of `<LiveExample>` tags in a given string.
@@ -39,6 +47,79 @@ const hasEmptyFileCodeFence = (str: string) =>
   /```[\w-]*\s+file="[^"]+"\s*\n\s*```/i.test(str) ||
   /```[\w-]*\s*\n\s*```/.test(str);
 
+/**
+ * Calculate template example counts.
+ *
+ * - When `?raw` import and `<LiveExample>` are paired (1:1), count as 1 unit.
+ * - When `?raw` import and `<LiveExample>` appear without the other (orphaned/unpaired), each adds 1 independently to the count.
+ *
+ * @param content - Input content.
+ * @returns Total effective template reference count.
+ */
+const getTemplateCount = (content: string): { pairedCount: number; orphanCount: number; totalUnits: number } => {
+  const liveCount = getLiveExampleCount(content);
+  const rawCount = getRawImportCount(content);
+
+  const pairedCount = Math.min(liveCount, rawCount);
+  const orphanCount = Math.abs(liveCount - rawCount);
+  const totalUnits = pairedCount + orphanCount; // Equivalent to Math.max(liveCount, rawCount)
+
+  return { pairedCount, orphanCount, totalUnits };
+};
+
+/**
+ * Is the content a content aggregator?
+ *
+ * @param content - Content to eval.
+ * @returns Returns `true` if the content aggregates other content.
+ */
+const isContentAggregator = (content: string): boolean => {
+  const type = contentType(content);
+
+  if (type !== '' && type !== 'markdown' && type !== 'html') {
+    return false;
+  }
+
+  const { totalUnits } = getTemplateCount(content);
+  const inlinedCodeCount = getInlinedCodeBlockCount(content);
+
+  // Check: Multiple external example tags without inlined blocks
+  if (totalUnits >= 2 && inlinedCodeCount === 0) {
+    return true;
+  }
+
+  // Check: High template density
+  if (totalUnits > inlinedCodeCount * 2 && totalUnits >= 3) {
+    return true;
+  }
+
+  // Check: Template tags present without paragraphs
+  const { paragraphs } = breakdownProse(content);
+
+  return totalUnits >= 1 && paragraphs < 2 && inlinedCodeCount === 0;
+};
+
+/**
+ * Determine if the content has anything to offer, weight.
+ *
+ * Counts:
+ * - if the content type must be empty or 'markdown'
+ * - if the content contains at least 2 paragraphs, or has a word count of at
+ *     least 100, or has at least one inline code block
+ * - if the live example, template count, is greater than zero
+ *
+ * @param content - Content to eval
+ * @returns `true` has weight.
+ */
+const isSubstantialGuide = (content: string) => {
+  const { totalUnits } = getTemplateCount(content);
+  const inlinedCount = getInlinedCodeBlockCount(content);
+  const { type, paragraphs, wordCount } = breakdownProse(content);
+  const hasSubstance = paragraphs >= 2 || wordCount >= 100 || inlinedCount >= 1;
+
+  return (type === '' || type === 'markdown') && hasSubstance && totalUnits > 0;
+};
+
 /**
  * Calculate a quality score for a PatternFly API response.
  *
@@ -53,7 +134,7 @@ const hasEmptyFileCodeFence = (str: string) =>
 const calculateContentQualityScore = (
   content: unknown,
   {
-    baseScore = 1, category, qualityReduction = 0.03, minCharacters = 150
+    baseScore = 1, category, qualityReduction = 0.03, minCharacters = 100
   }: { baseScore?: number; category?: undefined | string; qualityReduction?: number; minCharacters?: number } = {}
 ): number => {
   if (content === undefined || content === null) {
@@ -78,20 +159,21 @@ const calculateContentQualityScore = (
 
   let score = baseScore;
 
-  if (isJsonLike(trimmed)) {
-    const jsonValid = isJson(trimmed);
-
-    if (!jsonValid) {
-      score -= qualityReduction;
-    }
-  }
-
-  if (isRawImport(trimmed)) {
+  if (isJsonLike(trimmed) && !isJson(trimmed)) {
     score -= qualityReduction;
   }
 
-  if (hasLiveExample(trimmed)) {
-    score -= qualityReduction * getLiveExampleCount(trimmed);
+  const { totalUnits } = getTemplateCount(trimmed);
+
+  if (isContentAggregator(trimmed)) {
+    // Aggregator overview pages take linear deductions, falling below 0.95
+    score -= qualityReduction * Math.max(2, totalUnits);
+  } else if (isSubstantialGuide(trimmed)) {
+    // Developer guides, cap isolated demo tag/raw imports
+    score -= qualityReduction;
+  } else {
+    // Non-guide stubs
+    score -= qualityReduction * totalUnits;
   }
 
   if (trimmed.length < minCharacters && !trimmed.includes('```') && !hasEmptyFileCodeFence(trimmed)) {
@@ -231,31 +313,41 @@ const extractApiDisplayName = (content?: string, context: { slug?: string; categ
  * Provide a fallback description based on kind/category when no prose is available.
  *
  * @param displayName - Display name
- * @param category - Category / facet kind
+ * @param [category] - Category / facet kind
  */
-const getApiFallbackDescription = (displayName = '', category = 'doc'): string => {
+const getApiFallbackDescription = (displayName: string, category?: string): string => {
+  const trimmed = typeof displayName === 'string' ? displayName.trim() : '';
+  const updatedDisplayName = trimmed ? ` for ${trimmed}` : '';
+
   switch (category) {
     case 'props':
-      return `PatternFly React component props and TypeScript interfaces for ${displayName}.`;
+      return `PatternFly React component props and TypeScript interfaces${updatedDisplayName}.`;
     case 'css':
       return `PatternFly ${
-        displayName.toLowerCase().includes('css') ? '' : 'CSS '}variables and tokens for ${displayName}.`;
+        displayName.toLowerCase().includes('css') ? '' : 'CSS '}variables and tokens${updatedDisplayName}.`;
     case 'html':
     case 'html-demos':
-      return `PatternFly HTML examples and markup structure for ${displayName}.`;
+      return `PatternFly HTML examples and markup structure${updatedDisplayName}.`;
     case 'react':
     case 'react-demos':
-      return `PatternFly React component examples and demos for ${displayName}.`;
+      return `PatternFly React component examples and demos${updatedDisplayName}.`;
     case 'examples':
-      return `PatternFly ${displayName} examples and demos.`;
+      return `PatternFly examples and demos${updatedDisplayName}.`;
     default:
-      return `PatternFly documentation and guidelines for ${displayName}.`;
+      return `PatternFly documentation and guidelines${updatedDisplayName}.`;
   }
 };
 
 /**
  * Generate a description from metadata.
  *
+ * @note CodeQL false positive: Prose cleanup for plain-text LLM descriptions,
+ * not DOM XSS sanitization.
+ *
+ * @note This is NOT an HTML sanitizer for browser DOM rendering and is bound
+ * to trigger false positives in code evaluations. This produces concise plain-text
+ * descriptions.
+ *
  * @param [content] - Optional content.
  * @param [context] - Optional context for generating a unique description.
  * @param [context.displayName] - Display name.
@@ -288,29 +380,35 @@ const extractApiDescription = (
     const lines = cleanContent
       .split('\n')
       .map(line => line.trim())
-      .filter(line =>
-        line &&
-        !line.startsWith('import ') &&
-        !line.startsWith('#') &&
-        !line.startsWith('---') &&
-        !line.startsWith('![') &&
-        !line.startsWith('<') &&
-        !line.startsWith('```') &&
-        !line.startsWith('export ') &&
-        !line.startsWith('|') &&
-        !line.startsWith('class=') &&
-        !line.startsWith('className=') &&
-        !line.startsWith('style=') &&
-        !line.startsWith('d="') &&
-        !line.startsWith('viewBox=') &&
-        !/^[A-Za-z]+="(.*)"/.test(line) &&
-        !/^(ts|tsx|js|jsx|html)\s+/i.test(line) &&
-        !line.includes('file="./') &&
-        !line.startsWith('["') &&
-        !line.endsWith(',') &&
-        !/^[A-Za-z0-9]+\./.test(line) &&
-        !/^[A-Z][A-Za-z0-9]+,$/.test(line) &&
-        line.length > 20);
+      .filter(line => {
+        const updatedLine = line.toLowerCase();
+
+        return updatedLine &&
+          !updatedLine.startsWith('import ') &&
+          !updatedLine.startsWith('#') &&
+          !updatedLine.startsWith('---') &&
+          !updatedLine.startsWith('![') &&
+          !updatedLine.startsWith('<') &&
+          !updatedLine.startsWith('```') &&
+          !updatedLine.startsWith('export ') &&
+          !updatedLine.startsWith('|') &&
+          !updatedLine.startsWith('class=') &&
+          !updatedLine.startsWith('className=') &&
+          !updatedLine.startsWith('style=') &&
+          !updatedLine.startsWith('d="') &&
+          !updatedLine.startsWith('viewBox=') &&
+          !/^[A-Za-z]+="(.*)"/.test(updatedLine) &&
+          !/^(ts|tsx|js|jsx|html)\s+/i.test(updatedLine) &&
+          !updatedLine.includes('require(') &&
+          !updatedLine.includes('file="./') &&
+          !updatedLine.startsWith('["') &&
+          !updatedLine.endsWith(',') &&
+          !/^[A-Za-z0-9]+\./.test(updatedLine) &&
+          !/^[A-Z][A-Za-z0-9]+,$/.test(updatedLine) &&
+          !updatedLine.includes('<script') &&
+          !updatedLine.includes('&lt;script') &&
+          updatedLine.length > 20;
+      });
 
     // Finally, does the copy exist?
     if (lines.length > 0 && lines[0]) {
@@ -318,11 +416,11 @@ const extractApiDescription = (
         // Convert HTML links to their inner text
         .replace(/<a\b[^>]*>(.*?)<\/a>/gi, '$1')
         // Remove closing HTML tags
-        .replace(/<\/[A-Za-z0-9_-]+>/g, '')
+        .replace(/<\/[a-z0-9_-]+>/gi, '')
         // Convert bare tags
-        .replace(/<([A-Za-z0-9_\s-]+)>/g, '$1')
+        .replace(/<([a-z0-9_\s-]+)>/gi, '`$1`')
         // Remove remaining complex HTML tags with attributes
-        .replace(/<[A-Za-z0-9_-]+\b[^>]*\/?>/g, '')
+        .replace(/<[a-z0-9_-]+\b[^>]*\/?>/gi, '')
         // Replace Markdown inline images: `![alt](url) -> alt`
         .replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
         // Replace Markdown links: `[text](url) -> text`
@@ -380,10 +478,13 @@ export {
   extractApiDisplayName,
   extractApiName,
   formatSlugToTitle,
+  isContentAggregator,
+  isSubstantialGuide,
   getApiFallbackDescription,
   getLiveExampleCount,
+  getRawImportCount,
+  getTemplateCount,
   hasEmptyFileCodeFence,
-  hasLiveExample,
   isRawImport,
   normalizeSlug
 };
diff --git a/src/resource.helpers.ts b/src/resource.helpers.ts
index 67f2ddff..defa1e37 100644
--- a/src/resource.helpers.ts
+++ b/src/resource.helpers.ts
@@ -2,6 +2,23 @@ import { filterPatternFly, type FilterPatternFlyFilters } from './patternFly.sea
 import { normalizeEnumeratedPatternFlyVersion } from './patternFly.helpers';
 import { isPlainObject } from './server.helpers';
 
+/**
+ * Count the number of inlined code blocks in a given string.
+ *
+ * @param str - Input string.
+ * @param minBlockLength - Minimum length of code block content to consider it valid.
+ * @returns Number of inlined code blocks found in the input string.
+ */
+const getInlinedCodeBlockCount = (str: string, minBlockLength = 20): number => {
+  const codeBlocks = str.match(/```[a-zA-Z0-9_-]*\n([\s\S]*?)```/g) || [];
+
+  return codeBlocks.filter(block => {
+    const inner = block.replace(/^```[^\n]*\n/, '').replace(/```$/, '').trim();
+
+    return inner.length >= minBlockLength && !inner.startsWith('file=');
+  }).length;
+};
+
 /**
  * Is content CSS-like?
  *
@@ -406,6 +423,46 @@ const contentType = (content: unknown): '' | 'sh' | 'python' | 'markdown' | 'jav
   return updatedLanguage;
 };
 
+/**
+ * Break down prose content for quality evaluation.
+ *
+ * @note This function is intended to only evaluate prose content, not code.
+ * The internal content guard will return empty counts if the content is not
+ * prose.
+ *
+ * @param content - The content to be broken down.
+ * @returns An object containing the content type, original content, paragraphs, and word count of the content.
+ */
+const breakdownProse = (content: string): { type: string; content: string; paragraphs: number; wordCount: number } => {
+  const type = contentType(content);
+
+  if (type !== '' && type !== 'markdown') {
+    return {
+      type,
+      content,
+      paragraphs: 0,
+      wordCount: 0
+    };
+  }
+
+  const cleaned = content
+    .replace(/```[\s\S]*?```/g, '') // Remove fenced blocks (```...```)
+    .replace(/<[^>]+>/g, '') // Remove inline HTML/JSX
+    .replace(/^\s*(import|export)\s+.*?;?\s*$/gm, '') // Remove import / export statements
+    .trim();
+
+  // Split paragraphs, use min-length
+  const paragraphs = cleaned.split(/\n\s*\n/).filter(paragraph => paragraph.trim().length > 30);
+  const words = cleaned.split(/\s+/).filter(Boolean);
+
+  return {
+    type,
+    content,
+    paragraphs: paragraphs.length,
+    wordCount: words.length
+  };
+};
+
 /**
  * Format content as a code block for Markdown rendering.
  *
@@ -487,8 +544,10 @@ const paramCompletion = async (filters: FilterPatternFlyFilters) => {
 };
 
 export {
+  breakdownProse,
   contentType,
   formatContentForMarkdown,
+  getInlinedCodeBlockCount,
   isJavaLike,
   isJsLike,
   isJson,