diff --git a/.claude/commands/new-blog-post.md b/.claude/commands/new-blog-post.md
index b9779aa6b847..5acbe7f52054 100644
--- a/.claude/commands/new-blog-post.md
+++ b/.claude/commands/new-blog-post.md
@@ -138,6 +138,7 @@ After creating the files, tell the user:
    - **Optional but recommended**: Run `/add-borders` on the blog post to add 1px grey borders to PNG images for better visual presentation
    - Preview locally: `make serve` and visit <http://localhost:1313/blog/{slug}/>
    - **Recommended**: Run `/docs-review` on your blog post to check for style issues before committing
+   - **Recommended**: Run `/seo-enhance` on your blog post to optimize for search and AI discoverability
    - Run `make lint` before committing
    - **Important**: If your post is merged to master but not showing on the live site, check the date in frontmatter - posts only appear after their publish date.
 
diff --git a/.claude/commands/seo-enhance/SKILL.md b/.claude/commands/seo-enhance/SKILL.md
new file mode 100644
index 000000000000..cf54cf7396c5
--- /dev/null
+++ b/.claude/commands/seo-enhance/SKILL.md
@@ -0,0 +1,234 @@
+---
+description: Enhance content for better search engine and AI discoverability. Works during content creation (proactive) or on existing content (reactive).
+---
+
+# /seo-enhance Command
+
+**Use this when:** You're creating new content (blog post, documentation) or want to optimize existing content for better visibility in traditional search (SEO) and AI answer engines (AEO/GEO).
+
+## Usage
+
+```
+/seo-enhance [file-path]
+```
+
+**Examples:**
+- `/seo-enhance` - Analyze the currently open file
+- `/seo-enhance content/blog/2026/01/my-post/index.md` - Analyze a specific file
+- `/seo-enhance content/docs/esc/get-started/_index.md` - Analyze documentation
+
+## Instructions for Claude
+
+### Step 1: Detect Target File
+
+Determine the target file from (in order of priority):
+1. Explicit file path argument
+2. Currently open file in IDE context
+3. Ask the user which file to analyze
+
+If no file can be determined, use AskUserQuestion:
+```
+Which file would you like me to analyze for SEO/AEO improvements?
+```
+
+### Step 2: Analyze Current State
+
+Read the target file and extract:
+
+**Frontmatter:**
+- `title` - Current title tag
+- `meta_desc` - Current meta description
+- `h1` - First H1 if different from title
+- `date` - Publication date (for blog posts)
+- `authors` - Author information (for blog posts)
+
+**Content structure:**
+- H1 and H2 headings
+- Opening paragraph (first ~150 words)
+- Presence of lists, tables, FAQ sections
+- Internal links (count and anchor text quality)
+- Word count and content depth
+
+### Step 3: Check AEO Patterns
+
+**Load reference:** Read `references/aeo-checklist.md`
+
+Evaluate against AI discoverability patterns:
+
+| Pattern | Check | Status |
+|---------|-------|--------|
+| **Quotable Definition** | Opening paragraph contains a clear, direct answer | Pass/Fail |
+| **Semantic Chunking** | Each section covers one focused concept | Pass/Fail |
+| **FAQ Sections** | Common questions addressed in Q&A format | Pass/Fail/N/A |
+| **Citable Claims** | Factual statements include specific data | Pass/Fail |
+| **Comparison Tables** | Structured tables for comparisons | Pass/Fail/N/A |
+| **Question Coverage** | Content answers what/how/why/when | Pass/Fail |
+
+### Step 4: Check SEO Fundamentals
+
+**Load reference:** Read `references/seo-checklist.md`
+
+Evaluate against SEO best practices:
+
+| Element | Guideline | Current | Status |
+|---------|-----------|---------|--------|
+| **Title** | Under 60 chars, includes primary keyword | [actual] | Pass/Fail |
+| **Meta description** | Under 155 chars, compelling, includes keyword | [actual] | Pass/Fail |
+| **H1** | Matches search intent, unique | [actual] | Pass/Fail |
+| **H2s** | Include keyword variations | [list] | Pass/Fail |
+| **Internal links** | Descriptive anchor text, relevant targets | [count] | Pass/Fail |
+
+### Step 5: Check Positioning Alignment
+
+**Load reference:** Read `references/pulumi-positioning.md`
+
+For content promoting Pulumi capabilities, verify:
+
+| Alignment | Check | Status |
+|-----------|-------|--------|
+| **Differentiators** | Emphasizes relevant advantages (real languages, unified platform, etc.) | Pass/Fail/N/A |
+| **Jobs-to-be-Done** | Connects to customer outcomes | Pass/Fail/N/A |
+| **Terminology** | Uses Pulumi's language, not competitor's | Pass/Fail |
+
+### Step 6: Generate Recommendations
+
+Present findings in a structured format:
+
+---
+
+## SEO/AEO Analysis: `[filename]`
+
+### Summary
+
+| Category | Score | Priority Items |
+|----------|-------|----------------|
+| AEO Readiness | X/6 | [top issues] |
+| SEO Fundamentals | X/5 | [top issues] |
+| Positioning | X/3 | [top issues] |
+
+### Priority Recommendations
+
+#### High Priority (Quick Fixes)
+
+**1. [Issue]: [Current state]**
+- **Problem**: [Why this matters]
+- **Recommendation**: [Specific change]
+- **Example**:
+  ```
+  Current: [current value]
+  Proposed: [new value]
+  ```
+
+#### Medium Priority (Content Improvements)
+
+**2. [Issue]: [Current state]**
+- **Problem**: [Why this matters]
+- **Recommendation**: [Specific change]
+- **Suggested content**: [Brief outline or example]
+
+#### Low Priority (Nice to Have)
+
+**3. [Issue]**
+- **Recommendation**: [Suggestion]
+
+---
+
+### Step 7: Offer to Apply Changes
+
+After presenting recommendations, ask the user:
+
+```
+Would you like me to apply these changes?
+- [A] Apply all recommendations
+- [B] Apply high priority only
+- [C] Let me choose specific changes
+- [D] No changes - just wanted the analysis
+```
+
+If user approves changes:
+
+1. Edit the file using the Edit tool
+2. Make changes in order of priority
+3. After each major change, briefly note what was modified
+4. Run `make lint` to verify no issues introduced
+5. Summarize all changes made
+
+## Content Type-Specific Guidance
+
+### Blog Posts
+
+Additional checks for blog content:
+- **Recency signal**: Year in title or prominent placement
+- **Author credibility**: Author has bio with relevant expertise
+- **Social meta**: og:image, og:description present
+- **Call to action**: Clear next step for readers
+
+### Documentation
+
+Additional checks for docs:
+- **Task orientation**: Helps users accomplish specific goals
+- **Code examples**: Working, copy-pasteable code
+- **Prerequisites**: Clear about what users need to know/have
+- **Next steps**: Links to related content
+
+### What-Is Pages
+
+Additional checks for explainer content:
+- **Definition first**: Clear definition in first paragraph
+- **Comparison context**: How it relates to alternatives
+- **Use cases**: When and why to use this
+- **Getting started**: Path to hands-on experience
+
+## Example Output
+
+```markdown
+## SEO/AEO Analysis: `content/blog/2026/01/config-management/index.md`
+
+### Summary
+
+| Category | Score | Priority Items |
+|----------|-------|----------------|
+| AEO Readiness | 3/6 | Missing quotable definition, no FAQ section |
+| SEO Fundamentals | 4/5 | Title slightly long (67 chars) |
+| Positioning | 2/3 | Could emphasize real programming languages |
+
+### Priority Recommendations
+
+#### High Priority
+
+**1. Title too long (67 chars)**
+- **Problem**: May be truncated in search results
+- **Recommendation**: Shorten to under 60 characters
+- **Example**:
+  ```
+  Current: "How to Implement Configuration Management with Pulumi and TypeScript"
+  Proposed: "Configuration Management with Pulumi and TypeScript"
+  ```
+
+**2. Missing quotable definition**
+- **Problem**: AI tools can't extract a clear answer
+- **Recommendation**: Add a direct definition in the first paragraph
+- **Suggested opening**:
+  ```
+  Configuration management is the process of maintaining systems,
+  servers, and software in a desired, consistent state. Pulumi
+  enables configuration management using real programming languages
+  like TypeScript, Python, and Go.
+  ```
+
+#### Medium Priority
+
+**3. No FAQ section**
+- **Recommendation**: Add FAQ addressing common questions
+- **Suggested questions**:
+  - What is configuration management?
+  - How does Pulumi handle configuration management?
+  - What's the difference between configuration management and IaC?
+```
+
+## Integration Notes
+
+This skill is recommended as a follow-up to:
+- `/new-blog-post` - After creating a new blog post
+- `/glow-up` - After comprehensive content review
+- Manual content creation - Before committing new documentation
diff --git a/.claude/commands/seo-enhance/references/aeo-checklist.md b/.claude/commands/seo-enhance/references/aeo-checklist.md
new file mode 100644
index 000000000000..9b52089c4aa8
--- /dev/null
+++ b/.claude/commands/seo-enhance/references/aeo-checklist.md
@@ -0,0 +1,331 @@
+# AEO (Answer Engine Optimization) Checklist
+
+Use this checklist to evaluate content for AI discoverability. AI answer engines (ChatGPT, Claude, Perplexity, Google AI Overviews) prefer content that is structured, authoritative, and easy to extract.
+
+## Core AEO Patterns
+
+### 1. Quotable Definition (Opening Paragraph)
+
+**Why it matters:** AI tools extract opening paragraphs to answer "what is" queries. A clear, direct definition increases citation likelihood.
+
+**Check:**
+- First 1-2 sentences provide a clear, standalone definition
+- Definition can be quoted without requiring surrounding context
+- Avoids jargon or assumes minimal prior knowledge
+- Under 50 words for the core definition
+- **No hedging, no fluff** - direct answer without qualifiers
+
+**Good example:**
+```
+Configuration management is the process of maintaining systems, servers,
+and software in a desired, consistent state. It ensures that changes are
+tracked, controlled, and can be reversed if needed.
+```
+
+**Bad examples:**
+
+Fluffy intro (no direct answer):
+```
+In this article, we'll explore how modern teams are approaching the
+challenge of keeping their infrastructure consistent. Let's dive in!
+```
+
+Hedging language (avoids commitment):
+```
+Configuration management can mean different things depending on context.
+It depends on your specific needs, but generally speaking, it might involve...
+```
+
+### 2. Semantic Chunking
+
+**Why it matters:** AI systems extract self-contained meaning units. Each section should address one specific concept.
+
+**Check:**
+- Each H2 section covers a single, focused topic
+- Paragraphs are 2-4 sentences (not walls of text)
+- Sections can be understood in isolation
+- Clear topic sentences at the start of sections
+
+**Good structure:**
+```markdown
+## What is Configuration Management?
+[Definition and explanation - one concept]
+
+## Benefits of Configuration Management
+[List of benefits - one concept]
+
+## How Pulumi Handles Configuration Management
+[Pulumi-specific approach - one concept]
+```
+
+**Bad structure:**
+```markdown
+## Introduction
+[Mixes definition, history, benefits, and tools in one section]
+```
+
+### 3. FAQ Sections (Doubt-Removers)
+
+**Why it matters:** Q&A format directly matches how users query AI tools. FAQs should target "doubt-removers" - the specific questions that block purchase decisions.
+
+**Check:**
+- Questions target high-stakes evaluation criteria (not general education)
+- Answers are direct and complete (2-4 sentences)
+- Structure matters more than schema markup for LLM extraction
+
+**Priority FAQ topics (doubt-removers):**
+- **Integrations**: "Does Pulumi work with X?" / "Can I use Pulumi with Kubernetes?"
+- **Limits/constraints**: "What are the limits?" / "How many resources can I manage?"
+- **Pricing/billing**: "How does pricing work?" / "Is there a free tier?"
+- **Security/compliance**: "Is Pulumi SOC 2 compliant?" / "How are secrets stored?"
+- **Migration**: "How do I migrate from Terraform?" / "Can I import existing resources?"
+
+**Good format:**
+```markdown
+## Frequently Asked Questions
+
+### What is the difference between configuration management and IaC?
+Configuration management focuses on maintaining the state of existing
+systems, while Infrastructure as Code (IaC) provisions and manages
+the infrastructure itself. Pulumi bridges both by using real
+programming languages for infrastructure that can also manage
+configuration.
+
+### How do I get started with configuration management in Pulumi?
+Start by installing Pulumi and creating a new project with
+`pulumi new`. Then define your configuration using TypeScript,
+Python, Go, or another supported language.
+```
+
+### 4. Citable Claims with Specific Data
+
+**Why it matters:** AI tools prefer citing sources with specific, verifiable data over vague claims.
+
+**Check:**
+- Factual claims include specific numbers, dates, or metrics
+- Statistics are attributed to sources
+- Comparisons use concrete data points
+- Avoids vague superlatives ("very fast", "many users")
+
+**Good examples:**
+```
+Pulumi supports over 290 cloud and SaaS providers.
+Teams using Pulumi report 3-5x faster deployments.
+Founded in 2017, Pulumi has 8+ years of infrastructure intelligence.
+```
+
+**Bad examples:**
+```
+Pulumi supports many cloud providers.
+Pulumi makes deployments much faster.
+Pulumi has been around for a long time.
+```
+
+### 5. Comparison Tables
+
+**Why it matters:** AI systems easily parse structured tables. Comparison content ranks highly for "vs" and "best" queries.
+
+**Check:**
+- Use markdown tables for feature comparisons
+- Include clear column headers
+- Keep cells concise (1-5 words ideal)
+- Cover 3-5 key comparison points
+
+**Good format:**
+```markdown
+| Feature | Pulumi | Terraform | CloudFormation |
+|---------|--------|-----------|----------------|
+| Languages | TypeScript, Python, Go, C#, Java | HCL only | YAML/JSON |
+| Multi-cloud | Yes | Yes | AWS only |
+| Testing | Native language testing | Limited | Limited |
+| IDE Support | Full (IntelliSense, debugging) | Basic | Basic |
+```
+
+### 6. Question Coverage (What/How/Why/When)
+
+**Why it matters:** Users query AI tools with different intents. Comprehensive content addresses multiple question types.
+
+**Check:**
+- **What**: Definition and explanation covered
+- **How**: Implementation steps or tutorial included
+- **Why**: Benefits and use cases explained
+- **When**: Appropriate scenarios described
+
+**Question mapping:**
+```markdown
+## What is [Topic]?          <- Answers "what is" queries
+## Why Use [Topic]?          <- Answers "why should I" queries
+## How to Implement [Topic]  <- Answers "how do I" queries
+## When to Use [Topic]       <- Answers "when should I" queries
+```
+
+### 7. Listicle Format
+
+**Why it matters:** Research shows listicles make up 32% of all AI citations (SEOMator analysis of 177 million citations). AI systems prefer extracting from single comprehensive sources with clear, numbered or bulleted lists.
+
+**Check:**
+- Content includes numbered or bulleted lists where appropriate
+- List items are self-contained and extractable
+- Lists summarize key points, steps, or options
+- "Top X" or "X ways to" format for relevant content
+
+**Good formats:**
+```markdown
+## 5 Benefits of Configuration Management
+
+1. **Consistency**: Ensures all systems maintain the same state
+2. **Auditability**: Track all changes with version control
+3. **Reproducibility**: Recreate environments reliably
+4. **Compliance**: Meet regulatory requirements automatically
+5. **Efficiency**: Reduce manual configuration errors
+
+## Key Features of Pulumi ESC
+
+- **Hierarchical configuration**: Inherit and override settings
+- **Dynamic secrets**: Pull from external providers at runtime
+- **Environment composition**: Combine multiple config sources
+- **Access control**: Fine-grained permissions per environment
+```
+
+**When to use:**
+- "Best practices" content
+- Feature comparisons
+- Step-by-step guides
+- Benefits/advantages summaries
+- Tool or option roundups
+
+### 8. E-E-A-T Signals (Experience, Expertise, Authoritativeness, Trustworthiness)
+
+**Why it matters:** Google's quality guidelines emphasize E-E-A-T as a key factor in content evaluation. AI systems similarly prefer citing sources that demonstrate clear expertise and authority.
+
+**Check:**
+- **Experience**: Content shows real-world usage (code examples, screenshots, case studies)
+- **Expertise**: Author credentials visible, technical depth appropriate to topic
+- **Authoritativeness**: Citations to official docs, industry recognition, backlinks
+- **Trustworthiness**: Accurate information, recent updates, transparent about limitations
+
+**Good signals:**
+```markdown
+<!-- Experience -->
+In our production deployment at [Company], we reduced deployment time by 40%...
+Here's the actual Pulumi code we use to manage our Kubernetes clusters:
+
+<!-- Expertise -->
+Authors: jane-doe (Senior Platform Engineer, 8 years IaC experience)
+
+<!-- Authoritativeness -->
+Per Google's official documentation: "..."
+As recommended in the CIS Kubernetes Benchmark...
+
+<!-- Trustworthiness -->
+Last updated: January 2026
+Note: This approach works for Pulumi v3.x. For v2.x, see [migration guide].
+```
+
+**Content indicators:**
+- Author bios with relevant credentials
+- "Last updated" dates on technical content
+- Links to official documentation and standards
+- Real code examples from production use
+- Acknowledgment of edge cases or limitations
+
+### 9. Down-Funnel Specificity
+
+**Why it matters:** AEO skews heavily toward "down-funnel, specific, messy" questions - integrations, workflows, edge cases, comparisons. These are the queries where LLMs need authoritative answers most, and where generic content fails.
+
+**Check:**
+- Content addresses specific use cases, not just general concepts
+- Covers integrations with other tools/platforms
+- Documents edge cases and workarounds
+- Addresses real evaluation criteria buyers have
+
+**High-value content types:**
+- Integration guides ("Pulumi + Kubernetes + ArgoCD")
+- Workflow documentation ("CI/CD with Pulumi and GitHub Actions")
+- Edge case coverage ("Handling state drift", "Managing large stacks")
+- Comparison content ("Pulumi vs Terraform for multi-cloud")
+- Migration guides ("Moving from CloudFormation to Pulumi")
+
+**Bad example (too generic):**
+```
+Pulumi is an infrastructure as code platform. It helps you manage cloud resources.
+```
+
+**Good example (specific, actionable):**
+```
+To deploy a Kubernetes application with Pulumi and ArgoCD, first create a
+Pulumi program that defines your Kubernetes resources, then configure ArgoCD
+to watch your Git repository for changes. Here's a working example...
+```
+
+### 10. Agent-Friendly Content
+
+**Why it matters:** AI agents increasingly complete tasks, not just answer questions. Content should include clear, executable steps that an agent could follow or recommend.
+
+**Check:**
+- Clear CTAs with specific next steps
+- Numbered steps for executable actions
+- Well-defined tasks with concrete outcomes
+- Commands and code that can be copied/executed
+
+**Good format:**
+```markdown
+## Get started in 3 steps
+
+1. **Install the Pulumi CLI**
+   ```bash
+   curl -fsSL https://get.pulumi.com | sh
+   ```
+
+2. **Create a new project**
+   ```bash
+   pulumi new typescript
+   ```
+
+3. **Deploy your infrastructure**
+   ```bash
+   pulumi up
+   ```
+```
+
+**Why this works for agents:**
+- Each step has a concrete action
+- Commands are copy-pasteable
+- Success criteria is clear (infrastructure deployed)
+- No ambiguity about what to do next
+
+## AEO Scoring
+
+| Pattern | Weight | Pass Criteria |
+|---------|--------|---------------|
+| Quotable Definition | High | Clear definition in first 2 sentences, no hedging |
+| Semantic Chunking | High | Single concept per section |
+| FAQ Sections | Medium | Targets doubt-removers (integrations, limits, security, migration) |
+| Citable Claims | Medium | 3+ specific data points |
+| Comparison Tables | Medium | At least 1 table (where appropriate) |
+| Question Coverage | Medium | Addresses 3+ question types |
+| Listicle Format | Medium | Uses lists for key points (where appropriate) |
+| E-E-A-T Signals | High | Shows experience, expertise, authority, trust |
+| Down-Funnel Specificity | High | Covers integrations, edge cases, specific workflows |
+| Agent-Friendly Content | Medium | Clear CTAs, numbered steps, executable actions |
+
+**Scoring:**
+- 10/10: Excellent AEO readiness
+- 8-9/10: Good, minor improvements needed
+- 5-7/10: Moderate, some gaps to address
+- 0-4/10: Poor, major restructuring needed
+
+## Content Type Applicability
+
+| Pattern | Blog | Docs | What-Is | Tutorial |
+|---------|------|------|---------|----------|
+| Quotable Definition | Required | Required | Required | Optional |
+| Semantic Chunking | Required | Required | Required | Required |
+| FAQ Sections | Recommended | Optional | Recommended | Optional |
+| Citable Claims | Recommended | Recommended | Required | Optional |
+| Comparison Tables | Optional | Optional | Recommended | Optional |
+| Question Coverage | Recommended | Optional | Required | Optional |
+| Listicle Format | Recommended | Recommended | Recommended | Required |
+| E-E-A-T Signals | Required | Recommended | Required | Recommended |
+| Down-Funnel Specificity | Recommended | Required | Recommended | Required |
+| Agent-Friendly Content | Recommended | Required | Recommended | Required |
diff --git a/.claude/commands/seo-enhance/references/pulumi-positioning.md b/.claude/commands/seo-enhance/references/pulumi-positioning.md
new file mode 100644
index 000000000000..a147c48eaa71
--- /dev/null
+++ b/.claude/commands/seo-enhance/references/pulumi-positioning.md
@@ -0,0 +1,110 @@
+# Pulumi Positioning and Messaging Reference
+
+Use this reference to align content recommendations with Pulumi's messaging framework.
+
+## Master Positioning
+
+**Tagline:** "Infrastructure as Code Platform, Now with Agentic AI"
+
+**Positioning Statement:** "Pulumi is the comprehensive infrastructure as code platform trusted by thousands of teams worldwide. We unify infrastructure as code, secrets management, policy governance, and agentic AI in one platform—helping teams ship faster, scale confidently, and enable secure developer self-service without sacrificing control."
+
+## Key Differentiators
+
+When creating or optimizing content, emphasize these differentiators where relevant:
+
+1. **Unified IaC Platform**: Everything teams need in one place vs. stitching together disconnected tools
+2. **Real Programming Languages**: TypeScript, Python, Go, C#, Java—not proprietary DSLs like HCL
+3. **Agentic AI Integration (Neo)**: AI that understands infrastructure context, not generic automation
+4. **Human-in-the-Loop**: AI handles complexity, humans maintain control and governance
+5. **Proven at Scale**: 8+ years of infrastructure intelligence across thousands of teams
+6. **Developer-Native Design**: Built for developers using real programming languages
+
+## Identity-Based Positioning (vs. Competitors)
+
+**Pulumi:** Built for Software Development Teams
+- Use programming languages your team already knows
+- Software development mindset with testing, debugging, version control
+- Infrastructure as actual code, not configuration files
+
+**Terraform:** Built for Traditional IT Operations
+- Proprietary HCL language
+- Infrastructure operations mindset
+- Configuration management approach
+
+## Jobs-to-be-Done Framework
+
+Content should connect to these customer outcomes:
+
+### Job 1: "Ship Faster Without Breaking Things"
+- Deploy 3-5x faster with built-in testing, previews, rollback
+- Eliminate custom workarounds required by traditional IaC tools
+- Metrics: deployment frequency, change failure rate, MTTR
+
+### Job 2: "Multiply Team Capacity Without Adding Headcount"
+- Small platform teams support complexity that would require much larger teams
+- Automation, reusable components, self-service capabilities
+- Metrics: infrastructure managed per engineer, developer-to-platform-engineer ratio
+
+### Job 3: "Enable Developer Self-Service Without Losing Control"
+- Developers provision what they need while platform teams maintain oversight
+- Support multi-cloud, multi-tenant, customer-specific configurations
+- Metrics: self-service fulfillment rate, policy violation rate
+
+## Audience Value Propositions
+
+### Platform Engineers
+- "Deploy infrastructure faster using programming languages you already know"
+- Care about: familiar tools, reusable components, reducing operational toil
+- Language: "policy as code," "software development lifecycle," "version control"
+
+### Engineering Managers
+- "Stop being the bottleneck between your business and development speed"
+- Care about: scaling team impact, proving ROI, transformation without sacrificing governance
+- Language: "platform ROI," "developer velocity," "executive dashboards"
+
+### Executives
+- "Accelerate innovation while reducing infrastructure risk and cost"
+- Care about: business agility, cost optimization, risk reduction, measurable outcomes
+- Language: "competitive differentiation," "infrastructure costs," "compliance"
+
+## Key Products and Capabilities
+
+### Pulumi IaC
+- Infrastructure as Code using real programming languages
+- 290+ cloud and SaaS providers
+- Full IDE support, testing frameworks, debugging
+
+### Pulumi Cloud
+- Managed state and secrets (ESC)
+- Policy as Code (Policies/CrossGuard)
+- Deployments and automation
+- Infrastructure intelligence (Insights)
+- AI-powered operations (Neo)
+
+### Pulumi Neo
+- AI-powered platform engineering assistant
+- Natural language infrastructure delegation
+- Policy-aware automation with human-in-the-loop
+- Built on 8+ years of infrastructure intelligence
+
+### Pulumi Policies
+- Complete governance lifecycle: Audit, Remediate, Prevent
+- Policies in real programming languages (TypeScript, Python, Go, C#)
+- AI-powered remediation via Neo
+- Compliance framework support (CIS, NIST, HITRUST, SOC 2, ISO 27001)
+
+## Competitive Positioning Quick Reference
+
+| Competitor | Pulumi Advantage |
+|------------|------------------|
+| Terraform/HCL | Real programming languages vs. proprietary DSL; software dev culture vs. IT ops |
+| AWS CDK/CloudFormation | Multi-cloud vs. vendor lock-in; programming languages vs. YAML |
+| Crossplane | Works without Kubernetes; lower barrier to entry |
+| CSPM Tools | Prevention vs. detection; developer workflow integration |
+
+## Content Tone Guidelines
+
+- **Technical authenticity**: Developer-native language over corporate buzzwords
+- **Evidence-based**: Lead with proven customer results, not aspirational goals
+- **Multi-audience**: Clear value for engineers, managers, and executives simultaneously
+- **Heritage-forward**: Lead with platform capabilities before AI features
diff --git a/.claude/commands/seo-enhance/references/seo-checklist.md b/.claude/commands/seo-enhance/references/seo-checklist.md
new file mode 100644
index 000000000000..31dd2b1e98a5
--- /dev/null
+++ b/.claude/commands/seo-enhance/references/seo-checklist.md
@@ -0,0 +1,274 @@
+# SEO Fundamentals Checklist
+
+Use this checklist to evaluate content for traditional search engine optimization. These are established best practices based on Google's official guidelines.
+
+## On-Page SEO Elements
+
+### 1. Title Tag
+
+**Guidelines (per Google):**
+
+- Under 60 characters (Google typically displays 50-60)
+- Include primary keyword, preferably near the beginning
+- Unique for each page
+- Accurately describes the page content
+- Compelling to encourage clicks
+
+**Check:**
+
+- [ ] Length under 60 characters
+- [ ] Contains primary keyword
+- [ ] Accurately reflects content
+- [ ] Not duplicated elsewhere on site
+
+**Good examples:**
+
+```
+Configuration Management with Pulumi | Tutorial
+How to Use Pulumi ESC for Secrets Management
+Infrastructure as Code: Getting Started Guide
+```
+
+**Bad examples:**
+
+```
+A Comprehensive Guide to Understanding and Implementing Modern Configuration Management Practices (too long)
+Pulumi | Pulumi | Configuration (keyword stuffing)
+Blog Post (not descriptive)
+```
+
+### 2. Meta Description
+
+**Guidelines (per Google):**
+
+- Under 155 characters (Google may truncate longer descriptions)
+- Include primary keyword naturally
+- Compelling call-to-action or value proposition
+- Accurately summarizes page content
+- Unique for each page
+
+**Check:**
+
+- [ ] Length under 155 characters
+- [ ] Contains primary keyword
+- [ ] Includes value proposition or CTA
+- [ ] Accurately summarizes content
+
+**Good examples:**
+
+```
+Learn how to manage infrastructure configuration with Pulumi using TypeScript, Python, or Go. Get started in minutes with our step-by-step guide.
+```
+
+**Bad examples:**
+
+```
+This is a blog post about configuration management. We will discuss various topics related to configuration management and how it works. (no value prop)
+configuration management pulumi configuration management infrastructure (keyword stuffing)
+```
+
+### 3. H1 Heading
+
+**Guidelines:**
+
+- One H1 per page
+- Matches or closely relates to title tag
+- Addresses user's search intent
+- Includes primary keyword naturally
+
+**Check:**
+
+- [ ] Single H1 on page
+- [ ] Contains primary keyword
+- [ ] Matches search intent
+- [ ] Consistent with title tag
+
+**Relationship to title:**
+
+```yaml
+title: "Configuration Management with Pulumi | Tutorial"  # In search results
+h1: "Configuration Management with Pulumi"                 # On the page
+```
+
+### 4. H2 Headings (Subheadings)
+
+**Guidelines:**
+
+- Create logical content hierarchy
+- Include keyword variations and related terms
+- Use sentence case (per style guide)
+- Help users scan and navigate content
+
+**Check:**
+
+- [ ] Logical hierarchy (H2 > H3 > H4)
+- [ ] Include keyword variations
+- [ ] Descriptive and scannable
+- [ ] No skipped heading levels
+
+**Good structure:**
+
+```markdown
+# Configuration Management with Pulumi        <- H1 (primary keyword)
+
+## What is configuration management?          <- H2 (question variant)
+
+## Benefits of configuration management       <- H2 (related term)
+
+## How Pulumi handles configuration          <- H2 (branded variant)
+
+### Using the Command provider               <- H3 (specific subtopic)
+
+### Managing secrets with ESC                <- H3 (specific subtopic)
+```
+
+### 5. Internal Links
+
+**Guidelines (per Google):**
+
+- Use descriptive anchor text (not "click here")
+- Link to relevant, related content
+- Help users discover more content
+- Distribute page authority throughout the site
+
+**Check:**
+
+- [ ] At least 2-3 internal links per page
+- [ ] Descriptive anchor text
+- [ ] Links to relevant content
+- [ ] No broken links
+
+**Good anchor text:**
+
+```markdown
+Learn more about [Pulumi ESC for secrets management]({{< relref "/docs/esc" >}}).
+See our [getting started guide]({{< relref "/docs/get-started" >}}) for installation.
+```
+
+**Bad anchor text:**
+
+```markdown
+Learn more [here]({{< relref "/docs/esc" >}}).
+[Click here]({{< relref "/docs/get-started" >}}) to get started.
+```
+
+### 6. Image Alt Text
+
+**Guidelines:**
+
+- Every image should have descriptive alt text
+- Alt text should describe the image content, not just "image" or "screenshot"
+- Include relevant keywords naturally where appropriate
+- Keep alt text concise (125 characters or less recommended for user experience, though no technical limit exists)
+- Decorative images can use empty alt (`alt=""`)
+
+**Why it matters:**
+
+- Accessibility: Screen readers use alt text for visually impaired users
+- SEO: Search engines use alt text to understand image content
+- Fallback: Displays when images fail to load
+
+**Check:**
+
+- [ ] All content images have descriptive alt text
+- [ ] Alt text describes what the image shows
+- [ ] Keywords included where natural
+- [ ] Decorative images marked appropriately
+
+**Good examples:**
+
+```markdown
+![Pulumi Cloud dashboard showing deployment history](dashboard-deployments.png)
+![Architecture diagram of Pulumi ESC secrets flow](esc-architecture.png)
+```
+
+**Bad examples:**
+
+```markdown
+![image](dashboard.png)
+![screenshot](screenshot1.png)
+![](decorative-banner.png)  <!-- Missing alt text entirely -->
+```
+
+## SEO Scoring
+
+| Element | Weight | Pass Criteria |
+|---------|--------|---------------|
+| Title Tag | High | Under 60 chars, includes keyword |
+| Meta Description | High | Under 155 chars, includes keyword, has CTA |
+| H1 Heading | High | Single H1, matches search intent |
+| H2 Headings | Medium | Include keyword variations |
+| Internal Links | Medium | 2+ links with descriptive anchors |
+| Image Alt Text | Medium | Descriptive alt text on content images |
+
+**Scoring:**
+
+- 6/6: Excellent SEO fundamentals
+- 5/6: Good, minor improvement needed
+- 3-4/6: Fair, some gaps to address
+- 1-2/6: Poor, significant issues
+
+## Content-Specific Guidelines
+
+### Blog Posts
+
+Additional SEO considerations:
+
+- **Date freshness**: Include year in title for timely topics
+- **Author authority**: Author bio establishes expertise
+- **Social sharing**: og:title, og:description, og:image
+- **Related posts**: Link to other relevant blog content
+
+### Documentation
+
+Additional SEO considerations:
+
+- **Navigation context**: Breadcrumbs and menu structure
+- **Canonical URLs**: Avoid duplicate content issues
+- **Version handling**: Noindex old versions if applicable
+- **Code searchability**: Code examples are indexable text
+
+### What-Is Pages
+
+Additional SEO considerations:
+
+- **Featured snippet optimization**: Definition in first paragraph
+- **Related terms**: Link to related what-is pages
+- **Comparison hooks**: Address "vs" queries
+- **Getting started path**: Clear conversion path
+
+## Hugo-Specific Implementation
+
+### Frontmatter SEO Fields
+
+```yaml
+---
+title: "Configuration Management with Pulumi"  # Title tag (required)
+meta_desc: "Learn how to manage..."            # Meta description (required)
+h1: "Configuration Management with Pulumi"     # H1 if different from title
+---
+```
+
+### Internal Link Syntax
+
+Always use Hugo's `relref` shortcode for internal links:
+
+```markdown
+[descriptive text]({{< relref "/docs/path/to/page" >}})
+```
+
+This ensures:
+
+- Links work across environments
+- Broken links caught at build time
+- Proper URL generation
+
+### Canonical URLs
+
+Hugo handles canonical URLs automatically. Override if needed:
+
+```yaml
+---
+canonical_url: "https://www.pulumi.com/docs/preferred-url/"
+---
+```
diff --git a/.claude/commands/seo-gap-analyzer/SKILL.md b/.claude/commands/seo-gap-analyzer/SKILL.md
new file mode 100644
index 000000000000..863cb53cfba4
--- /dev/null
+++ b/.claude/commands/seo-gap-analyzer/SKILL.md
@@ -0,0 +1,283 @@
+---
+description: Analyze content coverage gaps for specific topics and produce strategic plans to improve Pulumi's visibility in traditional search (SEO) and AI discovery (AEO/GEO).
+---
+
+# /seo-gap-analyzer Command
+
+**Use this when:** You need to analyze content coverage gaps for a specific topic, keyword, or section of pulumi.com. Useful to identify visibility issues, competitors outranking Pulumi, or AI tools not mentioning Pulumi for relevant queries.
+
+## Usage
+
+```
+/seo-gap-analyzer <topic-or-scope>
+```
+
+**Examples:**
+
+- `/seo-gap-analyzer configuration management` - Analyze gap for a topic
+- `/seo-gap-analyzer content/docs/esc/` - Analyze a documentation section
+- `/seo-gap-analyzer https://pulumi.com/docs/iac/concepts/` - Analyze a specific page
+
+## Instructions for Claude
+
+This is a **hybrid skill**: research and plan first, then ask for approval before implementing changes.
+
+### Phase 1: Intake and Context Gathering
+
+Extract from the user's request:
+
+- **Target**: Topic, keyword, URL, or content section to analyze
+- **Scope**: Single page, section/topic, or cross-site competitive analysis
+- **Goals**: What outcome is expected (rank higher, get AI citations, etc.)
+- **Context**: Any Slack threads, competitor URLs, or product requirements provided
+
+If critical context is missing, ask:
+
+1. What specific search behavior should trigger Pulumi appearing?
+2. What Pulumi capabilities solve the searcher's problem?
+3. Are there specific competitors to benchmark against?
+
+### Phase 2: Keyword Research
+
+**Load reference:** Read `references/keyword-strategy.md` for the keyword classification framework.
+
+For the target topic, identify keyword variants:
+
+**Unbranded keywords (PRIMARY FOCUS):**
+
+- Head term: `[topic]` (e.g., "configuration management")
+- Long-tail: `[topic] + [modifier]` (e.g., "configuration management kubernetes")
+- Intent variants: `[topic] tutorial`, `what is [topic]`, `[topic] tools`
+
+**Branded keywords (SECONDARY):**
+
+- `pulumi [topic]`
+- `[topic] with pulumi`
+- `pulumi vs [competitor] [topic]`
+
+Prioritize unbranded keywords - they have higher volume and capture users earlier in the discovery journey.
+
+**Identify "Money Prompts":**
+
+Money prompts are high-value queries worth winning in AI tools. Identify them using these proxies:
+
+- **Paid search winners**: Keywords competitors bid on (high commercial intent)
+- **Sales call themes**: Questions prospects ask during evaluations
+- **Support tickets**: Common questions from existing users
+- **High-intent threads**: Reddit/HackerNews discussions about tool selection
+
+Aim to identify 30-100 prompts worth winning for any major topic area. These become AEO targets.
+
+### Phase 3: Current State Analysis
+
+**For SEO (use WebSearch):**
+
+Run searches for prioritized keywords:
+
+1. `[topic]` - Pure unbranded head term
+2. `[topic] infrastructure as code` - Category-qualified
+3. `[topic] tutorial` / `[topic] guide` - Educational intent
+4. `pulumi [topic]` - Branded
+
+For each search, document:
+
+- Pulumi's position (if ranking)
+- Which URL ranks (note if `/registry/` - non-editable)
+- Top 3 competitors and their content type
+- SERP features present (featured snippet, PAA, video)
+
+**For AEO (describe approach to user):**
+
+Explain that AI tools (ChatGPT, Claude, Perplexity) should be tested with queries like:
+
+- "What is [topic]?"
+- "How do I use Pulumi for [topic]?"
+- "Best tools for [topic] with infrastructure as code"
+
+Document whether AI tools mention Pulumi and in what context.
+
+**Reddit/Community Research:**
+
+Mine Reddit and other developer communities for valuable insights:
+
+- **Question phrasing**: How do users actually phrase their questions?
+- **Edge cases**: What specific scenarios cause confusion?
+- **Objections**: What concerns do people raise about Pulumi or alternatives?
+- **Comparison criteria**: What factors do people use to evaluate tools?
+
+Search relevant subreddits (r/devops, r/kubernetes, r/aws, r/terraform) for topic discussions. Turn findings into FAQ sections, comparison content, and use-case pages.
+
+### Phase 4: Existing Content Audit
+
+Use the Grep tool to search the repository for relevant content:
+
+- Find pages mentioning the topic in content
+- Check frontmatter for title and meta_desc fields containing the topic
+- Identify which content sections (docs, blog, learn, what-is, product) cover the topic
+
+**Categorize pages:**
+
+- **EDITABLE**: `/content/docs/`, `/content/blog/`, `/content/learn/`, `/content/what-is/`, `/content/product/`
+- **NON-EDITABLE** (different repo): Anything rendering to `/registry/*`
+
+For each EDITABLE page, evaluate:
+
+| Element | Check |
+|---------|-------|
+| Title | Includes primary keyword? Under 60 chars? |
+| Meta description | Includes keyword? Under 155 chars? Compelling? |
+| H1 | Matches search intent? |
+| H2s | Include keyword variations? |
+| Opening paragraph | Clear definition/answer? |
+| Content depth | Comprehensive coverage? |
+| Internal links | Well-connected to related content? |
+
+### Phase 5: Gap Analysis
+
+**Load reference:** Read `references/seo-aeo-sources.md` for authoritative best practices.
+
+Categorize identified gaps:
+
+| Gap Type | Description | Priority |
+|----------|-------------|----------|
+| **On-page optimization** | Pages with poor SEO elements | HIGH - Quick fix |
+| **Content depth** | Pages that mention topic but lack depth | HIGH - Moderate effort |
+| **Internal linking** | Pages exist but aren't connected | HIGH - Quick fix |
+| **Keyword coverage** | No page targeting key unbranded terms | MEDIUM - New content |
+| **AEO/GEO** | AI tools don't surface Pulumi | MEDIUM - Long-term |
+| **Citation gaps** | Competitors cited but Pulumi is not | HIGH - Content opportunity |
+
+**Citation Gap Mapping:**
+
+For each target topic, document the current citation landscape:
+
+1. **What gets cited?** - Which sources do AI tools currently reference for this topic?
+2. **Why them?** - What makes those sources "path of least resistance" for AI?
+3. **What's missing?** - What would Pulumi need to be the preferred citation?
+
+Common citation gap patterns:
+- Competitor has a dedicated page; Pulumi only mentions topic in passing
+- Competitor content is more structured (tables, lists, clear definitions)
+- Competitor content is more recent or comprehensive
+- Pulumi content exists but isn't well-connected (poor internal linking)
+
+### Phase 6: Strategic Plan
+
+**Load reference:** Read `references/pulumi-positioning.md` for messaging alignment.
+
+Produce a prioritized plan:
+
+#### Executive Summary
+
+- 2-3 sentence summary of gap and opportunity
+- Primary unbranded keyword target
+- Key existing page(s) to optimize
+
+#### Priority 1: Existing Page Optimizations
+
+For each page to optimize:
+
+**Page: [URL]**
+**File: `content/[path]/[file].md`**
+
+| Element | Current | Proposed | Rationale |
+|---------|---------|----------|-----------|
+| Title | [current] | [new] | Include keyword per Google guidelines |
+| Meta desc | [current] | [new] | Improve CTR |
+| H1 | [current] | [new] | Match search intent |
+
+**Content changes:**
+
+- Add section: [H2 heading] - [description]
+- Expand section: [existing H2] - [what to add]
+
+**Internal links:**
+
+- Link TO this page FROM: [pages with anchor text]
+- Link FROM this page TO: [pages with anchor text]
+
+#### Priority 2: Internal Linking Campaign
+
+| Source Page | Anchor Text | Location |
+|-------------|-------------|----------|
+| `content/docs/[path].md` | [keyword-rich anchor] | [section] |
+
+#### Priority 3: New Content (Only If Necessary)
+
+Only recommend if existing pages cannot cover the keyword:
+
+- **File path**: `content/[section]/[slug]/_index.md`
+- **Target keyword**: [unbranded keyword]
+- **Why new content**: [what gap this fills]
+- **Content brief**: [H1, key H2s, main points]
+
+#### Success Metrics
+
+- Rank top 10 for "[unbranded keyword]" within 90 days
+- Rank top 3 for "[branded keyword]" within 30 days
+- AI tools cite Pulumi for "[topic]" queries
+
+### Phase 7: Approval Gate
+
+**CRITICAL**: Present the complete plan to the user and ask for approval before making any changes.
+
+Use AskUserQuestion to confirm:
+
+- Which recommendations to implement
+- Any modifications to the plan
+- Priority order for implementation
+
+**Do NOT proceed to Phase 8 without explicit approval.**
+
+### Phase 8: Implementation
+
+After approval, implement changes:
+
+1. Create a feature branch:
+
+   ```bash
+   git checkout -b seo/[topic]-optimization
+   ```
+
+2. Make approved changes:
+   - Edit frontmatter (title, meta_desc)
+   - Update markdown content
+   - Add internal links using Hugo syntax:
+
+     ```markdown
+     [descriptive anchor text]({{< relref "/docs/path/to/page" >}})
+     ```
+
+3. Validate:
+
+   ```bash
+   make lint
+   make serve  # Preview at http://localhost:1313
+   ```
+
+4. Commit with clear message:
+
+   ```bash
+   git add content/[files]
+   git commit -m "SEO: Optimize [page] for '[keyword]'
+
+   - Updated title to include '[keyword]'
+   - Expanded [section] with [topic] coverage
+   - Added internal links
+
+   Target: Rank top 10 for '[keyword]'"
+   ```
+
+## Critical Constraints
+
+1. **Never modify `/registry/*` pages** - They're in a separate repository (pulumi/registry)
+2. **Optimize existing content first** - Existing pages have domain authority; new pages don't
+3. **Focus on unbranded keywords** - Higher volume, earlier funnel, builds awareness
+4. **Follow Google's guidelines** - See `references/seo-aeo-sources.md` for authoritative sources
+
+## Example Triggers
+
+- "We need better coverage for 'configuration management' - here's the Slack thread..."
+- "Competitors are outranking us for '[term]', what can we do?"
+- "AI tools don't mention Pulumi when asked about [capability]"
+- "The Command provider should rank for 'configuration management' but it's in Registry"
diff --git a/.claude/commands/seo-gap-analyzer/references/keyword-strategy.md b/.claude/commands/seo-gap-analyzer/references/keyword-strategy.md
new file mode 100644
index 000000000000..d5976ad3f808
--- /dev/null
+++ b/.claude/commands/seo-gap-analyzer/references/keyword-strategy.md
@@ -0,0 +1,97 @@
+# Keyword Strategy Framework
+
+## Unbranded vs. Branded Keywords
+
+### Unbranded Keywords (PRIMARY FOCUS)
+
+Unbranded keywords do not include "Pulumi" in the search query. They should be the primary focus because they:
+
+- Have higher search volume
+- Capture users earlier in the discovery journey
+- Build awareness among people who don't yet know Pulumi
+- Are more competitive but more valuable for growth
+
+**Examples:**
+- "configuration management"
+- "infrastructure as code"
+- "secrets management kubernetes"
+- "policy as code tutorial"
+
+### Branded Keywords (SECONDARY)
+
+Branded keywords include "Pulumi" in the search query. They are important but secondary because:
+
+- Lower search volume
+- Users already have Pulumi awareness
+- Often easier to rank for (less competition)
+- Important for conversion but not discovery
+
+**Examples:**
+- "pulumi configuration management"
+- "pulumi vs terraform"
+- "pulumi esc tutorial"
+
+## Keyword Priority Framework
+
+| Keyword Type | Example | Priority | Goal |
+|--------------|---------|----------|------|
+| **Unbranded - Head** | "configuration management" | HIGH | Compete for awareness |
+| **Unbranded - Long-tail** | "configuration management for kubernetes" | HIGH | Capture specific intent |
+| **Branded - Comparative** | "pulumi vs ansible" | MEDIUM | Win consideration |
+| **Branded - Navigational** | "pulumi command provider" | LOW | Already ranking likely |
+
+## Keyword Variant Generation
+
+For any target topic, generate these variant types:
+
+### Intent-Based Variants
+
+| Intent | Pattern | Example |
+|--------|---------|---------|
+| Informational | "what is [topic]" | "what is configuration management" |
+| Educational | "[topic] tutorial" | "configuration management tutorial" |
+| Commercial | "[topic] tools" | "configuration management tools" |
+| Comparison | "[topic] vs [alternative]" | "ansible vs terraform configuration" |
+
+### Modifier-Based Variants
+
+| Modifier Type | Examples |
+|---------------|----------|
+| Technology | "[topic] kubernetes", "[topic] aws" |
+| Use case | "[topic] best practices", "[topic] security" |
+| Audience | "[topic] for developers", "[topic] enterprise" |
+| Format | "[topic] guide", "[topic] examples" |
+
+## Search Intent Categories
+
+Understanding search intent helps match content to queries:
+
+### Informational Intent
+User wants to learn or understand something.
+- Signals: "what is", "how does", "why", "guide"
+- Content type: Explainer pages, tutorials, documentation
+
+### Navigational Intent
+User wants to find a specific page or resource.
+- Signals: Brand names, product names, specific features
+- Content type: Product pages, documentation sections
+
+### Commercial Intent
+User is researching before a purchase decision.
+- Signals: "best", "vs", "comparison", "review", "pricing"
+- Content type: Comparison pages, case studies, pricing pages
+
+### Transactional Intent
+User wants to take a specific action.
+- Signals: "download", "sign up", "buy", "get started"
+- Content type: Landing pages, signup flows, download pages
+
+## Competitive Analysis Questions
+
+When analyzing keyword competition:
+
+1. **Who ranks?** - Identify top 3-5 competitors for each keyword
+2. **What content type?** - Blog, documentation, landing page, tool?
+3. **What's their angle?** - Tutorial, comparison, reference, thought leadership?
+4. **What's missing?** - Gaps in their coverage Pulumi could fill
+5. **Authority signals?** - Domain authority, backlinks, content freshness
diff --git a/.claude/commands/seo-gap-analyzer/references/pulumi-positioning.md b/.claude/commands/seo-gap-analyzer/references/pulumi-positioning.md
new file mode 100644
index 000000000000..a147c48eaa71
--- /dev/null
+++ b/.claude/commands/seo-gap-analyzer/references/pulumi-positioning.md
@@ -0,0 +1,110 @@
+# Pulumi Positioning and Messaging Reference
+
+Use this reference to align content recommendations with Pulumi's messaging framework.
+
+## Master Positioning
+
+**Tagline:** "Infrastructure as Code Platform, Now with Agentic AI"
+
+**Positioning Statement:** "Pulumi is the comprehensive infrastructure as code platform trusted by thousands of teams worldwide. We unify infrastructure as code, secrets management, policy governance, and agentic AI in one platform—helping teams ship faster, scale confidently, and enable secure developer self-service without sacrificing control."
+
+## Key Differentiators
+
+When creating or optimizing content, emphasize these differentiators where relevant:
+
+1. **Unified IaC Platform**: Everything teams need in one place vs. stitching together disconnected tools
+2. **Real Programming Languages**: TypeScript, Python, Go, C#, Java—not proprietary DSLs like HCL
+3. **Agentic AI Integration (Neo)**: AI that understands infrastructure context, not generic automation
+4. **Human-in-the-Loop**: AI handles complexity, humans maintain control and governance
+5. **Proven at Scale**: 8+ years of infrastructure intelligence across thousands of teams
+6. **Developer-Native Design**: Built for developers using real programming languages
+
+## Identity-Based Positioning (vs. Competitors)
+
+**Pulumi:** Built for Software Development Teams
+- Use programming languages your team already knows
+- Software development mindset with testing, debugging, version control
+- Infrastructure as actual code, not configuration files
+
+**Terraform:** Built for Traditional IT Operations
+- Proprietary HCL language
+- Infrastructure operations mindset
+- Configuration management approach
+
+## Jobs-to-be-Done Framework
+
+Content should connect to these customer outcomes:
+
+### Job 1: "Ship Faster Without Breaking Things"
+- Deploy 3-5x faster with built-in testing, previews, rollback
+- Eliminate custom workarounds required by traditional IaC tools
+- Metrics: deployment frequency, change failure rate, MTTR
+
+### Job 2: "Multiply Team Capacity Without Adding Headcount"
+- Small platform teams support complexity that would require much larger teams
+- Automation, reusable components, self-service capabilities
+- Metrics: infrastructure managed per engineer, developer-to-platform-engineer ratio
+
+### Job 3: "Enable Developer Self-Service Without Losing Control"
+- Developers provision what they need while platform teams maintain oversight
+- Support multi-cloud, multi-tenant, customer-specific configurations
+- Metrics: self-service fulfillment rate, policy violation rate
+
+## Audience Value Propositions
+
+### Platform Engineers
+- "Deploy infrastructure faster using programming languages you already know"
+- Care about: familiar tools, reusable components, reducing operational toil
+- Language: "policy as code," "software development lifecycle," "version control"
+
+### Engineering Managers
+- "Stop being the bottleneck between your business and development speed"
+- Care about: scaling team impact, proving ROI, transformation without sacrificing governance
+- Language: "platform ROI," "developer velocity," "executive dashboards"
+
+### Executives
+- "Accelerate innovation while reducing infrastructure risk and cost"
+- Care about: business agility, cost optimization, risk reduction, measurable outcomes
+- Language: "competitive differentiation," "infrastructure costs," "compliance"
+
+## Key Products and Capabilities
+
+### Pulumi IaC
+- Infrastructure as Code using real programming languages
+- 290+ cloud and SaaS providers
+- Full IDE support, testing frameworks, debugging
+
+### Pulumi Cloud
+- Managed state and secrets (ESC)
+- Policy as Code (Policies/CrossGuard)
+- Deployments and automation
+- Infrastructure intelligence (Insights)
+- AI-powered operations (Neo)
+
+### Pulumi Neo
+- AI-powered platform engineering assistant
+- Natural language infrastructure delegation
+- Policy-aware automation with human-in-the-loop
+- Built on 8+ years of infrastructure intelligence
+
+### Pulumi Policies
+- Complete governance lifecycle: Audit, Remediate, Prevent
+- Policies in real programming languages (TypeScript, Python, Go, C#)
+- AI-powered remediation via Neo
+- Compliance framework support (CIS, NIST, HITRUST, SOC 2, ISO 27001)
+
+## Competitive Positioning Quick Reference
+
+| Competitor | Pulumi Advantage |
+|------------|------------------|
+| Terraform/HCL | Real programming languages vs. proprietary DSL; software dev culture vs. IT ops |
+| AWS CDK/CloudFormation | Multi-cloud vs. vendor lock-in; programming languages vs. YAML |
+| Crossplane | Works without Kubernetes; lower barrier to entry |
+| CSPM Tools | Prevention vs. detection; developer workflow integration |
+
+## Content Tone Guidelines
+
+- **Technical authenticity**: Developer-native language over corporate buzzwords
+- **Evidence-based**: Lead with proven customer results, not aspirational goals
+- **Multi-audience**: Clear value for engineers, managers, and executives simultaneously
+- **Heritage-forward**: Lead with platform capabilities before AI features
diff --git a/.claude/commands/seo-gap-analyzer/references/seo-aeo-sources.md b/.claude/commands/seo-gap-analyzer/references/seo-aeo-sources.md
new file mode 100644
index 000000000000..d1b937685008
--- /dev/null
+++ b/.claude/commands/seo-gap-analyzer/references/seo-aeo-sources.md
@@ -0,0 +1,108 @@
+# Authoritative SEO and AEO Sources
+
+Reference these authoritative sources when making recommendations. Always prefer established guidelines over anecdotal advice.
+
+## SEO Sources
+
+### Google Official Documentation
+
+| Resource | URL | Use For |
+|----------|-----|---------|
+| SEO Starter Guide | https://developers.google.com/search/docs/fundamentals/seo-starter-guide | Foundational best practices |
+| Helpful Content System | https://developers.google.com/search/docs/fundamentals/creating-helpful-content | Content quality guidelines |
+| Title Link Guidelines | https://developers.google.com/search/docs/appearance/title-link | Title tag optimization |
+| Snippet Guidelines | https://developers.google.com/search/docs/appearance/snippet | Meta description best practices |
+| Structured Data | https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data | Schema markup implementation |
+
+### Key Google Principles
+
+**Helpful Content:**
+- Content should be created primarily for people, not search engines
+- Demonstrate first-hand expertise and depth of knowledge
+- Provide substantial value compared to other pages in search results
+- Satisfy the user's need without requiring additional searches
+
+**E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness):**
+- Show real-world experience with the topic
+- Demonstrate subject matter expertise
+- Build authority through quality content and backlinks
+- Establish trust through accuracy and transparency
+
+## AEO (Answer Engine Optimization) Sources
+
+### Schema.org
+
+| Resource | URL | Use For |
+|----------|-----|---------|
+| Schema.org Main | https://schema.org | Structured data vocabulary |
+| FAQPage Schema | https://schema.org/FAQPage | FAQ markup |
+| HowTo Schema | https://schema.org/HowTo | Tutorial/guide markup |
+| TechArticle Schema | https://schema.org/TechArticle | Technical documentation markup |
+
+### AI Search Behavior Research
+
+**Key findings from industry research (Amsive, Conductor, SEOMator):**
+
+1. **Listicles dominate AI citations** - 32% of AI citations come from listicle-format content
+2. **Semantic chunking matters** - Structure content so each paragraph addresses one specific concept
+3. **Date signals increase citation** - Including current year in titles/meta descriptions improves AI selection
+4. **Tables are easily extracted** - AI systems prefer structured comparison tables
+5. **Answer-first structure** - Put the direct answer in the opening paragraph
+
+### AEO Best Practices
+
+**Content Structure:**
+- Lead with a clear, quotable definition or answer
+- Use semantic chunking (one concept per section)
+- Include FAQ sections for common questions
+- Use structured tables for comparisons
+- Make factual claims specific and citable (include numbers, dates)
+
+**Technical Requirements:**
+- Implement FAQ schema for Q&A content
+- Ensure pages are crawlable by AI bots
+- Use clean HTML structure with proper heading hierarchy
+- Include structured data markup where appropriate
+
+## Industry Resources
+
+### Methodology and Research
+
+| Resource | Focus |
+|----------|-------|
+| Ahrefs Blog | Keyword research, backlink analysis, competitive research |
+| Moz Blog | Domain authority, on-page SEO, local SEO |
+| Search Engine Land | Industry news, algorithm updates, best practices |
+| Search Engine Journal | Tactical guides, case studies |
+
+### Tools for Analysis
+
+| Tool | Use For |
+|------|---------|
+| Google Search Console | Actual search performance data |
+| Ahrefs/Semrush | Keyword research, competitor analysis |
+| Screaming Frog | Technical SEO audits |
+| Schema Markup Validator | Structured data validation |
+
+## Anti-Patterns to Avoid
+
+Based on Google's guidelines, avoid these practices:
+
+1. **Keyword stuffing** - Unnatural repetition of keywords
+2. **Thin content** - Pages with little substantive value
+3. **Duplicate content** - Same content across multiple pages
+4. **Hidden text** - Text hidden from users but visible to crawlers
+5. **Doorway pages** - Pages created solely to rank for specific queries
+6. **AI-generated content without value** - Content that doesn't add human expertise or insight
+
+## Citation Format
+
+When referencing these sources in recommendations:
+
+```
+Per Google's SEO Starter Guide: "[specific guidance]"
+Source: https://developers.google.com/search/docs/...
+
+Per Schema.org FAQPage specification: "[specific requirement]"
+Source: https://schema.org/FAQPage
+```