@opendirectory.dev/skills 0.1.0

package/skills/blog-cover-image-cli/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "blog-cover-image-cli",
+  "version": "1.0.17",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "blog-cover-cli": "bin/cli.js"
+  },
+  "directories": {
+    "example": "examples"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "files": [
+    "bin",
+    "src",
+    "examples",
+    "agent-skill",
+    "index.js"
+  ],
+  "dependencies": {
+    "@google/genai": "^1.44.0",
+    "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "dotenv": "^17.3.1",
+    "figlet": "^1.11.0",
+    "gradient-string": "^3.0.0",
+    "sharp": "^0.34.5"
+  }
+}

package/skills/blog-cover-image-cli/src/geminiGenerator.js

@@ -0,0 +1,126 @@
+import { GoogleGenAI } from '@google/genai';
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function getExampleImages() {
+  const examplesDir = path.join(__dirname, '..', 'examples');
+  const imageParts = [];
+  try {
+    const files = await readdir(examplesDir);
+    for (const file of files) {
+      if (file.match(/\.(png|jpe?g)$/i)) {
+        const filePath = path.join(examplesDir, file);
+        const buffer = await readFile(filePath);
+        const ext = path.extname(file).toLowerCase();
+        const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
+        imageParts.push({
+          inlineData: {
+            data: buffer.toString('base64'),
+            mimeType
+          }
+        });
+      }
+    }
+  } catch (err) {
+    console.warn('Warning: Could not load example images from ./examples directory.', err.message);
+  }
+  return imageParts;
+}
+
+/**
+ * Generates a blog cover image using Gemini 3.1 Flash Image Preview.
+ * 
+ * @param {string} title - The title text to include in the image.
+ * @param {Object|null} logoData - Optional logo data { data: base64String, mimeType: 'image/png' }.
+ * @param {string} [apiKey] - Optional API key.
+ * @param {string} [criticalFeedback] - Optional feedback from a previous failed attempt.
+ * @returns {Promise<{ base64Image: string, textOutput: string }>} - The base64 encoded image data and any text output.
+ */
+export async function generateCoverImage(title, logoData, apiKey, criticalFeedback) {
+  const ai = new GoogleGenAI({ apiKey: apiKey || process.env.GEMINI_API_KEY });
+  const exampleImages = await getExampleImages();
+
+  let textPrompt = `
+You are an expert technical marketing designer creating a high-converting, minimalist 16:9 blog cover image. Strictly match the visual aesthetic of the provided example images.
+
+CANVAS & TYPOGRAPHY:
+- Use a pure solid white background.
+- Render the text in a heavy, bold, black sans-serif font.
+- Perfectly center-align the text block in the middle of the canvas, leaving generous negative space (padding) around the edges. 
+- Break the text naturally into 1 to 3 balanced lines (ABSOLUTE MAXIMUM 3 LINES).
+
+THE EXACT TEXT TO RENDER: 
+"${title}"
+
+LOGO INTEGRATION RULES:
+Carefully analyze the provided reference logo(s) and integrate them into the text flow using these exact rules:
+1. IF the logo is a 'Wordmark' (it contains the brand's name text): Use it inline to completely replace that specific word in the text string.
+2. IF the logo is a 'Logomark' (a standalone icon or character): Place it immediately adjacent to the typed brand name in the text.
+3. TYPOGRAPHIC REPLACEMENT: If an icon is geometrically similar to a letter in the brand name (like the letter 'O'), creatively substitute the letter with the icon.
+
+AESTHETIC TOUCHES:
+Keep the composition radically uncluttered. DO NOT add random, unrelated third-party logos or generic floating UI icons unless explicitly requested in the title. The composition MUST be incredibly clean. If you add a UI element, it must make perfect contextual sense. The primary focus must remain on the bold text and the specific requested logo.
+`;
+
+  if (criticalFeedback) {
+    textPrompt += `\nCRITICAL FEEDBACK FROM PREVIOUS ATTEMPT: ${criticalFeedback}. You MUST fix these errors in this new generation or you will be penalized.\n`;
+  }
+
+  const parts = [];
+
+  // 1. Examples
+  if (exampleImages.length > 0) {
+    parts.push({ text: 'Here are some reference examples for the desired style and layout:' });
+    parts.push(...exampleImages);
+  }
+
+  // 2. Instructions + Title
+  parts.push({ text: textPrompt });
+
+  // 3. Logo
+  if (logoData) {
+    parts.push({ text: 'Here is the reference logo to include in the image:' });
+    parts.push({
+      inlineData: {
+        data: logoData.data,
+        mimeType: logoData.mimeType
+      }
+    });
+  }
+
+  const contents = [{ role: 'user', parts }];
+
+  const response = await ai.models.generateContent({
+    model: 'gemini-3.1-flash-image-preview',
+    contents,
+    config: {
+      responseModalities: ['TEXT', 'IMAGE'],
+      imageConfig: {
+        aspectRatio: '16:9',
+        numberOfImages: 1
+      },
+      tools: [{ googleSearch: {} }]
+    }
+  });
+
+  let base64Image = null;
+  let textOutput = '';
+
+  for (const part of response.candidates[0].content.parts) {
+    if (part.text) {
+      textOutput += part.text + '\n';
+    } else if (part.inlineData) {
+      base64Image = part.inlineData.data;
+    }
+  }
+  
+  if (!base64Image) {
+    throw new Error('No image was generated in the response. Text returned: ' + textOutput);
+  }
+
+  return { base64Image, textOutput };
+}

