# Via Homebrew (recommended)
brew install --cask visual-studio-code

# Or download from https://code.visualstudio.com

# Via Winget
winget install Microsoft.VisualStudioCode

# Or download installer from https://code.visualstudio.com

sudo apt update
sudo apt install code

# Or use Snap
sudo snap install code --classic

code --version
# Should output: 1.85.0 (or newer)

code --install-extension yzhang.markdown-all-in-one
code --install-extension shd101wyy.markdown-preview-enhanced
code --install-extension streetsidesoftware.code-spell-checker
code --install-extension ritwickdey.liveserver
code --install-extension eamodio.gitlens
code --install-extension esbenp.prettier-vscode
code --install-extension davidanson.vscode-markdownlint
code --install-extension bierner.markdown-mermaid

{
  "editor.wordWrap": "on",
  "editor.fontSize": 15,
  "editor.lineHeight": 1.6,
  "editor.minimap.enabled": false,
  "editor.renderWhitespace": "none",
  "markdown.preview.breaks": true,
  "markdown.preview.fontSize": 16,
  "files.autoSave": "afterDelay",
  "files.autoSaveDelay": 2000,
  "workbench.colorTheme": "Default Light+",
  "[markdown]": {
    "editor.quickSuggestions": {
      "comments": "off",
      "strings": "off",
      "other": "off"
    },
    "editor.wordBasedSuggestions": false,
    "editor.defaultFormatter": "esbenp.prettier-vscode",
    "editor.formatOnSave": true
  },
  "cSpell.userWords": [
    "blogging", "VSCode", "frontmatter", "SEO", "MCP"
  ]
}

# Create project directory
mkdir ~/blogging-workspace
cd ~/blogging-workspace

# Initialize Git repository
git init

# Create .gitignore
cat > .gitignore << EOF
.DS_Store
node_modules/
.vscode/settings.json
_site/
.jekyll-cache/
*.log
EOF

# Open in VSCode
code .

mkdir $HOME\blogging-workspace
cd $HOME\blogging-workspace
git init
code .

# Create comprehensive folder structure
mkdir -p _posts _drafts assets/{images,diagrams,downloads} prompts templates scripts config personas

blogging-workspace/
├── _posts/                          # Published articles
│   ├── 2025-11-11-vscode-guide.md
│   └── 2025-11-08-ai-integration.md
├── _drafts/                         # Work-in-progress content
│   ├── upcoming-mcp-tutorial.md
│   └── research-notes.md
├── assets/                          # All media files
│   ├── images/
│   │   ├── 2025-11/                # Date-organized images
│   │   └── reusable/               # Brand assets, logos
│   ├── diagrams/                   # Technical diagrams
│   │   ├── architecture/
│   │   └── flowcharts/
│   └── downloads/                  # Downloadable resources
│       ├── templates/
│       └── code-samples/
├── personas/                        # Audience persona definitions
│   ├── personas.json
│   ├── solo-ai-architect.md
│   └── freelance-maker.md
├── prompts/                         # Reusable AI prompts
│   ├── drafting/
│   │   ├── outline-generator.txt
│   │   └── introduction-writer.txt
│   ├── editing/
│   │   ├── clarity-improver.txt
│   │   └── technical-accuracy.txt
│   └── seo/
│       ├── keyword-optimizer.txt
│       └── meta-description.txt
├── templates/                       # Content templates
│   ├── blog-post-template.md
│   ├── tutorial-template.md
│   └── case-study-template.md
├── scripts/                         # Automation scripts
│   ├── deploy.sh
│   ├── optimize-images.sh
│   └── generate-toc.py
├── config/                          # Configuration files
│   ├── _config.yml                 # Jekyll config
│   ├── netlify.toml                # Netlify deployment
│   └── package.json                # Node dependencies
└── README.md                        # Project documentation

