---
title: 스킬
url: https://platform.claude.com/docs/ko/managed-agents/skills
description: Claude Managed Agents에서 에이전트에 사전 구축된 스킬 또는 커스텀 스킬을 연결하여 도메인별 워크플로를 위한 재사용 가능한 파일시스템 기반 전문 지식을 제공합니다.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

"Skills"(스킬)는 에이전트에 도메인별 전문 지식을 제공하는 재사용 가능한 파일시스템 기반 리소스입니다. 범용 에이전트를 전문가로 바꿔 주는 워크플로, 컨텍스트, 모범 사례가 여기에 해당합니다. 추가하는 각 스킬은 모델이 스킬을 사용하는 데 도움이 되는 지침과 메타데이터를 추가하므로 세션의 "context window"(컨텍스트 윈도우)에 약간의 비용을 발생시킵니다. 자세한 내용은 [Agent Skills](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/overview) 개요에서 알아보세요.

스킬은 두 가지 방식으로 에이전트에 전달됩니다. 에이전트의 `skills` (csharp, go: `Skills`) 배열을 통해 연결하거나, 세션에 마운트된 [GitHub 리포지토리에서 로드](https://platform.claude.com/docs/ko/managed-agents/skills#load-skills-from-a-github-repository)할 수 있습니다. 연결된 스킬에는 두 가지 유형이 있습니다. 모든 스킬은 동일한 방식으로 작동합니다. 즉, 작업과 관련이 있을 때 에이전트가 자동으로 호출합니다.

* **사전 구축된 Anthropic 스킬:** PowerPoint, Excel, Word, PDF 처리(`pptx`, `xlsx`, `docx`, `pdf`)와 같은 일반적인 문서 작업.
* **커스텀 스킬:** 직접 작성하여 워크스페이스에 업로드하는 스킬.

커스텀 스킬을 작성하는 방법을 알아보려면 [Agent Skills](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/overview) 및 [스킬 작성 모범 사례](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/best-practices)를 참조하세요. 커스텀 스킬을 워크스페이스에 업로드하려면 [커스텀 스킬 만들기](https://platform.claude.com/docs/ko/managed-agents/skills#create-a-custom-skill)를 참조하세요.

## 커스텀 스킬 만들기

커스텀 스킬은 `SKILL.md` 파일과 지원 파일을 포함하는 디렉터리로, zip 아카이브 또는 개별 파일로 워크스페이스에 업로드됩니다. 스킬을 생성하면 에이전트에 연결할 때 참조하는 `skill_*` ID가 반환됩니다. Anthropic 사전 구축 스킬은 모든 워크스페이스에서 이미 사용할 수 있으며 이 단계가 필요하지 않습니다. 사전 구축된 스킬만 사용하려면 [에이전트에 스킬 연결하기](https://platform.claude.com/docs/ko/managed-agents/skills#attach-skills-to-an-agent)로 건너뛰세요.

이 예제에서는 선택 사항인 `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) 필드를 생략하므로, 스킬의 표시 이름은 `SKILL.md`의 `name` 필드에서 파생됩니다. 명시적인 `display_name` (java, php: `displayName`; csharp, go: `DisplayName`)은 최대 255자까지 가능하며 워크스페이스 내에서 고유할 필요는 없습니다.

<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/ko/cli-sdks-libraries/cli/apply)는 `skills/pr-summary` 디렉터리를 업로드하고, 새 스킬의 ID를 출력하며, 이를 `claude-lock.json`에 기록합니다. 다음 `ant apply`가 두 번째 스킬을 생성하는 대신 수정 사항을 새 버전으로 업로드하도록 `claude-lock.json`을 커밋하세요.
  </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>

커스텀 스킬을 나열, 조회, 삭제하고 버전을 관리하려면 [커스텀 스킬 관리](https://platform.claude.com/docs/ko/build-with-claude/skills-guide#managing-custom-skills)를 참조하세요. 전체 요청 및 응답 스키마는 [Create Skill API 레퍼런스](https://platform.claude.com/docs/ko/api/skills/create)를 참조하세요. 스킬 번들은 [Files API](https://platform.claude.com/docs/ko/build-with-claude/files)를 통하지 않고 Skills API에 직접 업로드됩니다.

## 에이전트에 스킬 연결하기

에이전트를 생성할 때 스킬을 연결합니다. 각 [세션](https://platform.claude.com/docs/ko/managed-agents/sessions)은 최대 500개의 스킬을 지원하며, 이는 세션 내 모든 에이전트에 걸쳐 중복을 제거한 집합으로 계산됩니다([멀티에이전트 오케스트레이션](https://platform.claude.com/docs/ko/managed-agents/multiagent-orchestration) 참조).

<Note>
  더 많은 스킬을 마운트하면 세션의 샌드박스가 시작되는 데 걸리는 시간이 늘어납니다. 각 에이전트가 작업에 필요한 스킬만 연결하세요.
</Note>

`skills` (csharp, go: `Skills`) 배열의 각 항목은 다음 필드를 사용합니다.

| 필드                                                                  | 설명                                                                                                                                                                                              |
| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` (csharp, go: `Type`)                                         | 사전 구축된 스킬의 경우 `anthropic`, 워크스페이스에서 작성한 스킬의 경우 `custom`입니다.                                                                                                                                     |
| `skill_id` (java: `skillId`; php: `skillID`; csharp, go: `SkillID`) | 스킬 식별자입니다. Anthropic 스킬의 경우 짧은 이름(예: `xlsx`)을 사용합니다. 커스텀 스킬의 경우 생성 시 반환된 `skill_*` ID를 사용합니다([커스텀 스킬 만들기](https://platform.claude.com/docs/ko/managed-agents/skills#create-a-custom-skill) 참조). |
| `version` (csharp, go: `Version`)                                   | 특정 버전으로 고정하거나 `latest`를 사용합니다. 선택 사항입니다. 생략하면 기본값은 `latest`입니다. Anthropic 스킬과 커스텀 스킬 모두에 적용됩니다.                                                                                                 |

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

## GitHub 리포지토리에서 스킬 로드하기

스킬은 코드베이스에 둘 수도 있습니다. 세션이 [`github_repository` 리소스](https://platform.claude.com/docs/ko/managed-agents/github)를 통해 리포지토리를 마운트하면, 세션 시작 시 리포지토리 루트의 `.claude/skills` 디렉터리가 스캔되고, 그곳에서 발견된 각 스킬을 에이전트가 사용할 수 있게 됩니다. 업로드나 에이전트의 `skills` (csharp, go: `Skills`) 배열 항목은 필요하지 않습니다. 에이전트는 발견된 각 스킬의 이름, 설명 및 샌드박스 내 경로를 확인하고, 작업이 일치하면 스킬에 포함된 스크립트와 리소스를 포함하여 스킬의 `SKILL.md`를 읽습니다. 검색은 기본적으로 활성화되어 있는 [에이전트 도구 세트](https://platform.claude.com/docs/ko/managed-agents/tools)의 `read` 도구에 의존합니다. `read`가 비활성화된 에이전트는 리포지토리 스킬을 로드하지 않습니다.

<Warning>
  리포지토리 스킬은 에이전트 지침이므로, 마운트된 리포지토리는 에이전트의 신뢰 경계의 일부입니다. 리포지토리에 커밋할 수 있는 누구나(병합된 외부 풀 리퀘스트, 손상된 종속성, 기여자) 스킬을 추가하거나 변경할 수 있으며, 플랫폼은 검토 단계 없이 세션 시작 시 이를 로드하고, `bash` 및 `web_fetch`와 같은 세션 도구는 해당 지침에 실질적인 영향력을 부여합니다. 신뢰하는 리포지토리만 마운트하고, 외부 기여를 받는 리포지토리를 마운트하기 전에 `.claude/skills`를 검토하세요.
</Warning>

<Note>
  리포지토리 스킬 검색은 클라우드 샌드박스에서 실행됩니다. [자체 호스팅 샌드박스](https://platform.claude.com/docs/ko/managed-agents/self-hosted-sandboxes)는 GitHub 리포지토리 리소스를 지원하지 않습니다.
</Note>

검색은 리포지토리 루트에서 한 디렉터리 수준 깊이인 정확히 `.claude/skills/<skill-name>/SKILL.md` 위치에서 스킬을 찾습니다.

* `your-repo/`

  * `.claude/`

    * `skills/`

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

      * `release-process/`

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

  * `src/`

이 레이아웃과 일치하지 않는 위치는 세션 시작 시 검색되지 않습니다.

* `.claude/skills/SKILL.md`: 스킬 디렉터리로 감싸지 않은 `SKILL.md`
* `.claude/skills/tools/code-review/SKILL.md`: 한 디렉터리 수준보다 깊게 중첩됨
* `skills/code-review/SKILL.md`: `.claude` 외부에 있는 `skills` 디렉터리

패키지 하위 디렉터리 내부와 같이 리포지토리의 다른 위치에 있는 `.claude/skills` 디렉터리는 세션 시작 시 알려지지 않습니다. 이러한 스킬은 에이전트가 해당 하위 트리 아래의 파일을 읽을 때 여전히 드러날 수 있습니다.

리포지토리 스킬은 업로드하는 커스텀 스킬과 동일한 `SKILL.md` 형식을 사용합니다. 형식 및 작성 지침은 [Agent Skills](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/overview) 및 [스킬 작성 모범 사례](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/best-practices)를 참조하세요.

리포지토리에서 스킬을 로드하려면 해당 리포지토리를 마운트하는 세션을 생성하세요. 이는 [GitHub 액세스](https://platform.claude.com/docs/ko/managed-agents/github#token-permissions)에 나와 있는 것과 동일한 요청입니다. `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`)는 선택 사항이며 기본값은 `/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>

비공개 리포지토리의 경우, 리소스의 `authorization_token` (java, php: `authorizationToken`; csharp, go: `AuthorizationToken`)이 해당 리포지토리에 대한 액세스 권한을 가지고 있어야 합니다. 이는 모든 리포지토리 마운트에 사용되는 것과 동일한 개인 액세스 토큰 흐름입니다. [GitHub 액세스](https://platform.claude.com/docs/ko/managed-agents/github#token-permissions)를 참조하세요.

검색된 스킬은 리포지토리의 체크아웃된 상태를 따릅니다. 리소스가 `checkout` (csharp, go: `Checkout`) 브랜치나 커밋을 설정한 경우 해당 브랜치나 커밋을, 그렇지 않으면 리포지토리의 기본 브랜치를 따릅니다. 스캔은 세션이 시작될 때 한 번 실행됩니다. 세션 도중에 푸시된 커밋은 반영되지 않으므로, 업데이트된 스킬을 로드하려면 새 세션을 시작하세요.

리포지토리 스킬은 에이전트의 `skills` (csharp, go: `Skills`) 배열을 통해 연결된 스킬과 함께 작동합니다. 리포지토리 스킬이 연결된 스킬 또는 다른 마운트된 리포지토리의 스킬과 이름이 같은 경우, 둘 다 사용할 수 있으며 각각 고유한 경로와 함께 알려집니다.

## 다음 단계

<CardGroup cols={2}>
  <Card title="클라우드 환경 설정" icon="settings" href="https://platform.claude.com/docs/ko/managed-agents/environments">
    세션을 위한 클라우드 샌드박스를 사용자 지정합니다.
  </Card>

  <Card title="API로 Agent Skills 사용하기" icon="code" href="https://platform.claude.com/docs/ko/build-with-claude/skills-guide">
    API를 통해 Agent Skills를 사용하여 Claude의 기능을 확장하는 방법을 알아보세요.
  </Card>

  <Card title="Files API" icon="file" href="https://platform.claude.com/docs/ko/build-with-claude/files">
    파일을 한 번 업로드하고 여러 API 요청에서 참조하세요.
  </Card>

  <Card title="API에서 Agent Skills 시작하기" icon="graduation-cap" href="https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/quickstart">
    Claude API로 10분 이내에 Agent Skills를 사용하여 문서를 만드는 방법을 알아보세요.
  </Card>
</CardGroup>