package/skills/blog-cover-image-cli/src/imageValidator.js

@@ -0,0 +1,54 @@
+import { GoogleGenAI } from '@google/genai';
+
+export async function validateImage(base64Image, title, hasLogo, apiKey) {
+  const ai = new GoogleGenAI({ apiKey });
+
+  const prompt = `
+Analyze this blog cover image and verify if it meets the following CRITICAL requirements:
+1. TEXT ACCURACY: Does the image contain the exact text: "${title}"? It must be legible and spelled correctly.
+2. LOGO PRESENCE: ${hasLogo ? 'The image MUST contain the requested company logo.' : 'No specific logo was required.'}
+3. IMAGE INTEGRITY: Is the image clear and not obviously corrupted or garbled?
+4. UNWANTED ELEMENTS: Are there any redundant, misplaced, or entirely irrelevant third-party icons or UI elements that don't fit the strict title context? (If yes, the image is INVALID).
+
+RELAXED RULES (DO NOT FAIL FOR THESE):
+- Colored text is ALLOWED and ENCOURAGED if it matches the brand.
+- Brand-colored logos are ALLOWED.
+- Minimalist, subtle UI elements are allowed ONLY if they perfectly match the specific requested context.
+- The background does NOT have to be pure white; subtle gradients or brand colors are acceptable.
+
+Return a JSON object with:
+- "isValid": boolean (true only if CRITICAL requirements are met)
+- "issues": string (empty if isValid is true, otherwise describe what is wrong)
+`;
+
+  const contents = [
+    {
+      role: 'user',
+      parts: [
+        { text: prompt },
+        {
+          inlineData: {
+            data: base64Image,
+            mimeType: 'image/png',
+          },
+        },
+      ],
+    },
+  ];
+
+  const response = await ai.models.generateContent({
+    model: 'gemini-3.1-pro-preview',
+    contents,
+    config: {
+      responseMimeType: 'application/json',
+    },
+  });
+
+  const text = response.candidates[0].content.parts[0].text;
+  
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Failed to parse validation response: ${text}`);
+  }
+}

package/skills/blog-cover-image-cli/src/logoFetcher.js

@@ -0,0 +1,86 @@
+import sharp from 'sharp';
+
+/**
+ * Fetches a logo from a domain or URL and converts it to PNG.
+ * @param {string} logoInput - Domain (e.g., 'google.com') or full URL.
+ * @param {string} [clientId] - Brandfetch Client ID.
+ * @returns {Promise<{ data: string, mimeType: string } | null>}
+ */
+export async function fetchLogo(logoInput, clientId) {
+  let url;
+  const headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+    'Accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8'
+  };
+
+  if (logoInput.startsWith('http://') || logoInput.startsWith('https://')) {
+    url = logoInput;
+  } else {
+    // Assume it's a domain, use Brandfetch API
+    url = `https://cdn.brandfetch.io/domain/${logoInput}/w/820/h/110/theme/dark/logo?c=${clientId}`;
+  }
+
+  try {
+    let response;
+    if (!logoInput.startsWith('http')) {
+      try {
+        response = await fetch(url, { headers });
+      } catch (e) {
+        response = { ok: false, headers: new Headers() };
+      }
+
+      let contentType = response.headers.get('content-type');
+      if (!response.ok || !contentType?.includes('image')) {
+        const hunterUrl = `https://logos.hunter.io/${logoInput}`;
+        try {
+          response = await fetch(hunterUrl, { headers });
+        } catch (e) {
+          response = { ok: false, headers: new Headers() };
+        }
+
+        contentType = response.headers.get('content-type');
+        if (!response.ok || !contentType?.includes('image')) {
+          const fallbackUrl = `https://icon.horse/icon/${logoInput}`;
+          try {
+            response = await fetch(fallbackUrl, { headers });
+          } catch (e) {
+            return null;
+          }
+
+          contentType = response.headers.get('content-type');
+          if (!response.ok || !contentType?.includes('image')) {
+            return null;
+          }
+
+          if (contentType === 'image/x-icon' || contentType === 'image/vnd.microsoft.icon') {
+            throw new Error('Unsupported ICO format');
+          }
+        }
+      }
+    } else {
+      response = await fetch(url, { headers });
+      const contentType = response.headers.get('content-type');
+      if (!response.ok || !contentType?.includes('image')) {
+        return null;
+      }
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    // Convert to PNG using sharp
+    const pngBuffer = await sharp(buffer)
+      .png()
+      .toBuffer();
+
+    const base64String = pngBuffer.toString('base64');
+
+    return {
+      data: base64String,
+      mimeType: 'image/png'
+    };
+  } catch (error) {
+    console.error(`Error fetching logo:`, error.message);
+    return null;
+  }
+}