---
layout: post
title: "[DRAFT] Your Title Here"
date: YYYY-MM-DD
author: "Your Name"
description: "Brief 150-160 character description for SEO and social sharing"
tags: ["tag1", "tag2", "tag3"]
canonical_url: ""
image: "/assets/images/YYYY-MM/featured-image.png"
og:title: "OpenGraph title (can differ from main title)"
og:description: "OpenGraph description for social sharing"
og:image: "/assets/images/YYYY-MM/og-image.png"
og:url: "https://yourdomain.com/blog/post-slug"
og:type: "article"
twitter:card: "summary_large_image"
twitter:title: "Twitter-specific title"
twitter:description: "Twitter-specific description"
twitter:image: "/assets/images/YYYY-MM/twitter-image.png"
keywords: ["primary keyword", "secondary keyword", "long-tail keyword"]
readtime: "X min"
difficulty: "beginner/intermediate/advanced"
target_persona: "Solo AI Architect Sam"
---

# [Article Title]

**Brief compelling introduction paragraph**

## Table of Contents
- Introduction
- Main Section 1
- Main Section 2
- Conclusion

---

## Introduction {#introduction}

[Hook, context, problem statement, and value proposition]

## [Main Section] {#section-1}

[Content with subheadings, code blocks, and examples]

### Subsection

[Detailed content]



**Key Takeaway:** [Summary point]

## Conclusion {#conclusion}

[Summary, call to action, next steps]

---

**Related Resources:**
- [Link to related post]
- [External resource]

**Want more content like this?** [Subscription CTA]

# Set your identity
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Useful aliases for blogging workflow
git config --global alias.draft "checkout -b draft/"
git config --global alias.publish "checkout main"

# Stage all files
git add .

# First commit
git commit -m "Initial blogging workspace setup"

# Create main branch (if needed)
git branch -M main

# Create repository on GitHub, then:
git remote add origin https://github.com/yourusername/blog.git
git push -u origin main

YYYY-MM-DD-slug-with-hyphens.md

/assets/images/YYYY-MM/descriptive-name-with-keywords.png

# Start new post
git checkout -b draft/vscode-advanced-tips
# Edit in _drafts/ folder

# Ready for review
git checkout -b review/vscode-advanced-tips
# Move to _posts/ folder, update frontmatter

# Publish
git checkout main
git merge review/vscode-advanced-tips
git push origin main

---
# Required
title: "Post Title"                    # 50-60 characters optimal
date: 2025-11-11                       # YYYY-MM-DD format
description: "Meta description"        # 150-160 characters

# SEO Critical
keywords: ["primary", "secondary"]     # 3-5 keywords
canonical_url: "https://..."           # Prevent duplicate content

# Organization
tags: ["category1", "category2"]       # 3-7 tags
target_persona: "Solo AI Architect"    # Audience alignment

# Social Optimization
og:title: "OpenGraph Title"            # Can differ from title
og:description: "OG Description"       # Optimized for sharing
og:image: "/path/to/image.png"         # 1200x630px recommended

# Optional but Useful
readtime: "18 min"                     # Manual or auto-calculated
difficulty: "intermediate"              # Reader expectation setting
last_updated: 2025-11-15               # For evergreen content
---

#!/bin/bash
# Generate frontmatter template with current date

DATE=$(date +%Y-%m-%d)
SLUG=$1

if [ -z "$SLUG" ]; then
    echo "Usage: ./generate-frontmatter.sh post-slug"
    exit 1
fi

cat > "_drafts/${DATE}-${SLUG}.md" << EOF
---
layout: post
title: "[DRAFT] ${SLUG//-/ }"
date: ${DATE}
author: "Daniel Kliewer"
description: ""
tags: []
canonical_url: ""
image: "/assets/images/$(date +%Y-%m)/featured.png"
keywords: []
target_persona: ""
---

# [Title Here]

## Introduction

[Content starts here]
EOF

echo "Created: _drafts/${DATE}-${SLUG}.md"
code "_drafts/${DATE}-${SLUG}.md"

