feat: Complete Phase 1 - AI Coding Assistant Integrations (v2.10.0)

Add comprehensive integration guides for 4 AI coding assistants: ## New Integration Guides (98KB total) - docs/integrations/WINDSURF.md (20KB) - Windsurf IDE with .windsurfrules - docs/integrations/CLINE.md (25KB) - Cline VS Code extension with MCP - docs/integrations/CONTINUE_DEV.md (28KB) - Continue.dev for any IDE - docs/integrations/INTEGRATIONS.md (25KB) - Comprehensive hub with decision tree ## Working Examples (3 directories, 11 files) - examples/windsurf-fastapi-context/ - FastAPI + Windsurf automation - examples/cline-django-assistant/ - Django + Cline with MCP server - examples/continue-dev-universal/ - HTTP context server for all IDEs ## README.md Updates - Updated tagline: Universal preprocessor for 10+ AI systems - Expanded Supported Integrations table (7 → 10 platforms) - Added 'AI Coding Assistant Integrations' section (60+ lines) - Cross-links to all new guides and examples ## Impact - Week 2 of ACTION_PLAN.md: 4/4 tasks complete (100%) ✅ - Total new documentation: ~3,000 lines - Total new code: ~1,000 lines (automation scripts, servers) - Integration coverage: LangChain, LlamaIndex, Pinecone, Cursor, Windsurf, Cline, Continue.dev, Claude, Gemini, ChatGPT ## Key Features - All guides follow proven 11-section pattern from CURSOR.md - Real-world examples with automation scripts - Multi-IDE consistency (Continue.dev works in VS Code, JetBrains, Vim) - MCP integration for dynamic documentation access - Complete troubleshooting sections with solutions Positions Skill Seekers as universal preprocessor for ANY AI system. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-02-07 20:46:26 +03:00
parent eff6673c89
commit bdd61687c5
15 changed files with 5892 additions and 5 deletions
--- a/docs/integrations/WINDSURF.md
+++ b/docs/integrations/WINDSURF.md
@@ -0,0 +1,986 @@
+# Using Skill Seekers with Windsurf IDE
+
+**Last Updated:** February 7, 2026
+**Status:** Production Ready
+**Difficulty:** Easy ⭐
+
+---
+
+## 🎯 The Problem
+
+Windsurf IDE (by Codeium) offers powerful AI flows and Cascade agent, but:
+
+- **Generic Knowledge** - AI doesn't know your project-specific frameworks or internal patterns
+- **Manual Context** - Copy-pasting documentation into chat is tedious and breaks flow
+- **Limited Memory** - Memory feature requires manual teaching through conversations
+- **Context Limits** - Rules files are limited to 12,000 characters combined
+
+**Example:**
+> "When building a FastAPI app in Windsurf, Cascade might suggest outdated patterns or miss framework-specific best practices. You want the AI to reference comprehensive documentation without hitting character limits."
+
+---
+
+## ✨ The Solution
+
+Use Skill Seekers to create **custom rules** for Windsurf's Cascade agent:
+
+1. **Generate structured docs** from any framework or codebase
+2. **Package as .windsurfrules** - Windsurf's markdown rules format
+3. **Automatic Context** - Cascade references your docs in AI flows
+4. **Modular Rules** - Split large docs into multiple rule files (6K chars each)
+
+**Result:**
+Windsurf's Cascade becomes an expert in your frameworks with persistent, automatic context that fits within character limits.
+
+---
+
+## 🚀 Quick Start (5 Minutes)
+
+### Prerequisites
+
+- Windsurf IDE installed (https://windsurf.com/)
+- Python 3.10+ (for Skill Seekers)
+
+### Installation
+
+```bash
+# Install Skill Seekers
+pip install skill-seekers
+
+# Verify installation
+skill-seekers --version
+```
+
+### Generate .windsurfrules
+
+```bash
+# Example: FastAPI framework
+skill-seekers scrape --config configs/fastapi.json
+
+# Package for Windsurf (markdown format)
+skill-seekers package output/fastapi --target markdown
+
+# Extract SKILL.md
+# output/fastapi-markdown/SKILL.md
+```
+
+### Setup in Windsurf
+
+**Option 1: Project-Specific Rules** (recommended)
+
+```bash
+# Create rules directory
+mkdir -p /path/to/your/project/.windsurf/rules
+
+# Copy as rules.md
+cp output/fastapi-markdown/SKILL.md /path/to/your/project/.windsurf/rules/fastapi.md
+```
+
+**Option 2: Legacy .windsurfrules** (single file)
+
+```bash
+# Copy to project root (legacy format)
+cp output/fastapi-markdown/SKILL.md /path/to/your/project/.windsurfrules
+```
+
+**Option 3: Split Large Documentation** (for >6K char files)
+
+```bash
+# Skill Seekers automatically splits large files
+skill-seekers package output/react --target markdown --split-rules
+
+# This creates multiple rule files:
+# output/react-markdown/rules/
+#   ├── core-concepts.md      (5,800 chars)
+#   ├── hooks-reference.md    (5,400 chars)
+#   ├── components-guide.md   (5,900 chars)
+#   └── best-practices.md     (4,200 chars)
+
+# Copy all rules
+cp -r output/react-markdown/rules/* /path/to/your/project/.windsurf/rules/
+```
+
+### Test in Windsurf
+
+1. Open your project in Windsurf
+2. Start Cascade (Cmd+L or Ctrl+L)
+3. Test knowledge:
+   ```
+   "Create a FastAPI endpoint with async database queries using best practices"
+   ```
+4. Verify Cascade references your documentation
+
+---
+
+## 📖 Detailed Setup Guide
+
+### Step 1: Choose Your Documentation Source
+
+**Option A: Use Preset Configs** (24+ frameworks)
+
+```bash
+# List available presets
+ls configs/
+
+# Popular presets:
+# - react.json, vue.json, angular.json (Frontend)
+# - django.json, fastapi.json, flask.json (Backend)
+# - godot.json, unity.json (Game Development)
+# - kubernetes.json, docker.json (Infrastructure)
+```
+
+**Option B: Custom Documentation**
+
+Create `myframework-config.json`:
+
+```json
+{
+  "name": "myframework",
+  "description": "Custom framework documentation for Windsurf",
+  "base_url": "https://docs.myframework.com/",
+  "selectors": {
+    "main_content": "article",
+    "title": "h1",
+    "code_blocks": "pre code"
+  },
+  "categories": {
+    "getting_started": ["intro", "quickstart", "installation"],
+    "core_concepts": ["concepts", "architecture", "patterns"],
+    "api": ["api", "reference", "methods"],
+    "guides": ["guide", "tutorial", "how-to"],
+    "best_practices": ["best-practices", "tips", "patterns"]
+  }
+}
+```
+
+**Option C: GitHub Repository**
+
+```bash
+# Analyze open-source codebase
+skill-seekers github --repo facebook/react
+
+# Or local codebase
+skill-seekers analyze --directory /path/to/repo --comprehensive
+```
+
+### Step 2: Optimize for Windsurf
+
+**Character Limit Awareness**
+
+Windsurf has strict limits:
+- **Per rule file:** 6,000 characters max
+- **Combined global + local:** 12,000 characters max
+
+**Use split-rules flag:**
+
+```bash
+# Automatically split large documentation
+skill-seekers package output/django --target markdown --split-rules
+
+# This creates modular rules:
+# - core-concepts.md      (Always On)
+# - api-reference.md      (Model Decision)
+# - best-practices.md     (Always On)
+# - troubleshooting.md    (Manual @mention)
+```
+
+**Rule Activation Modes**
+
+Configure each rule file's activation mode in frontmatter:
+
+```markdown
+---
+name: "FastAPI Core Concepts"
+activation: "always-on"
+priority: "high"
+---
+
+# FastAPI Framework Expert
+
+You are an expert in FastAPI...
+```
+
+Activation modes:
+- **Always On** - Applied to every request (use for core concepts)
+- **Model Decision** - AI decides when to use (use for specialized topics)
+- **Manual** - Only when @mentioned (use for troubleshooting)
+- **Scheduled** - Time-based activation (use for context switching)
+
+### Step 3: Configure Windsurf Settings
+
+**Enable Rules**
+
+1. Open Windsurf Settings (Cmd+, or Ctrl+,)
+2. Search for "rules"
+3. Enable "Use Custom Rules"
+4. Set rules directory: `.windsurf/rules`
+
+**Memory Integration**
+
+Combine rules with Windsurf's Memory feature:
+
+```bash
+# Generate initial rules from docs
+skill-seekers package output/fastapi --target markdown
+
+# Windsurf Memory learns from your usage:
+# - Coding patterns you use frequently
+# - Variable naming conventions
+# - Architecture decisions
+# - Team-specific practices
+
+# Rules provide documentation, Memory provides personalization
+```
+
+**MCP Server Integration**
+
+For live documentation access:
+
+```bash
+# Install Skill Seekers MCP server
+pip install skill-seekers[mcp]
+
+# Configure in Windsurf's mcp_config.json
+{
+  "mcpServers": {
+    "skill-seekers": {
+      "command": "python",
+      "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
+    }
+  }
+}
+```
+
+### Step 4: Test and Refine
+
+**Test Cascade Knowledge**
+
+```bash
+# Start Cascade (Cmd+L)
+# Ask framework-specific questions:
+
+"Show me FastAPI async database patterns"
+"Create a React component with TypeScript best practices"
+"Implement Django REST framework viewset with pagination"
+```
+
+**Refine Rules**
+
+```bash
+# Add project-specific patterns
+cat >> .windsurf/rules/project-conventions.md << 'EOF'
+---
+name: "Project Conventions"
+activation: "always-on"
+priority: "highest"
+---
+
+# Project-Specific Patterns
+
+## Database Models
+- Always use async SQLAlchemy
+- Include created_at/updated_at timestamps
+- Add __repr__ for debugging
+
+## API Endpoints
+- Use dependency injection for database sessions
+- Return Pydantic models, not ORM instances
+- Include OpenAPI documentation strings
+EOF
+
+# Reload Windsurf window (Cmd+Shift+P → "Reload Window")
+```
+
+**Monitor Character Usage**
+
+```bash
+# Check rule file sizes
+find .windsurf/rules -name "*.md" -exec wc -c {} \;
+
+# Ensure no file exceeds 6,000 characters
+# If too large, split further:
+skill-seekers package output/react --target markdown --split-rules --max-chars 5000
+```
+
+---
+
+## 🎨 Advanced Usage
+
+### Multi-Framework Projects
+
+**Backend + Frontend Stack**
+
+```bash
+# Generate backend rules (FastAPI)
+skill-seekers scrape --config configs/fastapi.json
+skill-seekers package output/fastapi --target markdown --split-rules
+
+# Generate frontend rules (React)
+skill-seekers scrape --config configs/react.json
+skill-seekers package output/react --target markdown --split-rules
+
+# Organize rules directory:
+.windsurf/rules/
+├── backend/
+│   ├── fastapi-core.md          (Always On)
+│   ├── fastapi-database.md      (Model Decision)
+│   └── fastapi-testing.md       (Manual)
+├── frontend/
+│   ├── react-hooks.md           (Always On)
+│   ├── react-components.md      (Model Decision)
+│   └── react-performance.md     (Manual)
+└── project/
+    └── conventions.md           (Always On, Highest Priority)
+```
+
+### Dynamic Context per Workflow
+
+**Context Switching Based on Task**
+
+```markdown
+---
+name: "Testing Context"
+activation: "model-decision"
+description: "Use when user is writing or debugging tests"
+keywords: ["test", "pytest", "unittest", "mock", "fixture"]
+---
+
+# Testing Best Practices
+
+When writing tests, follow these patterns...
+```
+
+**Scheduled Rules for Time-Based Context**
+
+```markdown
+---
+name: "Code Review Mode"
+activation: "scheduled"
+schedule: "0 14 * * 1-5"  # 2 PM on weekdays
+priority: "high"
+---
+
+# Code Review Checklist
+
+During code review, verify:
+- Type annotations are complete
+- Tests cover edge cases
+- Documentation is updated
+```
+
+### Windsurf + RAG Pipeline
+
+**Combine Rules with Vector Search**
+
+```python
+# Use Skill Seekers to create both:
+# 1. Windsurf rules (for Cascade context)
+# 2. RAG chunks (for deep search)
+
+from skill_seekers.cli.doc_scraper import main as scrape
+from skill_seekers.cli.package_skill import main as package
+from skill_seekers.cli.adaptors import get_adaptor
+
+# Scrape documentation
+scrape(["--config", "configs/react.json"])
+
+# Create Windsurf rules
+package(["output/react", "--target", "markdown", "--split-rules"])
+
+# Also create RAG pipeline for deep search
+package(["output/react", "--target", "langchain", "--chunk-for-rag"])
+
+# Now you have:
+# - .windsurf/rules/*.md (for Cascade)
+# - output/react-langchain/ (for custom RAG search)
+```
+
+**MCP Tool for Dynamic Context**
+
+Create custom MCP tool that queries RAG pipeline:
+
+```python
+# mcp_custom_search.py
+from skill_seekers.mcp.tools import search_docs
+
+@mcp.tool()
+def search_react_docs(query: str) -> str:
+    """Search React documentation for specific patterns."""
+    # Query your RAG pipeline
+    results = vector_store.similarity_search(query, k=5)
+    return "\n\n".join([doc.page_content for doc in results])
+```
+
+Register in `mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "custom-search": {
+      "command": "python",
+      "args": ["mcp_custom_search.py"]
+    }
+  }
+}
+```
+
+---
+
+## 💡 Best Practices
+
+### 1. Keep Rules Focused
+
+**Bad: Single Monolithic Rule (15,000 chars - exceeds limit!)**
+
+```markdown
+---
+name: "Everything React"
+---
+# React Framework (Complete Guide)
+[... 15,000 characters of documentation ...]
+```
+
+**Good: Modular Rules (5,000 chars each)**
+
+```markdown
+<!-- react-core.md (5,200 chars) -->
+---
+name: "React Core Concepts"
+activation: "always-on"
+---
+# React Fundamentals
+[... focused on hooks, components, state ...]
+
+<!-- react-performance.md (4,800 chars) -->
+---
+name: "React Performance"
+activation: "model-decision"
+description: "Use when optimizing React performance"
+---
+# Performance Optimization
+[... focused on memoization, lazy loading ...]
+
+<!-- react-testing.md (5,100 chars) -->
+---
+name: "React Testing"
+activation: "manual"
+---
+# Testing React Components
+[... focused on testing patterns ...]
+```
+
+### 2. Use Activation Modes Wisely
+
+| Mode | Use Case | Example |
+|------|----------|---------|
+| **Always On** | Core concepts, common patterns | Framework fundamentals, project conventions |
+| **Model Decision** | Specialized topics | Performance optimization, advanced patterns |
+| **Manual** | Troubleshooting, rare tasks | Debugging guides, migration docs |
+| **Scheduled** | Time-based context | Code review checklists, release procedures |
+
+### 3. Prioritize Rules
+
+```markdown
+---
+name: "Project Conventions"
+activation: "always-on"
+priority: "highest"  # This overrides framework defaults
+---
+
+# Project-Specific Rules
+
+Always use:
+- Async/await for all database operations
+- Pydantic V2 (not V1)
+- pytest-asyncio for async tests
+```
+
+### 4. Include Code Examples
+
+**Don't just describe patterns:**
+
+```markdown
+## Creating Database Models
+
+Use SQLAlchemy with async patterns.
+```
+
+**Show actual code:**
+
+```markdown
+## Creating Database Models
+
+```python
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True)
+    email = Column(String, unique=True, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    def __repr__(self):
+        return f"<User(email='{self.email}')>"
+
+# Usage in endpoint
+async def create_user(email: str, db: AsyncSession):
+    user = User(email=email)
+    db.add(user)
+    await db.commit()
+    await db.refresh(user)
+    return user
+```
+\```
+
+Use this pattern in all endpoints.
+```
+
+### 5. Update Rules Regularly
+
+```bash
+# Framework updates quarterly
+skill-seekers scrape --config configs/react.json
+skill-seekers package output/react --target markdown --split-rules
+
+# Check what changed
+diff -r .windsurf/rules/react-old/ .windsurf/rules/react-new/
+
+# Merge updates
+cp -r .windsurf/rules/react-new/* .windsurf/rules/
+
+# Test with Cascade
+# Ask: "What's new in React 19?"
+```
+
+---
+
+## 🔥 Real-World Examples
+
+### Example 1: FastAPI + PostgreSQL Microservice
+
+**Project Structure:**
+
+```
+my-api/
+├── .windsurf/
+│   └── rules/
+│       ├── fastapi-core.md       (5,200 chars, Always On)
+│       ├── fastapi-database.md   (5,800 chars, Always On)
+│       ├── fastapi-testing.md    (4,100 chars, Manual)
+│       └── project-conventions.md (3,500 chars, Always On, Highest)
+├── app/
+│   ├── models.py
+│   ├── schemas.py
+│   └── routers/
+└── tests/
+```
+
+**fastapi-core.md**
+
+```markdown
+---
+name: "FastAPI Core Patterns"
+activation: "always-on"
+priority: "high"
+---
+
+# FastAPI Expert
+
+You are an expert in FastAPI. Use these patterns:
+
+## Endpoint Structure
+
+Always use dependency injection:
+
+\```python
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database import get_db
+
+router = APIRouter(prefix="/api/v1")
+
+@router.post("/users/", response_model=UserResponse)
+async def create_user(
+    user: UserCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    """Create a new user."""
+    # Implementation
+\```
+
+## Error Handling
+
+Use HTTPException with proper status codes:
+
+\```python
+from fastapi import HTTPException
+
+if not user:
+    raise HTTPException(
+        status_code=404,
+        detail="User not found"
+    )
+\```
+```
+
+**project-conventions.md**
+
+```markdown
+---
+name: "Project Conventions"
+activation: "always-on"
+priority: "highest"
+---
+
+# Project-Specific Patterns
+
+## Database Sessions
+
+ALWAYS use async sessions with context managers:
+
+\```python
+async with get_session() as db:
+    result = await db.execute(query)
+\```
+
+## Response Models
+
+NEVER return ORM instances directly. Use Pydantic:
+
+\```python
+# BAD
+return user  # SQLAlchemy model
+
+# GOOD
+return UserResponse.model_validate(user)
+\```
+
+## Testing
+
+All tests MUST use pytest-asyncio:
+
+\```python
+import pytest
+
+@pytest.mark.asyncio
+async def test_create_user():
+    # Test implementation
+\```
+```
+
+**Result:**
+
+When you ask Cascade:
+> "Create an endpoint to list all users with pagination"
+
+Cascade will:
+1. ✅ Use async/await (from project-conventions.md)
+2. ✅ Add dependency injection (from fastapi-core.md)
+3. ✅ Return Pydantic models (from project-conventions.md)
+4. ✅ Use proper database patterns (from fastapi-database.md)
+
+### Example 2: Godot Game Engine
+
+**Godot-Specific Rules**
+
+```bash
+# Generate Godot documentation + codebase analysis
+skill-seekers github --repo godotengine/godot-demo-projects
+skill-seekers package output/godot-demo-projects --target markdown --split-rules
+
+# Create rules structure:
+.windsurf/rules/
+├── godot-core.md           (GDScript syntax, node system)
+├── godot-signals.md        (Signal patterns, EventBus)
+├── godot-scenes.md         (Scene tree, node access)
+└── project-patterns.md     (Custom patterns from codebase)
+```
+
+**godot-signals.md**
+
+```markdown
+---
+name: "Godot Signal Patterns"
+activation: "model-decision"
+description: "Use when working with signals and events"
+keywords: ["signal", "connect", "emit", "EventBus"]
+---
+
+# Godot Signal Patterns
+
+## Signal Declaration
+
+\```gdscript
+signal health_changed(new_health: int, max_health: int)
+signal item_collected(item_type: String, quantity: int)
+\```
+
+## Connection Pattern
+
+\```gdscript
+func _ready():
+    player.health_changed.connect(_on_health_changed)
+
+func _on_health_changed(new_health: int, max_health: int):
+    health_bar.value = (new_health / float(max_health)) * 100
+\```
+
+## EventBus Pattern (from codebase analysis)
+
+\```gdscript
+# EventBus.gd (autoload singleton)
+extends Node
+
+signal game_started
+signal game_over(score: int)
+signal player_died
+
+# Usage in game scenes:
+EventBus.game_started.emit()
+EventBus.game_over.emit(final_score)
+\```
+```
+
+---
+
+## 🐛 Troubleshooting
+
+### Issue: Rules Not Loading
+
+**Symptoms:**
+- Cascade doesn't reference documentation
+- Rules directory exists but ignored
+
+**Solutions:**
+
+1. **Check rules directory location**
+   ```bash
+   # Must be exactly:
+   .windsurf/rules/
+
+   # Not:
+   .windsurf/rule/  # Missing 's'
+   windsurf/rules/  # Missing leading dot
+   ```
+
+2. **Verify file extensions**
+   ```bash
+   # Rules must be .md files
+   ls .windsurf/rules/
+   # Should show: fastapi.md, react.md, etc.
+   # NOT: fastapi.txt, rules.json
+   ```
+
+3. **Check Windsurf settings**
+   ```
+   Cmd+, → Search "rules" → Enable "Use Custom Rules"
+   ```
+
+4. **Reload Windsurf**
+   ```
+   Cmd+Shift+P → "Reload Window"
+   ```
+
+5. **Verify frontmatter syntax**
+   ```markdown
+   ---
+   name: "Rule Name"
+   activation: "always-on"
+   ---
+
+   # Content starts here
+   ```
+
+### Issue: Rules Exceeding Character Limit
+
+**Error:**
+> "Rule file exceeds 6,000 character limit"
+
+**Solutions:**
+
+1. **Use split-rules flag**
+   ```bash
+   skill-seekers package output/react --target markdown --split-rules
+   ```
+
+2. **Set custom max-chars**
+   ```bash
+   skill-seekers package output/django --target markdown --split-rules --max-chars 5000
+   ```
+
+3. **Manual splitting**
+   ```bash
+   # Split SKILL.md by sections
+   csplit SKILL.md '/^## /' '{*}'
+
+   # Rename files
+   mv xx00 core-concepts.md
+   mv xx01 api-reference.md
+   mv xx02 best-practices.md
+   ```
+
+4. **Use activation modes strategically**
+   ```markdown
+   <!-- Keep core concepts Always On -->
+   ---
+   name: "Core Concepts"
+   activation: "always-on"
+   ---
+
+   <!-- Make specialized topics Manual -->
+   ---
+   name: "Advanced Patterns"
+   activation: "manual"
+   ---
+   ```
+
+### Issue: Cascade Not Using Rules
+
+**Symptoms:**
+- Rules loaded but AI doesn't reference them
+- Generic responses despite custom documentation
+
+**Solutions:**
+
+1. **Check activation mode**
+   ```markdown
+   # Change from Model Decision to Always On
+   ---
+   activation: "always-on"  # Not "model-decision"
+   ---
+   ```
+
+2. **Increase priority**
+   ```markdown
+   ---
+   priority: "highest"  # Override framework defaults
+   ---
+   ```
+
+3. **Add explicit instructions**
+   ```markdown
+   # FastAPI Expert
+
+   You MUST follow these patterns in all FastAPI code:
+   - Use async/await
+   - Dependency injection for database
+   - Pydantic response models
+   ```
+
+4. **Test with explicit mention**
+   ```
+   In Cascade chat:
+   "@fastapi Create an endpoint with async database access"
+   ```
+
+5. **Combine with Memory**
+   ```
+   Ask Cascade to remember:
+   "Remember to always use the patterns from fastapi.md rules file"
+   ```
+
+### Issue: Conflicting Rules
+
+**Symptoms:**
+- AI mixes patterns from different frameworks
+- Inconsistent code suggestions
+
+**Solutions:**
+
+1. **Use priority levels**
+   ```markdown
+   <!-- project-conventions.md -->
+   ---
+   priority: "highest"
+   ---
+
+   <!-- framework-defaults.md -->
+   ---
+   priority: "medium"
+   ---
+   ```
+
+2. **Make project conventions always-on**
+   ```markdown
+   ---
+   name: "Project Conventions"
+   activation: "always-on"
+   priority: "highest"
+   ---
+
+   These rules OVERRIDE all framework defaults:
+   - [List project-specific patterns]
+   ```
+
+3. **Use model-decision for conflicting patterns**
+   ```markdown
+   <!-- rest-api.md -->
+   ---
+   activation: "model-decision"
+   description: "Use when creating REST APIs (not GraphQL)"
+   ---
+
+   <!-- graphql-api.md -->
+   ---
+   activation: "model-decision"
+   description: "Use when creating GraphQL APIs (not REST)"
+   ---
+   ```
+
+---
+
+## 📊 Before vs After Comparison
+
+| Aspect | Before Skill Seekers | After Skill Seekers |
+|--------|---------------------|---------------------|
+| **Context Source** | Copy-paste docs into chat | Automatic rules files |
+| **Character Limits** | Hit 12K limit easily | Modular rules fit perfectly |
+| **AI Knowledge** | Generic framework patterns | Project-specific best practices |
+| **Setup Time** | Manual doc curation (hours) | Automated scraping (5 min) |
+| **Consistency** | Varies per conversation | Persistent across all flows |
+| **Updates** | Manual doc editing | Re-run scraper for latest docs |
+| **Multi-Framework** | Context switching confusion | Separate rule files |
+| **Code Quality** | Hit-or-miss | Follows documented patterns |
+
+---
+
+## 🤝 Community & Support
+
+- **Questions:** [GitHub Discussions](https://github.com/yusufkaraaslan/Skill_Seekers/discussions)
+- **Issues:** [GitHub Issues](https://github.com/yusufkaraaslan/Skill_Seekers/issues)
+- **Website:** [skillseekersweb.com](https://skillseekersweb.com/)
+- **Windsurf Docs:** [docs.windsurf.com](https://docs.windsurf.com/)
+- **Windsurf Rules Directory:** [windsurf.com/editor/directory](https://windsurf.com/editor/directory)
+
+---
+
+## 📚 Related Guides
+
+- [Cursor Integration](CURSOR.md) - Similar IDE, different rules format
+- [Cline Integration](CLINE.md) - VS Code extension with MCP
+- [Continue.dev Integration](CONTINUE_DEV.md) - IDE-agnostic AI assistant
+- [LangChain Integration](LANGCHAIN.md) - Build RAG pipelines
+- [RAG Pipelines Guide](RAG_PIPELINES.md) - End-to-end RAG setup
+
+---
+
+## 📖 Next Steps
+
+1. **Try another framework:** `skill-seekers scrape --config configs/vue.json`
+2. **Combine multiple frameworks:** Create modular rules for full-stack projects
+3. **Integrate with MCP:** Add live documentation access via MCP servers
+4. **Build RAG pipeline:** Use `--target langchain` for deep search
+5. **Share your rules:** Contribute to [awesome-windsurfrules](https://github.com/SchneiderSam/awesome-windsurfrules)
+
+---
+
+**Sources:**
+- [Windsurf Official Site](https://windsurf.com/)
+- [Windsurf Documentation](https://docs.windsurf.com/windsurf/getting-started)
+- [Windsurf MCP Setup Guide](https://www.braingrid.ai/blog/windsurf-mcp)
+- [Awesome Windsurfrules Repository](https://github.com/SchneiderSam/awesome-windsurfrules)
+- [Windsurf Rules Directory](https://windsurf.com/editor/directory)
+- [Mastering .windsurfrules Guide](https://blog.stackademic.com/mastering-windsurfrules-react-typescript-projects-aee1e3fe4376)