package/skills/claude-md-generator/.env.example

@@ -0,0 +1,7 @@
+# claude-md-generator — Environment Variables
+# =============================================
+# Gemini is required for generating the CLAUDE.md content from analysis.
+
+# Required: Google Gemini API key for CLAUDE.md generation
+# Get it: aistudio.google.com, Get API key
+GEMINI_API_KEY=your_gemini_api_key_here

package/skills/claude-md-generator/README.md

@@ -0,0 +1,78 @@
+# claude-md-generator
+
+<img width="1280" height="640" alt="claude-md-generator" src="https://github.com/user-attachments/assets/0e295271-2216-47f7-828f-845c98ef0298" />
+
+
+Reads your codebase and writes a CLAUDE.md that gives Claude Code the context it needs: build commands, code conventions, architecture notes, and gotchas. Stays under 200 lines.
+
+## What It Does
+
+- Scans project files: package.json, tsconfig.json, linter configs, Makefile, directory structure
+- Extracts all build, test, lint, and dev commands
+- Identifies code style conventions that differ from defaults (path aliases, export patterns, naming)
+- Maps non-obvious architecture decisions
+- Finds gotchas: auto-generated files, required env var setup, test dependencies
+- Generates CLAUDE.md using Gemini, then verifies it stays under 200 lines
+- If CLAUDE.md already exists, improves it without discarding custom content
+
+## Requirements
+
+| Requirement | Purpose | How to Set Up |
+|------------|---------|--------------|
+| Gemini API key | CLAUDE.md generation from codebase analysis | aistudio.google.com, Get API key |
+
+## Setup
+
+```bash
+cp .env.example .env
+# Add GEMINI_API_KEY
+```
+
+## How to Use
+
+From the project root you want to document:
+```
+"Generate a CLAUDE.md for this project"
+"Create a CLAUDE.md"
+"Write Claude configuration for this repo"
+"Help Claude understand this codebase"
+```
+
+To update an existing CLAUDE.md:
+```
+"Update my CLAUDE.md: we added Vitest and changed the build system"
+"Improve my existing CLAUDE.md"
+```
+
+## What Goes in CLAUDE.md
+
+| Section | Include | Skip |
+|---------|---------|------|
+| Commands | Exact runnable commands, flags needed, env vars required | `npm install` and other obvious ones |
+| Architecture | Non-obvious structure, auto-generated directories | "src contains source files" |
+| Code Style | Path aliases, export conventions, non-default settings | Indent size (formatter handles it) |
+| Testing | Required setup, how to run one test | "we use Jest" (visible from package.json) |
+| Gotchas | Auto-generated files, env var order, known intentional issues | Things derivable from the code |
+
+## Why Under 200 Lines
+
+Long CLAUDE.md files get ignored. Claude loads the full file into context every session: a bloated CLAUDE.md with obvious content trains Claude to skim it. A tight 100-150 line CLAUDE.md with only non-obvious facts gets read and used.
+
+The skill cuts aggressively: if a section says only things Claude can infer from the code, it removes it.
+
+## Project Structure
+
+```
+claude-md-generator/
+├── SKILL.md
+├── README.md
+├── .env.example
+├── evals/
+│   └── evals.json
+└── references/
+    └── section-guide.md
+```
+
+## License
+
+MIT

