@muskanmeet/invoicing-design-system 0.1.0

package/.local/secondary_skills/flashcard-generator/.fingerprint

@@ -0,0 +1 @@
+7525648b82ef579c4b02612c0afe3495

package/.local/secondary_skills/flashcard-generator/SKILL.md

@@ -0,0 +1,233 @@
+---
+name: flashcard-generator
+description: Generate flashcards, quizzes, and study guides from notes or topics.
+---
+
+# Flashcard & Quiz Generator
+
+Generate study materials grounded in memory science. Follow Wozniak's formulation rules, schedule with SM-2, export to Anki via `genanki`.
+
+## When to Use
+
+- User pastes notes/textbook content to convert to cards, needs exam prep, or wants an Anki deck
+
+## When NOT to Use
+
+- In-depth research (deep-research), data analysis (data-analysis)
+
+## Why Spaced Repetition Works
+
+Ebbinghaus (1885) showed memory decays as `R = e^(-t/S)`where`S`is memory stability — without review, ~50-70% of new information is gone within 24 hours. The curve was replicated in 2015 (Murre & Dros, PLOS ONE). Each successful recall increases`S`, flattening the curve. **The core insight: reviewing just before you'd forget is the most efficient moment to review.** Active recall (retrieving the answer) builds stability far more than passive re-reading — this is why cards beat highlighting.
+
+## Card Formulation: Wozniak's 20 Rules
+
+Piotr Wozniak (SuperMemo creator; Anki forked his SM-2 algorithm) published the canonical rules in 1999 at supermemo.com. The ones that matter most for card generation:
+
+**Rule 1-2: Understand before you memorize.** Don't make cards for material the user hasn't grasped yet. Cards reinforce; they don't teach.
+
+**Rule 4: Minimum Information Principle — the single most important rule.** One atomic fact per card. Complex cards get forgotten as a unit — if any part fails, the whole card resets. Split aggressively.
+
+- Bad: `Q: What are the three branches of US government and what does each do?` (6 facts, fails together)
+- Good: Six cards. `Q: Which branch of US government writes laws? A: Legislative` × each branch × each function.
+
+**Rule 5: Cloze deletion is the fastest path from prose to cards.** Take a sentence, blank one term. Beginners who struggle with minimum-information should default to cloze.
+
+- Source: `TCP guarantees ordered delivery; UDP does not.`
+- Cards: `{{c1::TCP}} guarantees ordered delivery; {{c2::UDP}} does not.` → 2 cards from one sentence
+
+**Rule 9-10: Avoid sets and enumerations.**"List all 7 OSI layers" is a nightmare card — high failure rate, painful reviews. Instead, use**overlapping cloze**: one sentence with the full list, generate N cards each blanking one item. The redundancy is intentional — it's extra *cards*, not extra info per card.
+
+**Rule 11: Combat interference.** Similar cards confuse each other (`affect`vs`effect`, port 80 vs 443). Add disambiguating context:`Q: [web, unencrypted] Default HTTP port? A: 80`.
+
+**Rule 14: Personalize.** `Q: What's O(n log n)? A: Merge sort — like the algorithm you botched in the Stripe interview` sticks better than the abstract definition.
+
+**The diagnostic:** If a card's ease factor drops below 1.3 in review, the card is malformed, not hard. Rewrite it, don't grind it.
+
+## Card Types
+
+| Type | Use for | Example |
+
+|---|---|---|
+
+| **Basic Q→A** | Single facts | `Q: Capital of Mongolia? A: Ulaanbaatar` |
+
+| **Cloze** | Converting prose fast; lists | `The {{c1::mitochondria}} produces {{c2::ATP}} via {{c3::oxidative phosphorylation}}` → 3 cards |
+
+| **Reversed** | Bidirectional recall (vocab) | Generates both `fr→en`and`en→fr` |
+
+| **Application** | Understanding, not recall | `Q: Revenue +20%, profit −5%. Why? A: Costs grew faster than revenue` |
+
+| **Image occlusion** | Anatomy, diagrams, maps | Blank one label on a diagram per card (Wozniak rule 8) |
+
+Mix Bloom's levels: ~40% remember (basic/cloze), ~30% understand, ~30% apply/analyze. Pure recall decks feel productive but fail on exams that test transfer.
+
+## SM-2 Scheduling (What Anki Runs)
+
+Wozniak's 1987 algorithm. Each card tracks three values: repetition count `n`, ease factor`EF`(starts at 2.5), interval`I` in days. After each review, grade 0-5:
+
+```text
+
+if grade >= 3: \# correct
+
+if n == 0: I = 1
+
+elif n == 1: I = 6
+
+else: I = round(I * EF) \# exponential growth
+
+n += 1
+
+else: \# forgot
+
+n = 0; I = 1 \# reset interval, keep EF
+
+EF += 0.1 - (5-grade) * (0.08 + (5-grade)*0.02)
+
+EF = max(EF, 1.3) \# floor — below this, card is malformed
+
+```
+
+Grade 5 → EF +0.10. Grade 4 → no change. Grade 3 → EF −0.14. A card you always rate "good" (4) with EF 2.5 goes: 1 → 6 → 15 → 38 → 94 days. **FSRS** (Anki 23.10+) is the ML successor — fits a personal forgetting curve, ~20-30% fewer reviews for same retention. Mention it; default to SM-2 for simplicity.
+
+## Export to Anki: `genanki`
+
+`pip install genanki`(github.com/kerrickstaley/genanki). Generates`.apkg` files that import directly via File → Import.
+
+```python
+
+import genanki, random
+
+# Generate these ONCE, then hardcode — stable IDs let users re-import updates
+
+MODEL_ID = random.randrange(1 << 30, 1 << 31) \# e.g. 1607392319
+
+DECK_ID = random.randrange(1 << 30, 1 << 31)
+
+basic = genanki.Model(MODEL_ID, 'Basic',
+
+fields=[{'name': 'Q'}, {'name': 'A'}],
+
+templates=[{'name': 'Card 1', 'qfmt': '{{Q}}',
+
+'afmt': '{{FrontSide}}<hr id="answer">{{A}}'}],
+
+css='.card { font-family: Arial; font-size: 20px; text-align: center; }')
+
+deck = genanki.Deck(DECK_ID, 'Biology :: Cell Structure')
+
+deck.add_note(genanki.Note(model=basic,
+
+fields=['What organelle produces ATP?', 'Mitochondria']))
+
+# Cloze uses built-in model — second field required (can be empty) since 0.13.0
+
+deck.add_note(genanki.Note(model=genanki.builtin_models.CLOZE_MODEL,
+
+fields=['The {{c1::mitochondria}} produces {{c2::ATP}}', '']))
+
+genanki.Package(deck).write_to_file('cells.apkg')
+
+```
+
+**Gotchas:** Fields are HTML — `html.escape()`any user content with`<`,`>`,`&`. For images/audio, set`package.media_files = ['diagram.png']`and reference by **basename only** in the field:`<img src="diagram.png">`(paths break). Stable GUIDs let re-imports update cards in place — subclass`Note`and override`guid` to hash only the question field.
+
+**Quizlet/CSV fallback:** Tab-separated, one card per line: `question\tanswer\n`. Quizlet imports directly. Also works for Anki's File → Import → Text.
+
+## Output: Always Build a Web App
+
+**Every flashcard generation MUST produce an interactive web app as the primary output.**Do not output cards as plain text or markdown — always build a React + Vite single-page app with**two modes** the user can switch between:
+
+### Mode 1: Flashcard Review
+
+1. **Card display** — show front of card, flip to back on click or spacebar
+2. **SM-2 grading**— four buttons: Again (1), Hard (3), Good (4), Easy (5), wired to the SM-2 algorithm above.**Grading and accuracy:** grades 3-5 (Hard, Good, Easy) count as "correct"; grade 1 (Again) counts as "incorrect". Accuracy is calculated per session as `(correct / reviewed) * 100`. This resets on page reload; review progress (intervals, due dates) persists in localStorage.
+
+3. **Spaced repetition queue** — `localStorage`persistence for`{cardId: {n, EF, I, due}}`. **Card ordering:**previously reviewed cards that are due appear first, sorted by due date (most overdue first). New (unseen) cards are**shuffled randomly each session**using**Fisher-Yates shuffle** (the only unbiased O(n) shuffle algorithm — naive`array.sort(() => Math.random() - 0.5)` produces biased distributions). Never present new cards in a fixed order — it creates a false sense of learning tied to sequence rather than recall.
+4. **Session stats** — cards reviewed, accuracy %, cards due tomorrow, total remaining
+
+5. **Card type support** — render Basic Q→A, Cloze (hide blanked terms), and Reversed cards correctly
+6. **Flip animation** — CSS 3D transform, keyboard shortcuts (Space to flip, 1/2/3/4 for grading)
+
+7. **Card difficulty indicators** — show a visual indicator (colored dot or badge) on each card based on its current ease factor. Green for EF ≥ 2.5 (easy), yellow for 1.8 ≤ EF < 2.5 (moderate), red for EF < 1.8 (hard). Helps users see at a glance which cards they're mastering vs. struggling with.
+8. **Leech detection** — track how many times a card has been graded Again (1). If a card is reset more than 4 times, flag it as a "leech" with a visual warning (e.g., a ⚠️ icon). Leeches are almost always malformed cards that should be rewritten, not drilled harder. Optionally offer a "Rewrite this card" prompt.
+
+9. **Daily new card limit** — enforce a configurable daily limit for new (unseen) cards, defaulting to 20. Store the count in localStorage with today's date. Once the limit is reached, only show review cards. This prevents users from overwhelming themselves — the review debt from too many new cards becomes unsustainable by week 3.
+10. **Study streak** — track consecutive days of study in localStorage. Display a streak counter (e.g., "🔥 5-day streak") in the session stats area. A day counts if the user reviews at least 1 card. Streaks reset if a day is missed. Streaks are a proven motivator for building daily review habits.
+
+### Mode 2: AI Quiz
+
+An AI-powered quiz mode that generates and grades questions:
+
+1. **Quiz setup** — user picks a topic (or all topics) and number of questions (5, 10, 20, custom)
+2. **Question generation**— use AI integrations to generate N questions from the card material. Mix question types: multiple choice, short answer, and true/false. Questions should test understanding and application, not just recall.**Difficulty progression:** start with easier recall-level questions and ramp up to application/analysis questions as the quiz progresses. This builds confidence and mirrors real exam structure.
+
+3. **Answer & grade** — user answers each question, then AI grades the response with a score and explanation of what was right/wrong
+4. **Quiz results** — summary screen with overall score, per-question breakdown, and which topics need more work
+
+5. **Weak spot feedback**— highlight topics where the user scored lowest and suggest reviewing those flashcards.**Link back to flashcard mode:** include a "Review these cards" button next to weak topics that switches to flashcard mode pre-filtered to that topic. This closes the learn-test-review loop.
+
+### Mode 3 (Optional): Card Import from Notes
+
+If the user wants to create their own cards, offer a text import mode:
+
+1. **Paste area** — user pastes notes, bullet points, or prose into a text area
+2. **AI card generation** — use AI integrations to parse the text and generate flashcards following Wozniak's minimum information principle. Output Basic Q→A and Cloze cards.
+
+3. **Review before adding** — show the generated cards in an editable list. Let the user approve, edit, or delete each card before adding to the deck.
+4. **Merge into deck** — approved cards get added to the main deck with fresh SM-2 state (n=0, EF=2.5, I=0).
+
+### UI/UX Requirements
+
+- **Tab or toggle** to switch between Flashcard and Quiz modes
+- **Clean, focused design** — one card or question centered on screen, no clutter
+
+- **Mobile-friendly** — responsive layout, touch targets
+- **Topic/deck selector** — filter by topic in both modes
+
+- **Progress indicator** — card counter in flashcard mode, question progress bar in quiz mode
+- **Progress history** — store daily review counts and accuracy in localStorage. Optionally display a simple chart or heatmap showing review activity over the past 30 days. This gives users a sense of long-term progress beyond the current session.
+
+## Best Practices
+
+1. **Minimum information principle trumps everything** — when in doubt, split the card
+2. **Cloze is the default for prose** — fastest path from notes to reviewable cards
+
+3. **Never make set-enumeration cards** — "list all X" → overlapping cloze instead
+4. **30 great cards > 100 mediocre ones** — review burden compounds; every bad card costs minutes over months
+
+5. **Cap new cards at ~20/day** — the review debt from 100 new cards/day becomes unsustainable by week 3
+6. **Interleave topics in the card data array** — when hardcoding cards, mix topics throughout the array rather than grouping all cards of one topic together. Even with shuffle logic, interleaving ensures better variety if the shuffle ever fails or is bypassed
+
+## Technical Notes
+
+- **Fisher-Yates shuffle implementation:** When shuffling new cards, always use the Fisher-Yates (Knuth) algorithm. The naive `array.sort(() => Math.random() - 0.5)` approach produces biased distributions where some orderings are significantly more likely than others. Correct implementation:
+
+```typescript
+
+function fisherYatesShuffle<T>(arr: T[]): T[] {
+
+const shuffled = [...arr];
+
+for (let i = shuffled.length - 1; i > 0; i--) {
+
+const j = Math.floor(Math.random() * (i + 1));
+
+[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+
+}
+
+return shuffled;
+
+}
+
+```
+
+- **localStorage size limits** — localStorage has a ~5MB limit per origin. For small-to-medium decks (<500 cards), this is fine. For large decks (500+ cards) with extensive review history and progress tracking, consider using IndexedDB as a fallback. At minimum, store only essential SM-2 state per card (`{n, EF, I, due, lapses}`) — avoid storing full review logs in localStorage.
+- **React hook ordering** — when implementing the spaced repetition hook, declare all React hooks (`useState`,`useRef`,`useMemo`,`useEffect`) at the top of the function before any conditional logic. Adding hooks between existing hooks during iteration (e.g., inserting a`useRef`between`useMemo` calls) will crash React's HMR during development. The order must be stable across renders.
+
+## Limitations
+
+- Cannot read existing `.apkg` files (genanki is write-only); cannot sync to AnkiWeb
+- Cannot track review history across sessions unless building a persistent app (use localStorage or IndexedDB for client-side persistence)
+
+- Verify generated content for specialized domains — confident-sounding wrong cards are worse than no cards

