diff --git a/CLAUDE.md b/CLAUDE.md
index a6a77ea..45d4d08 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -127,13 +127,15 @@ npm run prettier:write
 3. Generator reads YAML configs and Jinja2 templates
 4. Transforms content through markdown pipeline
 5. Outputs MDX files and JSON configs
-6. Generates `public/llms.txt` with all AEP contents for LLM consumption
-7. Astro builds static site from generated content
+6. Generates `public/llms.txt` with AEP summaries and rules for LLM consumption
+7. Generates per-AEP `public/{id}/llms.txt` files with full Markdown content
+8. Astro builds static site from generated content
 
 ## Generated Files
 
 - `src/content/docs/` - Site content (MDX files)
 - `src/content/docs/aep-2026/` - AEP Edition 2026 content (MDX files, if `AEP_EDITION_2026` is set)
 - `generated/` - JSON configuration files (sidebar, redirects, etc.)
-- `public/llms.txt` - Consolidated AEP content for LLM training/reference
+- `public/llms.txt` - Site-wide AEP summaries and rules for LLM consumption
+- `public/{id}/llms.txt` - Per-AEP full Markdown content for LLM consumption
 - `public/json-schema/` - JSON schemas from components repo
diff --git a/scripts/generate.ts b/scripts/generate.ts
index 70de2b5..c806f40 100644
--- a/scripts/generate.ts
+++ b/scripts/generate.ts
@@ -274,30 +274,159 @@ function buildRedirects(aeps: AEP[]): object {
   return Object.fromEntries(aeps.map((aep) => [`/${aep.slug}`, `/${aep.id}`]));
 }
 