package/skills/claude-md-generator/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: claude-md-generator
+description: ''
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# CLAUDE.md Generator
+
+Read the codebase. Write a CLAUDE.md that tells Claude exactly what it needs: no more, no less.
+
+---
+
+**Critical rule:** A good CLAUDE.md is under 100 lines. It contains only information Claude cannot derive from reading the code itself. Do not auto-write the file: always show the draft and wait for user approval first.
+
+**Code snippet rule:** Never include inline code examples in CLAUDE.md. Instead use `file.ts:42` references. Code in CLAUDE.md wastes tokens and goes stale.
+
+---
+
+## Step 1: Detect Mode
+
+Determine which of three modes to run:
+
+**create**: No CLAUDE.md exists. Write one from scratch.
+**update**: A CLAUDE.md exists. Improve it without discarding custom content.
+**audit**: Score all CLAUDE.md files in the project A-F and output a quality report. If the user says "audit", "check", "review", or "grade" my CLAUDE.md, run audit mode.
+
+```bash
+# Discover ALL CLAUDE.md locations
+find . -name "CLAUDE.md" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null
+ls ~/.claude/CLAUDE.md 2>/dev/null && echo "Global CLAUDE.md found"
+ls .claude.local.md 2>/dev/null && echo ".claude.local.md found"
+```
+
+If multiple CLAUDE.md files are found: list them. Ask: "Found CLAUDE.md in [locations]. Should I update all of them or just [root]?"
+
+---
+
+## Step 2: Audit Mode (skip to Step 3 if create/update)
+
+For each CLAUDE.md found, score it A-F using this rubric:
+
+| Criterion | What to check |
+|-----------|--------------|
+| Commands | Build/test/lint commands present and runnable? |
+| Architecture | Non-obvious structure explained? |
+| Non-obvious patterns | Gotchas, generated files, env var order documented? |
+| Conciseness | Under 100 lines? No obvious filler? |
+| Currency | Commands still match current package.json/Makefile? |
+| Actionability | Can a new contributor follow this without asking questions? |
+
+Score: 90-100 = A, 70-89 = B, 50-69 = C, 30-49 = D, 0-29 = F
+
+Present as a table:
+
+```
+## CLAUDE.md Audit Report
+
+| File | Score | Grade | Top Issues |
+|------|-------|-------|-----------|
+| ./CLAUDE.md | 72 | B | Missing gotchas section, test command outdated |
+| ./packages/api/CLAUDE.md | 45 | D | No commands, 340 lines (too long), stale arch notes |
+
+**Overall: B (72/100)**
+
+Issues found:
+- ./packages/api/CLAUDE.md: 340 lines: well over the 100-line target
+- ./packages/api/CLAUDE.md: Test command references `jest` but package.json uses `vitest`
+- ./CLAUDE.md: No Gotchas section: most valuable section is missing
+```
+
+After the report, ask: "Want me to fix any of these? (all / just root / specify)"
+
+If user says yes, continue to Step 3 for each file they want fixed.
+
+---
+
+## Step 3: Scan Project Structure
+
+```bash
+# Project type and package manager
+ls package.json yarn.lock pnpm-lock.yaml bun.lockb requirements.txt pyproject.toml Cargo.toml go.mod 2>/dev/null
+
+# Top-level directory structure
+find . -maxdepth 2 -type d \
+  | grep -v node_modules | grep -v .git | grep -v __pycache__ \
+  | grep -v ".next" | grep -v dist | grep -v build | sort
+```
+
+---
+
+## Step 4: Extract Build and Test Commands
+
+```bash
+# npm/yarn/pnpm/bun scripts
+cat package.json 2>/dev/null \
+  | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+for name, cmd in d.get('scripts', {}).items():
+    print(f'{name}: {cmd}')
+"
+
+# Python, Go, Rust Makefiles
+cat Makefile 2>/dev/null | grep -E "^[a-z].*:" | head -20
+
+# Go
+cat go.mod 2>/dev/null | head -5
+
+# Rust
+cat Cargo.toml 2>/dev/null | grep -E "^\[" | head -10
+```
+
+Identify the exact commands for: build, test (all), test (single file/name), dev server, lint/typecheck. Note any env vars required to run them.
+
+---
+
+## Step 5: Find Code Style and Gotchas
+
+```bash
+# Import aliases (most commonly missed)
+python3 -c "
+import json, sys
+try:
+    d = json.load(open('tsconfig.json'))
+    paths = d.get('compilerOptions', {}).get('paths', {})
+    if paths: print('Import aliases:', json.dumps(paths, indent=2))
+except: pass
+" 2>/dev/null
+
+# Environment variables required
+cat .env.example 2>/dev/null | grep -v "^#" | grep -v "^$" | head -20
+
+# Auto-generated files (must not be edited)
+find . -path "*/node_modules" -prune -o -name "*.ts" -print \
+  | xargs grep -l "DO NOT EDIT\|@generated\|Generated by" 2>/dev/null | head -5
+
+# Test setup requirements
+cat jest.config.js jest.config.ts vitest.config.ts 2>/dev/null | head -30
+
+# Database/migration setup
+ls migrations/ prisma/ drizzle/ db/ 2>/dev/null
+```
+
+**What counts as a Gotcha** (include these, skip everything else):
+- Files that are auto-generated (must not edit)
+- Env vars required BEFORE tests run
+- Non-default import alias mappings
+- Test commands that require a running service
+- Known intentional quirks (workarounds, not bugs)
+
+---
+
+## Step 6: Generate CLAUDE.md Draft with Gemini
+
+Compile all findings and generate the draft:
+
+```bash
+cat > /tmp/claude-md-request.json << 'ENDJSON'
+{
+  "system_instruction": {
+    "parts": [{
+      "text": "Write a CLAUDE.md file for a software project. Rules: (1) Under 100 lines total. (2) Only include what Claude cannot derive from reading the code. (3) No inline code examples: use file.ts:42 references instead. (4) Sections: Commands, Code Style (only non-defaults), Testing (only if setup needed), Gotchas (required: what trips people up). Skip any section that has nothing non-obvious to say. (5) All commands in code blocks. (6) Preferred order: short Project Overview (1-2 sentences, only if non-obvious), Commands, Architecture (only non-obvious structure), Code Style, Testing, Gotchas. (7) Do not use em dashes. (8) Output only the CLAUDE.md content, no commentary."
+    }]
+  },
+  "contents": [{
+    "parts": [{
+      "text": "PROJECT_ANALYSIS_HERE"
+    }]
+  }],
+  "generationConfig": {
+    "temperature": 0.3,
+    "maxOutputTokens": 2048
+  }
+}
+ENDJSON
+
+curl -s -X POST \
+  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @/tmp/claude-md-request.json \
+  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['candidates'][0]['content']['parts'][0]['text'])"
+```
+
+Replace `PROJECT_ANALYSIS_HERE` with findings from Steps 3-5.
+
+**For large projects (50+ files):** Add a `@path` pointer at the bottom of CLAUDE.md instead of inline detail:
+
+```markdown
+## Extended Reference
+See @docs/ai-context/architecture.md for full module map.
+See @docs/ai-context/testing.md for integration test setup details.
+```
+
+Write the referenced files to `docs/ai-context/` with the detail that would not fit in 100 lines.
+
+---
+
+## Step 7: Self-QA
+
+Before presenting the draft, check:
+
+- [ ] Under 100 lines (count: `echo "$CONTENT" | wc -l`)
+- [ ] No inline code examples (only `file.ts:42` references or shell commands)
+- [ ] All commands in code blocks and runnable as-is
+- [ ] Gotchas section present with at least one real entry
+- [ ] No section that says only things obvious from the files
+- [ ] No em dashes
+- [ ] No marketing words or filler phrases ("This project uses React to...")
+- [ ] Import aliases documented if they exist
+- [ ] Auto-generated files marked "do not edit" if they exist
+
+If any check fails, revise before presenting.
+
+---
+
+## Step 8: Present Draft and Wait for Approval
+
+**Never write the file without user approval.**
+
+Present the draft in a code block:
+
+```
+## Draft CLAUDE.md ([N] lines)
+
+[full draft content here]
+
+---
+Write this to CLAUDE.md? (yes / edit first / cancel)
+```
+
+If user says **yes**: write the file, then confirm:
+"CLAUDE.md written ([N] lines). Sections: [list of ## headers]."
+
+If user says **edit first**: apply their edits, re-show the draft.
+
+If user says **cancel**: stop.
+
+---
+
+## What NOT to Include
+
+- Language/framework version ("This is a TypeScript project")
+- How the framework works (Claude already knows React, FastAPI, etc.)
+- List of all dependencies
+- Style rules the linter already enforces (indent size, quote style)
+- Content that duplicates README.md
+- Inline code examples or multi-line snippets
+- Anything that would be identical for any project using the same stack
+
+
+
+

