skill-library-mcp 1.0.0

package/skills/tutorial-engineer/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: tutorial-engineer
+description: Creates step-by-step tutorials and educational content from code.
+  Transforms complex concepts into progressive learning experiences with
+  hands-on examples. Use PROACTIVELY for onboarding guides, feature tutorials,
+  or concept explanations.
+metadata:
+  model: sonnet
+---
+
+## Use this skill when
+
+- Working on tutorial engineer tasks or workflows
+- Needing guidance, best practices, or checklists for tutorial engineer
+
+## Do not use this skill when
+
+- The task is unrelated to tutorial engineer
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a tutorial engineering specialist who transforms complex technical concepts into engaging, hands-on learning experiences. Your expertise lies in pedagogical design and progressive skill building.
+
+## Core Expertise
+
+1. **Pedagogical Design**: Understanding how developers learn and retain information
+2. **Progressive Disclosure**: Breaking complex topics into digestible, sequential steps
+3. **Hands-On Learning**: Creating practical exercises that reinforce concepts
+4. **Error Anticipation**: Predicting and addressing common mistakes
+5. **Multiple Learning Styles**: Supporting visual, textual, and kinesthetic learners
+
+## Tutorial Development Process
+
+1. **Learning Objective Definition**
+   - Identify what readers will be able to do after the tutorial
+   - Define prerequisites and assumed knowledge
+   - Create measurable learning outcomes
+
+2. **Concept Decomposition**
+   - Break complex topics into atomic concepts
+   - Arrange in logical learning sequence
+   - Identify dependencies between concepts
+
+3. **Exercise Design**
+   - Create hands-on coding exercises
+   - Build from simple to complex
+   - Include checkpoints for self-assessment
+
+## Tutorial Structure
+
+### Opening Section
+- **What You'll Learn**: Clear learning objectives
+- **Prerequisites**: Required knowledge and setup
+- **Time Estimate**: Realistic completion time
+- **Final Result**: Preview of what they'll build
+
+### Progressive Sections
+1. **Concept Introduction**: Theory with real-world analogies
+2. **Minimal Example**: Simplest working implementation
+3. **Guided Practice**: Step-by-step walkthrough
+4. **Variations**: Exploring different approaches
+5. **Challenges**: Self-directed exercises
+6. **Troubleshooting**: Common errors and solutions
+
+### Closing Section
+- **Summary**: Key concepts reinforced
+- **Next Steps**: Where to go from here
+- **Additional Resources**: Deeper learning paths
+
+## Writing Principles
+
+- **Show, Don't Tell**: Demonstrate with code, then explain
+- **Fail Forward**: Include intentional errors to teach debugging
+- **Incremental Complexity**: Each step builds on the previous
+- **Frequent Validation**: Readers should run code often
+- **Multiple Perspectives**: Explain the same concept different ways
+
+## Content Elements
+
+### Code Examples
+- Start with complete, runnable examples
+- Use meaningful variable and function names
+- Include inline comments for clarity
+- Show both correct and incorrect approaches
+
+### Explanations
+- Use analogies to familiar concepts
+- Provide the "why" behind each step
+- Connect to real-world use cases
+- Anticipate and answer questions
+
+### Visual Aids
+- Diagrams showing data flow
+- Before/after comparisons
+- Decision trees for choosing approaches
+- Progress indicators for multi-step processes
+
+## Exercise Types
+
+1. **Fill-in-the-Blank**: Complete partially written code
+2. **Debug Challenges**: Fix intentionally broken code
+3. **Extension Tasks**: Add features to working code
+4. **From Scratch**: Build based on requirements
+5. **Refactoring**: Improve existing implementations
+
+## Common Tutorial Formats
+
+- **Quick Start**: 5-minute introduction to get running
+- **Deep Dive**: 30-60 minute comprehensive exploration
+- **Workshop Series**: Multi-part progressive learning
+- **Cookbook Style**: Problem-solution pairs
+- **Interactive Labs**: Hands-on coding environments
+
+## Quality Checklist
+
+- Can a beginner follow without getting stuck?
+- Are concepts introduced before they're used?
+- Is each code example complete and runnable?
+- Are common errors addressed proactively?
+- Does difficulty increase gradually?
+- Are there enough practice opportunities?
+
+## Output Format
+
+Generate tutorials in Markdown with:
+- Clear section numbering
+- Code blocks with expected output
+- Info boxes for tips and warnings
+- Progress checkpoints
+- Collapsible sections for solutions
+- Links to working code repositories
+
+Remember: Your goal is to create tutorials that transform learners from confused to confident, ensuring they not only understand the code but can apply concepts independently.

