skill-seekers-reference/docs/integrations/CLINE.md

Using Skill Seekers with Cline (VS Code Extension)

Last Updated: February 7, 2026 Status: Production Ready Difficulty: Medium ⭐⭐

---

🎯 The Problem

Cline (formerly Claude Dev) is a powerful autonomous coding agent for VS Code, but:

• Generic Knowledge - AI doesn't know your project-specific frameworks or internal patterns
• Manual Context - Copy-pasting documentation into chat breaks autonomous workflow
• No Framework Memory - Cline forgets framework details between sessions
• Custom Instructions Limit - Built-in custom instructions are limited in scope

Example:

"When using Cline to build a Django app, the agent might use outdated patterns or miss framework-specific conventions. You want Cline to automatically reference comprehensive framework documentation without manual prompting."

---

✨ The Solution

Use Skill Seekers to create custom rules and MCP tools for Cline:

1. Generate structured docs from any framework or codebase
2. Package as .clinerules - Cline's markdown rules format
3. MCP Integration - Expose documentation via Model Context Protocol
4. Memory Bank - Persistent framework knowledge across sessions

Result: Cline becomes an expert in your frameworks with automatic context and autonomous access to documentation via MCP tools.

---

🚀 Quick Start (10 Minutes)

Prerequisites

• VS Code installed (https://code.visualstudio.com/)
• Cline extension installed (https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev)
• Python 3.10+ (for Skill Seekers)
• Claude API key (recommended) or other LLM

Installation

# Install Skill Seekers with MCP support
pip install skill-seekers[mcp]

# Verify installation
skill-seekers --version

Generate .clinerules

# Example: Django framework
skill-seekers scrape --config configs/django.json

# Package for Cline (markdown format)
skill-seekers package output/django --target markdown

# Extract SKILL.md (this becomes your .clinerules content)
# output/django-markdown/SKILL.md

Setup in Cline

Option 1: Project-Specific Rules (recommended)

# Copy to project root as .clinerules
cp output/django-markdown/SKILL.md /path/to/your/project/.clinerules

Option 2: Custom Instructions (per-project settings)

1. Open Cline settings in VS Code (Cmd+, → search "Cline")
2. Find "Custom Instructions"
3. Add framework knowledge:

You are an expert in Django. Follow these patterns:

[Paste contents of SKILL.md here]

Option 3: MCP Server (for dynamic access)

# Configure Cline's MCP settings
# In Cline panel → Settings → MCP Servers → Add Server

# Add Skill Seekers MCP server:
{
  "skill-seekers": {
    "command": "python",
    "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"],
    "env": {}
  }
}

Test in Cline

1. Open your project in VS Code
2. Open Cline panel (click Cline icon in sidebar)
3. Start a new task:

   Create a Django model for users with email authentication
   

4. Verify Cline references your documentation patterns

---

📖 Detailed Setup Guide

Step 1: Choose Your Documentation Source

Option A: Use Preset Configs (24+ frameworks)

# List available presets
ls configs/

# Popular presets:
# - react.json, vue.json, angular.json (Frontend)
# - django.json, fastapi.json, flask.json (Backend)
# - kubernetes.json, docker.json (Infrastructure)

Option B: Custom Documentation

Create myframework-config.json:

{
  "name": "myframework",
  "description": "Custom framework documentation for Cline",
  "base_url": "https://docs.myframework.com/",
  "selectors": {
    "main_content": "article",
    "title": "h1",
    "code_blocks": "pre code"
  },
  "categories": {
    "getting_started": ["intro", "quickstart"],
    "core_concepts": ["concepts", "architecture"],
    "api": ["api", "reference"],
    "best_practices": ["best-practices", "patterns"]
  }
}

Option C: GitHub Repository

# Analyze codebase patterns
skill-seekers github --repo facebook/react

# Or local codebase
skill-seekers analyze --directory /path/to/repo --comprehensive

Step 2: Optimize for Cline

File-Based Rules

Cline rules are markdown files with NO special syntax required:

<!-- .clinerules -->
# Django Expert

