Skip to main content Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/bobmatnyc/claude-mpm-skills --skill example-framework-skillO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Explorador de arquivos
3 arquivos Mais deste repositório LinkedIn automation via the Linked API CLI - fetch profiles, search people and companies, send messages, manage connections, create posts, react, comment, and run Sales Navigator and custom workflows. Use when the user wants to interact with LinkedIn.
Xquik X data automation API - Use REST or MCP for tweet search, user lookup, follower exports, media downloads, monitors, webhooks, giveaway draws, and confirmation-gated X actions.
MCP (Model Context Protocol) - Build AI-native servers with tools, resources, and prompts. TypeScript/Python SDKs for Claude Desktop integration.
name example-framework-skill description Example of a properly self-contained skill following all best practices user-invocable false disable-model-invocation true category framework toolchain python tags ["self-contained","example","template","best-practice"] version 1.0.0 author claude-mpm-skills updated "2025-11-30T00:00:00.000Z" progressive_disclosure {"entry_point":{"summary":"Example of a properly self-contained skill following all best practices","when_to_use":"When working with example-framework-skill or related functionality.","quick_start":"1. Review the core concepts below. 2. Apply patterns to your use case. 3. Follow best practices for implementation."}}
Example Framework Skill
A complete example demonstrating proper self-containment patterns for Claude Code skills.
When to Use : Building applications with Example Framework - includes setup, patterns, testing, and deployment.
Overview
This skill demonstrates the correct approach to self-contained skill development:
✅ Self-Contained : All essential content inlined - works standalone
✅ No Dependencies : No relative paths to other skills
✅ Complete Examples : Working code, not fragments
✅ Graceful Degradation : Notes optional enhancements without requiring them
✅ Flat Deployment Ready : Works in any directory structure
Quick Start
Installation
pip install example-framework
example-framework init my-project
cd my-project
pip install -r requirements.txt
example-framework dev
Minimal Example (Self-Contained)
"""
Minimal Example Framework application.
Self-contained - no external skill dependencies.
"""
from example_framework import App, route
app = App()
@route("/"
def home ():
"""Homepage route."""
return {"message" : "Hello, World!" }
@route("/users/{user_id}"
def get_user (user_id: int ):
"""Get user by ID."""
return {
"id" : user_id,
"username" : f"user_{user_id} "
}
if
"__main__"
"0.0.0.0"
8000
True
Core Patterns
1. Application Setup (Self-Contained) Complete setup pattern - no external dependencies:
from example_framework import App, Config
from example_framework.middleware import CORSMiddleware, LoggingMiddleware
config = Config(
DEBUG=True ,
SECRET_KEY="your-secret-key-here" ,
DATABASE_URL="sqlite:///./app.db"
)
app = App(config=config)
app.add_middleware(
CORSMiddleware,
allow_origins=["*" ],
allow_methods=["*" ],
allow_headers=["*" ]
)
app.add_middleware(LoggingMiddleware)
@app.route("/health"
def health_check ():
"""Health check endpoint."""
return {"status" : "healthy" }
2. Database Integration (Self-Contained) Essential database pattern - inlined for self-containment:
from example_framework import Database
from contextlib import contextmanager
db = Database("sqlite:///./app.db" )
@contextmanager
def get_db_session ():
"""
Database session context manager.
Usage:
with get_db_session() as session:
users = session.query(User).all()
"""
session = db.create_session()
try :
yield session
session.commit()
except Exception:
session.rollback()
raise
finally :
session.close()
class User (db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True )
username = db.Column(db.String(80 ), unique=True , nullable=False )
email = db.Column(db.String(120 ), unique=True , nullable=False )
def to_dict (self ):
"""Convert to dictionary."""
return {
"id" : self .id ,
"username" : self .username,
"email" : self .email
}
@app.route("/users" , methods=["POST" ]
def create_user (data ):
"""Create new user."""
with get_db_session() as session:
user = User(
username=data["username" ],
email=data["email" ]
)
session.add(user)
return user.to_dict(), 201
@app.route("/users/{user_id}"
def get_user (user_id: int ):
"""Get user by ID."""
with get_db_session() as session:
user = session.query(User).filter_by(id =user_id).first()
if not user:
return {"error" : "User not found" }, 404
return user.to_dict()
3. Testing Pattern (Self-Contained) Essential testing patterns - inlined from testing best practices:
"""
Test suite for Example Framework application.
Self-contained testing patterns - no external skill dependencies.
"""
import pytest
from example_framework.testing import TestClient
@pytest.fixture
def client ():
"""Create test client."""
return TestClient(app)
@pytest.fixture
def db_session ():
"""Create test database session."""
db.create_all()
session = db.create_session()
yield session
session.close()
db.drop_all()
def test_home_route (client ):
"""Test homepage returns correct response."""
response = client.get("/" )
assert response.status_code == 200
assert response.json() == {"message" : "Hello, World!" }
def test_create_user (client, db_session ):
"""Test user creation."""
response = client.post("/users" , json={
"username" : "testuser" ,
"email" : "test@example.com"
})
assert response.status_code == 201
data = response.json()
assert data["username" ] == "testuser"
assert data["email" ] == "test@example.com"
def test_get_user (client, db_session ):
"""Test get user by ID."""
user = User(username="testuser" , email="test@example.com" )
db_session.add(user)
db_session.commit()
response = client.get(f"/users/{user.id } " )
assert response.status_code == 200
assert response.json()["username" ] == "testuser"
def test_user_not_found (client ):
"""Test 404 for nonexistent user."""
response = client.get("/users/999" )
assert response.status_code == 404
Error Handling
Standard Error Handler Pattern (Self-Contained) from example_framework import HTTPException
@app.error_handler(404
def not_found_handler (error ):
"""Handle 404 errors."""
return {
"error" : "Not Found" ,
"message" : str (error)
}, 404
@app.error_handler(500
def server_error_handler (error ):
"""Handle 500 errors."""
return {
"error" : "Internal Server Error" ,
"message" : "An unexpected error occurred"
}, 500
@app.error_handler(HTTPException )
def http_exception_handler (error ):
"""Handle HTTP exceptions."""
return {
"error" : error.name,
"message" : error.description
}, error.status_code
class ValidationError (Exception ):
"""Validation error."""
pass
@app.error_handler(ValidationError )
def validation_error_handler (error ):
"""Handle validation errors."""
return {
"error" : "Validation Error" ,
"message" : str (error)
}, 400
Best Practices
1. Configuration Management
import os
from example_framework import Config
class DevelopmentConfig (Config ):
DEBUG = True
DATABASE_URL = "sqlite:///./dev.db"
class ProductionConfig (Config ):
DEBUG = False
DATABASE_URL = os.getenv("DATABASE_URL" )
SECRET_KEY = os.getenv("SECRET_KEY" )
env = os.getenv("ENV" , "development" )
config = DevelopmentConfig() if env == "development" else ProductionConfig()
app = App(config=config)
2. Dependency Injection
from example_framework import Depends
def get_current_user (token: str = Depends("Authorization" ):
"""Get current user from token."""
user_id = validate_token(token)
return User.query.get(user_id)
@app.route("/profile"
def get_profile (user: User = Depends(get_current_user ) ):
"""Get current user profile."""
return user.to_dict()
3. Request Validation from example_framework import validate_request
user_schema = {
"username" : {"type" : "string" , "minLength" : 3 , "maxLength" : 80 },
"email" : {"type" : "string" , "format" : "email" },
"age" : {"type" : "integer" , "minimum" : 0 }
}
@app.route("/users" , methods=["POST" ]
@validate_request(user_schema )
def create_user (data ):
"""Create user with validated data."""
user = User(**data)
db.session.add(user)
db.session.commit()
return user.to_dict(), 201
Deployment
Production Deployment (Self-Contained) """
Production deployment configuration.
Self-contained - all necessary patterns included.
"""
import os
class ProductionConfig :
DEBUG = False
TESTING = False
SECRET_KEY = os.getenv("SECRET_KEY" )
DATABASE_URL = os.getenv("DATABASE_URL" )
ALLOWED_HOSTS = os.getenv("ALLOWED_HOSTS" , "" ).split("," )
app = App(config=ProductionConfig())
Complementary Skills When using this skill, consider these related skills (if deployed):
pytest-patterns : Advanced testing patterns and fixtures
Use case : Comprehensive test suites with parametrizationIntegration : Enhance basic testing patterns shown aboveStatus : Optional - basic testing patterns included in this skill
database-orm-patterns : Advanced ORM patterns and optimization
Use case : Complex queries, relationships, performance tuningIntegration : Builds on basic database pattern shown aboveStatus : Optional - basic CRUD patterns included in this skill
api-security : Authentication, authorization, security best practices
Use case : Production-ready security implementationIntegration : Adds security layer to routesStatus : Recommended for production - basic examples shown above
deployment-patterns : Docker, CI/CD, monitoring, scaling
Use case : Production deployment and operationsIntegration : Deployment strategies and toolingStatus : Optional - basic deployment shown above
Note : All complementary skills are independently deployable. This skill is fully functional without them.
Common Pitfalls
❌ Don't: Relative Imports
from ..other_skill.patterns import setup
✅ Do: Self-Contained Patterns
def setup ():
"""Setup pattern (self-contained)."""
pass
❌ Don't: External Skill Dependencies
from skills.pytest_patterns import fixture_factory
✅ Do: Inline Essential Patterns
def fixture_factory (name, default=None ):
"""Fixture factory pattern (inlined)."""
@pytest.fixture
def _fixture ():
return default
_fixture.__name__ = name
return _fixture
Progressive Disclosure For more advanced topics, see the references/ directory:
Note : Main SKILL.md is self-sufficient. References provide optional deep dives.
Resources
Summary This skill demonstrates self-contained skill development :
✅ Complete : All essential patterns included inline
✅ Independent : Works without other skills
✅ Tested : Verified in isolation
✅ Deployable : Works in flat directory structure
✅ Graceful : Notes optional enhancements without requiring them
Use this as a template for creating new skills.
Version : 1.0.0
Last Updated : 2025-11-30
Self-Containment : ✅ Fully Compliant
