skill-sync

Skill Sync - Cross-Tool Knowledge Sharing

You are an expert at syncing Claude Skills with other AI coding assistants (Cursor, GitHub Copilot, Codeium, etc.) to create a unified knowledge base. This skill helps maximize the value of documented knowledge across your entire development toolchain.

What is Skill Sync?

Skill Sync enables:

• Sharing skill knowledge with other AI tools
• Creating cross-references in tool configs
• Maintaining unified project context
• Reducing duplicate documentation
• Ensuring consistent guidance across tools

When to Use This Skill

Invoke this skill when the user:

• Wants to share skills with Cursor, Copilot, or other tools
• Asks to create .cursorrules or similar configs
• Needs unified AI context across multiple assistants
• Wants to reference skills in other tools
• Asks about cross-tool integration
• Needs to sync project knowledge between AI assistants

Supported Tools

1. Cursor

Configuration Method: .cursorrules file

Cursor reads .cursorrules in the project root for context and instructions.

Capabilities:

• Markdown-based instructions
• Project-specific context
• Code style guidelines
• Framework preferences

2. GitHub Copilot

Configuration Method: Inline comments and project structure

Copilot learns from:

• Existing code patterns
• Comments and docstrings
• File organization
• README and documentation

Limitations:

• No dedicated config file (as of 2025)
• Context comes from open files
• Less explicit guidance than Cursor

3. Codeium

Configuration Method: Project documentation

Codeium uses:

• README.md and docs/
• Code comments
• Existing patterns

4. Continue.dev

Configuration Method: .continuerc.json or config.json

Continue supports:

• Custom context providers
• Documentation references
• Project-specific prompts

5. Tabnine

Configuration Method: Inline patterns

Tabnine learns from:

• Codebase patterns
• Team standards (enterprise)

Sync Strategies

Strategy 1: Reference-Based (Recommended)

Concept: Other tools reference Claude Skills without duplicating content.

Benefits:

• Single source of truth (Claude Skills)
• Easy to maintain
• No duplication
• Clear ownership

Implementation:

# .cursorrules

This project uses Claude Skills for detailed technical guidance.

## Framework Guidance

For Textual TUI development patterns, see:
- `.claude/skills/textual/SKILL.md` - Core concepts and patterns
- `.claude/skills/textual/quick-reference.md` - Quick lookups

When suggesting Textual code:
1. Follow patterns in `.claude/skills/textual/`
2. Use semantic color variables ($primary, $error, etc.)
3. Prefer composition over inheritance
4. Use reactive attributes for state

## Git Hook Management

For git hook configuration with hk, see:
- `.claude/skills/hk/SKILL.md` - Setup and patterns
- `.claude/skills/hk/reference.md` - Detailed options

## Testing Patterns

For pytest conventions, see:
- `.claude/skills/pytest-patterns/` (if exists)

Strategy 2: Summary-Based

Concept: Create condensed summaries of skills for other tools.

Benefits:

• Self-contained for each tool
• No file path dependencies
• Works with limited context windows

Implementation:

# .cursorrules

## Textual TUI Framework

This project uses Textual for building terminal UIs.

### Key Patterns
- Use reactive attributes for state: `count = reactive(0)`
- Follow "attributes down, messages up" for widget communication
- Use external CSS files for styling
- Always await async operations: `await self.mount(widget)`

### Common Mistakes to Avoid
- Don't modify reactives in __init__ (use on_mount)
- Always use `await pilot.pause()` in tests
- Don't block the event loop (use @work decorator)

For comprehensive guidance: `.claude/skills/textual/`

[More condensed summaries...]

Strategy 3: Shared Documentation

Concept: Create a central docs/ directory that all tools reference.

Benefits:

• Clear documentation structure
• Easy for humans to read
• Tools can reference same files
• Good for team onboarding

Structure:

docs/
├── frameworks/
│   ├── textual.md          # Extracted from Claude Skill
│   └── pytest.md
├── patterns/
│   ├── testing.md
│   └── async.md
└── conventions/
    ├── code-style.md
    └── git-workflow.md

.cursorrules                 # References docs/*
.claude/skills/              # Detailed skills

Implementation Guides

Creating .cursorrules

Basic Template:

# Project: [Project Name]

## Overview

[Brief project description]

## Tech Stack

- **Framework**: Textual (TUI framework)
- **Testing**: pytest with async support
- **Tools**: hk (git hooks), ruff (linting)

## AI Guidance Sources

This project maintains detailed knowledge in Claude Skills (`.claude/skills/`).

For comprehensive guidance on:
- **Textual framework**: `.claude/skills/textual/`
- **Git hooks (hk)**: `.claude/skills/hk/`
- **[Other skills]**: `.claude/skills/[name]/`

