diff --git a/.gitignore b/.gitignore
index bc614fc0ec5..b00f6dd876a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,6 +71,7 @@ public/**/**/nextImageExportOptimizer/
 public/next-image-export-optimizer-hashes.json
 src/directory/directory.json
 src/directory/flatDirectory.json
+public/ai/
 src/references/raw-references.json
 .yarn/*
 
diff --git a/next-env.d.ts b/next-env.d.ts
index a4a7b3f5cfa..ddb76465e52 100644
--- a/next-env.d.ts
+++ b/next-env.d.ts
@@ -1,5 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+import "./client/www/next-build/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
-// see https://nextjs.org/docs/pages/building-your-application/configuring/typescript for more information.
+// see https://nextjs.org/docs/pages/api-reference/config/typescript for more information.
diff --git a/package.json b/package.json
index 5fbdba2acd3..92325bced47 100644
--- a/package.json
+++ b/package.json
@@ -122,7 +122,7 @@
     "next-start": "next start --webpack",
     "prepare": "husky install",
     "analyze": "ANALYZE=true yarn next-build",
-    "prebuild": "node src/directory/generateDirectory.mjs && node src/directory/generateFlatDirectory.mjs",
+    "prebuild": "node src/directory/generateDirectory.mjs && node src/directory/generateFlatDirectory.mjs && node tasks/generate-llms-txt.mjs",
     "lint": "next lint --webpack",
     "clean-references": "node tasks/clean-references.mjs"
   },
diff --git a/src/components/Layout/Layout.tsx b/src/components/Layout/Layout.tsx
index 3ff54bd60f6..c6a06f63240 100644
--- a/src/components/Layout/Layout.tsx
+++ b/src/components/Layout/Layout.tsx
@@ -40,6 +40,7 @@ import { Gen1Banner } from '@/components/Gen1Banner';
 import { PinpointEOLBanner } from '@/components/PinpointEOLBanner';
 import { LexV1EOLBanner } from '../LexV1EOLBanner';
 import { ApiModalProvider } from '../ApiDocs/ApiModalProvider';
+import { MarkdownMenu } from '@/components/MarkdownMenu';
 
 export const Layout = ({
   children,
@@ -283,7 +284,19 @@ export const Layout = ({
                     ) : null}
                     {shouldShowAIBanner ? <AIBanner /> : null}
                     {useCustomTitle ? null : (
-                      <Heading level={1}>{pageTitle}</Heading>
+                      <Flex
+                        justifyContent="space-between"
+                        alignItems="flex-start"
+                        wrap="nowrap"
+                      >
+                        <Heading level={1}>{pageTitle}</Heading>
+                        <MarkdownMenu
+                          route={asPathWithNoHash}
+                          isGen1={isGen1}
+                          isHome={isHome}
+                          isOverview={isOverview}
+                        />
+                      </Flex>
                     )}
                     {(isGen1GettingStarted || isGen1HowAmplifyWorks) && (
                       <Gen1Banner currentPlatform={currentPlatform} />
diff --git a/src/components/MarkdownMenu/MarkdownMenu.tsx b/src/components/MarkdownMenu/MarkdownMenu.tsx
new file mode 100644
index 00000000000..91325be9b09
--- /dev/null
+++ b/src/components/MarkdownMenu/MarkdownMenu.tsx
@@ -0,0 +1,194 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { Button, Flex, Text } from '@aws-amplify/ui-react';
+
+interface MarkdownMenuProps {
+  route: string;
+  isGen1?: boolean;
+  isHome?: boolean;
+  isOverview?: boolean;
+}
+
+function getMarkdownUrl(route: string): string {
+  // Strip platform prefix and trailing slash
+  // e.g. /react/build-a-backend/auth/set-up-auth/ → build-a-backend/auth/set-up-auth
+  const parts = route.replace(/^\//, '').replace(/\/$/, '').split('/');
+  const withoutPlatform = parts.slice(1).join('/');
+  return `/ai/pages/${withoutPlatform}.md`;
+}
+
+export function MarkdownMenu({ route, isGen1, isHome, isOverview }: MarkdownMenuProps) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [copied, setCopied] = useState(false);
+  const menuRef = useRef<HTMLDivElement>(null);
+  const copiedTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const shouldRender = !isGen1 && !isHome && !isOverview;
+  const mdUrl = getMarkdownUrl(route);
+
+  const handleCopy = useCallback(async () => {
+    try {
+      const response = await fetch(mdUrl);
+      if (!response.ok) return;
+      const text = await response.text();
+      // Guard against accidentally copying HTML (e.g. 404 page)
+      if (/^\s*<!doctype/i.test(text) || /^\s*<html/i.test(text)) return;
+      await navigator.clipboard.writeText(text);
+      setCopied(true);
+      setIsOpen(false);
+      copiedTimerRef.current = setTimeout(() => setCopied(false), 2000);
+    } catch {
+      // Silently fail if clipboard not available
+    }
+  }, [mdUrl]);
+
+  const handleOpenMd = useCallback(() => {
+    window.open(mdUrl, '_blank');
+    setIsOpen(false);
+  }, [mdUrl]);
+
+  useEffect(() => {
+    return () => {
+      if (copiedTimerRef.current) clearTimeout(copiedTimerRef.current);
+    };
+  }, []);
+
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        setIsOpen(false);
+      }
+    }
+    if (isOpen) {
+      document.addEventListener('mousedown', handleClickOutside);
+      return () => document.removeEventListener('mousedown', handleClickOutside);
+    }
+  }, [isOpen]);
+
+  const handleKeyDown = useCallback(
+    (event: React.KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        setIsOpen(false);
+      }
+      if (!isOpen) return;
+      const items = menuRef.current?.querySelectorAll<HTMLButtonElement>(
+        '[role="menuitem"]'
+      );
+      if (!items?.length) return;
+      const focused = document.activeElement;
+      const index = Array.from(items).indexOf(focused as HTMLButtonElement);
+      if (event.key === 'ArrowDown') {
+        event.preventDefault();
+        items[index < items.length - 1 ? index + 1 : 0].focus();
+      } else if (event.key === 'ArrowUp') {
+        event.preventDefault();
+        items[index > 0 ? index - 1 : items.length - 1].focus();
+      }
+    },
+    [isOpen]
+  );
+
+  if (!shouldRender) return null;
+
+  return (
+    <div ref={menuRef} className="markdown-menu" onKeyDown={handleKeyDown}>
+      <Button
+        size="small"
+        variation="link"
+        className="markdown-menu__button"
+        onClick={() => setIsOpen(!isOpen)}
+        aria-expanded={isOpen}
+        aria-haspopup="true"
+      >
+        <Flex alignItems="center" gap="xs">
+          <span aria-hidden="true">✨</span>
+          <Text as="span" fontSize="small">
+            {copied ? 'Copied!' : 'Use with AI'}
+          </Text>
+          <svg
+            width="10"
+            height="10"
+            viewBox="0 0 10 10"
+            fill="none"
+            aria-hidden="true"
+            className="markdown-menu__chevron"
+          >
+            <path
+              d="M2 4L5 7L8 4"
+              stroke="currentColor"
+              strokeWidth="1.2"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+          </svg>
+        </Flex>
+      </Button>
+      {isOpen && (
+        <div className="markdown-menu__dropdown" role="menu">
+          <button
+            className="markdown-menu__item"
+            onClick={handleCopy}
+            role="menuitem"
+          >
+            <svg
+              width="14"
+              height="14"
+              viewBox="0 0 14 14"
+              fill="none"
+              aria-hidden="true"
+            >
+              <rect
+                x="4"
+                y="4"
+                width="8"
+                height="8"
+                rx="1"
+                stroke="currentColor"
+                strokeWidth="1.2"
+              />
+              <path
+                d="M10 4V2.5C10 1.95 9.55 1.5 9 1.5H2.5C1.95 1.5 1.5 1.95 1.5 2.5V9C1.5 9.55 1.95 10 2.5 10H4"
+                stroke="currentColor"
+                strokeWidth="1.2"
+              />
+            </svg>
+            Copy page MD
+          </button>
+          <button
+            className="markdown-menu__item"
+            onClick={handleOpenMd}
+            role="menuitem"
+          >
+            <svg
+              width="14"
+              height="14"
+              viewBox="0 0 14 14"
+              fill="none"
+              aria-hidden="true"
+            >
+              <path
+                d="M10 1.5H12.5V4"
+                stroke="currentColor"
+                strokeWidth="1.2"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              />
+              <path
+                d="M7 7L12.5 1.5"
+                stroke="currentColor"
+                strokeWidth="1.2"
+                strokeLinecap="round"
+              />
+              <path
+                d="M6 2H2.5C1.95 2 1.5 2.45 1.5 3V11.5C1.5 12.05 1.95 12.5 2.5 12.5H11C11.55 12.5 12 12.05 12 11.5V8"
+                stroke="currentColor"
+                strokeWidth="1.2"
+                strokeLinecap="round"
+              />
+            </svg>
+            Open this page as MD
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/MarkdownMenu/__tests__/MarkdownMenu.test.tsx b/src/components/MarkdownMenu/__tests__/MarkdownMenu.test.tsx
new file mode 100644
index 00000000000..6b4e314aaaa
--- /dev/null
+++ b/src/components/MarkdownMenu/__tests__/MarkdownMenu.test.tsx
@@ -0,0 +1,149 @@
+import * as React from 'react';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MarkdownMenu } from '../MarkdownMenu';
+
+// Mock fetch and clipboard
+const mockFetch = jest.fn();
+const mockWriteText = jest.fn();
+const mockOpen = jest.fn();
+
+beforeEach(() => {
+  global.fetch = mockFetch;
+  Object.assign(navigator, {
+    clipboard: { writeText: mockWriteText }
+  });
+  window.open = mockOpen;
+  mockFetch.mockReset();
+  mockWriteText.mockReset();
+  mockOpen.mockReset();
+});
+
+describe('MarkdownMenu', () => {
+  it('should render button with "Use with AI" label', () => {
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+    expect(screen.getByText('Use with AI')).toBeInTheDocument();
+  });
+
+  it('should not render on Gen1 pages', () => {
+    const { container } = render(
+      <MarkdownMenu route="/gen1/react/start/" isGen1={true} />
+    );
+    expect(container.innerHTML).toBe('');
+  });
+
+  it('should not render on home page', () => {
+    const { container } = render(
+      <MarkdownMenu route="/" isHome={true} />
+    );
+    expect(container.innerHTML).toBe('');
+  });
+
+  it('should show dropdown menu items on click', async () => {
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+
+    await act(async () => {
+      userEvent.click(screen.getByText('Use with AI'));
+    });
+
+    expect(screen.getByText('Copy page MD')).toBeVisible();
+    expect(screen.getByText('Open this page as MD')).toBeVisible();
+  });
+
+  it('should copy markdown to clipboard when "Copy page MD" is clicked', async () => {
+    const mdContent = '# Test Page\n\nSome content.';
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      text: () => Promise.resolve(mdContent)
+    });
+    mockWriteText.mockResolvedValueOnce(undefined);
+
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+
+    await act(async () => {
+      userEvent.click(screen.getByText('Use with AI'));
+    });
+    await act(async () => {
+      userEvent.click(screen.getByText('Copy page MD'));
+    });
+
+    await waitFor(() => {
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/ai/pages/build-a-backend/auth/set-up-auth.md'
+      );
+    });
+    expect(mockWriteText).toHaveBeenCalledWith(mdContent);
+  });
+
+  it('should open markdown file in new tab when "Open this page as MD" is clicked', async () => {
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+
+    await act(async () => {
+      userEvent.click(screen.getByText('Use with AI'));
+    });
+    await act(async () => {
+      userEvent.click(screen.getByText('Open this page as MD'));
+    });
+
+    expect(mockOpen).toHaveBeenCalledWith(
+      '/ai/pages/build-a-backend/auth/set-up-auth.md',
+      '_blank'
+    );
+  });
+
+  it('should construct correct markdown URL from route', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      text: () => Promise.resolve('content')
+    });
+    mockWriteText.mockResolvedValueOnce(undefined);
+
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+
+    await act(async () => {
+      userEvent.click(screen.getByText('Use with AI'));
+    });
+    await act(async () => {
+      userEvent.click(screen.getByText('Copy page MD'));
+    });
+
+    await waitFor(() => {
+      expect(mockFetch).toHaveBeenCalledWith(
+        '/ai/pages/build-a-backend/auth/set-up-auth.md'
+      );
+    });
+  });
+
+  it('should show "Copied!" feedback after copy', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      text: () => Promise.resolve('content')
+    });
+    mockWriteText.mockResolvedValueOnce(undefined);
+
+    render(
+      <MarkdownMenu route="/react/build-a-backend/auth/set-up-auth/" />
+    );
+
+    await act(async () => {
+      userEvent.click(screen.getByText('Use with AI'));
+    });
+    await act(async () => {
+      userEvent.click(screen.getByText('Copy page MD'));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Copied!')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/src/components/MarkdownMenu/index.ts b/src/components/MarkdownMenu/index.ts
new file mode 100644
index 00000000000..daceaa3ef68
--- /dev/null
+++ b/src/components/MarkdownMenu/index.ts
@@ -0,0 +1 @@
+export { MarkdownMenu } from './MarkdownMenu';
diff --git a/src/styles/markdown-menu.scss b/src/styles/markdown-menu.scss
new file mode 100644
index 00000000000..d14e70212d2
--- /dev/null
+++ b/src/styles/markdown-menu.scss
@@ -0,0 +1,55 @@
+.markdown-menu {
+  position: relative;
+  flex-shrink: 0;
+
+  &__button {
+    padding: var(--amplify-space-xxs) var(--amplify-space-small);
+    border: 1px solid var(--amplify-colors-border-primary);
+    border-radius: var(--amplify-radii-small);
+    background: var(--amplify-colors-background-primary);
+    color: var(--amplify-colors-font-secondary);
+    font-size: var(--amplify-font-sizes-small);
+    cursor: pointer;
+
+    &:hover {
+      background: var(--amplify-colors-overlay-5);
+      color: var(--amplify-colors-font-primary);
+    }
+  }
+
+  &__chevron {
+    transition: transform 0.15s ease;
+  }
+
+  &__dropdown {
+    position: absolute;
+    right: 0;
+    top: calc(100% + var(--amplify-space-xxs));
+    background: var(--amplify-colors-background-primary);
+    border: 1px solid var(--amplify-colors-border-primary);
+    border-radius: var(--amplify-radii-small);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    z-index: 10;
+    min-width: 200px;
+    padding: var(--amplify-space-xxs) 0;
+  }
+
+  &__item {
+    display: flex;
+    align-items: center;
+    gap: var(--amplify-space-small);
+    width: 100%;
+    padding: var(--amplify-space-xs) var(--amplify-space-medium);
+    border: none;
+    background: none;
+    color: var(--amplify-colors-font-primary);
+    font-size: var(--amplify-font-sizes-small);
+    cursor: pointer;
+    text-align: left;
+    white-space: nowrap;
+
+    &:hover {
+      background: var(--amplify-colors-overlay-5);
+    }
+  }
+}
diff --git a/src/styles/styles.scss b/src/styles/styles.scss
index c6958471e7b..4e85db13d8b 100644
--- a/src/styles/styles.scss
+++ b/src/styles/styles.scss
@@ -25,6 +25,7 @@
 @import './icons.scss';
 @import './layout.scss';
 @import './link-card.scss';
+@import './markdown-menu.scss';
 @import './menu.scss';
 @import './modal.scss';
 @import './next-previous.scss';
diff --git a/tasks/__tests__/generate-llms-txt.test.ts b/tasks/__tests__/generate-llms-txt.test.ts
new file mode 100644
index 00000000000..c09bcdee4e6
--- /dev/null
+++ b/tasks/__tests__/generate-llms-txt.test.ts
@@ -0,0 +1,273 @@
+import {
+  collectGen2Pages,
+  transformMdxToMarkdown,
+  generateFrontmatter,
+  generateLlmsIndex
+} from '../generate-llms-txt.mjs';
+
+describe('generate-llms-txt', () => {
+  describe('collectGen2Pages', () => {
+    it('should return only Gen2 pages', () => {
+      const mockDirectory = {
+        path: 'src/pages/[platform]/index.tsx',
+        children: [
+          {
+            path: 'src/pages/[platform]/build-a-backend/auth/set-up-auth/index.mdx',
+            title: 'Set up Amplify Auth',
+            description: 'Learn how to set up auth.',
+            platforms: ['react', 'nextjs'],
+            lastUpdated: '2025-01-15T00:00:00.000Z',
+            route: '/[platform]/build-a-backend/auth/set-up-auth'
+          },
+          {
+            path: 'src/pages/gen1/[platform]/start/index.mdx',
+            title: 'Gen1 Start',
+            description: 'Gen1 getting started.',
+            platforms: ['react'],
+            route: '/gen1/[platform]/start'
+          }
+        ]
+      };
+
+      const pages = collectGen2Pages(mockDirectory);
+      expect(pages.length).toBe(1);
+      expect(pages[0].title).toBe('Set up Amplify Auth');
+    });
+
+    it('should skip external links', () => {
+      const mockDirectory = {
+        path: 'src/pages/[platform]/index.tsx',
+        children: [
+          {
+            path: 'src/pages/[platform]/build-a-backend/auth/index.mdx',
+            title: 'Auth',
+            route: '/[platform]/build-a-backend/auth',
+            platforms: ['react'],
+            isExternal: true
+          }
+        ]
+      };
+
+      const pages = collectGen2Pages(mockDirectory);
+      expect(pages.length).toBe(0);
+    });
+
+    it('should extract correct section from route', () => {
+      const mockDirectory = {
+        path: 'src/pages/[platform]/index.tsx',
+        children: [
+          {
+            path: 'src/pages/[platform]/build-a-backend/auth/set-up-auth/index.mdx',
+            title: 'Set up Auth',
+            description: '',
+            platforms: ['react'],
+            route: '/[platform]/build-a-backend/auth/set-up-auth',
+            lastUpdated: ''
+          }
+        ]
+      };
+
+      const pages = collectGen2Pages(mockDirectory);
+      expect(pages[0].section).toBe('build-a-backend/auth');
+    });
+  });
+
+  describe('transformMdxToMarkdown', () => {
+    it('should strip exports and imports', () => {
+      const input = `import { getCustomStaticPath } from '@/utils/getCustomStaticPath';
+
+export const meta = {
+  title: 'Test',
+  description: 'test page',
+  platforms: ['react']
+};
+
+export function getStaticPaths() {
+  return getCustomStaticPath(meta.platforms);
+};
+
+export function getStaticProps() {
+  return {
+    props: {
+      meta
+    }
+  };
+};
+
+# Hello World
+
+Some content here.`;
+
+      const result = transformMdxToMarkdown(input);
+      expect(result).not.toContain('export const meta');
+      expect(result).not.toContain('import');
+      expect(result).not.toContain('getStaticPaths');
+      expect(result).not.toContain('getStaticProps');
+      expect(result).toContain('# Hello World');
+      expect(result).toContain('Some content here.');
+    });
+
+    it('should convert InlineFilter to HTML comments', () => {
+      const input = `<InlineFilter filters={["react"]}>React only content</InlineFilter>`;
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('<!-- Platform: react -->');
+      expect(result).toContain('React only content');
+      expect(result).toContain('<!-- /Platform -->');
+    });
+
+    it('should convert Callout info', () => {
+      const input = `<Callout info>This is important info.</Callout>`;
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('> **Info:** This is important info.');
+    });
+
+    it('should convert Callout warning', () => {
+      const input = `<Callout warning>Be careful!</Callout>`;
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('> **Warning:** Be careful!');
+    });
+
+    it('should convert BlockSwitcher/Block to headings', () => {
+      const input = `<BlockSwitcher>
+<Block name="TypeScript">
+TypeScript content here.
+</Block>
+<Block name="JavaScript">
+JavaScript content here.
+</Block>
+</BlockSwitcher>`;
+
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('#### [TypeScript]');
+      expect(result).toContain('TypeScript content here.');
+      expect(result).toContain('#### [JavaScript]');
+      expect(result).toContain('JavaScript content here.');
+      expect(result).not.toContain('<BlockSwitcher>');
+      expect(result).not.toContain('</Block>');
+    });
+
+    it('should convert Accordion to details/summary', () => {
+      const input = `<Accordion title="Click to expand" headingLevel="4">Some hidden content.</Accordion>`;
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('<details><summary>Click to expand</summary>');
+      expect(result).toContain('Some hidden content.');
+      expect(result).toContain('</details>');
+    });
+
+    it('should strip Overview component', () => {
+      const input = `<Overview childPageNodes={props.childPageNodes} />
+
+## Next section`;
+      const result = transformMdxToMarkdown(input);
+      expect(result).not.toContain('Overview');
+      expect(result).toContain('## Next section');
+    });
+
+    it('should preserve code blocks', () => {
+      const input = `Some text.
+
+\`\`\`tsx
+<InlineFilter filters={["react"]}>
+  <Block name="test">
+    <Callout info>This should not be transformed</Callout>
+  </Block>
+</InlineFilter>
+\`\`\`
+
+More text.`;
+
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('<InlineFilter filters={["react"]}>');
+      expect(result).toContain('<Block name="test">');
+      expect(result).toContain('<Callout info>This should not be transformed</Callout>');
+    });
+
+    it('should strip JSX comments', () => {
+      const input = `Some text.
+{/* This is a comment */}
+More text.`;
+
+      const result = transformMdxToMarkdown(input);
+      expect(result).not.toContain('This is a comment');
+      expect(result).toContain('Some text.');
+      expect(result).toContain('More text.');
+    });
+
+    it('should handle nested InlineFilters', () => {
+      const input = `<InlineFilter filters={["react", "nextjs"]}>
+Outer content.
+<InlineFilter filters={["react"]}>Inner react only.</InlineFilter>
+</InlineFilter>`;
+
+      const result = transformMdxToMarkdown(input);
+      expect(result).toContain('<!-- Platform: react, nextjs -->');
+      expect(result).toContain('<!-- Platform: react -->');
+      expect(result).toContain('Outer content.');
+      expect(result).toContain('Inner react only.');
+    });
+  });
+
+  describe('generateFrontmatter', () => {
+    it('should produce valid YAML frontmatter', () => {
+      const mockNode = {
+        title: 'Set up Amplify Auth',
+        description: 'Learn how to set up auth.',
+        platforms: ['react', 'nextjs'],
+        route: '/[platform]/build-a-backend/auth/set-up-auth',
+        path: 'src/pages/[platform]/build-a-backend/auth/set-up-auth/index.mdx',
+        lastUpdated: '2025-01-15T00:00:00.000Z',
+        section: 'build-a-backend/auth'
+      };
+
+      const result = generateFrontmatter(mockNode);
+      expect(result).toMatch(/^---/);
+      expect(result).toMatch(/---$/);
+      expect(result).toContain('title: "Set up Amplify Auth"');
+      expect(result).toContain('section: "build-a-backend/auth"');
+      expect(result).toContain('"react"');
+      expect(result).toContain('"nextjs"');
+      expect(result).toContain('gen: 2');
+      expect(result).toContain('last-updated: "2025-01-15T00:00:00.000Z"');
+      expect(result).toContain(
+        'url: "https://docs.amplify.aws/react/build-a-backend/auth/set-up-auth/"'
+      );
+    });
+  });
+
+  describe('generateLlmsIndex', () => {
+    it('should group pages by section', () => {
+      const mockNodes = [
+        {
+          title: 'Set up Auth',
+          description: 'Auth setup guide.',
+          platforms: ['react'],
+          route: '/[platform]/build-a-backend/auth/set-up-auth',
+          section: 'build-a-backend'
+        },
+        {
+          title: 'Quickstart',
+          description: 'Get started quickly.',
+          platforms: ['react'],
+          route: '/[platform]/start/quickstart',
+          section: 'start'
+        },
+        {
+          title: 'Data Modeling',
+          description: 'Model your data.',
+          platforms: ['react'],
+          route: '/[platform]/build-a-backend/data/data-modeling',
+          section: 'build-a-backend'
+        }
+      ];
+
+      const result = generateLlmsIndex(mockNodes);
+      expect(result).toContain('## build-a-backend');
+      expect(result).toContain('## start');
+      expect(result).toContain('- [Set up Auth]');
+      expect(result).toContain('- [Quickstart]');
+      expect(result).toContain('- [Data Modeling]');
+      expect(result).toContain(': Auth setup guide.');
+      expect(result).toContain('Markdown: /ai/pages/');
+    });
+  });
+});
diff --git a/tasks/generate-llms-txt.mjs b/tasks/generate-llms-txt.mjs
new file mode 100644
index 00000000000..bb21a399f68
--- /dev/null
+++ b/tasks/generate-llms-txt.mjs
@@ -0,0 +1,406 @@
+import { promises as fs, readFileSync } from 'fs';
+import path from 'path';
+
+const AI_PATH = './public/ai';
+const PAGES_PATH = `${AI_PATH}/pages`;
+const DOMAIN = 'https://docs.amplify.aws';
+const PROJECT_ROOT = path.resolve('.');
+
+/**
+ * Recursively walk directory.json and collect Gen2 page nodes
+ * (routes starting with /[platform]/).
+ */
+export function collectGen2Pages(node, section = '') {
+  const pages = [];
+
+  if (!node) return pages;
+
+  const route = node.route || '';
+  const isGen2 = route.startsWith('/[platform]/');
+  const isExternal = node.isExternal === true;
+
+  if (isGen2 && !isExternal && node.title) {
+    // Extract section: everything between /[platform]/ and the last segment
+    const routeWithoutPlatform = route.replace('/[platform]/', '');
+    const parts = routeWithoutPlatform.split('/');
+    const pageSection = parts.length > 1 ? parts.slice(0, -1).join('/') : parts[0];
+
+    pages.push({
+      title: node.title,
+      description: node.description || '',
+      platforms: node.platforms || [],
+      route: node.route,
+      path: node.path,
+      lastUpdated: node.lastUpdated || '',
+      section: section || pageSection
+    });
+  }
+
+  if (node.children) {
+    // Determine section from this node if it's a Gen2 container
+    const currentSection = isGen2 && route
+      ? route.replace('/[platform]/', '').split('/')[0]
+      : section;
+
+    for (const child of node.children) {
+      const childSection = isGen2
+        ? route.replace('/[platform]/', '')
+        : currentSection;
+      pages.push(...collectGen2Pages(child, childSection));
+    }
+  }
+
+  return pages;
+}
+
+/**
+ * Strip an export block that starts with the given prefix, handling nested braces.
+ */
+function stripExportBlock(content, prefix) {
+  const idx = content.indexOf(prefix);
+  if (idx === -1) return content;
+
+  // Find the first opening brace after the prefix
+  const braceStart = content.indexOf('{', idx);
+  if (braceStart === -1) return content;
+
+  // Count braces to find the matching closing brace
+  let depth = 0;
+  let i = braceStart;
+  for (; i < content.length; i++) {
+    if (content[i] === '{') depth++;
+    else if (content[i] === '}') {
+      depth--;
+      if (depth === 0) break;
+    }
+  }
+
+  // Remove from prefix start to after the closing brace (and optional semicolons/whitespace)
+  let end = i + 1;
+  while (end < content.length && (content[end] === ';' || content[end] === '\n' || content[end] === '\r' || content[end] === ' ')) {
+    end++;
+  }
+
+  return content.slice(0, idx) + content.slice(end);
+}
+
+/**
+ * Transform raw MDX content into clean markdown.
+ */
+export function transformMdxToMarkdown(rawMdx, srcDir = './src') {
+  let content = rawMdx;
+
+  // Step 1: Extract fenced code blocks as placeholders
+  const codeBlocks = [];
+  content = content.replace(/```[\s\S]*?```/g, (match) => {
+    const index = codeBlocks.length;
+    codeBlocks.push(match);
+    return `__CODE_BLOCK_${index}__`;
+  });
+
+  // Step 2: Strip export blocks (meta, getStaticPaths, getStaticProps)
+  // Use brace-counting to handle nested braces
+  content = stripExportBlock(content, 'export const meta');
+  content = stripExportBlock(content, 'export function getStaticPaths');
+  content = stripExportBlock(content, 'export const getStaticPaths');
+  content = stripExportBlock(content, 'export function getStaticProps');
+  content = stripExportBlock(content, 'export const getStaticProps');
+  // Catch any remaining single-line export statements
+  content = content.replace(/^export\s+(const|function|default)\s+.*$/gm, '');
+
+  // Step 3: Resolve Fragments - capture imports and inline content
+  const fragmentImports = {};
+  const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+\.mdx)['"]\s*;?/g;
+  let importMatch;
+  while ((importMatch = importRegex.exec(content)) !== null) {
+    fragmentImports[importMatch[1]] = importMatch[2];
+  }
+
+  // Replace <Fragments fragments={{ platform: varName, ... }} /> with inlined content
+  content = content.replace(
+    /<Fragments\s+fragments=\{\{[\s\S]*?\}\}\s*\/>/g,
+    (match) => {
+      // Extract the variable names from the fragments prop
+      const varNames = new Set();
+      const varRegex = /:\s*(\w+)/g;
+      let varMatch;
+      while ((varMatch = varRegex.exec(match)) !== null) {
+        varNames.add(varMatch[1]);
+      }
+
+      // Inline the first unique fragment (they're typically the same content for all platforms)
+      for (const varName of varNames) {
+        const fragmentPath = fragmentImports[varName];
+        if (fragmentPath) {
+          try {
+            const resolvedPath = path.resolve(srcDir, '..', fragmentPath);
+            // Ensure the resolved path stays within the project root
+            if (!resolvedPath.startsWith(PROJECT_ROOT)) {
+              continue;
+            }
+            const fragmentContent = readFileSync(resolvedPath, 'utf-8');
+            return transformMdxToMarkdown(fragmentContent, srcDir);
+          } catch {
+            // If we can't read the fragment, just remove the tag
+          }
+        }
+      }
+      return '';
+    }
+  );
+
+  // Step 4: Strip import statements
+  content = content.replace(/^import\s+.*?;\s*$/gm, '');
+  content = content.replace(/^import\s+.*?from\s+['"].*?['"]\s*$/gm, '');
+
+  // Step 5: Convert <InlineFilter filters={[...]}>...</InlineFilter>
+  // The regex matches innermost InlineFilter pairs first. Multiple passes handle
+  // nesting — each pass peels off one layer. We loop until no more replacements
+  // occur rather than using a fixed count.
+  let prevContent;
+  do {
+    prevContent = content;
+    content = content.replace(
+      /<InlineFilter\s+filters=\{(\[.*?\])\}>([\s\S]*?)<\/InlineFilter>/g,
+      (match, filters, inner) => {
+        // Clean up the filter list
+        const filterList = filters.replace(/[[\]'"]/g, '').trim();
+        return `<!-- Platform: ${filterList} -->\n${inner.trim()}\n<!-- /Platform -->`;
+      }
+    );
+  } while (content !== prevContent);
+
+  // Step 6: Convert <BlockSwitcher>/<Block name="X"> → #### [X]
+  content = content.replace(/<BlockSwitcher>/g, '');
+  content = content.replace(/<\/BlockSwitcher>/g, '');
+  content = content.replace(/<Block\s+name="([^"]*)">/g, (match, name) => {
+    return `#### [${name}]`;
+  });
+  content = content.replace(/<\/Block>/g, '');
+
+  // Step 7: Convert <Callout info|warning> → blockquote
+  content = content.replace(
+    /<Callout\s+(info|warning)(?:\s*=\s*\{?\s*true\s*\}?)?>([\s\S]*?)<\/Callout>/g,
+    (match, type, inner) => {
+      const label = type === 'warning' ? 'Warning' : 'Info';
+      const lines = inner.trim().split('\n');
+      return lines.map((line, i) => {
+        if (i === 0) return `> **${label}:** ${line}`;
+        return `> ${line}`;
+      }).join('\n');
+    }
+  );
+
+  // Step 8: Convert <Accordion title="X"> → <details><summary>
+  content = content.replace(
+    /<Accordion\s+title="([^"]*)"(?:\s+[^>]*)?>/g,
+    '<details><summary>$1</summary>'
+  );
+  content = content.replace(/<\/Accordion>/g, '</details>');
+
+  // Step 9: Strip <Overview>, <Video>, <YoutubeEmbed>
+  content = content.replace(/<Overview\s+childPageNodes=\{[^}]*\}\s*\/>/g, '');
+  content = content.replace(/<Video\s+src="([^"]*)"[^/]*\/>/g, '');
+  content = content.replace(/<YoutubeEmbed\s+embedId="([^"]*)"[^/]*\/>/g, '');
+
+  // Step 10: Strip JSX comments {/* ... */}
+  content = content.replace(/\{\/\*[\s\S]*?\*\/\}/g, '');
+
+  // Step 11: Restore code block placeholders
+  content = content.replace(/__CODE_BLOCK_(\d+)__/g, (match, index) => {
+    return codeBlocks[parseInt(index)];
+  });
+
+  // Step 12: Clean up excessive blank lines
+  content = content.replace(/\n{3,}/g, '\n\n');
+
+  return content.trim();
+}
+
+/**
+ * Generate YAML frontmatter for a page node.
+ */
+export function generateFrontmatter(pageNode) {
+  const routeWithoutPlatform = pageNode.route.replace('/[platform]/', '');
+  const section = routeWithoutPlatform.includes('/')
+    ? routeWithoutPlatform.split('/').slice(0, -1).join('/')
+    : routeWithoutPlatform;
+  const platformsStr = pageNode.platforms.map((p) => `"${p}"`).join(', ');
+  const url = `${DOMAIN}/react/${routeWithoutPlatform}/`;
+
+  return `---
+title: "${pageNode.title.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"
+section: "${section}"
+platforms: [${platformsStr}]
+gen: 2
+last-updated: "${pageNode.lastUpdated}"
+url: "${url}"
+---`;
+}
+
+/**
+ * Generate the llms.txt index file content.
+ */
+export function generateLlmsIndex(pageNodes) {
+  const lines = [
+    '# AWS Amplify Gen 2 Documentation',
+    '',
+    '> AWS Amplify documentation for building fullstack apps with TypeScript.',
+    '',
+    `Docs: ${DOMAIN}`,
+    ''
+  ];
+
+  // Group by top-level section
+  const sections = new Map();
+  for (const node of pageNodes) {
+    const routeWithoutPlatform = node.route.replace('/[platform]/', '');
+    const topSection = routeWithoutPlatform.split('/')[0];
+    if (!sections.has(topSection)) {
+      sections.set(topSection, []);
+    }
+    sections.get(topSection).push(node);
+  }
+
+  for (const [sectionName, nodes] of sections) {
+    lines.push(`## ${sectionName}`, '');
+    for (const node of nodes) {
+      const routeWithoutPlatform = node.route.replace('/[platform]/', '');
+      const url = `${DOMAIN}/react/${routeWithoutPlatform}/`;
+      const mdUrl = `/ai/pages/${routeWithoutPlatform}.md`;
+      let entry = `- [${node.title}](${url})`;
+      if (node.description) {
+        entry += `: ${node.description}`;
+      }
+      lines.push(entry, `  Markdown: ${mdUrl}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trim() + '\n';
+}
+
+/**
+ * Generate the llms-full.txt concatenated file content.
+ */
+export function generateLlmsFull(pageNodes, contentsMap) {
+  const lines = [
+    '# AWS Amplify Gen 2 Documentation (Full)',
+    '',
+    '> Complete documentation export for AI coding assistants.',
+    `> Generated: ${new Date().toISOString().split('T')[0]}`,
+    '',
+    '## Table of Contents',
+    ''
+  ];
+
+  // Table of contents
+  for (const node of pageNodes) {
+    const routeWithoutPlatform = node.route.replace('/[platform]/', '');
+    const anchor = routeWithoutPlatform.replace(/\//g, '-');
+    lines.push(`- [${node.title}](#${anchor})`);
+  }
+  lines.push('', '---', '');
+
+  // Concatenated pages
+  for (const node of pageNodes) {
+    const content = contentsMap.get(node.route) || '';
+    const frontmatter = generateFrontmatter(node);
+    lines.push(frontmatter, '', content, '', '---', '');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Read and transform a single MDX page file to markdown.
+ */
+async function processPage(pageNode) {
+  try {
+    const mdxPath = path.resolve(pageNode.path);
+    const rawMdx = await fs.readFile(mdxPath, 'utf-8');
+    return transformMdxToMarkdown(rawMdx, path.dirname(mdxPath));
+  } catch (error) {
+    console.warn(`Warning: Could not read ${pageNode.path}: ${error.message}`);
+    return '';
+  }
+}
+
+/**
+ * Ensure a directory exists, creating it recursively if needed.
+ */
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Main orchestrator: generate all llms.txt outputs.
+ */
+export async function generateLlmsTxt() {
+  console.log('Generating llms.txt files...');
+
+  // Step 1: Collect all Gen2 pages from directory.json
+  const directoryRaw = await fs.readFile('./src/directory/directory.json', 'utf-8');
+  const directory = JSON.parse(directoryRaw);
+  const platformRoot = directory.children?.find(
+    (child) => child.path === 'src/pages/[platform]/index.tsx'
+  );
+  if (!platformRoot) {
+    console.error('Could not find [platform] root in directory.json');
+    return;
+  }
+
+  const pageNodes = collectGen2Pages(platformRoot);
+  console.log(`Found ${pageNodes.length} Gen2 pages`);
+
+  // Step 2: Process all pages - read MDX and transform to markdown
+  const contentsMap = new Map();
+  for (const node of pageNodes) {
+    const content = await processPage(node);
+    contentsMap.set(node.route, content);
+  }
+
+  // Step 3: Write output files
+  await ensureDir(PAGES_PATH);
+
+  // Collect all unique directories needed, then create them in parallel
+  const dirs = new Set();
+  for (const node of pageNodes) {
+    const routeWithoutPlatform = node.route.replace('/[platform]/', '');
+    const pagePath = `${PAGES_PATH}/${routeWithoutPlatform}.md`;
+    dirs.add(path.dirname(pagePath));
+  }
+  await Promise.all([...dirs].map((dir) => ensureDir(dir)));
+
+  // Write individual page files in parallel
+  await Promise.all(
+    pageNodes.map((node) => {
+      const routeWithoutPlatform = node.route.replace('/[platform]/', '');
+      const pagePath = `${PAGES_PATH}/${routeWithoutPlatform}.md`;
+      const frontmatter = generateFrontmatter(node);
+      const content = contentsMap.get(node.route) || '';
+      return fs.writeFile(pagePath, `${frontmatter}\n\n${content}\n`);
+    })
+  );
+  console.log(`Wrote ${pageNodes.length} individual page files`);
+
+  // Write llms.txt and llms-full.txt in parallel
+  const indexContent = generateLlmsIndex(pageNodes);
+  const fullContent = generateLlmsFull(pageNodes, contentsMap);
+  await Promise.all([
+    fs.writeFile(`${AI_PATH}/llms.txt`, indexContent),
+    fs.writeFile(`${AI_PATH}/llms-full.txt`, fullContent)
+  ]);
+  console.log(`Wrote ${AI_PATH}/llms.txt`);
+  console.log(`Wrote ${AI_PATH}/llms-full.txt`);
+
+  console.log('llms.txt generation complete.');
+}
+
+// Allow running standalone: node tasks/generate-llms-txt.mjs
+const isMainModule = typeof process !== 'undefined' &&
+  process.argv[1] &&
+  process.argv[1].includes('generate-llms-txt');
+if (isMainModule) {
+  generateLlmsTxt().catch(console.error);
+}