---
title: Erste Schritte mit Agent Skills in der API
url: https://platform.claude.com/docs/de/agents-and-tools/agent-skills/quickstart
description: Erfahre, wie du Agent Skills verwendest, um mit der Claude API in weniger als 10 Minuten Dokumente zu erstellen.
---

Dieses Tutorial zeigt dir, wie du Agent Skills verwendest, um eine PowerPoint-Präsentation zu erstellen. Du lernst, wie du Skills aktivierst, eine Anfrage stellst und auf die generierte Datei zugreifst.

## Bevor du beginnst

Du benötigst ein [Client-SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) für deine Sprache oder `curl` und `jq` sowie grundlegende Vertrautheit mit dem Stellen von API-Anfragen.

<Steps continues>
  <Step title="Erstelle ein Claude Console-Konto">
    [Registriere dich](https://platform.claude.com/) für ein Claude Console-Konto oder melde dich bei deinem bestehenden Konto an.
  </Step>

  <Step title="Wähle aus, wie du dich authentifizierst">
    Für die lokale Entwicklung wird die Anmeldung über die CLI empfohlen.

    Follow the steps for one of the following options.
  </Step>
</Steps>

**CLI**

<Steps continued>
  <Step title="Installiere die CLI" stepNumber={3}>
    <Tabs noDeepLinks>
      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>

      <Tab title="curl (Linux/WSL)">
        Für Linux-Umgebungen lädst du das Release-Binary direkt herunter.

        ```bash
        VERSION=2.12.0
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        case $(uname -m) in
          x86_64) ARCH=amd64 ;;
          aarch64) ARCH=arm64 ;;
        esac
        curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
          | sudo tar -xz -C /usr/local/bin ant
        ```

        Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

      <Tab title="go install">
        Du kannst die CLI auch aus dem Quellcode mit `go install` installieren, was Go 1.26.10 oder höher erfordert.

        ```bash
        go install github.com/anthropics/anthropic-cli/v2/cmd/ant@latest
        ```

        `go install` legt die Binärdatei in `$(go env GOPATH)/bin` ab. Füge dieses Verzeichnis zu deinem `PATH` hinzu, falls es dort noch nicht enthalten ist:

        ```bash
        export PATH="$PATH:$(go env GOPATH)/bin"
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Melde dich an" stepNumber={4}>
    ```bash
    ant auth login
    ```

    Sobald die Anmeldung abgeschlossen ist, übernehmen die SDKs und die CLI deine Anmeldedaten automatisch.
  </Step>
</Steps>

**API-Key**

<Steps continued>
  <Step title="Erstelle einen API-Key" stepNumber={3}>
    Erstelle einen [API-Key](https://platform.claude.com/settings/keys) in der Claude Console.
  </Step>

  <Step title="Setze die Umgebungsvariable" stepNumber={4}>
    Die SDKs und die CLI lesen deinen Key aus `ANTHROPIC_API_KEY`:

    ```bash
    export ANTHROPIC_API_KEY="your-api-key-here"
    ```
  </Step>
</Steps>

**API-Key**

Um die CLI-Beispiele auszuführen, installiere die CLI:

<Tabs noDeepLinks>
  <Tab title="Homebrew (macOS)">
    ```bash
    brew install anthropics/tap/ant
    ```
  </Tab>

  <Tab title="curl (Linux/WSL)">
    Für Linux-Umgebungen lädst du das Release-Binary direkt herunter.

    ```bash
    VERSION=2.12.0
    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
    case $(uname -m) in
      x86_64) ARCH=amd64 ;;
      aarch64) ARCH=arm64 ;;
    esac
    curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
      | sudo tar -xz -C /usr/local/bin ant
    ```

    Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
  </Tab>

  <Tab title="go install">
    Du kannst die CLI auch aus dem Quellcode mit `go install` installieren, was Go 1.26.10 oder höher erfordert.

    ```bash
    go install github.com/anthropics/anthropic-cli/v2/cmd/ant@latest
    ```

    `go install` legt die Binärdatei in `$(go env GOPATH)/bin` ab. Füge dieses Verzeichnis zu deinem `PATH` hinzu, falls es dort noch nicht enthalten ist:

    ```bash
    export PATH="$PATH:$(go env GOPATH)/bin"
    ```
  </Tab>
</Tabs>

## Überblick über Agent Skills

Vorgefertigte Agent Skills erweitern Claudes Fähigkeiten um spezialisiertes Fachwissen für Aufgaben wie das Erstellen von Dokumenten, das Analysieren von Daten und das Verarbeiten von Dateien. Anthropic stellt die folgenden vorgefertigten Agent Skills in der API bereit:

* **PowerPoint (pptx):** Präsentationen erstellen und bearbeiten
* **Excel (xlsx):** Tabellenkalkulationen erstellen und analysieren
* **Word (docx):** Dokumente erstellen und bearbeiten
* **PDF (pdf):** PDF-Dokumente generieren

<Note>
  Um benutzerdefinierte Skills zu erstellen, sieh dir das [Agent Skills Cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction) an. Dort findest du Beispiele für den Aufbau eigener Skills mit domänenspezifischem Fachwissen.
</Note>

## Schritt 1: Verfügbare Skills auflisten

Prüfe zunächst, welche Skills verfügbar sind. Verwende die Skills API, um alle von Anthropic verwalteten Skills aufzulisten. Das Beispiel ist ein Auszug aus einem durchgehenden Skript, mit etwaigen Imports und der Client-Einrichtung am Anfang:

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  # Von Anthropic verwaltete Skills auflisten
  curl --fail-with-body -sS "https://api.anthropic.com/v1/skills?source=anthropic" \
    -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
    -H "anthropic-version: 2026-10-21"
  ```

  **API-Key**

  ```bash cURL
  # Von Anthropic verwaltete Skills auflisten
  curl --fail-with-body -sS "https://api.anthropic.com/v1/skills?source=anthropic" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21"
  ```

  ```bash CLI
  # Von Anthropic verwaltete Skills auflisten
  ant skills list --source anthropic
  ```

  ```python Python
  # Von Anthropic verwaltete Skills auflisten
  skills = client.skills.list(source="anthropic")

  for skill in skills.data:
      print(f"{skill.id}: {skill.display_name}")
  ```

  ```typescript TypeScript
  // Von Anthropic verwaltete Skills auflisten
  const skills = await client.skills.list({ source: "anthropic" });

  for (const skill of skills.data) {
    console.log(`${skill.id}: ${skill.display_name}`);
  }
  ```

  ```csharp C#
  // Von Anthropic verwaltete Skills auflisten
  var skills = await client.Skills.List(new SkillListParams { Source = "anthropic" });

  foreach (var skill in skills.Items)
  {
      Console.WriteLine($"{skill.ID}: {skill.DisplayName}");
  }
  ```

  ```go Go
  // Von Anthropic verwaltete Skills auflisten
  skills, err := client.Skills.List(ctx, anthropic.SkillListParams{
  	Source: anthropic.String("anthropic"),
  })
  if err != nil {
  	panic(err)
  }

  for _, skill := range skills.Data {
  	fmt.Printf("%s: %s\n", skill.ID, skill.DisplayName)
  }
  ```

  ```java Java
  // Von Anthropic verwaltete Skills auflisten
  SkillListPage skills = client.skills().list(
      SkillListParams.builder()
          .source("anthropic")
          .build()
  );

  for (Skill skill : skills.data()) {
      IO.println(skill.id() + ": " + skill.displayName());
  }
  ```

  ```php PHP
  // Von Anthropic verwaltete Skills auflisten
  $skills = $client->skills->list(source: 'anthropic');

  foreach ($skills->getItems() as $skill) {
      echo "{$skill->id}: {$skill->displayName}\n";
  }
  ```

  ```ruby Ruby
  # Von Anthropic verwaltete Skills auflisten
  skills = client.skills.list(source: "anthropic")

  skills.data.each do |skill|
    puts "#{skill.id}: #{skill.display_name}"
  end
  ```