package/skills/claude-md-generator/evals/evals.json

@@ -0,0 +1,35 @@
+{
+  "skill_name": "claude-md-generator",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Generate a CLAUDE.md for this project.",
+      "expected_output": "Agent runs all scan commands from Steps 1-5: directory structure, package.json scripts, tsconfig.json, ESLint config, test setup, .env.example. Calls Gemini with analysis to generate CLAUDE.md. Output is under 200 lines. Contains: Commands section with exact runnable commands, Code Style section noting any non-default aliases or export conventions, Testing section with any required setup, Gotchas section with at least one entry (auto-generated files, required env vars, etc.). Does not include obvious facts derivable from the files (e.g., 'This project uses TypeScript').",
+      "files": ["package.json", "tsconfig.json", ".eslintrc.json", ".env.example"]
+    },
+    {
+      "id": 2,
+      "prompt": "Create a CLAUDE.md. The project already has one.",
+      "expected_output": "Agent detects existing CLAUDE.md at project root. Reads it before generating. Preserves any sections the user has manually added. Improves sections that are outdated or missing. Shows a diff summary: 'Kept: [sections]. Updated: [sections]. Added: [sections].' Final file is still under 200 lines. Does not wholesale replace the existing file without showing what changed.",
+      "files": ["CLAUDE.md", "package.json"]
+    },
+    {
+      "id": 3,
+      "prompt": "Write a CLAUDE.md for this Python project.",
+      "expected_output": "Agent detects Python project from requirements.txt or pyproject.toml. Reads Makefile or pyproject.toml for commands. Identifies test runner (pytest, unittest). Notes any virtual environment setup required. Checks for generated files (migrations, protobuf stubs). Commands section shows exact Python commands (pytest, python -m, etc.). Gotchas section notes any required env vars and any generated files that should not be edited.",
+      "files": ["requirements.txt", "pyproject.toml", "Makefile"]
+    },
+    {
+      "id": 4,
+      "prompt": "Generate CLAUDE.md for this monorepo.",
+      "expected_output": "Agent detects monorepo from presence of packages/ or apps/ directory with multiple package.json files. Notes workspace structure in Architecture section. Documents root-level commands vs package-level commands. Notes any shared packages and how they are linked. Keeps the output under 200 lines by focusing on the most important commands and conventions. Does not try to document every package: focuses on the top-level patterns and the most commonly developed packages.",
+      "files": ["package.json", "packages/"]
+    },
+    {
+      "id": 5,
+      "prompt": "Create a CLAUDE.md. There are no config files: it's a small Go project with just main.go and a Makefile.",
+      "expected_output": "Agent finds main.go and Makefile. Reads Makefile for build/test/run targets. Notes that there is no package manager. Commands section shows make targets. Architecture section notes entry point (main.go). Gotchas section notes any env vars referenced in main.go. Output is short (under 50 lines) because there is not much to document: the agent does not pad with filler content. Does not invent sections for things that do not exist in this project.",
+      "files": ["main.go", "Makefile"]
+    }
+  ]
+}