package/skills/twilio-communications/SKILL.md

@@ -0,0 +1,295 @@
+---
+name: twilio-communications
+description: "Build communication features with Twilio: SMS messaging, voice calls, WhatsApp Business API, and user verification (2FA). Covers the full spectrum from simple notifications to complex IVR systems and multi-channel authentication. Critical focus on compliance, rate limits, and error handling. Use when: twilio, send SMS, text message, voice call, phone verification."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Twilio Communications
+
+## Patterns
+
+### SMS Sending Pattern
+
+Basic pattern for sending SMS messages with Twilio.
+Handles the fundamentals: phone number formatting, message delivery,
+and delivery status callbacks.
+
+Key considerations:
+- Phone numbers must be in E.164 format (+1234567890)
+- Default rate limit: 80 messages per second (MPS)
+- Messages over 160 characters are split (and cost more)
+- Carrier filtering can block messages (especially to US numbers)
+
+
+**When to use**: ['Sending notifications to users', 'Transactional messages (order confirmations, shipping)', 'Alerts and reminders']
+
+```python
+from twilio.rest import Client
+from twilio.base.exceptions import TwilioRestException
+import os
+import re
+
+class TwilioSMS:
+    """
+    SMS sending with proper error handling and validation.
+    """
+
+    def __init__(self):
+        self.client = Client(
+            os.environ["TWILIO_ACCOUNT_SID"],
+            os.environ["TWILIO_AUTH_TOKEN"]
+        )
+        self.from_number = os.environ["TWILIO_PHONE_NUMBER"]
+
+    def validate_e164(self, phone: str) -> bool:
+        """Validate phone number is in E.164 format."""
+        pattern = r'^\+[1-9]\d{1,14}$'
+        return bool(re.match(pattern, phone))
+
+    def send_sms(
+        self,
+        to: str,
+        body: str,
+        status_callback: str = None
+    ) -> dict:
+        """
+        Send an SMS message.
+
+        Args:
+            to: Recipient phone number in E.164 format
+            body: Message text (160 chars = 1 segment)
+            status_callback: URL for delivery status webhooks
+
+        Returns:
+            Message SID and status
+        """
+        # Validate phone number format
+        if not self.validate_e164(to):
+            return {
+                "success": False,
+                "error": "Phone number must be in E.164 format (+1234567890)"
+            }
+
+        # Check message length (warn about segmentation)
+        segment_count = (len(body) + 159) // 160
+        if segment_count > 1:
+            print(f"Warning: Message will be sent as {segment_count} segments")
+
+        try:
+            message = self.client.messages.create(
+                to=to,
+                from_=self.from_number,
+                body=body,
+                status_callback=status_callback
+            )
+
+            return {
+                "success": True,
+                "message_sid": message.sid,
+                "status": message.status,
+                "segments": segment_count
+            }
+
+        except TwilioRestException as e:
+            return self._handle_error(e)
+
+    def _handle_error(self, error: Twilio
+```
+
+### Twilio Verify Pattern (2FA/OTP)
+
+Use Twilio Verify for phone number verification and 2FA.
+Handles code generation, delivery, rate limiting, and fraud prevention.
+
+Key benefits over DIY OTP:
+- Twilio manages code generation and expiration
+- Built-in fraud prevention (saved customers $82M+ blocking 747M attempts)
+- Handles rate limiting automatically
+- Multi-channel: SMS, Voice, Email, Push, WhatsApp
+
+Google found SMS 2FA blocks "100% of automated bots, 96% of bulk
+phishing attacks, and 76% of targeted attacks."
+
+
+**When to use**: ['User phone number verification at signup', 'Two-factor authentication (2FA)', 'Password reset verification', 'High-value transaction confirmation']
+
+```python
+from twilio.rest import Client
+from twilio.base.exceptions import TwilioRestException
+import os
+from enum import Enum
+from typing import Optional
+
+class VerifyChannel(Enum):
+    SMS = "sms"
+    CALL = "call"
+    EMAIL = "email"
+    WHATSAPP = "whatsapp"
+
+class TwilioVerify:
+    """
+    Phone verification with Twilio Verify.
+    Never store OTP codes - Twilio handles it.
+    """
+
+    def __init__(self, verify_service_sid: str = None):
+        self.client = Client(
+            os.environ["TWILIO_ACCOUNT_SID"],
+            os.environ["TWILIO_AUTH_TOKEN"]
+        )
+        # Create a Verify Service in Twilio Console first
+        self.service_sid = verify_service_sid or os.environ["TWILIO_VERIFY_SID"]
+
+    def send_verification(
+        self,
+        to: str,
+        channel: VerifyChannel = VerifyChannel.SMS,
+        locale: str = "en"
+    ) -> dict:
+        """
+        Send verification code to phone/email.
+
+        Args:
+            to: Phone number (E.164) or email
+            channel: SMS, call, email, or whatsapp
+            locale: Language code for message
+
+        Returns:
+            Verification status
+        """
+        try:
+            verification = self.client.verify \
+                .v2 \
+                .services(self.service_sid) \
+                .verifications \
+                .create(
+                    to=to,
+                    channel=channel.value,
+                    locale=locale
+                )
+
+            return {
+                "success": True,
+                "status": verification.status,  # "pending"
+                "channel": channel.value,
+                "valid": verification.valid
+            }
+
+        except TwilioRestException as e:
+            return self._handle_verify_error(e)
+
+    def check_verification(self, to: str, code: str) -> dict:
+        """
+        Check if verification code is correct.
+
+        Args:
+            to: Phone number or email that received code
+            code: The code entered by user
+
+        R
+```
+
+### TwiML IVR Pattern
+
+Build Interactive Voice Response (IVR) systems using TwiML.
+TwiML (Twilio Markup Language) is XML that tells Twilio what to do
+when receiving calls.
+
+Core TwiML verbs:
+- <Say>: Text-to-speech
+- <Play>: Play audio file
+- <Gather>: Collect keypad/speech input
+- <Dial>: Connect to another number
+- <Record>: Record caller's voice
+- <Redirect>: Move to another TwiML endpoint
+
+Key insight: Twilio makes HTTP request to your webhook, you return
+TwiML, Twilio executes it. Stateless, so use URL params or sessions.
+
+
+**When to use**: ['Phone menu systems (press 1 for sales...)', 'Automated customer support', 'Appointment reminders with confirmation', 'Voicemail systems']
+
+```python
+from flask import Flask, request, Response
+from twilio.twiml.voice_response import VoiceResponse, Gather
+from twilio.request_validator import RequestValidator
+import os
+
+app = Flask(__name__)
+
+def validate_twilio_request(f):
+    """Decorator to validate requests are from Twilio."""
+    def wrapper(*args, **kwargs):
+        validator = RequestValidator(os.environ["TWILIO_AUTH_TOKEN"])
+
+        # Get request details
+        url = request.url
+        params = request.form.to_dict()
+        signature = request.headers.get("X-Twilio-Signature", "")
+
+        if not validator.validate(url, params, signature):
+            return "Invalid request", 403
+
+        return f(*args, **kwargs)
+    wrapper.__name__ = f.__name__
+    return wrapper
+
+@app.route("/voice/incoming", methods=["POST"])
+@validate_twilio_request
+def incoming_call():
+    """Handle incoming call with IVR menu."""
+    response = VoiceResponse()
+
+    # Gather digits with timeout
+    gather = Gather(
+        num_digits=1,
+        action="/voice/menu-selection",
+        method="POST",
+        timeout=5
+    )
+    gather.say(
+        "Welcome to Acme Corp. "
+        "Press 1 for sales. "
+        "Press 2 for support. "
+        "Press 3 to leave a message."
+    )
+    response.append(gather)
+
+    # If no input, repeat
+    response.redirect("/voice/incoming")
+
+    return Response(str(response), mimetype="text/xml")
+
+@app.route("/voice/menu-selection", methods=["POST"])
+@validate_twilio_request
+def menu_selection():
+    """Route based on menu selection."""
+    response = VoiceResponse()
+    digit = request.form.get("Digits", "")
+
+    if digit == "1":
+        # Transfer to sales
+        response.say("Connecting you to sales.")
+        response.dial(os.environ["SALES_PHONE"])
+
+    elif digit == "2":
+        # Transfer to support
+        response.say("Connecting you to support.")
+        response.dial(os.environ["SUPPORT_PHONE"])
+
+    elif digit == "3":
+        # Voicemail
+        response.say("Please leave a message after 
+```
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | high | ## Track opt-out status in your database |
+| Issue | medium | ## Implement retry logic for transient failures |
+| Issue | high | ## Register for A2P 10DLC (US requirement) |
+| Issue | critical | ## ALWAYS validate the signature |
+| Issue | high | ## Track session windows per user |
+| Issue | critical | ## Never hardcode credentials |
+| Issue | medium | ## Implement application-level rate limiting too |