+/**
+ * Cleans transformed MDX/JSX content back into plain Markdown
+ * suitable for LLM consumption.
+ */
+export function cleanContentForLLMs(content: string): string {
+  let cleaned = content;
+
+  // Remove import statements
+  cleaned = cleaned.replace(/import\s+.*from\s+['"].*['"];?\n?/g, "");
+
+  // Replace <b class="...">keyword</b> with **keyword** (restore rule identifiers)
+  cleaned = cleaned.replace(/<b class="[^"]*">(.*?)<\/b>/g, "**$1**");
+
+  // Replace <AepLink href="...">text</AepLink> with [text](href)
+  cleaned = cleaned.replace(
+    /<AepLink href="([^"]*)">(.*?)<\/AepLink>/g,
+    "[$2]($1)",
+  );
+  cleaned = cleaned.replace(/<AepLink>(.*?)<\/AepLink>/g, "$1");
+
+  // Replace <Aside> with markdown callout format
+  cleaned = cleaned.replace(
+    /<Aside[^>]*title="([^"]*)"[^>]*>\n?([\s\S]*?)\n?<\/Aside>/g,
+    (match, title, body) =>
+      `**${title}:** ${body
+        .split("\n")
+        .map((l: string) => l.trim())
+        .join("\n")}`,
+  );
+
+  // Handle Tabs/TabItem - convert to markdown sections
+  cleaned = cleaned.replace(/<Tabs[^>]*>\s*/g, "");
+  cleaned = cleaned.replace(/<\/Tabs>\s*/g, "");
+  cleaned = cleaned.replace(/<TabItem label="([^"]*)">\s*/g, "#### $1\n");
+  cleaned = cleaned.replace(/<\/TabItem>\s*/g, "");
+
+  // Remove <Sample> tags
+  cleaned = cleaned.replace(/<Sample[^>]*\/>/g, "");
+
+  // Remove remaining uppercase component tags (JSX)
+  cleaned = cleaned.replace(
+    /<[A-Z][^>]*\/?>[\s\S]*?<\/[A-Z][^>]*>|<[A-Z][^>]*\/>/gs,
+    "",
+  );
+
+  // Remove JSX comments
+  cleaned = cleaned.replace(/\{\/\*[\s\S]*?\*\/\}/g, "");
+
+  // Remove HTML comments
+  cleaned = cleaned.replace(/<!--[\s\S]*?-->/g, "");
+
+  // Unescape comparison operators
+  cleaned = cleaned.replace(/\\<=/g, "<=");
+  cleaned = cleaned.replace(/\\>=/g, ">=");
+
+  // Clean up excessive blank lines
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+
+  return cleaned.trim();
+}
+
+/**
+ * Extracts the first paragraph from cleaned markdown content.
+ * Skips headings and blank lines, returns the first block of text.
+ */
+export function getFirstParagraph(content: string): string {
+  const paragraphs = content.split(/\n\n+/);
+  for (const para of paragraphs) {
+    const trimmed = para.trim();
+    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("---")) {
+      // Collapse to single line for summary use
+      return trimmed.replace(/\n/g, " ");
+    }
+  }
+  return "";
+}
+
+/**
+ * Extracts lines containing should/must/may rule keywords from cleaned content.
+ */
+export function extractRules(content: string): string[] {
+  const rules: string[] = [];
+  const lines = content.split("\n");
+  const ruleKeywords = /\*\*(must|must not|should|should not|may|may not)\*\*/i;
+
+  for (const line of lines) {
+    if (ruleKeywords.test(line)) {
+      let trimmed = line.trim();
+      if (trimmed) {
+        // Normalize bullet points
+        if (!trimmed.startsWith("-")) {
+          trimmed = `- ${trimmed}`;
+        }
+        rules.push(trimmed);
+      }
+    }
+  }
+
+  // Deduplicate
+  return [...new Set(rules)];
+}
+
+/**
+ * Builds a per-AEP llms.txt file with the full cleaned markdown content.
+ */
+export function buildPerAEPLLMsTxt(aep: AEP): string {
+  const cleaned = cleanContentForLLMs(aep.contents.contents);
+  return `# AEP-${aep.id}: ${aep.title}\n\n${cleaned}`;
+}
+
+/**
+ * Builds the site-wide llms.txt with a short description of each AEP
+ * and all should/must/may rules.
+ */
 export function buildLLMsTxt(aeps: AEP[]): string {
   // Sort AEPs by ID for consistent ordering
   const sortedAEPs = aeps.sort((a, b) => parseInt(a.id) - parseInt(b.id));
 
-  const sections = sortedAEPs.map((aep) => {
-    // Get the raw markdown content without frontmatter and components
-    let content = aep.contents.contents;
-
-    // Remove any remaining component imports or JSX-style tags
-    content = content.replace(/import\s+.*from\s+['"].*['"];?\n?/g, "");
-    content = content.replace(
-      /<[A-Z][^>]*\/?>.*?<\/[A-Z][^>]*>|<[A-Z][^>]*\/>/gs,
-      "",
+  const lines: string[] = [];
+  lines.push("# AEP - API Enhancement Proposals");
+  lines.push("");
+  lines.push(
+    "> API Enhancement Proposals (AEPs) are design documents that provide high-quality, consistent guidance for API development.",
+  );
+  lines.push("");
+  lines.push("## AEPs");
+  lines.push("");
+
+  for (const aep of sortedAEPs) {
+    const cleaned = cleanContentForLLMs(aep.contents.contents);
+    const description = getFirstParagraph(cleaned);
+    lines.push(
+      `- [AEP-${aep.id}: ${aep.title}](/${aep.id}/llms.txt): ${description}`,
     );
+  }
 
-    // Clean up any remaining MDX artifacts
-    content = content.replace(/\{\/\*[\s\S]*?\*\/\}/g, ""); // Remove JSX comments
-    content = content.replace(/<!--[\s\S]*?-->/g, ""); // Remove HTML comments
-    content = content.trim();
-
-    return `# AEP-${aep.id} ${aep.title}\n\n${content}`;
-  });
+  lines.push("");
+  lines.push("## Rules");
+
+  for (const aep of sortedAEPs) {
+    const cleaned = cleanContentForLLMs(aep.contents.contents);
+    const rules = extractRules(cleaned);
+    if (rules.length > 0) {
+      lines.push("");
+      lines.push(`### AEP-${aep.id}: ${aep.title}`);
+      lines.push("");
+      for (const rule of rules) {
+        lines.push(rule);
+      }
+    }
+  }
 
-  return sections.join("\n\n---\n\n");
+  return lines.join("\n");
 }
 
 // Log folder detection status
@@ -333,7 +462,13 @@ if (AEP_LOC != "") {
 
   writeSidebar(buildRedirects(categorizedAEPs), "redirects.json");
 
-  // Generate llms.txt file with all AEP contents
+  // Generate per-AEP llms.txt files
+  for (const aep of categorizedAEPs) {
+    const perAEPContent = buildPerAEPLLMsTxt(aep);
+    writeFile(path.join("public", aep.id, "llms.txt"), perAEPContent);
+  }
+
+  // Generate site-wide llms.txt with summaries and rules
   const llmsTxtContent = buildLLMsTxt(categorizedAEPs);
   writeFile("public/llms.txt", llmsTxtContent);
 
diff --git a/test/sampleCode.test.ts b/test/sampleCode.test.ts
index c7ebc22..bb6d2ea 100644
--- a/test/sampleCode.test.ts
+++ b/test/sampleCode.test.ts
@@ -1,7 +1,13 @@
 import * as fs from "fs";
 import * as path from "path";
 import sampleCode from "../src/components/utils/sample";
-import { buildLLMsTxt } from "../scripts/generate";
+import {
+  buildLLMsTxt,
+  buildPerAEPLLMsTxt,
+  cleanContentForLLMs,
+  getFirstParagraph,
+  extractRules,
+} from "../scripts/generate";
 import { fileURLToPath } from "url";
 import { describe, it, expect } from "@jest/globals";
 
@@ -71,16 +77,163 @@ describe("sampleCode", () => {
   });
 });
 
+describe("cleanContentForLLMs", () => {
+  it("should remove import statements", () => {
+    const content =
+      'import { Sample } from "../../components/Sample.astro";\n\nSome content.';
+    const result = cleanContentForLLMs(content);
+    expect(result).not.toContain("import");
+    expect(result).toContain("Some content.");
+  });
+
+  it("should restore rule identifiers from JSX to markdown bold", () => {
+    const content =
+      'APIs <b class="font-extrabold text-red-700">must</b> include a name field.';
+    const result = cleanContentForLLMs(content);
+    expect(result).toContain("**must**");
+    expect(result).not.toContain("<b");
+  });
+
+  it("should convert AepLink components to markdown links", () => {
+    const content =
+      'See <AepLink href="/133">Standard Methods</AepLink> for details.';
+    const result = cleanContentForLLMs(content);
+    expect(result).toContain("[Standard Methods](/133)");
+    expect(result).not.toContain("<AepLink");
+  });
+
+  it("should remove Sample tags", () => {
+    const content =
+      'Some text.\n\n<Sample path="/foo" type="proto" token1="bar" token2="" />\n\nMore text.';
+    const result = cleanContentForLLMs(content);
+    expect(result).not.toContain("<Sample");
+    expect(result).toContain("Some text.");
+    expect(result).toContain("More text.");
+  });
+
+  it("should remove JSX and HTML comments", () => {
+    const content = "Before {/* JSX comment */} middle <!-- HTML --> after";
+    const result = cleanContentForLLMs(content);
+    expect(result).not.toContain("JSX comment");
+    expect(result).not.toContain("HTML");
+    expect(result).toContain("Before");
+    expect(result).toContain("after");
+  });
+
+  it("should unescape comparison operators", () => {
+    const content = "Values \\<= 10 and \\>= 5.";
+    const result = cleanContentForLLMs(content);
+    expect(result).toContain("<= 10");
+    expect(result).toContain(">= 5");
+  });
+});
+
+describe("getFirstParagraph", () => {
+  it("should return the first non-heading paragraph", () => {
+    const content =
+      "## Overview\n\nThis is the first paragraph.\n\nThis is the second.";
+    const result = getFirstParagraph(content);
+    expect(result).toBe("This is the first paragraph.");
+  });
+
+  it("should skip headings and separators", () => {
+    const content = "---\n\n## Title\n\nActual description here.\n\nMore text.";
+    const result = getFirstParagraph(content);
+    expect(result).toBe("Actual description here.");
+  });
+
+  it("should collapse multiline paragraphs to a single line", () => {
+    const content = "First line\ncontinued here.\n\nSecond paragraph.";
+    const result = getFirstParagraph(content);
+    expect(result).toBe("First line continued here.");
+  });
+
+  it("should return empty string for empty content", () => {
+    expect(getFirstParagraph("")).toBe("");
+    expect(getFirstParagraph("## Just a heading")).toBe("");
+  });
+});
+
+describe("extractRules", () => {
+  it("should extract lines with must/should/may keywords", () => {
+    const content =
+      "APIs **must** include a name field.\n\nResources **should** use standard methods.\n\nThis is a normal line.";
+    const rules = extractRules(content);
+    expect(rules).toHaveLength(2);
+    expect(rules[0]).toContain("**must**");
+    expect(rules[1]).toContain("**should**");
+  });
+
+  it("should handle must not, should not, may not", () => {
+    const content =
+      "APIs **must not** use reserved words.\nFields **should not** be optional.\nClients **may not** cache responses.";
+    const rules = extractRules(content);
+    expect(rules).toHaveLength(3);
+  });
+
+  it("should handle may keyword", () => {
+    const content = "Clients **may** include optional headers.";
+    const rules = extractRules(content);
+    expect(rules).toHaveLength(1);
+    expect(rules[0]).toContain("**may**");
+  });
+
+  it("should normalize non-bullet lines to bullet points", () => {
+    const content = "APIs **must** include a name.";
+    const rules = extractRules(content);
+    expect(rules[0].startsWith("- ")).toBe(true);
+  });
+
+  it("should preserve existing bullet points", () => {
+    const content = "- APIs **must** include a name.";
+    const rules = extractRules(content);
+    expect(rules[0]).toBe("- APIs **must** include a name.");
+  });
+
+  it("should deduplicate identical rules", () => {
+    const content =
+      "APIs **must** include a name.\nAPIs **must** include a name.";
+    const rules = extractRules(content);
+    expect(rules).toHaveLength(1);
+  });
+
+  it("should return empty array when no rules found", () => {
+    const content = "This is normal text without any rule keywords.";
+    const rules = extractRules(content);
+    expect(rules).toHaveLength(0);
+  });
+});
+
+describe("buildPerAEPLLMsTxt", () => {
+  it("should generate full cleaned content with title", () => {
+    const mockAep = {
+      id: "133",
+      title: "Standard Methods: Create",
+      contents: {
+        contents:
+          'import { Sample } from "../../components/Sample.astro";\n\nThis AEP defines create methods.\n\nAPIs <b class="font-extrabold text-red-700">must</b> use POST.',
+      },
+    };
+
+    const result = buildPerAEPLLMsTxt(mockAep);
+
+    expect(result.startsWith("# AEP-133: Standard Methods: Create")).toBe(true);
+    expect(result).toContain("This AEP defines create methods.");
+    expect(result).toContain("**must**");
+    expect(result).not.toContain("import");
+    expect(result).not.toContain("<b class");
+  });
+});
+
 describe("buildLLMsTxt", () => {
-  it("should generate correct llms.txt format", () => {
-    // Mock AEP data
+  it("should generate site-wide llms.txt with descriptions and rules", () => {
     const mockAeps = [
       {
         id: "140",
         title: "Field Behavior",
         contents: {
           contents:
-            "This AEP defines field behavior patterns.\n\n## Overview\n\nField behavior is important for APIs.",
+            'This AEP defines field behavior patterns.\n\n## Overview\n\nField behavior is important for APIs.\n\nAPIs <b class="font-extrabold text-red-700">must</b> annotate fields.',
         },
       },
       {
@@ -96,23 +249,26 @@ describe("buildLLMsTxt", () => {
         title: "Standard Methods: Create",
         contents: {
           contents:
-            'import { Sample } from "../../components/Sample.astro";\n\nThis AEP defines create methods.\n\n<Sample type="proto" /><!-- Comment -->\n\n{/* JSX comment */}',
+            'import { Sample } from "../../components/Sample.astro";\n\nThis AEP defines create methods.\n\n<Sample type="proto" /><!-- Comment -->\n\n{/* JSX comment */}\n\nCreate methods <b class="font-extrabold text-red-700">must</b> use POST.\n\nThe response <b class="font-extrabold text-yellow-700">should</b> include the resource.',
         },
       },
     ];
 
     const result = buildLLMsTxt(mockAeps);
 
-    // Verify AEPs are sorted by ID
+    // Verify header
+    expect(result).toContain("# AEP - API Enhancement Proposals");
+
+    // Verify AEPs are sorted by ID in the listing
     const lines = result.split("\n");
     const aep1Index = lines.findIndex((line) =>
-      line.includes("AEP-1 AEP Purpose"),
+      line.includes("AEP-1: AEP Purpose"),
     );
     const aep133Index = lines.findIndex((line) =>
-      line.includes("AEP-133 Standard Methods"),
+      line.includes("AEP-133: Standard Methods"),
     );
     const aep140Index = lines.findIndex((line) =>
-      line.includes("AEP-140 Field Behavior"),
+      line.includes("AEP-140: Field Behavior"),
     );
 
     expect(aep1Index).not.toBe(-1);
@@ -121,25 +277,30 @@ describe("buildLLMsTxt", () => {
     expect(aep1Index).toBeLessThan(aep133Index);
     expect(aep133Index).toBeLessThan(aep140Index);
 
-    // Verify section separators
-    expect(result).toContain("\n---\n");
-
     // Verify MDX artifacts are removed
     expect(result).not.toContain("import {");
     expect(result).not.toContain("<Sample");
     expect(result).not.toContain("{/* JSX comment */}");
-
-    // Verify HTML comments are removed
     expect(result).not.toContain("<!-- Comment -->");
 
-    // Verify proper heading format
-    expect(result).toContain("# AEP-1 AEP Purpose and Guidelines");
-    expect(result).toContain("# AEP-133 Standard Methods: Create");
-    expect(result).toContain("# AEP-140 Field Behavior");
+    // Verify descriptions are present (first paragraphs)
+    expect(result).toContain("This document describes the AEP process.");
+    expect(result).toContain("This AEP defines create methods.");
+    expect(result).toContain("This AEP defines field behavior patterns.");
+
+    // Verify links to per-AEP llms.txt
+    expect(result).toContain("/1/llms.txt");
+    expect(result).toContain("/133/llms.txt");
+    expect(result).toContain("/140/llms.txt");
+
+    // Verify rules section exists with extracted rules
+    expect(result).toContain("## Rules");
+    expect(result).toContain("**must** use POST");
+    expect(result).toContain("**should** include the resource");
+    expect(result).toContain("**must** annotate fields");
 
-    // Verify content is present
-    expect(result).toContain("This document describes the AEP process");
-    expect(result).toContain("Field behavior is important for APIs");
-    expect(result).toContain("This AEP defines create methods");
+    // Verify AEP-1 has no rules section (no rule keywords)
+    const rulesSection = result.substring(result.indexOf("## Rules"));
+    expect(rulesSection).not.toContain("### AEP-1:");
   });
 });