---
title: Skills
url: https://platform.claude.com/docs/fr/managed-agents/skills
description: Attachez des skills pré-construits ou personnalisés à un agent dans Claude Managed Agents pour lui donner une expertise réutilisable, basée sur le système de fichiers, pour des flux de travail spécifiques à un domaine.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Les « skills » (compétences) sont des ressources réutilisables, basées sur le système de fichiers, qui donnent à votre agent une expertise spécifique à un domaine : des flux de travail, du contexte et des bonnes pratiques qui transforment un agent généraliste en spécialiste. Chaque skill que vous ajoutez entraîne un coût modeste sur la « context window » (fenêtre de contexte) de la session, en ajoutant des instructions et des métadonnées qui aident le modèle à utiliser le skill. Pour en savoir plus, consultez la présentation des [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview).

Les skills parviennent à votre agent de deux manières : attachez-les via le tableau `skills` (csharp, go: `Skills`) de l'agent, ou [chargez-les depuis un dépôt GitHub](https://platform.claude.com/docs/fr/managed-agents/skills#load-skills-from-a-github-repository) monté sur la session. Les skills attachés sont de deux types. Tous les skills fonctionnent de la même manière : votre agent les invoque automatiquement lorsqu'ils sont pertinents pour la tâche.

* **Skills Anthropic pré-construits :** tâches documentaires courantes telles que la gestion de PowerPoint, Excel, Word et PDF (`pptx`, `xlsx`, `docx`, `pdf`).
* **Skills personnalisés :** skills que vous créez et téléversez dans votre espace de travail.

Pour apprendre à créer des skills personnalisés, consultez [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview) et [Bonnes pratiques de création de skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/best-practices). Pour téléverser un skill personnalisé dans votre espace de travail, consultez [Créer un skill personnalisé](https://platform.claude.com/docs/fr/managed-agents/skills#create-a-custom-skill).

## Créer un skill personnalisé

Un skill personnalisé est un répertoire contenant un fichier `SKILL.md` ainsi que tous les fichiers d'accompagnement, téléversé dans votre espace de travail sous forme d'archive zip ou de fichiers individuels. La création du skill renvoie l'ID `skill_*` que vous référencez lorsque vous l'attachez à un agent. Les skills pré-construits d'Anthropic sont déjà disponibles dans chaque espace de travail et ne nécessitent pas cette étape. Pour utiliser uniquement des skills pré-construits, passez directement à [Attacher des skills à un agent](https://platform.claude.com/docs/fr/managed-agents/skills#attach-skills-to-an-agent).

Ces exemples omettent le champ facultatif `display_name` (java, php: `displayName`; csharp, go: `DisplayName`), de sorte que le nom d'affichage du skill est dérivé du champ `name` dans `SKILL.md`. Un `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) explicite peut comporter jusqu'à 255 caractères et n'a pas besoin d'être unique au sein de votre espace de travail.

<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/fr/cli-sdks-libraries/cli/apply) téléverse le répertoire `skills/pr-summary`, affiche l'ID du nouveau skill et l'enregistre dans `claude-lock.json`. Validez (commit) `claude-lock.json` afin que le prochain `ant apply` téléverse vos modifications en tant que nouvelle version au lieu de créer un second 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>