chmod +x scripts/generate-frontmatter.sh
./scripts/generate-frontmatter.sh my-new-post

{
  "personas": [
    {
      "persona_name": "Solo AI Architect Sam",
      "age_range": "28-38",
      "location": "US tech hub",
      "role": "Independent AI consultant/architect",
      "technical_skill": 0.85,
      "attributes": {
        "prefers_deep_dive_content": 0.90,
        "wants_code_examples": 0.92,
        "budget_consciousness": 0.78,
        "time_available": 0.60,
        "open_source_preference": 0.92,
        "local_first_ai_interest": 0.95
      },
      "content_preferences": {
        "ideal_length": "2000-3500 words",
        "code_to_explanation_ratio": "40:60",
        "prefers_cli_over_gui": true,
        "values_reproducibility": true
      },
      "pain_points": [
        "API costs eating into project budgets",
        "Platform lock-in limiting flexibility",
        "Privacy concerns with cloud-based tools",
        "Need for production-ready solutions, not demos"
      ],
      "goals": [
        "Build sustainable AI architecture practice",
        "Minimize recurring tool costs",
        "Maintain data sovereignty",
        "Document and share unique approaches"
      ]
    },
    {
      "persona_name": "Freelance Maker Maya",
      "age_range": "24-34",
      "location": "Urban (US/EU)",
      "role": "Solo developer building products",
      "technical_skill": 0.70,
      "attributes": {
        "entrepreneurial_mindset": 0.91,
        "prefers_tutorials": 0.79,
        "budget_consciousness": 0.88,
        "wants_productization": 0.82,
        "monetization_interest": 0.90
      },
      "content_preferences": {
        "ideal_length": "1500-2500 words",
        "code_to_explanation_ratio": "30:70",
        "needs_quick_wins": true,
        "values_actionable_steps": true
      },
      "pain_points": [
        "Limited time for deep technical learning",
        "Need to ship quickly without sacrificing quality",
        "Tool costs cutting into margins",
        "Wearing too many hats (dev, marketing, sales)"
      ],
      "goals": [
        "Launch products faster",
        "Build sustainable income streams",
        "Learn while building",
        "Create content that attracts customers"
      ]
    }
  ]
}

# Before writing, answer:
# - Which persona is this for?
# - What specific pain point does this address?
# - What's the skill level assumption?
# - What's the optimal length and depth?

"Review this draft through the lens of Solo AI Architect Sam—
a highly technical independent consultant (skill: 0.85) who 
prefers deep-dive content (0.90), values local-first AI (0.95), 
and is budget-conscious (0.78). 

Does the content:
- Provide sufficient technical depth?
- Emphasize cost control and open-source alternatives?
- Include production-ready code examples?
- Respect the reader's time with scannable structure?

Suggest improvements to better align with this persona."

# Self-Hosted AI Writing Assistant: Complete Architecture Guide

## Local LLM Deployment with Ollama
- Docker container orchestration
- GPU acceleration configuration  
- Model quantization for resource optimization
- API integration patterns

[Deep technical content, 3,000 words, code-heavy]

# Free AI Writing Assistant Setup in 30 Minutes

## Quick Start with Ready-Made Tools
- Installing Ollama (5 minutes)
- Running your first model (one command)
- VSCode integration with Cline
- Prompt templates to copy-paste

[Practical tutorial, 1,800 words, screenshot-heavy]

# Q1 2026 Content Calendar

## January (Focus: Solo AI Architect Sam)
- Week 1: Advanced MCP server development
- Week 2: Benchmarking local LLMs for production
- Week 3: Cost analysis: Self-hosted vs. API-based AI
- Week 4: Security hardening for AI toolchains

## February (Focus: Freelance Maker Maya)
- Week 1: Quick AI tools for indie hackers
- Week 2: Automating content marketing with AI
- Week 3: Building AI features on a budget
- Week 4: AI-powered customer support for solopreneurs