## Key Patterns

### Textual Development

1. **Widget Structure**
   ```python
   class MyWidget(Widget):
       count = reactive(0)

       def compose(self) -> ComposeResult:
           yield ChildWidget()

2. Testing Pattern

   async with app.run_test() as pilot:
       await pilot.click("#button")
       await pilot.pause()  # Critical!
   

3. CSS Styling

   • Use semantic colors: $primary, $error, $success
   • FR units for flexible sizing: width: 1fr;
   • Dock for fixed elements: dock: top;

Code Quality

• Run hk check before committing
• All tests must pass
• Type hints required
• Use ruff for formatting

Common Mistakes

• ❌ Don't modify reactives in __init__
• ❌ Don't forget await pilot.pause() in tests
• ❌ Don't block the event loop
• ✅ Use @work decorator for async operations
• ✅ Use set_reactive() for init-time values

Project Structure

src/
├── app.py              # Main app
├── screens/            # Screen classes
├── widgets/            # Custom widgets
└── business_logic/     # Separate from UI

Additional Context

For detailed explanations, examples, and troubleshooting:

1. Check relevant skill in .claude/skills/
2. Refer to framework documentation
3. See examples in existing codebase

### Integrating with Cursor AI

**Step 1: Create .cursorrules**

```bash
# Generate .cursorrules from skills
cat > .cursorrules << 'EOF'
# [Content from template above]
EOF

Step 2: Test Integration

1. Open project in Cursor
2. Ask Cursor: "How should I create a Textual widget?"
3. Verify it references patterns from .cursorrules

Step 3: Maintain Sync

When updating skills:

# Update .cursorrules with key changes
# Keep it concise - full details stay in .claude/skills/

Integrating with GitHub Copilot

Copilot learns from context, so:

Step 1: Add Context Comments

# This project uses Textual TUI framework
# Follow patterns in .claude/skills/textual/
# Key principle: "attributes down, messages up"

from textual.app import App
from textual.widget import Widget

Step 2: Create Documentation File

# docs/COPILOT_CONTEXT.md

## Development Context for AI Assistants

This file provides context for GitHub Copilot and similar tools.

### Framework: Textual

We use Textual for building terminal UIs. Key patterns:

[Include condensed patterns from skills]

For full details: `.claude/skills/textual/`

Step 3: Reference in README

# README.md

## For AI Assistants

Development guidance is available in:
- `.claude/skills/` - Comprehensive Claude Skills
- `docs/COPILOT_CONTEXT.md` - Quick reference for all AI tools

Integrating with Continue.dev

Step 1: Create Context Provider

// .continue/config.json
{
  "contextProviders": [
    {
      "name": "skills",
      "type": "file",
      "params": {
        "patterns": [
          ".claude/skills/*/SKILL.md",
          ".claude/skills/*/quick-reference.md"
        ]
      }
    }
  ]
}

Step 2: Configure Custom Commands

{
  "customCommands": [
    {
      "name": "textual-help",
      "prompt": "Refer to .claude/skills/textual/ and help with: {input}",
      "description": "Get Textual framework help"
    }
  ]
}

Sync Maintenance Workflow

When Creating a New Skill

1. Create Claude Skill (primary source)

   mkdir -p .claude/skills/new-skill
   # Create SKILL.md, etc.
   

2. Update .cursorrules (if needed)

   ## New Skill Topic
   
   Brief summary...
   
   For details: `.claude/skills/new-skill/`
   

3. Update docs/ (if using shared docs)

   # Extract key points to docs/
   # Keep synchronized
   

4. Test cross-tool

   • Ask Claude and Cursor same question
   • Verify consistent guidance

When Updating an Existing Skill

1. Update Claude Skill first

   # Edit .claude/skills/skill-name/SKILL.md
   

2. Review impact on other tools

   • Check if .cursorrules needs updates
   • Update summary content
   • Sync shared docs

3. Test changes

   • Verify updated guidance works
   • Check for contradictions

Regular Sync Checks

Monthly:

• Review .cursorrules for accuracy
• Check shared docs are current
• Test sample queries across tools

Quarterly:

• Full audit of cross-tool consistency
• Update summaries with new patterns
• Refactor if needed

File Organization

Recommended Structure

project/
├── .cursorrules                    # Cursor AI context
├── .claude/
│   ├── skills/                     # Primary knowledge base
│   │   ├── textual/
│   │   ├── hk/
│   │   └── ...
│   └── settings.local.json
├── docs/
│   ├── COPILOT_CONTEXT.md         # Context for Copilot
│   ├── AI_GUIDANCE.md             # General AI context
│   └── frameworks/                # Shared framework docs
├── README.md           

---

*Content truncated.*