</CodeGroup>

Du siehst die folgenden Skills: `pptx`, `xlsx`, `docx` und `pdf`.

Diese API gibt die Metadaten jedes Skills zurück: seinen Namen und seine Beschreibung. Claude lädt diese Metadaten beim Start, um zu bestimmen, welche Skills verfügbar sind. Dies ist die erste Stufe der **„progressive disclosure“** (schrittweisen Offenlegung), bei der Claude Skills entdeckt, ohne bereits ihre vollständigen Anweisungen zu laden.

## Schritt 2: Eine Präsentation erstellen

Verwende den PowerPoint-Skill, um eine Präsentation über erneuerbare Energien zu erstellen. Gib Skills über den Parameter `container` in der Messages API an:

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  # Erstelle eine Nachricht mit dem PowerPoint-Skill
  response=$(
    curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
      -H "content-type: application/json" \
      -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
      -H "anthropic-version: 2026-10-21" \
      -d '{
        "model": "claude-opus-5-5",
        "max_tokens": 16000,
        "container": {
          "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
        },
        "messages": [
          {"role": "user", "content": "Create a presentation about renewable energy with 5 slides"}
        ],
        "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
      }'
  )
  ```

  **API-Key**

  ```bash cURL
  # Erstelle eine Nachricht mit dem PowerPoint-Skill
  response=$(
    curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
      -H "content-type: application/json" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2026-10-21" \
      -d '{
        "model": "claude-opus-5-5",
        "max_tokens": 16000,
        "container": {
          "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
        },
        "messages": [
          {"role": "user", "content": "Create a presentation about renewable energy with 5 slides"}
        ],
        "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
      }'
  )
  ```

  ```bash CLI
  # Eine Nachricht mit dem PowerPoint-Skill erstellen
  response=$(ant messages create --format json <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  container:
    skills:
      - type: anthropic
        skill_id: pptx
        version: latest
  messages:
    - role: user
      content: Create a presentation about renewable energy with 5 slides
  tools:
    - type: code_execution_20260521
      name: code_execution
  YAML
  )
  ```

  ```python Python
  # Erstelle eine Nachricht mit dem PowerPoint-Skill
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      container={
          "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
      },
      messages=[
          {
              "role": "user",
              "content": "Create a presentation about renewable energy with 5 slides",
          }
      ],
      tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
  )

  print(f"stop_reason={response.stop_reason}, blocks={len(response.content)}")
  ```

  ```typescript TypeScript
  // Eine Nachricht mit dem PowerPoint-Skill erstellen
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    container: {
      skills: [{ type: "anthropic", skill_id: "pptx", version: "latest" }]
    },
    messages: [
      {
        role: "user",
        content: "Create a presentation about renewable energy with 5 slides"
      }
    ],
    tools: [{ type: "code_execution_20260521", name: "code_execution" }]
  });

  console.log(`stop_reason=${response.stop_reason}, blocks=${response.content.length}`);
  ```

  ```csharp C#
  // Erstelle eine Nachricht mit dem PowerPoint-Skill
  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Container = new ContainerParams
      {
          Skills =
          [
              new SkillParams
              {
                  Type = SkillParamsType.Anthropic,
                  SkillID = "pptx",
                  Version = "latest",
              },
          ],
      },
      Messages =
      [
          new UserMessageParam
          {
              Content = "Create a presentation about renewable energy with 5 slides",
          },
      ],
      Tools = [new CodeExecutionTool20260521()],
  });

  Console.WriteLine($"stop_reason={response.StopReason?.Raw()}, blocks={response.Content.Count}");
  ```

  ```go Go
  // Erstelle eine Nachricht mit dem PowerPoint-Skill
  response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Container: anthropic.MessageCreateParamsContainerUnion{
  		OfContainers: &anthropic.ContainerParams{
  			Skills: []anthropic.SkillParams{
  				{
  					Type:    anthropic.SkillParamsTypeAnthropic,
  					SkillID: "pptx",
  					Version: anthropic.String("latest"),
  				},
  			},
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("Create a presentation about renewable energy with 5 slides"),
  		),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{}},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("stop_reason=%s, blocks=%d\n", response.StopReason, len(response.Content))
  ```

  ```java Java
  // Erstelle eine Nachricht mit dem PowerPoint-Skill
  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000)
          .container(
              ContainerParams.builder()
                  .addSkill(
                      SkillParams.builder()
                          .type(SkillParams.Type.ANTHROPIC)
                          .skillId("pptx")
                          .version("latest")
                          .build()
                  )
                  .build()
          )
          .addUserMessage("Create a presentation about renewable energy with 5 slides")
          .addTool(CodeExecutionTool20260521.builder().build())
          .build()
  );

  IO.println(
      "stop_reason=" + response.stopReason().orElse(null)
          + ", blocks=" + response.content().size()
  );
  ```

  ```php PHP
  // Eine Nachricht mit dem PowerPoint-Skill erstellen
  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 16000,
      container: [
          'skills' => [['type' => 'anthropic', 'skillID' => 'pptx', 'version' => 'latest']],
      ],
      messages: [
          [
              'role' => 'user',
              'content' => 'Create a presentation about renewable energy with 5 slides',
          ],
      ],
      tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
  );

  printf("stop_reason=%s, blocks=%d\n", $response->stopReason, count($response->content));
  ```

  ```ruby Ruby
  # Erstelle eine Nachricht mit dem PowerPoint-Skill
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16_000,
    container: {
      skills: [{type: "anthropic", skill_id: "pptx", version: "latest"}]
    },
    messages: [
      {
        role: "user",
        content: "Create a presentation about renewable energy with 5 slides"
      }
    ],
    tools: [{type: "code_execution_20260521", name: "code_execution"}]
  )

  puts "stop_reason=#{response.stop_reason}, blocks=#{response.content.length}"
  ```
</CodeGroup>

Die Anfrage enthält die folgenden Bestandteile:

* **`model`:** Ein [Modell, das das Code-Ausführungstool unterstützt](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#availability-feature-support)
* **`container.skills`:** Gibt an, welche Skills Claude verwenden kann
* **`type: "anthropic"`:** Zeigt an, dass es sich um einen von Anthropic verwalteten Skill handelt
* **`skill_id: "pptx"`:** Die Kennung des PowerPoint-Skills
* **`version: "latest"`:** Die Skill-Version, festgelegt auf die zuletzt veröffentlichte
* **`tools`:** Aktiviert die Code-Ausführung (für Skills erforderlich)

<Note>
  Die Beispiele verwenden die Tool-Version `code_execution_20260521`, und der Code in Schritt 3 parst die Ergebnistypen, die aktuelle Tool-Versionen zurückgeben. Skills funktionieren auch mit anderen Versionen des [Code-Ausführungstools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool) wie `code_execution_20250825`: Jede aktuelle Version des Code-Ausführungstools erfüllt die Anforderung für Skills. Wenn du eine andere Version verwendest, nutze den Tool-`type`, der auf der Seite zum Code-Ausführungstool aufgeführt ist.
</Note>

Wenn du diese Anfrage stellst, ordnet Claude deine Aufgabe automatisch dem passenden Skill zu. Da du nach einer Präsentation gefragt hast, stellt Claude fest, dass der PowerPoint-Skill relevant ist, und lädt dessen vollständige Anweisungen: die zweite Stufe der schrittweisen Offenlegung. Anschließend führt Claude den Code des Skills aus, um deine Präsentation zu erstellen.

## Schritt 3: Die erstellte Datei herunterladen

Die Präsentation wurde im Code-Ausführungscontainer erstellt und als Datei gespeichert. Die `response` aus Schritt 2 enthält eine Dateireferenz mit einer Datei-ID. Extrahiere die Datei-ID und lade die Datei mit der Files API herunter. Das Beispiel speichert sie im temporären Verzeichnis deines Systems:

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  # Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  # sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  # Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  file_id=$(jq -r '
    last(
      .content[]
      | select(.type == "bash_code_execution_tool_result")
      | .content
      | select(.type == "bash_code_execution_result")
      | .content[].file_id
    ) // empty
  ' <<<"$response")

  if [[ -n "$file_id" ]]; then
    # Lade die Datei herunter und speichere sie
    curl --fail-with-body -sS "https://api.anthropic.com/v1/files/$file_id/content" \
      -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
      -H "anthropic-version: 2026-10-21" \
      -o "${TMPDIR:-/tmp}/renewable_energy.pptx"
  fi
  ```

  **API-Key**

  ```bash cURL
  # Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  # sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  # Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  file_id=$(jq -r '
    last(
      .content[]
      | select(.type == "bash_code_execution_tool_result")
      | .content
      | select(.type == "bash_code_execution_result")
      | .content[].file_id
    ) // empty
  ' <<<"$response")

  if [[ -n "$file_id" ]]; then
    # Lade die Datei herunter und speichere sie
    curl --fail-with-body -sS "https://api.anthropic.com/v1/files/$file_id/content" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2026-10-21" \
      -o "${TMPDIR:-/tmp}/renewable_energy.pptx"
  fi
  ```

  ```bash CLI
  # Die Datei-ID extrahieren. Das Code-Ausführungstool führt den Code des Skills über
  # sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  # Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  file_id=$(jq -r '
    last(
      .content[]
      | select(.type == "bash_code_execution_tool_result")
      | .content
      | select(.type == "bash_code_execution_result")
      | .content[].file_id
    ) // empty
  ' <<<"$response")

  if [[ -n "$file_id" ]]; then
    # Die Datei herunterladen und speichern
    ant files download \
      --file-id "$file_id" \
      --output "${TMPDIR:-/tmp}/renewable_energy.pptx"
  fi
  ```

  ```python Python
  # Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  # sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  # Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  file_id = None
  for block in response.content:
      if block.type == "bash_code_execution_tool_result":
          if block.content.type == "bash_code_execution_result":
              for output in block.content.content:
                  file_id = output.file_id

  if file_id:
      # Lade die Datei herunter und speichere sie
      output_path = Path(tempfile.gettempdir()) / "renewable_energy.pptx"
      file_content = client.files.download(file_id=file_id)
      file_content.write_to_file(output_path)
      print(f"Presentation saved to {output_path}")
  ```

  ```typescript TypeScript
  // Die Datei-ID extrahieren. Das Code-Ausführungstool führt den Code des Skills über
  // sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  // Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  let fileId: string | undefined;
  for (const block of response.content) {
    if (
      block.type === "bash_code_execution_tool_result" &&
      block.content.type === "bash_code_execution_result"
    ) {
      for (const output of block.content.content) {
        fileId = output.file_id;
      }
    }
  }

  if (fileId) {
    // Die Datei herunterladen und speichern
    const outputPath = path.join(os.tmpdir(), "renewable_energy.pptx");
    const fileContent = await client.files.download(fileId);
    await fs.writeFile(outputPath, Buffer.from(await fileContent.arrayBuffer()));
    console.log(`Presentation saved to ${outputPath}`);
  }
  ```

  ```csharp C#
  // Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  // sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  // Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  string? fileId = null;
  foreach (var block in response.Content)
  {
      if (block.TryPickBashCodeExecutionToolResult(out var bashResult)
          && bashResult.Content.TryPickBashCodeExecutionResultBlock(out var bashResultBlock))
      {
          foreach (var output in bashResultBlock.Content)
          {
              fileId = output.FileID;
          }
      }
  }

  if (fileId is not null)
  {
      // Lade die Datei herunter und speichere sie
      var outputPath = Path.Combine(Path.GetTempPath(), "renewable_energy.pptx");
      using var download = await client.Files.Download(fileId);
      await using var source = await download.ReadAsStream();
      await using var destination = File.Create(outputPath);
      await source.CopyToAsync(destination);
      Console.WriteLine($"Presentation saved to {outputPath}");
  }
  ```

  ```go Go
  // Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  // sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  // Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  var fileID string
  for _, block := range response.Content {
  	switch result := block.AsAny().(type) {
  	case anthropic.BashCodeExecutionToolResultBlock:
  		if result.Content.Type == "bash_code_execution_result" {
  			for _, output := range result.Content.Content {
  				fileID = output.FileID
  			}
  		}
  	}
  }

  if fileID != "" {
  	// Lade die Datei herunter und speichere sie
  	outputPath := filepath.Join(os.TempDir(), "renewable_energy.pptx")
  	fileContent, err := client.Files.Download(ctx, fileID, anthropic.FileDownloadParams{})
  	if err != nil {
  		panic(err)
  	}
  	defer fileContent.Body.Close()
  	outFile, err := os.Create(outputPath)
  	if err != nil {
  		panic(err)
  	}
  	defer outFile.Close()
  	if _, err := io.Copy(outFile, fileContent.Body); err != nil {
  		panic(err)
  	}
  	fmt.Printf("Presentation saved to %s\n", outputPath)
  }
  ```

  ```java Java
  // Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  // sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  // Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  String fileId = null;
  for (ContentBlock block : response.content()) {
      if (block.isBashCodeExecutionToolResult()) {
          var content = block.asBashCodeExecutionToolResult().content();
          if (content.isBashCodeExecutionResultBlock()) {
              for (var output : content.asBashCodeExecutionResultBlock().content()) {
                  fileId = output.fileId();
              }
          }
      }
  }

  if (fileId != null) {
      // Lade die Datei herunter und speichere sie
      Path outputPath = Files.createTempFile("renewable_energy", ".pptx");
      try (HttpResponse fileContent = client.files().download(fileId)) {
          Files.copy(fileContent.body(), outputPath, StandardCopyOption.REPLACE_EXISTING);
      }
      IO.println("Presentation saved to " + outputPath);
  }
  ```

  ```php PHP
  // Datei-ID extrahieren. Das Code-Ausführungstool führt den Code des Skills über
  // sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  // Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  $fileId = null;
  foreach ($response->content as $block) {
      if ($block->type !== 'bash_code_execution_tool_result') {
          continue;
      }
      $resultBlock = $block->content;
      if ($resultBlock->type !== 'bash_code_execution_result') {
          continue;
      }
      foreach ($resultBlock->content as $output) {
          $fileId = $output->fileID;
      }
  }

  if ($fileId !== null) {
      // Datei herunterladen und speichern
      $outputPath = sys_get_temp_dir() . '/renewable_energy.pptx';
      $fileContent = $client->files->download($fileId);
      file_put_contents($outputPath, $fileContent);
      echo "Presentation saved to {$outputPath}\n";
  }
  ```

  ```ruby Ruby
  # Extrahiere die Datei-ID. Das Code-Ausführungstool führt den Code des Skills über
  # sein Bash-Sub-Tool aus, und erzeugte Dateien erscheinen als bash_code_execution_output-
  # Einträge innerhalb des bash_code_execution_tool_result-Blocks.
  file_id = nil
  response.content.each do |block|
    next unless block.type == :bash_code_execution_tool_result

    if block.content[:type].to_s == "bash_code_execution_result"
      Array(block.content[:content]).each { |output| file_id = output[:file_id] }
    end
  end

  if file_id
    # Lade die Datei herunter und speichere sie
    output_path = File.join(Dir.tmpdir, "renewable_energy.pptx")
    file_content = client.files.download(file_id)
    File.binwrite(output_path, file_content.read)
    puts "Presentation saved to #{output_path}"
  end
  ```