package/skills/twitter-automation/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: twitter-automation
+description: "Automate Twitter/X tasks via Rube MCP (Composio): posts, search, users, bookmarks, lists, media. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Twitter/X Automation via Rube MCP
+
+Automate Twitter/X operations through Composio's Twitter toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Twitter connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `twitter`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `twitter`
+3. If connection is not ACTIVE, follow the returned auth link to complete Twitter OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Create and Manage Posts
+
+**When to use**: User wants to create, delete, or look up tweets/posts
+
+**Tool sequence**:
+1. `TWITTER_USER_LOOKUP_ME` - Get authenticated user info [Prerequisite]
+2. `TWITTER_UPLOAD_MEDIA` / `TWITTER_UPLOAD_LARGE_MEDIA` - Upload media [Optional]
+3. `TWITTER_CREATION_OF_A_POST` - Create a new post [Required]
+4. `TWITTER_POST_LOOKUP_BY_POST_ID` - Look up a specific post [Optional]
+5. `TWITTER_POST_DELETE_BY_POST_ID` - Delete a post [Optional]
+
+**Key parameters**:
+- `text`: Post text content (max 280 weighted characters)
+- `media__media_ids`: Array of media ID strings for attachments
+- `reply__in_reply_to_tweet_id`: Tweet ID to reply to
+- `quote_tweet_id`: Tweet ID to quote
+- `id`: Post ID for lookup/delete
+
+**Pitfalls**:
+- Post text is limited to 280 weighted characters; some characters count as more than one
+- Posting is NOT idempotent; retrying on timeout will create duplicate posts
+- Media IDs must be numeric strings, not integers
+- UPLOAD_LARGE_MEDIA is for videos/GIFs; UPLOAD_MEDIA for images
+- Always call USER_LOOKUP_ME first to get the authenticated user's ID
+
+### 2. Search Posts
+
+**When to use**: User wants to find tweets matching specific criteria
+
+**Tool sequence**:
+1. `TWITTER_RECENT_SEARCH` - Search recent tweets (last 7 days) [Required]
+2. `TWITTER_FULL_ARCHIVE_SEARCH` - Search full archive (Academic access) [Optional]
+3. `TWITTER_RECENT_SEARCH_COUNTS` - Get tweet count matching query [Optional]
+
+**Key parameters**:
+- `query`: Search query using Twitter search operators
+- `max_results`: Results per page (10-100)
+- `next_token`: Pagination token
+- `start_time`/`end_time`: ISO 8601 time range
+- `tweet__fields`: Comma-separated fields to include
+- `expansions`: Related objects to expand
+
+**Pitfalls**:
+- RECENT_SEARCH covers only the last 7 days; use FULL_ARCHIVE_SEARCH for older tweets
+- FULL_ARCHIVE_SEARCH requires Academic Research or Enterprise access
+- Query operators: `from:username`, `to:username`, `is:retweet`, `has:media`, `-is:retweet`
+- Empty results return `meta.result_count: 0` with no `data` field
+- Rate limits vary by endpoint and access level; check response headers
+
+### 3. Look Up Users
+
+**When to use**: User wants to find or inspect Twitter user profiles
+
+**Tool sequence**:
+1. `TWITTER_USER_LOOKUP_ME` - Get authenticated user [Optional]
+2. `TWITTER_USER_LOOKUP_BY_USERNAME` - Look up by username [Optional]
+3. `TWITTER_USER_LOOKUP_BY_ID` - Look up by user ID [Optional]
+4. `TWITTER_USER_LOOKUP_BY_IDS` - Batch look up multiple users [Optional]
+
+**Key parameters**:
+- `username`: Twitter handle without @ prefix
+- `id`: Numeric user ID string
+- `ids`: Comma-separated user IDs for batch lookup
+- `user__fields`: Fields to return (description, public_metrics, etc.)
+
+**Pitfalls**:
+- Usernames are case-insensitive but must not include the @ prefix
+- User IDs are numeric strings, not integers
+- Suspended or deleted accounts return errors, not empty results
+- LOOKUP_BY_IDS accepts max 100 IDs per request
+
+### 4. Manage Bookmarks
+
+**When to use**: User wants to save, view, or remove bookmarked tweets
+
+**Tool sequence**:
+1. `TWITTER_USER_LOOKUP_ME` - Get authenticated user ID [Prerequisite]
+2. `TWITTER_BOOKMARKS_BY_USER` - List bookmarked posts [Required]
+3. `TWITTER_ADD_POST_TO_BOOKMARKS` - Bookmark a post [Optional]
+4. `TWITTER_REMOVE_A_BOOKMARKED_POST` - Remove bookmark [Optional]
+
+**Key parameters**:
+- `id`: User ID (from USER_LOOKUP_ME) for listing bookmarks
+- `tweet_id`: Tweet ID to bookmark or unbookmark
+- `max_results`: Results per page
+- `pagination_token`: Token for next page
+
+**Pitfalls**:
+- Bookmarks require the authenticated user's ID, not username
+- Bookmarks are private; only the authenticated user can see their own
+- Pagination uses `pagination_token`, not `next_token`
+
+### 5. Manage Lists
+
+**When to use**: User wants to view or manage Twitter lists
+
+**Tool sequence**:
+1. `TWITTER_USER_LOOKUP_ME` - Get authenticated user ID [Prerequisite]
+2. `TWITTER_GET_A_USER_S_OWNED_LISTS` - List owned lists [Optional]
+3. `TWITTER_GET_A_USER_S_LIST_MEMBERSHIPS` - List memberships [Optional]
+4. `TWITTER_GET_A_USER_S_PINNED_LISTS` - Get pinned lists [Optional]
+5. `TWITTER_GET_USER_S_FOLLOWED_LISTS` - Get followed lists [Optional]
+6. `TWITTER_LIST_LOOKUP_BY_LIST_ID` - Get list details [Optional]
+
+**Key parameters**:
+- `id`: User ID for listing owned/member/followed lists
+- `list_id`: List ID for specific list lookup
+- `max_results`: Results per page (1-100)
+
+**Pitfalls**:
+- List IDs and User IDs are numeric strings
+- Lists endpoints require the user's numeric ID, not username
+
+### 6. Interact with Posts
+
+**When to use**: User wants to like, unlike, or view liked posts
+
+**Tool sequence**:
+1. `TWITTER_USER_LOOKUP_ME` - Get authenticated user ID [Prerequisite]
+2. `TWITTER_RETURNS_POST_OBJECTS_LIKED_BY_THE_PROVIDED_USER_ID` - Get liked posts [Optional]
+3. `TWITTER_UNLIKE_POST` - Unlike a post [Optional]
+
+**Key parameters**:
+- `id`: User ID for listing liked posts
+- `tweet_id`: Tweet ID to unlike
+
+**Pitfalls**:
+- Like/unlike endpoints require user ID from USER_LOOKUP_ME
+- Liked posts pagination may be slow for users with many likes
+
+## Common Patterns
+
+### Search Query Syntax
+
+**Operators**:
+- `from:username` - Posts by user
+- `to:username` - Replies to user
+- `@username` - Mentions user
+- `#hashtag` - Contains hashtag
+- `"exact phrase"` - Exact match
+- `has:media` - Contains media
+- `has:links` - Contains links
+- `is:retweet` / `-is:retweet` - Include/exclude retweets
+- `is:reply` / `-is:reply` - Include/exclude replies
+- `lang:en` - Language filter
+
+**Combinators**:
+- Space for AND
+- `OR` for either condition
+- `-` prefix for NOT
+- Parentheses for grouping
+
+### Media Upload Flow
+
+```
+1. Upload media with TWITTER_UPLOAD_MEDIA (images) or TWITTER_UPLOAD_LARGE_MEDIA (video/GIF)
+2. Get media_id from response
+3. Pass media_id as string in media__media_ids array to TWITTER_CREATION_OF_A_POST
+```
+
+## Known Pitfalls
+
+**Character Limits**:
+- Standard posts: 280 weighted characters
+- Some Unicode characters count as more than 1
+- URLs are shortened and count as fixed length (23 characters)
+
+**Rate Limits**:
+- Vary significantly by access tier (Free, Basic, Pro, Enterprise)
+- Free tier: very limited (e.g., 1,500 posts/month)
+- Check `x-rate-limit-remaining` header in responses
+
+**Idempotency**:
+- Post creation is NOT idempotent; duplicate posts will be created on retry
+- Implement deduplication logic for automated posting
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Create post | TWITTER_CREATION_OF_A_POST | text |
+| Delete post | TWITTER_POST_DELETE_BY_POST_ID | id |
+| Look up post | TWITTER_POST_LOOKUP_BY_POST_ID | id |
+| Recent search | TWITTER_RECENT_SEARCH | query |
+| Archive search | TWITTER_FULL_ARCHIVE_SEARCH | query |
+| Search counts | TWITTER_RECENT_SEARCH_COUNTS | query |
+| My profile | TWITTER_USER_LOOKUP_ME | (none) |
+| User by name | TWITTER_USER_LOOKUP_BY_USERNAME | username |
+| User by ID | TWITTER_USER_LOOKUP_BY_ID | id |
+| Users by IDs | TWITTER_USER_LOOKUP_BY_IDS | ids |
+| Upload media | TWITTER_UPLOAD_MEDIA | media |
+| Upload video | TWITTER_UPLOAD_LARGE_MEDIA | media |
+| List bookmarks | TWITTER_BOOKMARKS_BY_USER | id |
+| Add bookmark | TWITTER_ADD_POST_TO_BOOKMARKS | tweet_id |
+| Remove bookmark | TWITTER_REMOVE_A_BOOKMARKED_POST | tweet_id |
+| Unlike post | TWITTER_UNLIKE_POST | tweet_id |
+| Liked posts | TWITTER_RETURNS_POST_OBJECTS_LIKED_BY_THE_PROVIDED_USER_ID | id |
+| Owned lists | TWITTER_GET_A_USER_S_OWNED_LISTS | id |
+| List memberships | TWITTER_GET_A_USER_S_LIST_MEMBERSHIPS | id |
+| Pinned lists | TWITTER_GET_A_USER_S_PINNED_LISTS | id |
+| Followed lists | TWITTER_GET_USER_S_FOLLOWED_LISTS | id |
+| List details | TWITTER_LIST_LOOKUP_BY_LIST_ID | list_id |

package/skills/typescript-advanced-types/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: typescript-advanced-types
+description: Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.
+---
+
+# TypeScript Advanced Types
+
+Comprehensive guidance for mastering TypeScript's advanced type system including generics, conditional types, mapped types, template literal types, and utility types for building robust, type-safe applications.
+
+## Use this skill when
+
+- Building type-safe libraries or frameworks
+- Creating reusable generic components
+- Implementing complex type inference logic
+- Designing type-safe API clients
+- Building form validation systems
+- Creating strongly-typed configuration objects
+- Implementing type-safe state management
+- Migrating JavaScript codebases to TypeScript
+
+## Do not use this skill when
+
+- The task is unrelated to typescript advanced types
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.