# Install Node.js if not present
node --version  # Should be 18.0+

# Install MCP GitHub server
npm install -g @modelcontextprotocol/server-github

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your_github_personal_access_token"
      }
    }
  }
}

"Fetch the latest release notes from the 'vscode-cline' repository 
and summarize the new features for my blog post."

# Install filesystem MCP server for local docs
npm install -g @modelcontextprotocol/server-filesystem

{
  "mcpServers": {
    "docs": {
      "command": "npx",
      "args": [
        "-y", 
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/documentation"
      ]
    }
  }
}

{
  "mcpServers": {
    "notes": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/Documents/research-notes"
      ]
    }
  }
}

npm install -g @modelcontextprotocol/server-brave-search

{
  "mcpServers": {
    "search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_api_key"
      }
    }
  }
}

// blog-analytics-server.js
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import fs from 'fs/promises';
import path from 'path';

const server = new Server({
  name: "blog-analytics",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});

// Tool: Get post statistics
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_post_stats",
    description: "Get word count, read time, and metadata for a blog post",
    inputSchema: {
      type: "object",
      properties: {
        filename: { type: "string", description: "Post filename" }
      },
      required: ["filename"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "get_post_stats") {
    const filename = request.params.arguments.filename;
    const filepath = path.join(process.cwd(), '_posts', filename);
    const content = await fs.readFile(filepath, 'utf-8');
    
    const wordCount = content.split(/\s+/).length;
    const readTime = Math.ceil(wordCount / 200); // 200 WPM average
    
    return {
      content: [{
        type: "text",
        text: `Stats for ${filename}:\n- Word count: ${wordCount}\n- Est. read time: ${readTime} min`
      }]
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

# Make executable
chmod +x blog-analytics-server.js

# Add to Cline config
{
  "mcpServers": {
    "blog-analytics": {
      "command": "node",
      "args": ["/path/to/blog-analytics-server.js"]
    }
  }
}

# Test MCP server independently
npx @modelcontextprotocol/server-github --help

# Check server logs
# Cline logs location: VSCode Output panel → MCP Servers

# Via command line
code --install-extension saoudrizwan.claude-dev

# Or via VSCode Extensions panel: Search "Cline"

{
  "cline.apiProvider": "openai-compatible",
  "cline.apiEndpoint": "https://api.x.ai/v1",
  "cline.apiKey": "your-xai-api-key",
  "cline.modelId": "grok-beta"
}

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Download a capable model
ollama pull llama3.1:8b

# Configure Cline for local usage

{
  "cline.apiProvider": "ollama",
  "cline.apiEndpoint": "http://localhost:11434",
  "cline.modelId": "llama3.1:8b"
}

Role: Technical content writer for [target persona]

Task: Generate a detailed outline for a blog post about [topic]

Requirements:
- Target audience: [persona name + key attributes]
- Desired length: [word count]
- Technical depth: [beginner/intermediate/advanced]
- Must include: [specific sections or requirements]
- SEO focus: [primary keyword]

Output format: Markdown with H2/H3 structure

Role: Technical content writer for Solo AI Architect Sam

Task: Generate outline for "Setting up Local LLM Development Environment"

Requirements:
- Target: highly technical AI consultant (skill 0.85)
- Length: 3,000 words
- Depth: advanced with production-ready examples
- Include: Docker setup, GPU config, model selection, API integration
- SEO: "local llm development environment"
- Emphasize: cost savings vs cloud APIs, data privacy

Output: Markdown outline with H2/H3

Current section: [paste your draft section]

Target persona: [persona name]
Technical level: [0.0-1.0 score]

Enhancement requests:
1. Add specific code example demonstrating [concept]
2. Include troubleshooting subsection for common errors
3. Expand explanation of [technical term] for clarity
4. Add real-world use case scenario
5. Ensure [word count] words minimum

Maintain technical accuracy and practical focus.

Content: [paste your draft]
Primary keyword: [keyword]
Secondary keywords: [keyword1, keyword2, keyword3]

SEO analysis needed:
1. Keyword density check (target: 1-2% for primary)
2. Heading structure optimization (H1/H2/H3 with keywords)
3. Meta description suggestion (155 characters, compelling)
4. Alt text for images
5. Internal linking opportunities
6. Readability score (Flesch-Kincaid target: 60-70)

Provide specific recommendations with before/after examples.

Review this technical content for accuracy:

[paste content]

Check for:
- Incorrect technical statements or outdated information
- Misleading simplifications that could cause issues
- Missing important caveats or warnings
- Code examples that won't run as-written
- Deprecated methods or approaches
- Security concerns in examples

For each issue found, provide:
1. Location (heading/paragraph)
2. Problem description
3. Corrected version
4. Brief explanation

prompts/
├── drafting/
│   ├── outline-generator.txt
│   ├── introduction-writer.txt
│   ├── conclusion-writer.txt
│   └── code-example-generator.txt
├── editing/
│   ├── clarity-enhancer.txt
│   ├── technical-accuracy-checker.txt
│   ├── tone-adjuster.txt
│   └── redundancy-eliminator.txt
├── seo/
│   ├── keyword-optimizer.txt
│   ├── meta-description-writer.txt
│   ├── heading-structure-analyzer.txt
│   └── readability-improver.txt
└── research/
    ├── topic-researcher.txt
    ├── competitor-analysis.txt
    └── trend-analyzer.txt

ROLE: Expert technical editor specializing in developer documentation

TASK: Improve clarity and readability of the following content without 
changing technical accuracy or overall structure.

CONTENT:
{PASTE_CONTENT_HERE}

TARGET AUDIENCE: {PERSONA_NAME} (technical skill: {SKILL_SCORE})

FOCUS AREAS:
1. Eliminate jargon where simpler terms work equally well
2. Break long sentences (>25 words) into shorter ones
3. Replace passive voice with active voice
4. Add concrete examples to abstract concepts
5. Improve paragraph transitions
6. Highlight key takeaways

OUTPUT: 
- Revised content with [EDIT] markers showing changes
- Summary of major improvements made
- Readability score before/after (estimated)

Step 1: "Generate outline for [topic]"
[Review outline]

Step 2: "Expand section 2 of the outline with 500 words"
[Review expansion]

Step 3: "Add code example demonstrating [concept] from section 2"
[Review code]

You: "Draft intro for VSCode setup guide"
Cline: [provides draft]
You: "Make it more conversational, add specific pain point"
Cline: [revises]
You: "Good, now add a hook about platform lock-in"
Cline: [refines further]

{
  "cline.customCommands": {
    "/outline": "Generate detailed blog post outline for: ",
    "/seo": "Optimize this content for SEO, primary keyword: ",
    "/expand": "Expand this section to 500 words with examples: ",
    "/check": "Review for technical accuracy: "
  }
}

## Keyword Research Template

### Topic: [Your blog post topic]

### Seed Keywords:
- Primary: [main keyword]
- Secondary: [related keyword 1]
- Secondary: [related keyword 2]

### Research Results:

| Keyword | Monthly Volume | Competition | Intent | Priority |
|---------|----------------|-------------|--------|----------|
| vscode blogging setup | 480 | Low | Tutorial | High |
| free blogging platform | 12,000 | High | Comparison | Medium |
| markdown blog editor | 720 | Medium | Tool | High |
| technical writing tools | 1,600 | Medium | Listicle | Medium |

### Long-Tail Opportunities:
- "how to set up vscode for blogging" (190/month, low competition)
- "vscode extensions for technical writing" (110/month, low competition)
- "free alternative to medium" (320/month, medium competition)

### Search Intent Analysis:
- Informational: 70% (users want tutorials)
- Commercial: 20% (users comparing platforms)
- Navigational: 10% (users seeking specific tools)

### Content Angle Decision:
Focus on comprehensive tutorial (informational intent) with comparison 
elements and tool recommendations.

Prompt for Cline:

"Analyze these primary keywords for a technical blog post:
- vscode blogging
- technical writing setup
- free blogging tools

For each, suggest:
1. 5 related long-tail keywords
2. Common questions people ask (based on 'People Also Ask')
3. Semantic keywords to include naturally
4. Content gaps in existing top-ranking articles

Format as a research table."

## Pre-Publish SEO Checklist

### Title Optimization
- [ ] Primary keyword in title
- [ ] 50-60 characters total
- [ ] Compelling and click-worthy
- [ ] Numbers or power words included (e.g., "Complete", "Ultimate")

### URL Structure  
- [ ] Short, descriptive slug
- [ ] Primary keyword included
- [ ] Hyphens separate words
- [ ] No stop words (a, the, in)
- Example: ✅ `/vscode-blogging-guide` ❌ `/the-complete-guide-to-blogging-with-vscode-2025`

### Meta Description
- [ ] 150-160 characters
- [ ] Primary keyword included naturally
- [ ] Clear value proposition
- [ ] Call to action implied
- [ ] No truncation when displayed

### Heading Structure
- [ ] Single H1 (post title)
- [ ] H2s include keywords naturally
- [ ] Logical hierarchy (H2 → H3 → H4)
- [ ] Descriptive, not generic ("Setup Guide" not "Introduction")

### Content Optimization
- [ ] Primary keyword in first 100 words
- [ ] Keyword density: 1-2% (natural, not forced)
- [ ] Semantic keywords throughout content
- [ ] LSI (Latent Semantic Indexing) keywords included
- [ ] 1,500+ words for competitive keywords
- [ ] Short paragraphs (3-4 sentences max)
- [ ] Bullet points and lists for scannability

### Images and Media
- [ ] Descriptive file names (vscode-setup-screenshot.png)
- [ ] Alt text with keywords (naturally written)
- [ ] Compressed for fast loading (<200KB)
- [ ] Responsive sizing
- [ ] Proper attribution if not original

### Internal Linking
- [ ] 2-4 links to related posts
- [ ] Descriptive anchor text
- [ ] Links add value (not forced)

### External Linking
- [ ] 2-3 links to authoritative sources
- [ ] Links open in new tab (optional)
- [ ] Verify all links work

### Technical SEO
- [ ] Mobile-responsive design
- [ ] Fast page load (<3 seconds)
- [ ] HTTPS enabled
- [ ] Structured data markup (if applicable)
- [ ] Canonical URL set

# Primary Keyword in H1 (Exact match or close variation)

**Brief introduction (100-150 words) with:**
- Problem statement
- Primary keyword in first paragraph
- Hook/value proposition

## Table of Contents
[Auto-generated from H2s]

---

## H2: Why [Primary Keyword] Matters
[300-500 words: Context, importance, user benefits]

## H2: [Primary Keyword] - Complete Setup Guide
[800-1200 words: Step-by-step process]

### H3: Step 1: [Specific Action]
[Detailed instructions with screenshots]

### H3: Step 2: [Specific Action]
[Detailed instructions with code examples]

## H2: Advanced [Primary Keyword] Techniques
[500-800 words: Power tips, alternatives, optimizations]

## H2: Common Issues and Troubleshooting
[400-600 words: FAQ-style solutions]

## H2: Conclusion and Next Steps
[200-300 words: Summary, CTA, related resources]

---

**Related Articles:**
- [Internal link 1 with descriptive anchor]
- [Internal link 2 with descriptive anchor]

**Additional Resources:**
- [External authoritative source]
- [Official documentation]

#!/bin/bash
# SEO validation script for blog posts

POST_FILE=$1

if [ -z "$POST_FILE" ]; then
    echo "Usage: ./seo-check.sh path/to/post.md"
    exit 1
fi

echo "🔍 SEO Analysis for: $POST_FILE"
echo "================================"

# Extract frontmatter
TITLE=$(grep "^title:" "$POST_FILE" | head -1 | cut -d'"' -f2)
DESCRIPTION=$(grep "^description:" "$POST_FILE" | head -1 | cut -d'"' -f2)

# Title length check
TITLE_LENGTH=${#TITLE}
echo "📝 Title: $TITLE"
echo "   Length: $TITLE_LENGTH chars"
if [ $TITLE_LENGTH -lt 50 ] || [ $TITLE_LENGTH -gt 60 ]; then
    echo "   ⚠️  Warning: Optimal title length is 50-60 characters"
fi

# Description length check
DESC_LENGTH=${#DESCRIPTION}
echo ""
echo "📄 Meta Description: $DESCRIPTION"
echo "   Length: $DESC_LENGTH chars"
if [ $DESC_LENGTH -lt 150 ] || [ $DESC_LENGTH -gt 160 ]; then
    echo "   ⚠️  Warning: Optimal description length is 150-160 characters"
fi

# Word count
WORD_COUNT=$(grep -v "^---" "$POST_FILE" | grep -v "^#" | wc -w | tr -d ' ')
echo ""
echo "📊 Word Count: $WORD_COUNT"
if [ $WORD_COUNT -lt 1500 ]; then
    echo "   ⚠️  Warning: Consider expanding to 1,500+ words for better SEO"
fi

# H1 count (should be exactly 1)
H1_COUNT=$(grep -c "^# " "$POST_FILE")
echo ""
echo "📑 H1 Count: $H1_COUNT"
if [ $H1_COUNT -ne 1 ]; then
    echo "   ❌ Error: Should have exactly 1 H1"
fi

# Image alt text check
IMAGES=$(grep -c "!\[" "$POST_FILE")
echo ""
echo "🖼️  Images: $IMAGES found"
if [ $IMAGES -gt 0 ]; then
    echo "   ✓ Remember to verify all images have descriptive alt text"
fi

echo ""
echo "✅ SEO check complete!"

chmod +x scripts/seo-check.sh
./scripts/seo-check.sh _posts/2025-11-11-vscode-guide.md

#!/usr/bin/env python3
"""
Simple local analytics tracker for static blogs
Reads server logs and generates basic stats
"""

import re
from collections import Counter
from datetime import datetime

def parse_log_file(log_path):
    """Parse Apache/Nginx logs for blog post views"""
    views = Counter()

    with open(log_path, 'r') as f:
        for line in f:
            # Extract blog post URLs
            match = re.search(r'GET (/blog/[\w-]+)', line)
            if match:
                views[match.group(1)] += 1

    return views

def generate_report(views):
    """Generate readable analytics report"""
    print("📊 Blog Analytics Summary")
    print("=" * 50)
    print(f"Report generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n")

    print("Top 10 Posts by Views:")
    for url, count in views.most_common(10):
        print(f"  {count:>5} views - {url}")

if __name__ == "__main__":
    # Adjust path to your server logs
    log_path = "/var/log/nginx/access.log"
    views = parse_log_file(log_path)
    generate_report(views)

# Content Performance Tracker

## Q4 2025 Performance

| Post Title | Published | Primary Keyword | Impressions | Clicks | CTR | Avg Position |
|------------|-----------|-----------------|-------------|--------|-----|--------------|
| VSCode Blogging Guide | 2025-11-11 | vscode blogging | 2,400 | 180 | 7.5% | 4.2 |
| AI Writing Tools | 2025-11-08 | ai writing assistant | 1,800 | 95 | 5.3% | 6.8 |

## Insights:
- VSCode guide performing well (top 5 for target keyword)
- AI tools post needs optimization (position 6.8, aim for top 5)
- CTR above 5% is good; below 3% needs title/description work

## Action Items:
- [ ] Update AI tools post with more specific use cases
- [ ] Add comparison table to AI tools post
- [ ] Build internal links from VSCode guide to AI tools post