</CodeGroup>

<Note>
  Vollständige Details zur Arbeit mit generierten Dateien findest du unter [Generierte Dateien abrufen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#retrieve-generated-files) in der Dokumentation zum Code-Ausführungstool.
</Note>

## Weitere Beispiele ausprobieren

Probiere diese Varianten aus:

### Eine Tabellenkalkulation erstellen

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Create a quarterly sales tracking spreadsheet with sample data"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  **API-Key**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Create a quarterly sales tracking spreadsheet with sample data"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  container:
    skills:
      - type: anthropic
        skill_id: xlsx
        version: latest
  messages:
    - role: user
      content: Create a quarterly sales tracking spreadsheet with sample data
  tools:
    - type: code_execution_20260521
      name: code_execution
  YAML
  ```

  ```python Python
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      container={
          "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
      },
      messages=[
          {
              "role": "user",
              "content": "Create a quarterly sales tracking spreadsheet with sample data",
          }
      ],
      tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
  )
  ```

  ```typescript TypeScript
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    container: {
      skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
    },
    messages: [
      {
        role: "user",
        content: "Create a quarterly sales tracking spreadsheet with sample data"
      }
    ],
    tools: [{ type: "code_execution_20260521", name: "code_execution" }]
  });
  ```

  ```csharp C#
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 16000,
          Container = new ContainerParams
          {
              Skills =
              [
                  new SkillParams
                  {
                      Type = SkillParamsType.Anthropic,
                      SkillID = "xlsx",
                      Version = "latest",
                  },
              ],
          },
          Messages =
          [
              new UserMessageParam
              {
                  Content = "Create a quarterly sales tracking spreadsheet with sample data",
              },
          ],
          Tools = [new CodeExecutionTool20260521()],
      }
  );
  ```

  ```go Go
  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Container: anthropic.MessageCreateParamsContainerUnion{
  		OfContainers: &anthropic.ContainerParams{
  			Skills: []anthropic.SkillParams{
  				{
  					Type:    anthropic.SkillParamsTypeAnthropic,
  					SkillID: "xlsx",
  					Version: anthropic.String("latest"),
  				},
  			},
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a quarterly sales tracking spreadsheet with sample data")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{
  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(CLAUDE_OPUS_5_5)
          .maxTokens(16000)
          .container(
              ContainerParams.builder()
                  .addSkill(
                      SkillParams.builder()
                          .type(ANTHROPIC)
                          .skillId("xlsx")
                          .version("latest")
                          .build()
                  )
                  .build()
          )
          .addUserMessage("Create a quarterly sales tracking spreadsheet with sample data")
          .addTool(CodeExecutionTool20260521.builder().build())
          .build()
  );

  ```

  ```php PHP
  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 16000,
      container: [
          'skills' => [
              ['type' => 'anthropic', 'skillID' => 'xlsx', 'version' => 'latest'],
          ],
      ],
      messages: [
          [
              'role' => 'user',
              'content' => 'Create a quarterly sales tracking spreadsheet with sample data',
          ],
      ],
      tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
  );
  ```

  ```ruby Ruby
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16_000,
    container: {
      skills: [{type: "anthropic", skill_id: "xlsx", version: "latest"}]
    },
    messages: [
      {
        role: "user",
        content: "Create a quarterly sales tracking spreadsheet with sample data"
      }
    ],
    tools: [{type: "code_execution_20260521", name: "code_execution"}]
  )
  ```
</CodeGroup>

### Ein Word-Dokument erstellen

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "docx", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Write a 2-page report on the benefits of renewable energy"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  **API-Key**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "docx", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Write a 2-page report on the benefits of renewable energy"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  container:
    skills:
      - type: anthropic
        skill_id: docx
        version: latest
  messages:
    - role: user
      content: Write a 2-page report on the benefits of renewable energy
  tools:
    - type: code_execution_20260521
      name: code_execution
  YAML
  ```

  ```python Python
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      container={
          "skills": [{"type": "anthropic", "skill_id": "docx", "version": "latest"}]
      },
      messages=[
          {
              "role": "user",
              "content": "Write a 2-page report on the benefits of renewable energy",
          }
      ],
      tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
  )
  ```

  ```typescript TypeScript
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    container: {
      skills: [{ type: "anthropic", skill_id: "docx", version: "latest" }]
    },
    messages: [
      {
        role: "user",
        content: "Write a 2-page report on the benefits of renewable energy"
      }
    ],
    tools: [{ type: "code_execution_20260521", name: "code_execution" }]
  });
  ```

  ```csharp C#
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 16000,
          Container = new ContainerParams
          {
              Skills =
              [
                  new SkillParams
                  {
                      Type = SkillParamsType.Anthropic,
                      SkillID = "docx",
                      Version = "latest",
                  },
              ],
          },
          Messages =
          [
              new UserMessageParam
              {
                  Content = "Write a 2-page report on the benefits of renewable energy",
              },
          ],
          Tools = [new CodeExecutionTool20260521()],
      }
  );
  ```

  ```go Go
  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Container: anthropic.MessageCreateParamsContainerUnion{
  		OfContainers: &anthropic.ContainerParams{
  			Skills: []anthropic.SkillParams{
  				{
  					Type:    anthropic.SkillParamsTypeAnthropic,
  					SkillID: "docx",
  					Version: anthropic.String("latest"),
  				},
  			},
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Write a 2-page report on the benefits of renewable energy")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{
  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(CLAUDE_OPUS_5_5)
          .maxTokens(16000)
          .container(
              ContainerParams.builder()
                  .addSkill(
                      SkillParams.builder()
                          .type(ANTHROPIC)
                          .skillId("docx")
                          .version("latest")
                          .build()
                  )
                  .build()
          )
          .addUserMessage("Write a 2-page report on the benefits of renewable energy")
          .addTool(CodeExecutionTool20260521.builder().build())
          .build()
  );

  ```

  ```php PHP
  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 16000,
      container: [
          'skills' => [
              ['type' => 'anthropic', 'skillID' => 'docx', 'version' => 'latest'],
          ],
      ],
      messages: [
          [
              'role' => 'user',
              'content' => 'Write a 2-page report on the benefits of renewable energy',
          ],
      ],
      tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
  );
  ```

  ```ruby Ruby
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16_000,
    container: {
      skills: [{type: "anthropic", skill_id: "docx", version: "latest"}]
    },
    messages: [
      {
        role: "user",
        content: "Write a 2-page report on the benefits of renewable energy"
      }
    ],
    tools: [{type: "code_execution_20260521", name: "code_execution"}]
  )
  ```