package/.local/secondary_skills/geo/.fingerprint

@@ -0,0 +1 @@
+9f1de8dad3314e20861c4d5b4efcddbc

package/.local/secondary_skills/geo/SKILL.md

@@ -0,0 +1,378 @@
+---
+name: geo
+description: Optimize content for AI-generated answers in ChatGPT, Perplexity, and Google AI Overviews.
+---
+
+# Generative Engine Optimization (GEO)
+
+Optimize web content so it gets cited, quoted, and surfaced by AI engines (ChatGPT, Google AI Overviews/SGE, Perplexity, Bing Copilot, Claude, and others). GEO differs from traditional SEO because AI engines don't rank pages — they synthesize answers from sources. The goal is to become one of those sources.
+
+## When to Use
+
+- User asks to optimize content for AI search or AI engines
+- User wants to audit or rewrite existing pages/posts for GEO readiness
+
+- User wants to create new content designed to appear in AI-generated answers
+- User wants a GEO content strategy or roadmap for their brand/blog
+
+- User mentions GEO, generative engine optimization, or AI visibility
+- User asks how to get cited by ChatGPT, Perplexity, Google AI Overviews, etc.
+
+## Research Foundation
+
+Key research finding (Princeton/IIT Delhi, KDD 2024): The most impactful GEO signals are **statistics (+33.9% visibility)**, **expert quotes (+32%)**, **fluent writing (+30%)**, and **authoritative citations (+30.3%)**. These numbers should guide prioritization — when time is limited, adding statistics and expert quotes yields the highest return.
+
+## How AI Engines Select Sources
+
+AI engines decide what to cite based on several signals. Every recommendation in this skill traces back to one of them:
+
+1. **Direct answerability** — Content that directly answers a question in a clear, self-contained way is more likely to be extracted. AI engines prefer content that doesn't require inference to understand.
+2. **Authority signals** — Cited statistics, named sources, references to studies, and expert attribution increase trust. AI engines weight sourced claims higher than unsourced opinions.
+
+3. **Structured clarity** — Well-organized content with clear headings, lists, and logical flow is easier for models to parse and quote. 74% of AI citations come from structured lists and comparison formats.
+4. **Topical depth** — Content that covers a topic comprehensively with specifics (numbers, examples, comparisons) is preferred over shallow overviews.
+
+5. **Freshness and accuracy** — Up-to-date content with current data points wins over stale pages. Contradicting widely-known facts gets filtered out.
+6. **Technical accessibility** — Proper schema markup, fast load times, and clean HTML help crawlers index content correctly.
+
+7. **Community signals** — Reddit, LinkedIn, Quora, and forum mentions are crawled by AI engines. Content that generates authentic discussion in these communities gets additional visibility.
+
+## Three Modes
+
+### Mode 1: Audit & Rewrite Existing Content
+
+When the user provides existing content (URL, blog post, article, page) to evaluate or improve.
+
+#### Process
+
+1. **Collect the content** — Get the URL or raw content from the user. If it's a URL, fetch and extract the main content body.
+2. **Identify the core query** — What search or AI prompt is this content answering? What would someone type into ChatGPT to find this?
+
+3. **Evaluate against the GEO scorecard** (see `scorecard.md` for the full checklist).
+4. **Apply the rewrite checklist** if the user wants improvements (not just an audit):
+
+- Add a direct answer block in the first 40-60 words — open with the key phrase ("X is..." or "The best Y for Z is..."). This is the single highest-impact change.
+- Inject statistics — at least one concrete data point per major section. Flag where data is needed if none is available.
+
+- Add or strengthen named expert quotes — direct attribution to a real person or study.
+- Add source citations inline — link to research, .gov, .edu, or recognized publications.
+
+- Rewrite H2/H3 headings as questions or clear topical answers ("How does X work?" not "Overview").
+- Add or expand a FAQ section — 5-10 questions in real user language at the end.
+
+- Improve information density — named entities, stats, and specific claims per paragraph (not vague generalities).
+- Clearly name the brand/author early in the post and in the byline.
+
+- Trim marketing fluff — remove filler phrases that add length without adding facts ("In today's fast-paced world...", "It's important to note...").
+- Add Article JSON-LD schema (see `technical-checklist.md`) if the user manages their own site.
+
+1. **Produce the audit report** using the format below.
+
+#### Audit Report Format
+
+```markdown
+
+# GEO Audit Report: [Page Title or URL]
+
+## Overall GEO Readiness: [Score]/100
+
+## Summary
+
+[2-3 sentence overview of the page's GEO strengths and weaknesses]
+
+## Scores by Category
+
+| Category | Score | Status |
+
+|----------|-------|--------|
+
+| Direct Answerability | X/20 | [needs work / good / strong] |
+
+| Authority & Citations | X/20 | [needs work / good / strong] |
+
+| Structure & Formatting | X/20 | [needs work / good / strong] |
+
+| Topical Depth | X/20 | [needs work / good / strong] |
+
+| Technical Optimization | X/20 | [needs work / good / strong] |
+
+## Detailed Findings
+
+### Direct Answerability
+
+[What's working, what's missing, specific examples from the content]
+
+### Authority & Citations
+
+[Assessment of sourcing, statistics, expert quotes, credibility signals]
+
+### Structure & Formatting
+
+[Heading hierarchy, use of lists, paragraph length, scanability]
+
+### Topical Depth
+
+[Coverage completeness, specificity, comparisons, examples provided]
+
+### Technical Optimization
+
+[Schema markup, meta data, page speed considerations, HTML cleanliness]
+
+## Priority Recommendations
+
+1. [Highest-impact change with specific instructions]
+2. [Second priority]
+
+3. [Third priority]
+
+...
+
+## Rewritten Sections (if requested)
+
+[Full rewritten content, followed by a "GEO changes made" summary]
+
+```
+
+#### Delivering the Report as PDF
+
+After writing the audit report as a markdown file, convert it to PDF and present it to the user.
+
+1. Write the audit report to a `.md` file (e.g., `.local/geo-audit-[site-name].md`).
+2. Convert the markdown to a styled PDF (use available workspace tools or libraries such as `pdfkit`).
+3. Present the PDF to the user using the file presentation tool.
+
+### Mode 2: Create GEO-Optimized Content
+
+When the user wants to write new content from scratch.
+
+#### Pre-Writing — Confirm These First (ask if not provided)
+
+- **Target query / topic** — What question is this content answering?
+- **Target audience** — Who is reading this?
+
+- **Content type** — Blog post, product page, FAQ, documentation, landing page, comparison page?
+- **Brand voice/tone** — Formal, conversational, technical?
+
+- **Approximate length** — Default: 1,200-2,000 words for blog posts/articles.
+
+#### GEO-Native Blog Post Structure
+
+```text
+
+[TITLE — phrased as a question or definitive answer]
+
+e.g. "What Is X? The Complete Guide" or "How to Do Y in 2026"
+
+[BYLINE — Author name + credentials/title]
+
+[DATE — always include publish date]
+
+[DIRECT ANSWER BLOCK — 40-60 words]
+
+Immediately answers the post's core question. No preamble.
+
+Starts with the key phrase: "X is..." or "The best way to Y is..."
+
+[KEY STATISTICS — 2-3 bullet data points]
+
+Fast-load authority signals AI engines extract immediately.
+
+[H2: Why Does X Matter? / What Is X?]
+
+Dense, factual prose. Named sources. Specific claims.
+
+[H2: How Does X Work? — or next logical question]
+
+Same pattern. Include at least one expert quote or study citation.
+
+[H2: Ranked List or Comparison Table]
+
+"Top 5 ways to..." or "X vs Y" — structured lists are highly citable.
+
+[H2: Common Questions About X]
+
+5-10 FAQ entries in real user language.
+
+Q: [exact phrasing someone would type into ChatGPT]
+
+A: [self-contained 2-3 sentence answer — extractable on its own]
+
+[SOURCES / REFERENCES]
+
+Numbered list of all cited sources with URLs.
+
+```
+
+For other content types (product pages, documentation, landing pages, comparison pages), read `content-patterns.md` for type-specific templates.
+
+#### Creation Process
+
+1. **Research the query landscape** — Identify the questions users and AI engines ask about this topic. Think about what an AI engine would need to construct a complete answer.
+2. **Plan the content structure** — Use the blog post template above or the appropriate pattern from `content-patterns.md`.
+
+3. **Write with GEO principles applied** throughout (see Writing Rules below).
+4. **Add technical optimization** — Schema markup recommendations, meta descriptions, etc.
+
+### Mode 3: GEO Content Strategy
+
+When the user wants a strategic GEO roadmap for their blog, brand, or website.
+
+#### Process (2)
+
+##### Step 1: Define the entity
+
+- What is the brand/person/product being optimized?
+- What are the 3-5 core topics they want to be cited for?
+
+- Who are the target audiences?
+
+###### Step 2: Identify target prompts
+
+Generate 15-25 specific prompts the target audience would type into ChatGPT, Perplexity, or Google AI Overviews — these are the GEO equivalent of keywords. Focus on:
+
+- Informational: "What is the best [topic] for [use case]?"
+- How-to: "How do I [task related to the niche]?"
+
+- Comparative: "X vs Y: which is better for Z?"
+- Definitional: "What is [core concept]?"
+
+###### Step 3: Content gap analysis
+
+For each target prompt, assess:
+
+- Does existing content answer it directly?
+- What content format would AI engines prefer? (FAQ, article, comparison, listicle)
+
+- What authority signals are missing?
+
+###### Step 4: Prioritized content plan
+
+Produce a prioritized list of content pieces to create or optimize, ranked by:
+
+- **Citation potential** — How likely is an AI engine to pull from this format?
+- **Competitive gap** — Is this topic underserved by competitors?
+
+- **Business impact** — Does citation here drive leads, revenue, or brand awareness?
+
+###### Step 5: Platform-specific tactics
+
+Read `platform-notes.md` for engine-specific recommendations.
+
+###### Step 6: Measurement framework
+
+Recommend the user track:
+
+- **Mention rate** — % of target prompts that return the brand name (test manually or via tools like Profound, Otterly.ai)
+- **Citation rate** — % that include a clickable URL to their domain
+
+- **Citation position** — First mention vs. buried in the response
+- **Review cadence** — Monthly minimum; weekly for active campaigns
+
+## Writing Rules
+
+These apply across all modes — as requirements when creating, as recommendations when auditing:
+
+### Answer-First Structure
+
+Place the direct answer in the first 40-60 words of the relevant section. AI engines extract opening statements more frequently than buried conclusions. Don't build up to the answer — lead with it, then support it. This is the single highest-impact optimization.
+
+### Quotable Statements
+
+Write sentences that work as standalone quotes. AI engines pull individual sentences or short paragraphs. Each key claim should be a self-contained, factual statement that makes sense without surrounding context.
+
+- Good: "The average cost of a kitchen renovation in 2025 ranges from $15,000 to $45,000, depending on scope, materials, and geographic location."
+- Bad: "When thinking about costs, there are many factors to consider, and it really depends on what you're looking for."
+
+### Facts Over Opinions
+
+Every claim gets a source. Include specific numbers, percentages, study names, expert names, and publication references. Unsourced claims are treated as opinions by AI engines. Even when writing original analysis, anchor claims to verifiable data points. Flag where data is needed if it's unavailable — don't leave unsourced assertions.
+
+### Use Structured Formats
+
+- **Definition blocks** — "X is [clear definition]" format for definitional queries
+- **Step-by-step lists** — Numbered steps for how-to queries
+
+- **Comparison tables** — Side-by-side comparisons for "vs" or "best" queries
+- **FAQ sections** — Question-and-answer pairs using actual user questions
+
+- **Pros/cons lists** — For evaluation queries
+
+### Heading Hierarchy as Query Map
+
+Each H2/H3 should mirror a natural question someone would ask. AI engines use headings to locate relevant sections. "How Much Does X Cost?" is better than "Pricing Information" because it matches the query pattern.
+
+### Comprehensive Coverage
+
+Cover the topic from multiple angles. AI engines prefer sources that address the full scope of a query — including related questions, edge cases, and common follow-ups. Thin content that only partially answers a question gets passed over for more complete sources.
+
+### Freshness Signals
+
+Include dates, version numbers, "as of [year]" references, and "updated on" indicators. AI engines prefer current information and will note when content appears outdated. Especially critical for Perplexity (real-time crawling) and Google AI Overviews.
+
+### Entity Clarity
+
+Name things explicitly. Instead of "the platform" or "the tool," use the actual name every time. AI engines match entities by name — pronouns and vague references break that matching. The brand/author/company should be unambiguously named and described.
+
+### No Filler
+
+Trim phrases that add length without adding facts. Remove: "In today's fast-paced world...", "It's important to note...", "As we all know...", "When it comes to...". Every sentence should contain a fact, a specific claim, or a direct answer.
+
+### Paragraph Discipline
+
+Keep paragraphs to 3-5 sentences maximum. Dense walls of text get skipped by both AI engines and human readers.
+
+## Universal Principles
+
+- **GEO and SEO compound.** Content that ranks well on Google is more likely to be in AI training data. Optimize for both.
+- **Community signals count.** Reddit, LinkedIn, Quora, and forum mentions are crawled by AI engines. Encourage authentic discussion around your content.
+
+- **Write for humans first.** AI clarity follows from human clarity — if it reads well to a person, it parses well for an AI engine.
+
+## Content Patterns by Type
+
+Read `content-patterns.md` for detailed templates and examples for each content type:
+
+- Blog posts and articles
+- Product and service pages
+
+- FAQ and knowledge base pages
+- Technical documentation
+
+- Landing pages
+- Comparison and review pages
+
+## Technical Optimization Checklist
+
+Read `technical-checklist.md` for:
+
+- Schema markup (JSON-LD) recommendations by content type
+- Meta description optimization for AI extraction
+
+- HTML semantics best practices
+- Page performance considerations
+
+- Sitemap and crawlability
+
+## Platform-Specific Considerations
+
+Different AI engines have different behaviors. Read `platform-notes.md` for engine-specific guidance:
+
+- **ChatGPT/OpenAI** — Browsing plugin and training data considerations
+- **Google AI Overviews** — Integration with traditional search signals
+
+- **Perplexity** — Real-time crawling and citation patterns
+- **Bing Copilot** — Bing index reliance and citation style
+
+## Common Mistakes
+
+- **Keyword stuffing** — AI engines parse semantics, not keyword density. Unnatural repetition hurts readability without improving AI visibility.
+- **Thin content** — Short pages that only scratch the surface lose to comprehensive competitors. Depth wins.
+
+- **Missing attribution** — Claims without sources are treated as opinions. Always cite.
+- **Poor structure** — Wall-of-text content is hard for AI to parse and quote. Use headings, lists, and short paragraphs.
+
+- **Ignoring related queries** — Answering only the primary question misses opportunities. Cover the "People Also Ask" and follow-up questions.
+- **Outdated information** — AI engines deprioritize stale content. Keep data points and references current.
+
+- **Burying the answer** — Leading with background or preamble instead of the direct answer. The answer belongs in the first 40-60 words.
+- **Vague language** — Generic statements ("many experts agree", "studies show") without naming the experts or studies. AI engines can't cite what isn't specific.