Pour lister, récupérer, supprimer et versionner des skills personnalisés, consultez [Gestion des skills personnalisés](https://platform.claude.com/docs/fr/build-with-claude/skills-guide#managing-custom-skills). Pour les schémas complets de requête et de réponse, consultez la [référence de l'API Create Skill](https://platform.claude.com/docs/fr/api/skills/create). Les bundles de skills sont téléversés directement vers l'API Skills plutôt que via l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files).

## Attacher des skills à un agent

Attachez des skills lors de la création d'un agent. Chaque [session](https://platform.claude.com/docs/fr/managed-agents/sessions) prend en charge jusqu'à 500 skills, comptés comme l'ensemble dédupliqué sur tous les agents de la session (voir [Orchestration multi-agents](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration)).

<Note>
  Monter davantage de skills augmente le temps nécessaire au démarrage du sandbox de la session. N'attachez que les skills dont chaque agent a besoin pour sa tâche.
</Note>

Chaque entrée du tableau `skills` (csharp, go: `Skills`) utilise les champs suivants :

| Champ                                                               | Description                                                                                                                                                                                                                                                                                                    |
| ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` (csharp, go: `Type`)                                         | Soit `anthropic` pour les skills pré-construits, soit `custom` pour les skills créés dans l'espace de travail.                                                                                                                                                                                                 |
| `skill_id` (java: `skillId`; php: `skillID`; csharp, go: `SkillID`) | L'identifiant du skill. Pour les skills Anthropic, utilisez le nom court (par exemple, `xlsx`). Pour les skills personnalisés, utilisez l'ID `skill_*` renvoyé lors de la création (consultez [Créer un skill personnalisé](https://platform.claude.com/docs/fr/managed-agents/skills#create-a-custom-skill)). |
| `version` (csharp, go: `Version`)                                   | Épinglez une version spécifique ou utilisez `latest`. Facultatif. La valeur par défaut est `latest` en cas d'omission. S'applique aux skills Anthropic comme aux skills personnalisés.                                                                                                                         |

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

## Charger des skills depuis un dépôt GitHub

Les skills peuvent également résider dans votre base de code. Lorsqu'une session monte un dépôt via la [ressource `github_repository`](https://platform.claude.com/docs/fr/managed-agents/github), le répertoire `.claude/skills` à la racine du dépôt est analysé au démarrage de la session, et chaque skill qui s'y trouve devient disponible pour l'agent. Aucun téléversement ni aucune entrée dans le tableau `skills` (csharp, go: `Skills`) de l'agent ne sont nécessaires. L'agent voit le nom, la description et le chemin dans le sandbox de chaque skill découvert, et lit le fichier `SKILL.md` du skill lorsqu'une tâche correspond, y compris les scripts et ressources fournis avec le skill. La découverte repose sur l'outil `read` de l'agent issu de l'[ensemble d'outils de l'agent](https://platform.claude.com/docs/fr/managed-agents/tools), qui est activé par défaut ; un agent dont `read` est désactivé ne charge pas les skills du dépôt.

<Warning>
  Les skills de dépôt sont des instructions pour l'agent, de sorte qu'un dépôt monté fait partie du périmètre de confiance de votre agent. Toute personne pouvant effectuer un commit dans le dépôt (une pull request externe fusionnée, une dépendance compromise, un contributeur) peut ajouter ou modifier un skill, la plateforme le charge au démarrage de la session sans étape de revue, et les outils de session tels que `bash` et `web_fetch` donnent à ces instructions une portée réelle. Ne montez que des dépôts auxquels vous faites confiance, et examinez `.claude/skills` avant de monter un dépôt qui accepte des contributions externes.
</Warning>

<Note>
  La découverte des skills de dépôt s'exécute dans les sandbox cloud. Les [sandbox auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes) ne prennent pas en charge les ressources de dépôt GitHub.
</Note>

La découverte trouve les skills exactement à l'emplacement `.claude/skills/<skill-name>/SKILL.md`, à un niveau de répertoire de profondeur à la racine du dépôt :

* `your-repo/`

  * `.claude/`

    * `skills/`

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

      * `release-process/`

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

  * `src/`

Les emplacements qui ne correspondent pas à cette disposition ne sont pas découverts au démarrage de la session :

* `.claude/skills/SKILL.md` : un `SKILL.md` sans répertoire de skill autour de lui
* `.claude/skills/tools/code-review/SKILL.md` : imbriqué à plus d'un niveau de répertoire de profondeur
* `skills/code-review/SKILL.md` : un répertoire `skills` en dehors de `.claude`

Un répertoire `.claude/skills` situé ailleurs dans le dépôt, par exemple à l'intérieur d'un sous-répertoire de package, n'est pas annoncé au démarrage de la session ; ces skills peuvent tout de même apparaître lorsque l'agent lit des fichiers sous cette sous-arborescence.

Les skills de dépôt utilisent le même format `SKILL.md` que les skills personnalisés que vous téléversez. Pour le format et les conseils de création, consultez [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview) et [Bonnes pratiques de création de skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/best-practices).

Pour charger des skills depuis un dépôt, créez une session qui le monte. Il s'agit de la même requête que celle présentée dans [Accéder à GitHub](https://platform.claude.com/docs/fr/managed-agents/github#token-permissions) ; `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) est facultatif et vaut par défaut `/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>

Pour les dépôts privés, le `authorization_token` (java, php: `authorizationToken`; csharp, go: `AuthorizationToken`) de la ressource doit avoir accès au dépôt. Il s'agit du même flux de jeton d'accès personnel que celui utilisé pour tout montage de dépôt ; consultez [Accéder à GitHub](https://platform.claude.com/docs/fr/managed-agents/github#token-permissions).

Les skills découverts suivent l'état extrait du dépôt : la branche ou le commit `checkout` (csharp, go: `Checkout`) lorsque la ressource en définit un, sinon la branche par défaut du dépôt. L'analyse s'exécute une seule fois, au démarrage de la session. Les commits poussés en cours de session ne sont pas pris en compte ; pour charger des skills mis à jour, démarrez une nouvelle session.

Les skills de dépôt fonctionnent conjointement avec les skills attachés via le tableau `skills` (csharp, go: `Skills`) de l'agent. Si un skill de dépôt porte le même nom qu'un skill attaché, ou qu'un skill provenant d'un autre dépôt monté, les deux sont disponibles ; chacun est annoncé avec son propre chemin.

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Configuration de l'environnement cloud" icon="settings" href="https://platform.claude.com/docs/fr/managed-agents/environments">
    Personnalisez les sandbox cloud pour vos sessions.
  </Card>

  <Card title="Utiliser les Agent Skills avec l'API" icon="code" href="https://platform.claude.com/docs/fr/build-with-claude/skills-guide">
    Apprenez à utiliser les Agent Skills pour étendre les capacités de Claude via l'API.
  </Card>

  <Card title="API Files" icon="file" href="https://platform.claude.com/docs/fr/build-with-claude/files">
    Téléversez des fichiers une seule fois et référencez-les dans plusieurs requêtes API.
  </Card>

  <Card title="Démarrer avec les Agent Skills dans l'API" icon="graduation-cap" href="https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/quickstart">
    Apprenez à utiliser les Agent Skills pour créer des documents avec l'API Claude en moins de 10 minutes.
  </Card>
</CardGroup>