</CodeGroup>

### Ein PDF generieren

<CodeGroup>
  **CLI-Anmeldung**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "pdf", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Generate a PDF invoice template"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  **API-Key**

  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "container": {
        "skills": [{"type": "anthropic", "skill_id": "pdf", "version": "latest"}]
      },
      "messages": [
        {"role": "user", "content": "Generate a PDF invoice template"}
      ],
      "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  container:
    skills:
      - type: anthropic
        skill_id: pdf
        version: latest
  messages:
    - role: user
      content: Generate a PDF invoice template
  tools:
    - type: code_execution_20260521
      name: code_execution
  YAML
  ```

  ```python Python
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      container={
          "skills": [{"type": "anthropic", "skill_id": "pdf", "version": "latest"}]
      },
      messages=[
          {
              "role": "user",
              "content": "Generate a PDF invoice template",
          }
      ],
      tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
  )
  ```

  ```typescript TypeScript
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    container: {
      skills: [{ type: "anthropic", skill_id: "pdf", version: "latest" }]
    },
    messages: [
      {
        role: "user",
        content: "Generate a PDF invoice template"
      }
    ],
    tools: [{ type: "code_execution_20260521", name: "code_execution" }]
  });
  ```

  ```csharp C#
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 16000,
          Container = new ContainerParams
          {
              Skills =
              [
                  new SkillParams
                  {
                      Type = SkillParamsType.Anthropic,
                      SkillID = "pdf",
                      Version = "latest",
                  },
              ],
          },
          Messages = [new UserMessageParam { Content = "Generate a PDF invoice template" }],
          Tools = [new CodeExecutionTool20260521()],
      }
  );
  ```

  ```go Go
  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Container: anthropic.MessageCreateParamsContainerUnion{
  		OfContainers: &anthropic.ContainerParams{
  			Skills: []anthropic.SkillParams{
  				{
  					Type:    anthropic.SkillParamsTypeAnthropic,
  					SkillID: "pdf",
  					Version: anthropic.String("latest"),
  				},
  			},
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Generate a PDF invoice template")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{
  			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(CLAUDE_OPUS_5_5)
          .maxTokens(16000)
          .container(
              ContainerParams.builder()
                  .addSkill(
                      SkillParams.builder()
                          .type(ANTHROPIC)
                          .skillId("pdf")
                          .version("latest")
                          .build()
                  )
                  .build()
          )
          .addUserMessage("Generate a PDF invoice template")
          .addTool(CodeExecutionTool20260521.builder().build())
          .build()
  );

  ```

  ```php PHP
  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 16000,
      container: [
          'skills' => [
              ['type' => 'anthropic', 'skillID' => 'pdf', 'version' => 'latest'],
          ],
      ],
      messages: [
          [
              'role' => 'user',
              'content' => 'Generate a PDF invoice template',
          ],
      ],
      tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
  );
  ```

  ```ruby Ruby
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16_000,
    container: {
      skills: [{type: "anthropic", skill_id: "pdf", version: "latest"}]
    },
    messages: [
      {
        role: "user",
        content: "Generate a PDF invoice template"
      }
    ],
    tools: [{type: "code_execution_20260521", name: "code_execution"}]
  )
  ```
</CodeGroup>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Best Practices für das Erstellen von Skills" icon="edit" href="https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices">
    Erfahre, wie du effektive Skills schreibst, die Claude entdecken und erfolgreich verwenden kann.
  </Card>

  <Card title="Agent Skills mit der API verwenden" icon="book" href="https://platform.claude.com/docs/de/build-with-claude/skills-guide">
    Erfahre, wie du Agent Skills verwendest, um Claudes Fähigkeiten über die API zu erweitern.
  </Card>

  <Card title="Benutzerdefinierte Skills erstellen" icon="code" href="https://platform.claude.com/docs/de/api/skills/create">
    Lade deine eigenen Skills für spezialisierte Aufgaben hoch.
  </Card>

  <Card title="Skills in Claude Code verwenden" icon="terminal" href="https://code.claude.com/docs/de/skills">
    Erfahre mehr über Skills in Claude Code.
  </Card>

  <Card title="Agent Skills Cookbook" icon="book" href="https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction">
    Entdecke Beispiel-Skills und Implementierungsmuster.
  </Card>
</CardGroup>
