Cómo crear Skills: pasos clave, limitaciones y ejemplos
Aprende a escribir skills a medida para obtener resultados mejores y más eficaces de Claude.
Las Skills son instrucciones personalizadas que amplían las capacidades de Claude para tareas o dominios específicos.
Cuando creas una skill mediante un archivo SKILL.md, enseñas a Claude a gestionar escenarios específicos con más eficacia. La fuerza de las skills reside en su capacidad para codificar el conocimiento institucional, estandarizar los resultados y gestionar flujos de trabajo complejos de varios pasos que, de otro modo, exigirían explicaciones repetidas o invertir en crear un agente personalizado.
Aprende a crear skills que convierten a Claude de un asistente de uso general en un experto en tus flujos de trabajo, ya sea con nuestra plantilla del skill creator o de forma manual. (Consejo útil: para facilitarlo, recomendamos crear tu archivo SKILL.md con esta plantilla y personalizarlo a partir de ahí).
Crear una skill en 5 pasos
Sigue este enfoque estructurado para crear skills que se activen de forma más fiable.
1. Comprende los requisitos principales
Antes de escribir nada, define qué problema resuelve tu skill. Las buenas skills responden a necesidades concretas con resultados medibles. "Extrae datos financieros de PDF y dales formato CSV" es mejor que "Ayúdame con mis cosas de finanzas" porque especifica el formato de entrada, la operación y la salida esperada.
Empieza por preguntarte: ¿qué tarea específica realiza esta skill? ¿Qué desencadenantes deberían activarla? ¿Qué se considera un éxito? ¿Cuáles son los casos límite o las limitaciones?
2. Escribe el nombre
Tu skill necesita tres componentes principales: nombre (identificador claro), descripción (cuándo activarse) e instrucciones (cómo ejecutarse). De hecho, el nombre y la descripción son las únicas partes del archivo SKILL.md que influyen en la activación; es decir, en la capacidad de Claude para invocar una skill para obtener conocimientos especializados o flujos de trabajo.
El nombre debe ser directo y descriptivo. Usa minúsculas con guiones (p. ej., pdf-editor, brand-guidelines). Que sea breve y claro.
3. Escribe el campo de descripción
La descripción determina cuándo se activa tu skill, por lo que es el componente más importante. Escríbela desde la perspectiva de Claude, centrándote en los desencadenantes, las capacidades y los casos de uso.
Una buena descripción equilibra varios elementos: capacidades específicas, desencadenantes claros, contexto relevante y límites.
Descripción débil:
This skill helps with PDFs and documents.Descripción sólida:
Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale. Use for document workflows and batch operations. Not for simple PDF viewing or basic conversions.La versión sólida ofrece a Claude varios datos: verbos específicos (extraer, crear, combinar), casos de uso concretos (rellenar formularios, operaciones por lotes) y límites claros (no sirve para simple visualización).
4. Escribe las instrucciones principales
Tus instrucciones deben ser estructuradas, fáciles de leer y prácticas. Usa encabezados Markdown, viñetas para las opciones y bloques de código para los ejemplos.
Estructúralas con una jerarquía clara: descripción general, requisitos previos, pasos de ejecución, ejemplos, gestión de errores y limitaciones. Divide los flujos de trabajo complejos en fases bien definidas con entradas y salidas claras.
Incluye ejemplos concretos que muestren el uso correcto. Especifica lo que la skill no puede hacer para evitar usos indebidos y gestionar las expectativas. Tu archivo SKILL.md también puede incluir archivos de referencia y recursos adicionales para aportar aún más claridad y orientación sobre lo que le pides al agente cuando se activa la skill.
5. Carga tu skill
Según la plataforma de Claude en la que desarrolles, así puedes subir tu skill para usarla:
- Claude.ai (aplicaciones de Claude): ve a Configuración y añade allí tu skill personalizada. Las skills personalizadas requieren un plan Pro, Max, Ultra, Team o Enterprise con la ejecución de código activada. Las skills que subas aquí son individuales para cada usuario. No se comparten con toda la organización y los administradores no pueden gestionarlas de forma centralizada.
- Claude Code: crea un directorio skills/ en la raíz de tu plugin o proyecto y añade carpetas de skills con archivos SKILL.md. Claude las detecta y las usa automáticamente cuando el plugin está instalado. Estructura de ejemplo:
my-project/
├── skills/
│ └── my-skill/
│ └── SKILL.md- Claude Developer Platform: sube skills a través de la API de Skills (endpoints /v1/skills). Usa una solicitud POST con los encabezados beta necesarios:
curl -X POST "https://api.anthropic.com/v1/skills" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: skills-2025-10-02" \
-F "display_title=My Skill Name" \
-F "files[]=@my-skill/SKILL.md;filename=my-skill/SKILL.md"4. Pruebas y validación
Prueba tu skill con escenarios realistas antes de implementarla. Las pruebas sistemáticas revelan lagunas en las instrucciones, ambigüedades en las descripciones y casos límite inesperados que solo aparecen con el uso real.
Crea una matriz de pruebas que cubra tres escenarios:
- Operaciones normales: prueba la skill con solicitudes típicas que debería manejar a la perfección. Si has creado una skill de análisis financiero, prueba con "analiza los últimos resultados de Microsoft" o "crea un datapack para este informe 10-K". Estas pruebas de referencia confirman que tus instrucciones funcionan según lo previsto.
- Casos límite: prueba con entradas incompletas o inusuales. ¿Qué ocurre cuando faltan datos? ¿Y cuando los formatos de archivo son inesperados? ¿Y cuando los usuarios dan instrucciones ambiguas? Tu skill debería gestionar estos casos con solvencia, ya sea ofreciendo un resultado limitado pero útil o explicando qué se necesita para continuar.
- Solicitudes fuera de alcance: prueba con tareas que parezcan relacionadas pero que no deberían activar tu skill. Si has creado una skill de revisión de NDA, prueba a pedir "revisa este contrato de trabajo" o "analiza este contrato de arrendamiento". La skill debería permanecer inactiva y dejar que otras skills o las capacidades generales de Claude se encarguen de la solicitud.
Valora implementar las siguientes pruebas para una validación aún más profunda:
- Pruebas de activación: ¿se activa la skill cuando se espera? Prueba tanto con solicitudes explícitas ("usa la skill de datapack financiero para analizar esta empresa") como con solicitudes naturales ("ayúdame a entender los datos financieros de esta empresa"). ¿Permanece inactiva cuando no es relevante? Una skill con un alcance bien definido sabe cuándo no activarse. Prueba solicitudes similares pero distintas para verificar los límites.
- Pruebas funcionales: incluyen la coherencia de los resultados (¿varias ejecuciones con entradas similares producen resultados comparables?), la usabilidad (¿alguien que no esté familiarizado con el dominio puede usarla con éxito?) y la precisión de la documentación (¿tus ejemplos coinciden con el comportamiento real?).
5. Itera en función del uso
Supervisa el rendimiento de tu skill en el uso real. Ajusta las descripciones si la activación es irregular. Aclara las instrucciones si los resultados varían de forma inesperada. Al igual que con los prompts, las mejores skills evolucionan a través de la aplicación práctica.
Prácticas recomendadas generales para crear skills
Estos principios te ayudan a crear skills que sean fáciles de mantener, reutilizables y realmente útiles en lugar de teóricas.
Empieza por los casos de uso
No escribas skills de forma especulativa. Créalas cuando tengas tareas reales y repetitivas. Las mejores skills resuelven problemas con los que te encuentras habitualmente.
Antes de crear una skill, pregúntate: ¿he realizado esta tarea al menos cinco veces? ¿Lo haré al menos diez veces más? Si es así, tiene sentido crear una skill.
Define los criterios de éxito e inclúyelos en la skill
Indica a Claude cómo es un buen resultado. Si creas informes financieros, especifica las secciones obligatorias, los estándares de formato, las comprobaciones de validación y los umbrales de calidad. Incluye estos criterios en tus instrucciones para que Claude pueda autoevaluarse.
Usa la skill Skill-Creator
La skill skill-creator te guía en la creación de skills bien estructuradas. Formula preguntas aclaratorias, sugiere mejoras en la descripción y te ayuda a dar el formato adecuado a las instrucciones. Disponible en el repositorio de Skills en GitHub y directamente a través de Claude.ai, resulta especialmente útil para tus primeras skills.
Limitaciones y consideraciones de las skills
Comprender cómo funcionan las skills (y sus límites) te ayuda a diseñar skills más eficaces y a establecer expectativas adecuadas.
Activación de skills
Claude evalúa las descripciones de las skills en función de tu solicitud para determinar su relevancia. No se trata de una simple coincidencia de palabras clave: Claude entiende las relaciones semánticas. Sin embargo, las descripciones vagas reducen la precisión de la activación.
Varias skills pueden activarse simultáneamente si abordan diferentes aspectos de una tarea compleja. Las descripciones demasiado genéricas provocan activaciones inapropiadas, mientras que la omisión de casos de uso provoca activaciones fallidas.
Tamaños de archivo apropiados
Al escribir skills, evita sobrecargar la ventana de contexto con contenido innecesario. Plantéate si cada dato necesita cargarse siempre o solo de forma condicional.
Usa un enfoque de "menú": si tu skill abarca varios procesos u opciones distintos, el archivo SKILL.md debe describir lo que está disponible y usar rutas relativas para hacer referencia a archivos separados para cada uno. Luego, Claude lee solo el archivo relevante para la tarea del usuario y deja los demás sin tocar durante esa conversación.
Estos archivos independientes no tienen por qué representar rutas que se excluyan mutuamente. El principio clave es dividir el contenido en fragmentos razonables y dejar que Claude seleccione lo que necesita en función de la tarea en cuestión.
Ejemplos reales de skills
Ejemplo de skill n.º 1: skill de creación de docx
#---
name: docx
description: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"
license: Proprietary. LICENSE.txt has complete terms
---
# DOCX creation, editing, and analysis
## Overview
A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
## Workflow Decision Tree
### Reading/Analyzing Content
Use "Text extraction" or "Raw XML access" sections below
### Creating New Document
Use "Creating a new Word document" workflow
### Editing Existing Document
- **Your own document + simple changes**
Use "Basic OOXML editing" workflow
- **Someone else's document**
Use **"Redlining workflow"** (recommended default)
- **Legal, academic, business, or government docs**
Use **"Redlining workflow"** (required)
## Reading and analyzing content
### Text extraction
If you just need to read the text contents of a document, you should convert the document to markdown using pandoc. Pandoc provides excellent support for preserving document structure and can show tracked changes:
```bash
# Convert document to markdown with tracked changes
pandoc --track-changes=all path-to-file.docx -o output.md
# Options: --track-changes=accept/reject/all
```
### Raw XML access
You need raw XML access for: comments, complex formatting, document structure, embedded media, and metadata. For any of these features, you'll need to unpack a document and read its raw XML contents.
#### Unpacking a file
`python ooxml/scripts/unpack.py <office_file> <output_directory>`
#### Key file structures
* `word/document.xml` - Main document contents
* `word/comments.xml` - Comments referenced in document.xml
* `word/media/` - Embedded images and media files
* Tracked changes use `<w:ins>` (insertions) and `<w:del>` (deletions) tags
## Creating a new Word document
When creating a new Word document from scratch, use **docx-js**, which allows you to create Word documents using JavaScript/TypeScript.
### Workflow
1. **MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.
2. Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)
3. Export as .docx using Packer.toBuffer()
## Editing an existing Word document
When editing an existing Word document, use the **Document library** (a Python library for OOXML manipulation). The library automatically handles infrastructure setup and provides methods for document manipulation. For complex scenarios, you can access the underlying DOM directly through the library.
### Workflow
1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.
2. Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`
3. Create and run a Python script using the Document library (see "Document Library" section in ooxml.md)
4. Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`
The Document library provides both high-level methods for common operations and direct DOM access for complex scenarios.
## Redlining workflow for document review
This workflow allows you to plan comprehensive tracked changes using markdown before implementing them in OOXML. **CRITICAL**: For complete tracked changes, you must implement ALL changes systematically.
**Batching Strategy**: Group related changes into batches of 3-10 changes. This makes debugging manageable while maintaining efficiency. Test each batch before moving to the next.
**Principle: Minimal, Precise Edits**
When implementing tracked changes, only mark text that actually changes. Repeating unchanged text makes edits harder to review and appears unprofessional. Break replacements into: [unchanged text] + [deletion] + [insertion] + [unchanged text]. Preserve the original run's RSID for unchanged text by extracting the `<w:r>` element from the original and reusing it.
Example - Changing "30 days" to "60 days" in a sentence:
```python
# BAD - Replaces entire sentence
'<w:del><w:r><w:delText>The term is 30 days.</w:delText></w:r></w:del><w:ins><w:r><w:t>The term is 60 days.</w:t></w:r></w:ins>'
# GOOD - Only marks what changed, preserves original <w:r> for unchanged text
'<w:r w:rsidR="00AB12CD"><w:t>The term is </w:t></w:r><w:del><w:r><w:delText>30</w:delText></w:r></w:del><w:ins><w:r><w:t>60</w:t></w:r></w:ins><w:r w:rsidR="00AB12CD"><w:t> days.</w:t></w:r>'
```
### Tracked changes workflow
1. **Get markdown representation**: Convert document to markdown with tracked changes preserved:
```bash
pandoc --track-changes=all path-to-file.docx -o current.md
```
2. **Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:
**Location methods** (for finding changes in XML):
- Section/heading numbers (e.g., "Section 3.2", "Article IV")
- Paragraph identifiers if numbered
- Grep patterns with unique surrounding text
- Document structure (e.g., "first paragraph", "signature block")
- **DO NOT use markdown line numbers** - they don't map to XML structure
**Batch organization** (group 3-10 related changes per batch):
- By section: "Batch 1: Section 2 amendments", "Batch 2: Section 5 updates"
- By type: "Batch 1: Date corrections", "Batch 2: Party name changes"
- By complexity: Start with simple text replacements, then tackle complex structural changes
- Sequential: "Batch 1: Pages 1-3", "Batch 2: Pages 4-6"
3. **Read documentation and unpack**:
- **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Pay special attention to the "Document Library" and "Tracked Change Patterns" sections.
- **Unpack the document**: `python ooxml/scripts/unpack.py <file.docx> <dir>`
- **Note the suggested RSID**: The unpack script will suggest an RSID to use for your tracked changes. Copy this RSID for use in step 4b.
4. **Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:
- Makes debugging easier (smaller batch = easier to isolate errors)
- Allows incremental progress
- Maintains efficiency (batch size of 3-10 changes works well)
**Suggested batch groupings:**
- By document section (e.g., "Section 3 changes", "Definitions", "Termination clause")
- By change type (e.g., "Date changes", "Party name updates", "Legal term replacements")
- By proximity (e.g., "Changes on pages 1-3", "Changes in first half of document")
For each batch of related changes:
**a. Map text to XML**: Grep for text in `word/document.xml` to verify how text is split across `<w:r>` elements.
**b. Create and run script**: Use `get_node` to find nodes, implement changes, then `doc.save()`. See **"Document Library"** section in ooxml.md for patterns.
**Note**: Always grep `word/document.xml` immediately before writing a script to get current line numbers and verify text content. Line numbers change after each script run.
5. **Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:
```bash
python ooxml/scripts/pack.py unpacked reviewed-document.docx
```
6. **Final verification**: Do a comprehensive check of the complete document:
- Convert final document to markdown:
```bash
pandoc --track-changes=all reviewed-document.docx -o verification.md
```
- Verify ALL changes were applied correctly:
```bash
grep "original phrase" verification.md # Should NOT find it
grep "replacement phrase" verification.md # Should find it
```
- Check that no unintended changes were introduced
## Converting Documents to Images
To visually analyze Word documents, convert them to images using a two-step process:
1. **Convert DOCX to PDF**:
```bash
soffice --headless --convert-to pdf document.docx
```
2. **Convert PDF pages to JPEG images**:
```bash
pdftoppm -jpeg -r 150 document.pdf page
```
This creates files like `page-1.jpg`, `page-2.jpg`, etc.
Options:
- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
- `page`: Prefix for output files
Example for specific range:
```bash
pdftoppm -jpeg -r 150 -f 2 -l 5 document.pdf page # Converts only pages 2-5
```
## Code Style Guidelines
**IMPORTANT**: When generating code for DOCX operations:
- Write concise code
- Avoid verbose variable names and redundant operations
- Avoid unnecessary print statements
## Dependencies
Required dependencies (install if not available):
- **pandoc**: `sudo apt-get install pandoc` (for text extraction)
- **docx**: `npm install -g docx` (for creating new documents)
- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
- **defusedxml**: `pip install defusedxml` (for secure XML parsing)Qué la hace eficaz: ofrece un árbol de decisiones claro que dirige a Claude al flujo de trabajo adecuado según el tipo de tarea, usa la revelación progresiva para mantener ligero el archivo principal y solo remite a archivos de implementación detallados cuando es necesario, e incluye ejemplos concretos de lo que hay y no hay que hacer que muestran exactamente cómo implementar patrones complejos, como el control de cambios.
Ejemplo de skill n.º 2: directrices de marca
#name: brand-guidelines
description: Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
license: Complete terms in LICENSE.txt
---
# Anthropic Brand Styling
## Overview
To access Anthropic's official brand identity and style resources, use this skill.
**Keywords**: branding, corporate identity, visual identity, post-processing, styling, brand colors, typography, Anthropic brand, visual formatting, visual design
## Brand Guidelines
### Colors
**Main Colors:**
- Dark: `#141413` - Primary text and dark backgrounds
- Light: `#faf9f5` - Light backgrounds and text on dark
- Mid Gray: `#b0aea5` - Secondary elements
- Light Gray: `#e8e6dc` - Subtle backgrounds
**Accent Colors:**
- Orange: `#d97757` - Primary accent
- Blue: `#6a9bcc` - Secondary accent
- Green: `#788c5d` - Tertiary accent
### Typography
- **Headings**: Poppins (with Arial fallback)
- **Body Text**: Lora (with Georgia fallback)
- **Note**: Fonts should be pre-installed in your environment for best results
## Features
### Smart Font Application
- Applies Poppins font to headings (24pt and larger)
- Applies Lora font to body text
- Automatically falls back to Arial/Georgia if custom fonts unavailable
- Preserves readability across all systems
### Text Styling
- Headings (24pt+): Poppins font
- Body text: Lora font
- Smart color selection based on background
- Preserves text hierarchy and formatting
### Shape and Accent Colors
- Non-text shapes use accent colors
- Cycles through orange, blue, and green accents
- Maintains visual interest while staying on-brand
## Technical Details
### Font Management
- Uses system-installed Poppins and Lora fonts when available
- Provides automatic fallback to Arial (headings) and Georgia (body)
- No font installation required - works with existing system fonts
- For best results, pre-install Poppins and Lora fonts in your environment
### Color Application
- Uses RGB color values for precise brand matching
- Applied via python-pptx's RGBColor class
- Maintains color fidelity across different systemsQué la hace eficaz: ofrece información precisa y aplicable que Claude no tiene de forma inherente (códigos hexadecimales exactos, nombres de fuentes, umbrales de tamaño) con una descripción clara que indica a Claude tanto lo que hace como cuándo activarla.
Qué la hace eficaz: capacidad creativa con límites claros, protección de derechos de autor integrada, andamiaje técnico para quienes no son músicos y estándares de calidad.
Ejemplo de skill n.º 3: skill de diseño de frontend
name: frontend-design
description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
license: Complete terms in LICENSE.txt
---
This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
## Design Thinking
Before coding, understand the context and commit to a BOLD aesthetic direction:
- **Purpose**: What problem does this interface solve? Who uses it?
- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
- **Constraints**: Technical requirements (framework, performance, accessibility).
- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
- Production-grade and functional
- Visually striking and memorable
- Cohesive with a clear aesthetic point-of-view
- Meticulously refined in every detail
## Frontend Aesthetics Guidelines
Focus on:
- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.Qué la hace eficaz: capacidad creativa con límites claros, protección de derechos de autor integrada, andamiaje técnico para quienes no son músicos y estándares de calidad.
Preguntas comunes
¿Cómo escribo descripciones que realmente activen la skill?
Céntrate en las capacidades y en los escenarios, no en palabras clave genéricas. Incluye verbos de acción, tipos de archivo específicos y casos de uso claros. En lugar de "skill de procesamiento de documentos", escribe "extrae tablas de PDF y conviértelas a formato CSV para flujos de trabajo de análisis de datos".
¿Cómo decide Claude qué skills invocar?
Claude evalúa tu solicitud en función de las descripciones de las skills mediante comprensión semántica. No se trata de buscar coincidencias de palabras clave: Claude determina la relevancia según el contexto. Se pueden activar varias skills si abordan diferentes aspectos de tu solicitud.
¿Cuál es el nivel de detalle adecuado para mis descripciones?
Procura crear skills con un único propósito. "Optimización SEO para publicaciones de blog" es lo bastante específica para dar instrucciones concretas y lo bastante amplia para reutilizarse. Demasiado amplia: "Asistente de marketing de contenidos". Demasiado restrictiva: "Añade metadescripciones".
¿Cómo comparto Skills en toda mi organización?
Independientemente del tamaño de tu equipo, te recomendamos crear un repositorio de documentos compartido con las especificaciones de las skills.
Para equipos más pequeños, utiliza un formato de plantilla con nombre, descripción, instrucciones e información de la versión.
Para equipos medianos y grandes, establece un proceso de gobernanza de skills:
- Designa responsables de skills para cada área (finanzas, asuntos legales, marketing)
- Mantén una wiki central o una unidad compartida como biblioteca de skills
- Incluye ejemplos de uso y soluciones a problemas habituales para cada skill
- Versiona tus skills y documenta los cambios en un registro de cambios
- Programa revisiones trimestrales para actualizar o retirar las skills obsoletas
Prácticas recomendadas para equipos de todos los tamaños:
- Documenta el propósito empresarial de cada skill
- Asigna una responsabilidad clara sobre el mantenimiento y las actualizaciones
- Crea materiales de incorporación que muestren a los nuevos miembros del equipo cómo implementar skills compartidas
- Haz un seguimiento de qué skills aportan más valor para priorizar las tareas de mantenimiento
- Usa convenciones de nomenclatura coherentes para que las skills sean fáciles de encontrar
Los clientes Enterprise pueden colaborar con el equipo de éxito del cliente de Anthropic para explorar más opciones de implementación y marcos de gobernanza.
¿Cómo depuro las skills?
Prueba la activación y la ejecución por separado. Si las skills no se activan, amplía la descripción y añade casos de uso. Si los resultados son incoherentes, concreta más las instrucciones e incluye pasos de validación. Crea una biblioteca de casos de prueba que cubra el uso normal, los casos límite y las solicitudes fuera de alcance.
¿Cómo comparto Skills en toda mi organización?
En Claude.ai, las Skills son actualmente individuales para cada usuario, aunque pronto estarán disponibles funciones de gestión y uso compartido en toda la organización. Mientras tanto, independientemente del tamaño de tu equipo, te sugerimos crear un repositorio de documentos compartido con las especificaciones de las skills. Esto prepara a tu organización para las próximas funciones y, al mismo tiempo, establece buenas prácticas de gobernanza desde hoy.
Empezar
¿Todo listo para crear con Skills? Aquí te indicamos cómo empezar:
Usuarios de Claude.ai:
- Activa las Skills en Configuración → Funciones
- Crea tu primer proyecto en claude.ai/projects
- Prueba a combinar el conocimiento del proyecto con Skills para tu próxima tarea de análisis
Desarrolladores de API:
- Explora el punto de conexión de Skills en la documentación
- Echa un vistazo a nuestro recetario de skills
Usuarios de Claude Code:
- Instala Skills a través de tiendas de plugins
- Echa un vistazo a nuestro recetario de skills