---
title: Skills
url: https://platform.claude.com/docs/es/managed-agents/skills
description: Adjunta skills predefinidas o personalizadas a un agente en Claude Managed Agents para darle experiencia reutilizable, basada en el sistema de archivos, para flujos de trabajo específicos de un dominio.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Las "skills" (habilidades) son recursos reutilizables, basados en el sistema de archivos, que le dan a tu agente experiencia específica de un dominio: flujos de trabajo, contexto y mejores prácticas que convierten a un agente de propósito general en un especialista. Cada skill que agregas implica un costo modesto en la "context window" (ventana de contexto) de la sesión, ya que añade instrucciones y metadatos que ayudan al modelo a usar la skill. Obtén más información en la descripción general de [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview).

Las skills llegan a tu agente de dos maneras: adjúntalas mediante el array `skills` (csharp, go: `Skills`) del agente, o [cárgalas desde un repositorio de GitHub](https://platform.claude.com/docs/es/managed-agents/skills#load-skills-from-a-github-repository) montado en la sesión. Las skills adjuntas son de dos tipos. Todas las skills funcionan de la misma manera: tu agente las invoca automáticamente cuando son relevantes para la tarea.

* **Skills predefinidas de Anthropic:** Tareas comunes con documentos, como el manejo de PowerPoint, Excel, Word y PDF (`pptx`, `xlsx`, `docx`, `pdf`).
* **Skills personalizadas:** Skills que tú creas y subes a tu espacio de trabajo.

Para aprender a crear skills personalizadas, consulta [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview) y [Mejores prácticas para la creación de skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/best-practices). Para subir una skill personalizada a tu espacio de trabajo, consulta [Crear una skill personalizada](https://platform.claude.com/docs/es/managed-agents/skills#create-a-custom-skill).

## Crear una skill personalizada

Una skill personalizada es un directorio que contiene un archivo `SKILL.md` más cualquier archivo de apoyo, subido a tu espacio de trabajo como un archivo zip o como archivos individuales. Al crear la skill se devuelve el ID `skill_*` al que haces referencia cuando la adjuntas a un agente. Las skills predefinidas de Anthropic ya están disponibles en todos los espacios de trabajo y no requieren este paso. Para usar solo skills predefinidas, salta a [Adjuntar skills a un agente](https://platform.claude.com/docs/es/managed-agents/skills#attach-skills-to-an-agent).

Estos ejemplos omiten el campo opcional `display_name` (java, php: `displayName`; csharp, go: `DisplayName`), por lo que el nombre para mostrar de la skill se deriva del campo `name` en `SKILL.md`. Un `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) explícito puede tener hasta 255 caracteres y no necesita ser único dentro de tu espacio de trabajo.

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/skills" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -F "files[]=@example_skill.zip"
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply skills/pr-summary
    ```

    <File filename="skills/pr-summary/SKILL.md">
      ```markdown
      ---
      name: pr-summary
      description: Summarize a pull request's changes and risks in the team's review format.
      ---

      # PR summary

      List what changed, why, and anything a reviewer should look at closely, in three short sections.
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/apply) sube el directorio `skills/pr-summary`, imprime el ID de la nueva skill y lo registra en `claude-lock.json`. Haz commit de `claude-lock.json` para que el siguiente `ant apply` suba tus ediciones como una nueva versión en lugar de crear una segunda skill.
  </CodeGroupItem>

  ```python Python
  import anthropic
  from anthropic.lib import files_from_dir

  client = anthropic.Anthropic()

  skill = client.skills.create(
      files=files_from_dir("example_skill"),
  )

  print(f"Created skill: {skill.id}")
  print(f"Latest version: {skill.latest_version_id}")
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { toFile } from "@anthropic-ai/sdk";
  import fs from "node:fs";

  const client = new Anthropic();

  const skill = await client.skills.create({
    files: [await toFile(fs.createReadStream("example_skill.zip"), "example_skill.zip")]
  });

  console.log(`Created skill: ${skill.id}`);
  console.log(`Latest version: ${skill.latest_version_id}`);
  ```

  ```csharp C#
  using System.IO;
  using Anthropic;
  using Anthropic.Models.Skills;

  AnthropicClient client = new();

  var parameters = new SkillCreateParams
  {
      Files = [
          new FileStream("example_skill.zip", FileMode.Open, FileAccess.Read)
      ],
  };

  var skill = await client.Skills.Create(parameters);

  Console.WriteLine($"Created skill: {skill.ID}");
  Console.WriteLine($"Latest version: {skill.LatestVersionID}");
  ```

  ```go Go
  package main

  import (
  	"context"
  	"fmt"
  	"io"
  	"log"
  	"os"

  	"github.com/anthropics/anthropic-sdk-go"
  )

  func main() {
  	client := anthropic.NewClient()

  	zipFile, err := os.Open("example_skill.zip")
  	if err != nil {
  		log.Fatal(err)
  	}
  	defer zipFile.Close()

  	skill, err := client.Skills.New(context.TODO(), anthropic.SkillNewParams{
  		Files: []io.Reader{zipFile},
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	fmt.Printf("Created skill: %s\n", skill.ID)
  	fmt.Printf("Latest version: %s\n", skill.LatestVersionID)
  }
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.skills.Skill;
  import com.anthropic.models.skills.SkillCreateParams;
  import java.io.IOException;
  import java.io.InputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;

  void main() throws IOException {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      SkillCreateParams params = SkillCreateParams.builder()
          .addFile(MultipartField.<InputStream>builder()
              .value(Files.newInputStream(Path.of("example_skill.zip")))
              .filename("example_skill.zip")
              .contentType("application/zip")
              .build())
          .build();

      Skill skill = client.skills().create(params);

      IO.println("Created skill: " + skill.id());
      IO.println("Latest version: " + skill.latestVersionId());
  }
  ```

  ```php PHP
  use Anthropic\Client;
  use Anthropic\Core\FileParam;

  $client = new Client();

  $skill = $client->skills->create(
      files: [
          FileParam::fromResource(fopen('example_skill.zip', 'r')),
      ],
  );

  echo "Created skill: {$skill->id}\n";
  echo "Latest version: {$skill->latestVersionID}\n";
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::Client.new

  skill = client.skills.create(
    files: [
      File.open("example_skill.zip", "rb")
    ]
  )

  puts "Created skill: #{skill.id}"
  puts "Latest version: #{skill.latest_version_id}"
  ```
</CodeGroup>

Para listar, recuperar, eliminar y versionar skills personalizadas, consulta [Administración de skills personalizadas](https://platform.claude.com/docs/es/build-with-claude/skills-guide#managing-custom-skills). Para los esquemas completos de solicitud y respuesta, consulta la [referencia de la API Create Skill](https://platform.claude.com/docs/es/api/skills/create). Los paquetes de skills se suben directamente a la Skills API en lugar de a través de la [Files API](https://platform.claude.com/docs/es/build-with-claude/files).

## Adjuntar skills a un agente

Adjunta skills al crear un agente. Cada [sesión](https://platform.claude.com/docs/es/managed-agents/sessions) admite hasta 500 skills, contadas como el conjunto deduplicado entre todos los agentes de la sesión (consulta [Orquestación multiagente](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration)).

<Note>
  Montar más skills aumenta el tiempo que tarda en iniciarse el sandbox de la sesión. Adjunta solo las skills que cada agente necesita para su tarea.
</Note>

Cada entrada del array `skills` (csharp, go: `Skills`) usa los siguientes campos:

| Campo                                                               | Descripción                                                                                                                                                                                                                                                                                             |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` (csharp, go: `Type`)                                         | `anthropic` para skills predefinidas o `custom` para skills creadas en el espacio de trabajo.                                                                                                                                                                                                           |
| `skill_id` (java: `skillId`; php: `skillID`; csharp, go: `SkillID`) | El identificador de la skill. Para skills de Anthropic, usa el nombre corto (por ejemplo, `xlsx`). Para skills personalizadas, usa el ID `skill_*` devuelto en la creación (consulta [Crear una skill personalizada](https://platform.claude.com/docs/es/managed-agents/skills#create-a-custom-skill)). |
| `version` (csharp, go: `Version`)                                   | Fija una versión específica o usa `latest`. Opcional. El valor predeterminado es `latest` cuando se omite. Se aplica tanto a skills de Anthropic como a skills personalizadas.                                                                                                                          |

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  agent=$(curl -sS https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    --json '{
      "name": "Financial Analyst",
      "model": "claude-opus-5-5",
      "system": "You are a financial analysis agent.",
      "skills": [
        {"type": "anthropic", "skill_id": "xlsx"},
        {"type": "custom", "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv", "version": "latest"}
      ]
    }'
  )
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Financial Analyst
      model: claude-opus-5-5
      skills:
        - type: anthropic
          skill_id: xlsx
        - type: custom
          skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
          version: latest
      ---

      You are a financial analysis agent.
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Financial Analyst",
      model="claude-opus-5-5",
      system="You are a financial analysis agent.",
      skills=[
          {
              "type": "anthropic",
              "skill_id": "xlsx",
          },
          {
              "type": "custom",
              "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
              "version": "latest",
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Financial Analyst",
    model: "claude-opus-5-5",
    system: "You are a financial analysis agent.",
    skills: [
      {
        type: "anthropic",
        skill_id: "xlsx"
      },
      {
        type: "custom",
        skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
        version: "latest"
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Financial Analyst",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      System = "You are a financial analysis agent.",
      Skills =
      [
          new BetaManagedAgentsAnthropicSkillParams { Type = BetaManagedAgentsAnthropicSkillParamsType.Anthropic, SkillID = "xlsx" },
          new BetaManagedAgentsCustomSkillParams { Type = BetaManagedAgentsCustomSkillParamsType.Custom, SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv", Version = "latest" },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Financial Analyst",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	System: anthropic.String("You are a financial analysis agent."),
  	Skills: []anthropic.BetaManagedAgentsSkillParamsUnion{
  		{OfAnthropic: &anthropic.BetaManagedAgentsAnthropicSkillParams{
  			SkillID: "xlsx",
  			Type:    anthropic.BetaManagedAgentsAnthropicSkillParamsTypeAnthropic,
  		}},
  		{OfCustom: &anthropic.BetaManagedAgentsCustomSkillParams{
  			SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
  			Type:    anthropic.BetaManagedAgentsCustomSkillParamsTypeCustom,
  			Version: anthropic.String("latest"),
  		}},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = agent
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Financial Analyst")
          .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
          .system("You are a financial analysis agent.")
          .addSkill(
              BetaManagedAgentsAnthropicSkillParams.builder()
                  .type(BetaManagedAgentsAnthropicSkillParams.Type.ANTHROPIC)
                  .skillId("xlsx")
                  .build()
          )
          .addSkill(
              BetaManagedAgentsCustomSkillParams.builder()
                  .type(BetaManagedAgentsCustomSkillParams.Type.CUSTOM)
                  .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
                  .version("latest")
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  $agent = $client->beta->agents->create(
      name: 'Financial Analyst',
      model: 'claude-opus-5-5',
      system: 'You are a financial analysis agent.',
      skills: [
          ['type' => 'anthropic', 'skillID' => 'xlsx'],
          ['type' => 'custom', 'skillID' => 'skill_01AbCdEfGhIjKlMnOpQrStUv', 'version' => 'latest'],
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Financial Analyst",
    model: "claude-opus-5-5",
    system_: "You are a financial analysis agent.",
    skills: [
      {type: "anthropic", skill_id: "xlsx"},
      {type: "custom", skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv", version: "latest"}
    ]
  )
  ```
</CodeGroup>

## Cargar skills desde un repositorio de GitHub

Las skills también pueden vivir en tu base de código. Cuando una sesión monta un repositorio mediante el [recurso `github_repository`](https://platform.claude.com/docs/es/managed-agents/github), el directorio `.claude/skills` de la raíz del repositorio se escanea al iniciar la sesión, y cada skill que se encuentra allí queda disponible para el agente. No se requiere ninguna subida ni ninguna entrada en el array `skills` (csharp, go: `Skills`) del agente. El agente ve el nombre, la descripción y la ruta en el sandbox de cada skill descubierta, y lee el `SKILL.md` de la skill cuando una tarea coincide, incluidos los scripts y recursos que incluya la skill. El descubrimiento depende de la herramienta `read` del agente, del [conjunto de herramientas del agente](https://platform.claude.com/docs/es/managed-agents/tools), que está habilitada de forma predeterminada; un agente con `read` deshabilitada no carga skills del repositorio.

<Warning>
  Las skills del repositorio son instrucciones para el agente, por lo que un repositorio montado forma parte del límite de confianza de tu agente. Cualquiera que pueda hacer commits en el repositorio (un pull request externo fusionado, una dependencia comprometida, un colaborador) puede agregar o cambiar una skill, la plataforma la carga al inicio de la sesión sin un paso de revisión, y las herramientas de la sesión como `bash` y `web_fetch` les dan a esas instrucciones un alcance real. Monta solo repositorios en los que confíes, y revisa `.claude/skills` antes de montar un repositorio que acepte contribuciones externas.
</Warning>

<Note>
  El descubrimiento de skills del repositorio se ejecuta en sandboxes en la nube. Los [sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes) no admiten recursos de repositorio de GitHub.
</Note>

El descubrimiento encuentra skills exactamente en `.claude/skills/<skill-name>/SKILL.md`, a un nivel de directorio de profundidad en la raíz del repositorio:

* `your-repo/`

  * `.claude/`

    * `skills/`

      * `code-review/`
        * `SKILL.md`

      * `release-process/`

        * `SKILL.md`
        * `scripts/`
          * `run_checks.sh`

  * `src/`

Las ubicaciones que no coinciden con esta estructura no se descubren al inicio de la sesión:

* `.claude/skills/SKILL.md`: un `SKILL.md` sin un directorio de skill que lo contenga
* `.claude/skills/tools/code-review/SKILL.md`: anidado a más de un nivel de directorio de profundidad
* `skills/code-review/SKILL.md`: un directorio `skills` fuera de `.claude`

Un directorio `.claude/skills` en otra parte del repositorio, como dentro de un subdirectorio de un paquete, no se anuncia al inicio de la sesión; esas skills aún pueden aparecer cuando el agente lee archivos bajo ese subárbol.

Las skills del repositorio usan el mismo formato `SKILL.md` que las skills personalizadas que subes. Para el formato y la guía de creación, consulta [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview) y [Mejores prácticas para la creación de skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/best-practices).

Para cargar skills desde un repositorio, crea una sesión que lo monte. Es la misma solicitud que se muestra en [Acceso a GitHub](https://platform.claude.com/docs/es/managed-agents/github#token-permissions); `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) es opcional y su valor predeterminado es `/workspace/<repo-name>`:

<CodeGroup>
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d @- <<JSON
  {
    "agent": "$agent_id",
    "environment_id": "$environment_id",
    "resources": [
      {
        "type": "github_repository",
        "url": "https://github.com/org/repo",
        "mount_path": "/workspace/repo",
        "authorization_token": "ghp_your_github_token"
      }
    ]
  }
  JSON
  ```

  ```bash CLI
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" <<'EOF'
  resources:
    - type: github_repository
      url: https://github.com/org/repo
      mount_path: /workspace/repo
      authorization_token: ghp_your_github_token
  EOF
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      resources=[
          {
              "type": "github_repository",
              "url": "https://github.com/org/repo",
              "mount_path": "/workspace/repo",
              "authorization_token": "ghp_your_github_token",
          },
      ],
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    resources: [
      {
        type: "github_repository",
        url: "https://github.com/org/repo",
        mount_path: "/workspace/repo",
        authorization_token: "ghp_your_github_token"
      }
    ]
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Resources =
      [
          new BetaManagedAgentsGitHubRepositoryResourceParams
          {
              Type = "github_repository",
              Url = "https://github.com/org/repo",
              MountPath = "/workspace/repo",
              AuthorizationToken = "ghp_your_github_token",
          },
      ],
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
  	EnvironmentID: environment.ID,
  	Resources: []anthropic.BetaSessionNewParamsResourceUnion{
  		{
  			OfGitHubRepository: &anthropic.BetaManagedAgentsGitHubRepositoryResourceParams{
  				Type:               anthropic.BetaManagedAgentsGitHubRepositoryResourceParamsTypeGitHubRepository,
  				URL:                "https://github.com/org/repo",
  				MountPath:          anthropic.String("/workspace/repo"),
  				AuthorizationToken: "ghp_your_github_token",
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .addResource(BetaManagedAgentsGitHubRepositoryResourceParams.builder()
          .type(BetaManagedAgentsGitHubRepositoryResourceParams.Type.GITHUB_REPOSITORY)
          .url("https://github.com/org/repo")
          .mountPath("/workspace/repo")
          .authorizationToken("ghp_your_github_token")
          .build())
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      resources: [
          [
              'type' => 'github_repository',
              'url' => 'https://github.com/org/repo',
              'mountPath' => '/workspace/repo',
              'authorizationToken' => 'ghp_your_github_token',
          ],
      ],
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    resources: [
      {
        type: "github_repository",
        url: "https://github.com/org/repo",
        mount_path: "/workspace/repo",
        authorization_token: "ghp_your_github_token"
      }
    ]
  )
  ```
</CodeGroup>

Para repositorios privados, el `authorization_token` (java, php: `authorizationToken`; csharp, go: `AuthorizationToken`) del recurso debe tener acceso al repositorio. Es el mismo flujo de token de acceso personal que se usa para cualquier montaje de repositorio; consulta [Acceso a GitHub](https://platform.claude.com/docs/es/managed-agents/github#token-permissions).

Las skills descubiertas siguen el estado del checkout del repositorio: la rama o el commit de `checkout` (csharp, go: `Checkout`) cuando el recurso establece uno; de lo contrario, la rama predeterminada del repositorio. El escaneo se ejecuta una sola vez, cuando se inicia la sesión. Los commits enviados a mitad de la sesión no se detectan; para cargar skills actualizadas, inicia una nueva sesión.

Las skills del repositorio funcionan junto con las skills adjuntas mediante el array `skills` (csharp, go: `Skills`) del agente. Si una skill del repositorio comparte nombre con una skill adjunta, o con una skill de otro repositorio montado, ambas están disponibles; cada una se anuncia con su propia ruta.

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Configuración del entorno en la nube" icon="settings" href="https://platform.claude.com/docs/es/managed-agents/environments">
    Personaliza los sandboxes en la nube para tus sesiones.
  </Card>

  <Card title="Uso de Agent Skills con la API" icon="code" href="https://platform.claude.com/docs/es/build-with-claude/skills-guide">
    Aprende a usar Agent Skills para ampliar las capacidades de Claude a través de la API.
  </Card>

  <Card title="Files API" icon="file" href="https://platform.claude.com/docs/es/build-with-claude/files">
    Sube archivos una vez y haz referencia a ellos en múltiples solicitudes de API.
  </Card>

  <Card title="Comienza con Agent Skills en la API" icon="graduation-cap" href="https://platform.claude.com/docs/es/agents-and-tools/agent-skills/quickstart">
    Aprende a usar Agent Skills para crear documentos con la Claude API en menos de 10 minutos.
  </Card>
</CardGroup>