---
title: Skills
url: https://platform.claude.com/docs/it/managed-agents/skills
description: Collega skill predefinite o personalizzate a un agente in Claude Managed Agents per fornirgli competenze riutilizzabili, basate sul filesystem, per flussi di lavoro specifici di 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
---

Le skill sono risorse riutilizzabili, basate su filesystem, che forniscono al tuo agente competenze specifiche di un dominio: flussi di lavoro, contesto e best practice che trasformano un agente generico in uno specialista. Ogni skill che aggiungi comporta un costo modesto sulla "context window" (finestra di contesto) della sessione, aggiungendo istruzioni e metadati che aiutano il modello a usare la skill. Scopri di più nella panoramica [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview).

Le skill raggiungono il tuo agente in due modi: collegale tramite l'array `skills` (csharp, go: `Skills`) dell'agente, oppure [caricale da un repository GitHub](https://platform.claude.com/docs/it/managed-agents/skills#load-skills-from-a-github-repository) montato sulla sessione. Le skill collegate sono di due tipi. Tutte le skill funzionano allo stesso modo: il tuo agente le invoca automaticamente quando sono pertinenti all'attività.

* **Skill predefinite di Anthropic:** Attività comuni sui documenti come la gestione di PowerPoint, Excel, Word e PDF (`pptx`, `xlsx`, `docx`, `pdf`).
* **Skill personalizzate:** Skill che crei tu e carichi nel tuo workspace.

Per imparare a creare skill personalizzate, consulta [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview) e [Best practice per la creazione di skill](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/best-practices). Per caricare una skill personalizzata nel tuo workspace, consulta [Crea una skill personalizzata](https://platform.claude.com/docs/it/managed-agents/skills#create-a-custom-skill).

## Crea una skill personalizzata

Una skill personalizzata è una directory contenente un file `SKILL.md` più eventuali file di supporto, caricata nel tuo workspace come archivio zip o come file singoli. La creazione della skill restituisce l'ID `skill_*` a cui fai riferimento quando la colleghi a un agente. Le skill predefinite di Anthropic sono già disponibili in ogni workspace e non richiedono questo passaggio. Per usare solo skill predefinite, passa direttamente a [Collega skill a un agente](https://platform.claude.com/docs/it/managed-agents/skills#attach-skills-to-an-agent).

Questi esempi omettono il campo facoltativo `display_name` (java, php: `displayName`; csharp, go: `DisplayName`), quindi il nome visualizzato della skill viene derivato dal campo `name` in `SKILL.md`. Un `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) esplicito può contenere fino a 255 caratteri e non deve necessariamente essere univoco all'interno del tuo workspace.

<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/it/cli-sdks-libraries/cli/apply) carica la directory `skills/pr-summary`, stampa l'ID della nuova skill e lo registra in `claude-lock.json`. Esegui il commit di `claude-lock.json` in modo che il successivo `ant apply` carichi le tue modifiche come nuova versione invece di creare una seconda 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>

Per elencare, recuperare, eliminare e versionare le skill personalizzate, consulta [Gestione delle skill personalizzate](https://platform.claude.com/docs/it/build-with-claude/skills-guide#managing-custom-skills). Per gli schemi completi di richiesta e risposta, consulta il [riferimento API Create Skill](https://platform.claude.com/docs/it/api/skills/create). I bundle delle skill vengono caricati direttamente nella Skills API anziché tramite la [Files API](https://platform.claude.com/docs/it/build-with-claude/files).

## Collega skill a un agente

Collega le skill quando crei un agente. Ogni [sessione](https://platform.claude.com/docs/it/managed-agents/sessions) supporta fino a 500 skill, conteggiate come l'insieme deduplicato tra tutti gli agenti della sessione (consulta [Orchestrazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration)).

<Note>
  Montare più skill aumenta il tempo necessario all'avvio della sandbox della sessione. Collega solo le skill di cui ogni agente ha bisogno per la propria attività.
</Note>

Ogni voce nell'array `skills` (csharp, go: `Skills`) usa i seguenti campi:

| Campo                                                               | Descrizione                                                                                                                                                                                                                                                                                          |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` (csharp, go: `Type`)                                         | `anthropic` per le skill predefinite oppure `custom` per le skill create nel workspace.                                                                                                                                                                                                              |
| `skill_id` (java: `skillId`; php: `skillID`; csharp, go: `SkillID`) | L'identificatore della skill. Per le skill Anthropic, usa il nome breve (ad esempio, `xlsx`). Per le skill personalizzate, usa l'ID `skill_*` restituito alla creazione (consulta [Crea una skill personalizzata](https://platform.claude.com/docs/it/managed-agents/skills#create-a-custom-skill)). |
| `version` (csharp, go: `Version`)                                   | Fissa una versione specifica oppure usa `latest`. Opzionale. Il valore predefinito è `latest` quando omesso. Si applica sia alle skill Anthropic sia a quelle personalizzate.                                                                                                                        |

<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>

## Carica skill da un repository GitHub

Le skill possono anche risiedere nel tuo codebase. Quando una sessione monta un repository tramite la [risorsa `github_repository`](https://platform.claude.com/docs/it/managed-agents/github), la directory `.claude/skills` nella radice del repository viene analizzata all'avvio della sessione e ogni skill trovata lì diventa disponibile per l'agente. Non sono necessari né un caricamento né una voce nell'array `skills` (csharp, go: `Skills`) dell'agente. L'agente vede il nome, la descrizione e il percorso nella sandbox di ogni skill individuata, e legge il file `SKILL.md` della skill quando un'attività corrisponde, inclusi eventuali script e risorse forniti con la skill. L'individuazione si basa sullo strumento `read` dell'agente incluso nel [toolset dell'agente](https://platform.claude.com/docs/it/managed-agents/tools), abilitato per impostazione predefinita; un agente con `read` disabilitato non carica le skill del repository.

<Warning>
  Le skill del repository sono istruzioni per l'agente, quindi un repository montato fa parte del perimetro di fiducia del tuo agente. Chiunque possa effettuare commit nel repository (una pull request esterna unita, una dipendenza compromessa, un collaboratore) può aggiungere o modificare una skill, la piattaforma la carica all'avvio della sessione senza un passaggio di revisione, e gli strumenti della sessione come `bash` e `web_fetch` danno a quelle istruzioni una portata reale. Monta solo repository di cui ti fidi e rivedi `.claude/skills` prima di montare un repository che accetta contributi esterni.
</Warning>

<Note>
  L'individuazione delle skill del repository viene eseguita nelle sandbox cloud. Le [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes) non supportano le risorse repository GitHub.
</Note>

L'individuazione trova le skill esattamente in `.claude/skills/<skill-name>/SKILL.md`, a un livello di directory di profondità alla radice del repository:

* `your-repo/`

  * `.claude/`

    * `skills/`

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

      * `release-process/`

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

  * `src/`

Le posizioni che non corrispondono a questa struttura non vengono individuate all'avvio della sessione:

* `.claude/skills/SKILL.md`: un `SKILL.md` senza una directory di skill che lo contenga
* `.claude/skills/tools/code-review/SKILL.md`: annidato a più di un livello di directory di profondità
* `skills/code-review/SKILL.md`: una directory `skills` al di fuori di `.claude`

Una directory `.claude/skills` altrove nel repository, ad esempio all'interno di una sottodirectory di un pacchetto, non viene annunciata all'avvio della sessione; quelle skill possono comunque emergere quando l'agente legge file in quel sottoalbero.

Le skill del repository usano lo stesso formato `SKILL.md` delle skill personalizzate che carichi. Per il formato e le indicazioni sulla creazione, consulta [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview) e [Best practice per la creazione di skill](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/best-practices).

Per caricare skill da un repository, crea una sessione che lo monti. Si tratta della stessa richiesta mostrata in [Accesso a GitHub](https://platform.claude.com/docs/it/managed-agents/github#token-permissions); `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) è facoltativo e il valore predefinito è `/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>

Per i repository privati, l'`authorization_token` (java, php: `authorizationToken`; csharp, go: `AuthorizationToken`) della risorsa deve avere accesso al repository. Si tratta dello stesso flusso con personal access token usato per qualsiasi montaggio di repository; consulta [Accesso a GitHub](https://platform.claude.com/docs/it/managed-agents/github#token-permissions).

Le skill individuate seguono lo stato di checkout del repository: il branch o commit di `checkout` (csharp, go: `Checkout`) quando la risorsa ne imposta uno, altrimenti il branch predefinito del repository. L'analisi viene eseguita una sola volta, all'avvio della sessione. I commit inviati durante la sessione non vengono recepiti; per caricare skill aggiornate, avvia una nuova sessione.

Le skill del repository funzionano insieme alle skill collegate tramite l'array `skills` (csharp, go: `Skills`) dell'agente. Se una skill del repository condivide il nome con una skill collegata, o con una skill di un altro repository montato, entrambe sono disponibili; ciascuna viene annunciata con il proprio percorso.

## Passaggi successivi

<CardGroup cols={2}>
  <Card title="Configurazione dell'ambiente cloud" icon="settings" href="https://platform.claude.com/docs/it/managed-agents/environments">
    Personalizza le sandbox cloud per le tue sessioni.
  </Card>

  <Card title="Usare Agent Skills con l'API" icon="code" href="https://platform.claude.com/docs/it/build-with-claude/skills-guide">
    Scopri come usare Agent Skills per estendere le capacità di Claude tramite l'API.
  </Card>

  <Card title="Files API" icon="file" href="https://platform.claude.com/docs/it/build-with-claude/files">
    Carica i file una sola volta e fai riferimento a essi in più richieste API.
  </Card>

  <Card title="Inizia con Agent Skills nell'API" icon="graduation-cap" href="https://platform.claude.com/docs/it/agents-and-tools/agent-skills/quickstart">
    Scopri come usare Agent Skills per creare documenti con la Claude API in meno di 10 minuti.
  </Card>
</CardGroup>