Skill Claude Cortex: Инструмент для разработки навыков Claude

--- name: your-skill-name description: Brief description of what this skill does and provides. Use when [clear trigger condition that indicates this skill should activate]. Keep under 200 words. author: Your Name <your.email@example.com> version: 1.0.0 license: MIT tags: [category1, category2, category3] created: 2024-10-17 updated: 2024-10-17 --- # Skill Title Brief overview paragraph explaining what this skill provides, its purpose, and its scope. Include key concepts and what makes this skill valuable. ## When to Use This Skill Provide 5-10 specific scenarios when this skill should be activated: - Scenario 1: Specific use case with clear trigger - Scenario 2: Another distinct situation - Scenario 3: Related but different context - Scenario 4: Edge case or advanced usage - Scenario 5: Integration with other tools/frameworks ## Core Concepts Brief introduction to foundational concepts needed to understand this skill. ### Concept 1: Foundation Explanation of first essential concept with simple example: ```language // Simple, clear example demonstrating concept // Include comments explaining key points ``` **Key points:** - Important aspect 1 - Important aspect 2 - Important aspect 3 ### Concept 2: Building Blocks Second essential concept with progression from basic to intermediate: ```language // Example showing concept application // Demonstrate best practices ``` **When to use:** - Use case 1 - Use case 2 - Use case 3 ## Common Patterns ### Pattern 1: [Pattern Name] **Problem**: Describe the problem this pattern solves **Solution**: Explain the pattern approach **Example**: ```language // Complete, working example // Well-commented to explain approach // Include edge cases if relevant function examplePattern() { // Implementation details // Show best practices } ``` **Pros:** - Advantage 1 - Advantage 2 - Advantage 3 **Cons:** - Limitation 1 - Limitation 2 **When to use**: Specific criteria for applying this pattern ### Pattern 2: [Pattern Name] **Problem**: Second problem domain **Solution**: Alternative or complementary approach **Example**: ```language // Different approach showing variety // Demonstrate trade-offs ``` **Comparison**: How this pattern differs from Pattern 1 ## Advanced Usage This section provides deeper patterns for complex scenarios. Load only when needed. ### Advanced Pattern 1: [Complex Scenario] Context for when advanced usage is necessary: ```language // More sophisticated example // Show integration with multiple concepts // Demonstrate production-ready code class AdvancedExample { // Complete implementation // Include error handling // Show performance considerations } ``` **Considerations:** - Performance impact - Scalability concerns - Security implications - Maintenance burden ### Advanced Pattern 2: [Edge Cases] Handling edge cases and uncommon scenarios: ```language // Edge case handling // Defensive programming // Graceful degradation ``` ## Integration Examples ### Integrating with [Related Technology 1] ```language // Show how this skill integrates with other systems // Practical, real-world example ``` ### Integrating with [Related Technology 2] ```language // Different integration scenario // Demonstrate flexibility ``` ## Best Practices Summary Quick reference for implementing this skill effectively: ### Do's - Do this for best results - Always consider this aspect - Prefer this approach when possible - Validate this condition before proceeding - Document this information for maintainability ### Don'ts - Avoid this anti-pattern - Don't forget this critical step - Never do this in production - Don't overlook this edge case - Avoid this common mistake ### Performance Tips - Optimization technique 1 - Optimization technique 2 - Caching strategy - Resource management ### Security Considerations - Security practice 1 - Security practice 2 - Input validation requirements - Authentication/authorization concerns ## Common Pitfalls ### Pitfall 1: [Common Mistake] **Problem**: Description of what goes wrong **Why it happens**: Explanation of root cause **Solution**: How to avoid or fix ```language // Incorrect approach (anti-pattern) // badExample(); // Correct approach // goodExample(); ``` ### Pitfall 2: [Another Mistake] **Problem**: Second common issue **Solution**: Prevention strategy ## Testing Strategies ### Unit Testing ```language // Example test cases // Show test structure // Demonstrate assertions describe('Feature', () => { it('should handle expected case', () => { // Test implementation }); it('should handle edge case', () => { // Edge case testing }); }); ``` ### Integration Testing ```language // Integration test example // Show testing across boundaries ``` ## Real-World Examples ### Example 1: [Practical Scenario] **Context**: Real-world situation description **Implementation**: ```language // Complete, production-ready example // Include error handling // Show configuration // Demonstrate best practices class RealWorldExample { // Full implementation // Comments explaining decisions // Edge case handling } ``` **Results**: Outcome and benefits achieved ### Example 2: [Different Scenario] **Context**: Alternative use case **Implementation**: ```language // Different approach for different context ``` **Lessons learned**: Insights from this implementation ## Troubleshooting ### Issue 1: [Common Problem] **Symptoms**: What the user observes **Causes**: Typical root causes **Solutions**: 1. First attempt solution 2. Alternative approach 3. Last resort option **Prevention**: How to avoid this issue ### Issue 2: [Another Problem] **Symptoms**: Observable behavior **Diagnostic steps**: 1. Check this first 2. Verify this condition 3. Investigate this aspect **Resolution**: How to fix ## Tools and Resources ### Recommended Tools - **Tool 1**: What it does and when to use - **Tool 2**: Alternative tool and trade-offs - **Tool 3**: Complementary tool ### Libraries and Frameworks - **Library 1**: Purpose and integration approach - **Library 2**: Alternative library comparison ### Documentation Links - [Official Documentation](https://example.com/docs) - [API Reference](https://example.com/api) - [Community Resources](https://example.com/community) ### Further Reading - Article/book: Brief description - Tutorial: What it covers - Video course: Key takeaways ## Version History - **1.0.0** (2024-10-17): Initial release - Core patterns implemented - Examples validated - Best practices documented ## Related Skills This skill works well with: - **related-skill-1**: How they complement each other - **related-skill-2**: When to use together - **related-skill-3**: Integration points ## Maintenance Notes **Author commitment**: Expected update frequency and maintenance approach **Contribution welcome**: Areas where community contributions would be valuable **Known limitations**: Current gaps or planned improvements **Deprecation policy**: How breaking changes will be handled ## License This skill is licensed under the MIT License. See LICENSE file for details. ## Author Contact - **Name**: Your Name - **Email**: your.email@example.com - **GitHub**: [@yourusername](https://github.com/yourusername) - **Website**: https://yourwebsite.com (optional) For issues or questions about this skill, please: 1. Check documentation above 2. Search existing GitHub issues 3. Open new issue with `community-skill:your-skill-name` label 4. Contact author directly for urgent matters