You are an expert in Django. Follow these patterns:

## Models

Always include these fields in models:

\```python
from django.db import models

class MyModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ['-created_at']
\```

## Views

Use class-based views for CRUD operations:

\```python
from django.views.generic import ListView, DetailView

class UserListView(ListView):
    model = User
    template_name = 'users/list.html'
    context_object_name = 'users'
\```

Hierarchical Rules

Create multiple rules files for organization:

my-django-project/
├── .clinerules                    # Core framework patterns
├── .clinerules.models             # Model-specific rules
├── .clinerules.views              # View-specific rules
├── .clinerules.testing            # Testing patterns
└── .clinerules.project            # Project-specific conventions

Cline automatically loads all .clinerules* files.

Memory Bank Integration

Combine rules with Cline's Memory Bank:

# Create memory bank structure
mkdir -p .cline/memory-bank

# Initialize memory bank
echo "# Project Memory Bank

## Tech Stack
- Django 5.x
- PostgreSQL 16
- Redis for caching

## Architecture
- Modular apps structure
- API-first design
- Async views for I/O-bound operations

## Conventions
- All models include timestamps
- Use class-based views
- pytest for testing
" > .cline/memory-bank/README.md

# Ask Cline to initialize
# In Cline chat: "Initialize a memory bank for this Django project"

Step 3: Configure MCP Integration

MCP Server Setup (for dynamic documentation access)

1. Install Skill Seekers MCP server:

pip install skill-seekers[mcp]

2. Configure in Cline settings:

Open Cline panel → Settings → MCP Servers → Configure

Add this configuration:

{
  "mcpServers": {
    "skill-seekers": {
      "command": "python",
      "args": [
        "-m",
        "skill_seekers.mcp.server_fastmcp",
        "--transport",
        "stdio"
      ],
      "env": {}
    }
  }
}

3. Restart VS Code

4. Verify MCP tools available:

In Cline panel, check "Available Tools" - you should see:

• list_configs - List preset configurations
• scrape_docs - Scrape documentation dynamically
• package_skill - Package skills for Cline
• ... (26 total MCP tools)

Using MCP Tools

Now Cline can access documentation on-demand:

In Cline chat:

"Use the skill-seekers MCP tool to scrape React documentation
and generate .clinerules for this project"

Cline will:
1. Call list_configs to find react.json
2. Call scrape_docs with config
3. Call package_skill to create .clinerules
4. Load rules automatically

Step 4: Test and Refine

Test Cline's Knowledge

Start autonomous tasks:

"Create a complete Django REST API for blog posts with:
- Post model with author foreign key
- Serializers with nested author data
- ViewSets with filtering and pagination
- URL routing
- Tests with pytest"

Verify Cline follows your documented patterns.

Refine Rules

Add project-specific patterns:

<!-- .clinerules.project -->
# Project-Specific Conventions

## Database Queries

ALWAYS use select_related/prefetch_related for foreign keys:

\```python
# BAD
posts = Post.objects.all()  # N+1 queries

# GOOD
posts = Post.objects.select_related('author').all()
\```

## API Responses

NEVER return sensitive fields:

\```python
class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email']
        # Exclude: password, is_staff, etc.
\```

Monitor Cline's Behavior

Watch for:

• ✅ Cline references rules in explanations
• ✅ Generated code follows patterns
• ✅ Autonomous decisions align with documentation
• ❌ Generic patterns not from your rules (needs refinement)

---

🎨 Advanced Usage

Multi-Framework Projects

Full-Stack Django + React

# Generate backend rules
skill-seekers scrape --config configs/django.json
cp output/django-markdown/SKILL.md .clinerules.backend

# Generate frontend rules
skill-seekers scrape --config configs/react.json
cp output/react-markdown/SKILL.md .clinerules.frontend

# Add project conventions
cat > .clinerules.project << 'EOF'
# Project Conventions

## Backend
- Django REST framework for API
- JWT authentication
- Async views for heavy operations

## Frontend
- React 18 with TypeScript
- Tanstack Query for API calls
- Zustand for state management

## Communication
- Backend exposes /api/v1/* endpoints
- Frontend proxies to localhost:8000 in dev
EOF

# Now Cline knows both Django AND React patterns

Testing with Multiple Frameworks

# Backend testing rules
cat > .clinerules.testing-backend << 'EOF'
# Django Testing Patterns

Use pytest with pytest-django:

\```python
import pytest
from django.test import Client

@pytest.mark.django_db
def test_create_post(client: Client):
    response = client.post('/api/v1/posts/', {
        'title': 'Test Post',
        'content': 'Test content'
    })
    assert response.status_code == 201
\```
EOF

# Frontend testing rules
cat > .clinerules.testing-frontend << 'EOF'
# React Testing Patterns

Use React Testing Library:

\```typescript
import { render, screen } from '@testing-library/react';
import { Post } from './Post';

test('renders post title', () => {
  render(<Post title="Test" />);
  expect(screen.getByText('Test')).toBeInTheDocument();
});
\```
EOF

Dynamic Context with MCP Tools

Custom MCP Tool for Framework Search

Create custom_mcp_tool.py:

from fastmcp import FastMCP

mcp = FastMCP("Custom Framework Search")

@mcp.tool()
def search_framework_docs(framework: str, query: str) -> str:
    """
    Search framework documentation dynamically.

    Args:
        framework: Framework name (django, react, etc.)
        query: Search query

    Returns:
        Relevant documentation snippets
    """
    # Use Skill Seekers to search
    from skill_seekers.cli.adaptors import get_adaptor

    adaptor = get_adaptor('markdown')
    results = adaptor.search(framework, query)

    return results

Register in Cline's MCP config:

{
  "mcpServers": {
    "skill-seekers": {
      "command": "python",
      "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
    },
    "custom-search": {
      "command": "python",
      "args": ["custom_mcp_tool.py"]
    }
  }
}

Now Cline can search docs on-demand:

In Cline: "Use custom-search MCP tool to find Django async views best practices"

Cline + RAG Pipeline

Combine Rules with Vector Search

# setup_cline_rag.py
from skill_seekers.cli.doc_scraper import main as scrape
from skill_seekers.cli.package_skill import main as package

# Scrape documentation
scrape(["--config", "configs/django.json"])

# Create Cline rules
package(["output/django", "--target", "markdown"])

# Also create RAG pipeline
package(["output/django", "--target", "langchain", "--chunk-for-rag"])

# Now you have:
# 1. .clinerules for Cline's context
# 2. LangChain documents for deep vector search

MCP Tool for RAG Query

# mcp_rag_tool.py
from fastmcp import FastMCP
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

mcp = FastMCP("RAG Search")

# Load vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

@mcp.tool()
def rag_search(query: str, k: int = 5) -> str:
    """
    Search documentation using RAG.

    Args:
        query: Search query
        k: Number of results

    Returns:
        Top-k relevant documentation snippets
    """
    results = vectorstore.similarity_search(query, k=k)
    return "\n\n".join([doc.page_content for doc in results])

---

💡 Best Practices

1. Keep Rules Focused

Bad: Everything in One File

<!-- .clinerules (20,000 chars!) -->
# Django Complete Guide
[... massive unstructured documentation ...]

Good: Modular Rules

<!-- .clinerules (core concepts, 5,000 chars) -->
# Django Core Patterns
[... focused on common patterns ...]

<!-- .clinerules.models (database, 3,000 chars) -->
# Django Models Best Practices
[... focused on database patterns ...]

<!-- .clinerules.api (REST API, 4,000 chars) -->
# Django REST Framework
[... focused on API patterns ...]

2. Use Hierarchical Loading

Cline loads all .clinerules* files. Use naming for precedence:

.clinerules                    # Core framework (loaded first)
.clinerules.01-models          # Database patterns
.clinerules.02-views           # View patterns
.clinerules.03-testing         # Testing patterns
.clinerules.99-project         # Project overrides (loaded last)

3. Include Code Examples

Don't just describe patterns - show them:

## Creating Django Models

\```python
from django.db import models
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    email = models.EmailField(unique=True)
    bio = models.TextField(blank=True)

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ['-created_at']

    def __str__(self):
        return self.username
\```

Use this exact pattern for all models.

4. Leverage MCP for Dynamic Context

Static Rules (in .clinerules):

• Core patterns that rarely change
• Framework conventions
• Code style preferences

Dynamic MCP Tools:

• Search latest documentation
• Query GitHub for code examples
• Fetch API references on-demand

In Cline:
"Use skill-seekers MCP to search Django 5.0 async views documentation"

Cline calls MCP tool → gets latest docs → applies to task

5. Update Rules Regularly

# Quarterly framework updates
skill-seekers scrape --config configs/django.json
cp output/django-markdown/SKILL.md .clinerules

# Check what changed
diff .clinerules.old .clinerules

# Test with Cline
# Ask: "What's new in Django 5.0?"

---

🔥 Real-World Examples

Example 1: Django REST API with Cline

Project Structure:

my-django-api/
├── .clinerules                    # Core Django patterns
├── .clinerules.api                # DRF patterns
├── .clinerules.testing            # pytest patterns
├── .clinerules.project            # Project conventions
├── app/
│   ├── models.py
│   ├── serializers.py
│   ├── views.py
│   └── urls.py
└── tests/

.clinerules (Core Django)

# Django Expert

You are an expert in Django 5.0. Follow these patterns:

## Models

Always include timestamps and __str__:

\```python
from django.db import models

class BaseModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

class Post(BaseModel):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)

    def __str__(self):
        return self.title
\```

## Queries

Use select_related/prefetch_related:

\```python
# BAD
posts = Post.objects.all()

# GOOD
posts = Post.objects.select_related('author').all()
\```

.clinerules.api (Django REST Framework)

# Django REST Framework Patterns

## Serializers

Use nested serializers for relationships:

\```python
from rest_framework import serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email']

class PostSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)

    class Meta:
        model = Post
        fields = ['id', 'title', 'content', 'author', 'created_at']
\```

## ViewSets

Use ViewSets with filtering:

\```python
from rest_framework import viewsets, filters

class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.select_related('author').all()
    serializer_class = PostSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['title', 'content']
\```

Using Cline:

Start Cline task:

"Create a complete blog API with posts and comments:
- Post model with author, title, content, created_at
- Comment model with author, post foreign key, content
- Serializers with nested data
- ViewSets with filtering
- URL routing
- Full test suite with pytest"

Cline will:
1. ✅ Use BaseModel with timestamps (from .clinerules)
2. ✅ Add __str__ methods (from .clinerules)
3. ✅ Use select_related in viewsets (from .clinerules)
4. ✅ Create nested serializers (from .clinerules.api)
5. ✅ Add filtering (from .clinerules.api)
6. ✅ Write pytest tests (from .clinerules.testing)

Result: Production-ready API following all your patterns!

Example 2: React + TypeScript with Cline

Project Structure:

my-react-app/
├── .clinerules                    # Core React patterns
├── .clinerules.typescript         # TypeScript patterns
├── .clinerules.testing            # Testing Library patterns
├── src/
│   ├── components/
│   ├── hooks/
│   └── utils/
└── tests/

.clinerules (Core React)

# React 18 + TypeScript Expert

## Components

Use functional components with TypeScript:

\```typescript
import { FC } from 'react';

interface PostProps {
  title: string;
  content: string;
  author: {
    name: string;
    email: string;
  };
}

export const Post: FC<PostProps> = ({ title, content, author }) => {
  return (
    <article>
      <h2>{title}</h2>
      <p>{content}</p>
      <footer>By {author.name}</footer>
    </article>
  );
};
\```

## Hooks

Use custom hooks for logic:

\```typescript
import { useState, useEffect } from 'react';

interface UseFetchResult<T> {
  data: T | null;
  loading: boolean;
  error: Error | null;
}

export function useFetch<T>(url: string): UseFetchResult<T> {
  const [data, setData] = useState<T | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    fetch(url)
      .then(res => res.json())
      .then(setData)
      .catch(setError)
      .finally(() => setLoading(false));
  }, [url]);

  return { data, loading, error };
}
\```

---

🐛 Troubleshooting

Issue: .clinerules Not Loading

Symptoms:

• Cline doesn't reference documentation
• Rules file exists but ignored

Solutions:

1. Check file location

   # Must be at project root
   ls -la .clinerules
   
   # Not in subdirectory
   # NOT: src/.clinerules
   

2. Verify file format

   # Must be plain markdown
   file .clinerules
   # Should show: ASCII text
   
   # Not binary or encoded
   

3. Reload VS Code

   Cmd+Shift+P → "Developer: Reload Window"
   

4. Check Cline logs

   In Cline panel → Settings → Show Logs
   # Look for "Loaded rules from .clinerules"
   

Issue: MCP Server Not Connecting

Error:

"Failed to connect to MCP server: skill-seekers"

Solutions:

1. Verify installation

   pip show skill-seekers
   # Check [mcp] extra is installed
   

2. Test MCP server directly

   python -m skill_seekers.mcp.server_fastmcp --transport stdio
   # Should start without errors
   

3. Check Python path

   // MCP config - use absolute path
   {
     "mcpServers": {
       "skill-seekers": {
         "command": "/usr/local/bin/python3",  // Absolute path
         "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
       }
     }
   }
   

4. Check environment variables

   {
     "mcpServers": {
       "skill-seekers": {
         "command": "python",
         "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"],
         "env": {
           "ANTHROPIC_API_KEY": "${env:ANTHROPIC_API_KEY}"
         }
       }
     }
   }
   

Issue: Cline Not Using Rules

Symptoms:

• Rules loaded but Cline ignores them
• Generic code patterns

Solutions:

1. Add explicit instructions

   # Django Expert
   
   You MUST follow these patterns in ALL Django code:
   - Use timestamps in all models
   - Use select_related for foreign keys
   - Write tests for all views
   
   Never deviate from these patterns.
   

2. Use memory bank

   In Cline chat:
   "Remember to ALWAYS follow the patterns in .clinerules"
   

3. Reference rules explicitly

   In Cline task:
   "Create a Django model following the patterns in .clinerules"
   

4. Check custom instructions

   Cline Settings → Custom Instructions
   # Should NOT conflict with .clinerules
   

---

📊 Before vs After Comparison

Aspect	Before Skill Seekers	After Skill Seekers
Context Source	Copy-paste into chat	Auto-loaded .clinerules
AI Knowledge	Generic patterns	Framework-specific patterns
Setup Time	Manual curation (hours)	Automated scraping (10 min)
Consistency	Varies per task	Persistent across tasks
Updates	Manual editing	Re-run scraper
MCP Integration	Manual tool creation	Pre-built MCP tools
Multi-Framework	Context confusion	Modular rules per framework
Autonomous Workflow	Frequent interruptions	Autonomous with correct patterns

---

🤝 Community & Support

• Questions: GitHub Discussions
• Issues: GitHub Issues
• Website: skillseekersweb.com
• Cline Docs: docs.cline.bot
• Cline GitHub: github.com/cline/cline

---

📚 Related Guides

• Cursor Integration - Similar IDE, different approach
• Windsurf Integration - Alternative AI IDE
• Continue.dev Integration - IDE-agnostic assistant
• LangChain Integration - Build RAG pipelines
• MCP Setup Guide - Detailed MCP configuration

---

📖 Next Steps

1. Try another framework: skill-seekers scrape --config configs/fastapi.json
2. Set up MCP server: Dynamic documentation access
3. Create memory bank: Persistent project knowledge
4. Build RAG pipeline: Deep documentation search with --target langchain
5. Contribute examples: Share your .clinerules patterns

---

Sources:

• Cline VS Code Marketplace
• Cline GitHub Repository
• Cline Documentation
• Cline Rules Documentation
• Cline Prompt Engineering Guide
• VS Code MCP Integration
• MCP Developer Guide
• Cline MCP Setup Guide