---
title: Skills
url: https://platform.claude.com/docs/de/managed-agents/skills
description: Hänge vorgefertigte oder benutzerdefinierte Skills an einen Agenten in Claude Managed Agents an, um ihm wiederverwendbare, dateisystembasierte Expertise für domänenspezifische Workflows zu verleihen.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Skills sind wiederverwendbare, dateisystembasierte Ressourcen, die deinem Agenten domänenspezifische Expertise verleihen: Workflows, Kontext und Best Practices, die einen Allzweck-Agenten in einen Spezialisten verwandeln. Jeder Skill, den du hinzufügst, verursacht geringe Kosten im „context window“ (Kontextfenster) der Session, da Anweisungen und Metadaten hinzugefügt werden, die dem Modell helfen, den Skill zu nutzen. Mehr dazu erfährst du in der Übersicht zu [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview).

Skills gelangen auf zwei Wegen zu deinem Agenten: Hänge sie über das `skills` (csharp, go: `Skills`)-Array des Agenten an, oder [lade sie aus einem GitHub-Repository](https://platform.claude.com/docs/de/managed-agents/skills#load-skills-from-a-github-repository), das in der Session gemountet ist. Angehängte Skills gibt es in zwei Typen. Alle Skills funktionieren auf die gleiche Weise: Dein Agent ruft sie automatisch auf, wenn sie für die Aufgabe relevant sind.

* **Vorgefertigte Anthropic-Skills:** Gängige Dokumentaufgaben wie die Verarbeitung von PowerPoint, Excel, Word und PDF (`pptx`, `xlsx`, `docx`, `pdf`).
* **Benutzerdefinierte Skills:** Skills, die du selbst erstellst und in deinen Workspace hochlädst.

Wie du benutzerdefinierte Skills erstellst, erfährst du unter [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) und [Best Practices für die Skill-Erstellung](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices). Wie du einen benutzerdefinierten Skill in deinen Workspace hochlädst, erfährst du unter [Einen benutzerdefinierten Skill erstellen](https://platform.claude.com/docs/de/managed-agents/skills#create-a-custom-skill).

## Einen benutzerdefinierten Skill erstellen

Ein benutzerdefinierter Skill ist ein Verzeichnis, das eine `SKILL.md`-Datei sowie beliebige unterstützende Dateien enthält und als Zip-Archiv oder als einzelne Dateien in deinen Workspace hochgeladen wird. Beim Erstellen des Skills wird die `skill_*`-ID zurückgegeben, auf die du verweist, wenn du ihn an einen Agenten anhängst. Vorgefertigte Anthropic-Skills sind bereits in jedem Workspace verfügbar und erfordern diesen Schritt nicht. Wenn du nur vorgefertigte Skills verwenden möchtest, springe zu [Skills an einen Agenten anhängen](https://platform.claude.com/docs/de/managed-agents/skills#attach-skills-to-an-agent).

Diese Beispiele lassen das optionale Feld `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) weg, sodass der Anzeigename des Skills aus dem Feld `name` in `SKILL.md` abgeleitet wird. Ein explizites `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) kann bis zu 255 Zeichen lang sein und muss innerhalb deines Workspace nicht eindeutig sein.

<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/de/cli-sdks-libraries/cli/apply) lädt das Verzeichnis `skills/pr-summary` hoch, gibt die ID des neuen Skills aus und speichert sie in `claude-lock.json`. Committe `claude-lock.json`, damit das nächste `ant apply` deine Änderungen als neue Version hochlädt, anstatt einen zweiten Skill zu erstellen.
  </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>

Wie du benutzerdefinierte Skills auflistest, abrufst, löschst und versionierst, erfährst du unter [Benutzerdefinierte Skills verwalten](https://platform.claude.com/docs/de/build-with-claude/skills-guide#managing-custom-skills). Die vollständigen Request- und Response-Schemas findest du in der [API-Referenz zu Create Skill](https://platform.claude.com/docs/de/api/skills/create). Skill-Bundles werden direkt in die Skills API hochgeladen und nicht über die [Files API](https://platform.claude.com/docs/de/build-with-claude/files).

## Skills an einen Agenten anhängen

Hänge Skills beim Erstellen eines Agenten an. Jede [Session](https://platform.claude.com/docs/de/managed-agents/sessions) unterstützt bis zu 500 Skills, gezählt als deduplizierte Menge über alle Agenten in der Session hinweg (siehe [Multiagenten-Orchestrierung](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration)).

<Note>
  Das Mounten weiterer Skills verlängert die Zeit, die die Sandbox der Session zum Starten benötigt. Hänge nur die Skills an, die jeder Agent für seine Aufgabe benötigt.
</Note>

Jeder Eintrag im `skills` (csharp, go: `Skills`)-Array verwendet die folgenden Felder:

| Feld                                                                | Beschreibung                                                                                                                                                                                                                                                                                                          |
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` (csharp, go: `Type`)                                         | Entweder `anthropic` für vorgefertigte Skills oder `custom` für im Workspace erstellte Skills.                                                                                                                                                                                                                        |
| `skill_id` (java: `skillId`; php: `skillID`; csharp, go: `SkillID`) | Die Skill-Kennung. Verwende für Anthropic-Skills den Kurznamen (zum Beispiel `xlsx`). Verwende für benutzerdefinierte Skills die bei der Erstellung zurückgegebene `skill_*`-ID (siehe [Einen benutzerdefinierten Skill erstellen](https://platform.claude.com/docs/de/managed-agents/skills#create-a-custom-skill)). |
| `version` (csharp, go: `Version`)                                   | Auf eine bestimmte Version festlegen oder `latest` verwenden. Optional. Standardmäßig `latest`, wenn weggelassen. Gilt sowohl für Anthropic- als auch für benutzerdefinierte Skills.                                                                                                                                  |

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

## Skills aus einem GitHub-Repository laden

Skills können auch in deiner Codebasis liegen. Wenn eine Session ein Repository über die [`github_repository`-Ressource](https://platform.claude.com/docs/de/managed-agents/github) mountet, wird das Verzeichnis `.claude/skills` im Stammverzeichnis des Repositorys beim Start der Session durchsucht, und jeder dort gefundene Skill wird für den Agenten verfügbar. Es sind weder ein Upload noch ein Eintrag im `skills` (csharp, go: `Skills`)-Array des Agenten erforderlich. Der Agent sieht den Namen, die Beschreibung und den Pfad jedes gefundenen Skills in der Sandbox und liest die `SKILL.md` des Skills, wenn eine Aufgabe passt, einschließlich aller Skripte und Ressourcen, die der Skill mitbringt. Die Erkennung basiert auf dem `read`-Tool des Agenten aus dem [Agent-Toolset](https://platform.claude.com/docs/de/managed-agents/tools), das standardmäßig aktiviert ist; ein Agent mit deaktiviertem `read` lädt keine Repository-Skills.

<Warning>
  Repository-Skills sind Agentenanweisungen, daher ist ein gemountetes Repository Teil der Vertrauensgrenze deines Agenten. Jeder, der in das Repository committen kann (ein gemergter externer Pull Request, eine kompromittierte Abhängigkeit, ein Mitwirkender), kann einen Skill hinzufügen oder ändern; die Plattform lädt ihn beim Start der Session ohne Prüfschritt, und Session-Tools wie `bash` und `web_fetch` verleihen diesen Anweisungen echte Reichweite. Mounte nur Repositorys, denen du vertraust, und prüfe `.claude/skills`, bevor du ein Repository mountest, das externe Beiträge akzeptiert.
</Warning>

<Note>
  Die Erkennung von Repository-Skills läuft in Cloud-Sandboxes. [Selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes) unterstützen keine GitHub-Repository-Ressourcen.
</Note>

Die Erkennung findet Skills genau unter `.claude/skills/<skill-name>/SKILL.md`, eine Verzeichnisebene tief im Stammverzeichnis des Repositorys:

* `your-repo/`

  * `.claude/`

    * `skills/`

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

      * `release-process/`

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

  * `src/`

Speicherorte, die diesem Layout nicht entsprechen, werden beim Start der Session nicht erkannt:

* `.claude/skills/SKILL.md`: eine `SKILL.md` ohne umgebendes Skill-Verzeichnis
* `.claude/skills/tools/code-review/SKILL.md`: mehr als eine Verzeichnisebene tief verschachtelt
* `skills/code-review/SKILL.md`: ein `skills`-Verzeichnis außerhalb von `.claude`

Ein `.claude/skills`-Verzeichnis an anderer Stelle im Repository, etwa innerhalb eines Paket-Unterverzeichnisses, wird beim Start der Session nicht angekündigt; diese Skills können dennoch auftauchen, wenn der Agent Dateien unterhalb dieses Teilbaums liest.

Repository-Skills verwenden dasselbe `SKILL.md`-Format wie die benutzerdefinierten Skills, die du hochlädst. Das Format und Hinweise zur Erstellung findest du unter [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) und [Best Practices für die Skill-Erstellung](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices).

Um Skills aus einem Repository zu laden, erstelle eine Session, die es mountet. Dies ist derselbe Request wie unter [Zugriff auf GitHub](https://platform.claude.com/docs/de/managed-agents/github#token-permissions); `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) ist optional und standardmäßig `/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>

Bei privaten Repositorys muss das `authorization_token` (java, php: `authorizationToken`; csharp, go: `AuthorizationToken`) der Ressource Zugriff auf das Repository haben. Dies ist derselbe Ablauf mit Personal Access Token, der für jeden Repository-Mount verwendet wird; siehe [Zugriff auf GitHub](https://platform.claude.com/docs/de/managed-agents/github#token-permissions).

Gefundene Skills folgen dem ausgecheckten Zustand des Repositorys: dem `checkout` (csharp, go: `Checkout`)-Branch oder -Commit, wenn die Ressource einen festlegt, andernfalls dem Standard-Branch des Repositorys. Der Scan läuft einmal, beim Start der Session. Commits, die während der Session gepusht werden, werden nicht übernommen; um aktualisierte Skills zu laden, starte eine neue Session.

Repository-Skills funktionieren zusammen mit Skills, die über das `skills` (csharp, go: `Skills`)-Array des Agenten angehängt sind. Wenn ein Repository-Skill denselben Namen wie ein angehängter Skill oder wie ein Skill aus einem anderen gemounteten Repository hat, sind beide verfügbar; jeder wird mit seinem eigenen Pfad angekündigt.

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Einrichtung der Cloud-Umgebung" icon="settings" href="https://platform.claude.com/docs/de/managed-agents/environments">
    Passe Cloud-Sandboxes für deine Sessions an.
  </Card>

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

  <Card title="Files API" icon="file" href="https://platform.claude.com/docs/de/build-with-claude/files">
    Lade Dateien einmal hoch und verweise in mehreren API-Requests darauf.
  </Card>

  <Card title="Erste Schritte mit Agent Skills in der API" icon="graduation-cap" href="https://platform.claude.com/docs/de/agents-and-tools/agent-skills/quickstart">
    Erfahre, wie du mit Agent Skills in weniger als 10 Minuten Dokumente mit der Claude API erstellst.
  </Card>
</CardGroup>