New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Official agent skill

Make Custom Agent

by dotnet in dotnet/efcore

Create custom GitHub Copilot agents. An agent skill from dotnet/efcore.

OfficialMITAuto-check passed

Install Make Custom Agent

skills CLI
$ npx skills add dotnet/efcore --skill make-custom-agent -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install dotnet/efcore make-custom-agent --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/dotnet/efcore.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/make-custom-agent .claude/skills/make-custom-agent && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
make-custom-agent
GitHub stars
15k
Token cost
~2.3k tokens
SKILL.md length
784 words
Files
1
Skills in repo
17
Repo updated
First seen
Licence
MIT

At a glance

Create custom GitHub Copilot agents. An agent skill from dotnet/efcore.

  • Works in 7 steps: Choose the agent type → Create a declarative agent (prompt file) → Configure tools → …
  • Asked to create
  • SKILL.md covers When Not to Use, Workflow, Common Pitfalls and References
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Make Custom Agent is an agent skill from dotnet/efcore, published by the product's own GitHub organization. Create custom GitHub Copilot agents. Use when asked to create, scaffold, or configure a custom agent, declarative agent, or @-invokable chat participant for GitHub Copilot.

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It works with Visual Studio Code and GitHub. The repository describes itself as: EF Core is a modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations. The licence is MIT.

When your agent uses it

  • Asked to create
  • Configure a custom agent
  • Declarative agent
  • @-invokable chat participant for GitHub Copilot

Example prompts

  • “/make-custom-agent”

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Choose the agent type
  2. Create a declarative agent (prompt file)
  3. Configure tools
  4. Add handoffs (optional, VS Code only)
  5. Create an extension-based chat participant (VS Code only)
  6. Create a GitHub App (Copilot Extension) for cross-surface availability (optional)
  7. Validate

What it can do on your machine

Read from SKILL.md and the folder at commit 7adff35. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are yaml, json, typescript and markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.github.com
    • code.visualstudio.com
    • github.com
    • agentskills.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Make Custom Agent loads about 2.3k tokens when it runs. Until then it costs about 48 tokens; SKILL.md has 784 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~48
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from dotnet/efcore at commit 7adff35, republished under its MIT licence (© dotnet). 784 words, ~2,344 tokens.

Download SKILL.mdSave it as .claude/skills/make-custom-agent/SKILL.md (or your agent's skills folder).
name
make-custom-agent
description
Create custom GitHub Copilot agents. Use when asked to create, scaffold, or configure a custom agent, declarative agent, or @-invokable chat participant for GitHub Copilot.

Create Custom Agent

This skill guides you through creating a custom GitHub Copilot agent — an @-invokable chat participant that extends Copilot with domain-specific expertise. Custom agents are distinct from Agent Skills: skills provide reusable instructions loaded on demand, while agents own the full conversational interaction and can orchestrate tools, call APIs, and maintain their own prompt strategies.

When Not to Use

  • Adding reusable, invokable workflows — use Agent Skills (.agents/skills/) instead
  • Adding background coding guidelines — use file-based instructions (.github/instructions/) instead
  • Adding project-wide context for Copilot — use .github/copilot-instructions.md instead
  • Creating reusable prompts — use .prompt.md instead

Workflow

Step 1: Choose the agent type
TypeLocationBest for
Declarative (prompt file).github/agents/<name>.mdSimple prompt-driven cross-surface agents with no code
Extension-based (chat participant)VS Code extension projectFull control, tool calling, VS Code API access
GitHub App (Copilot Extension)Hosted service + GitHub AppCross-surface agents (github.com, VS Code, Visual Studio)

If the agent only needs a scoped system prompt and doesn't require custom code, start with a declarative agent.

Step 2: Create a declarative agent (prompt file)

Declarative agents are Markdown files in .github/agents/. VS Code and GitHub Copilot discover them automatically.

.github/agents/
└── <agent-name>.md        # Agent definition

Template:

markdown
---
name: my-agent
description: A short description of what this agent does and when to use it.
---

# <Agent Title>

You are an expert in <domain>. Your job is to:
- <behavior 1>
- <behavior 2>

## Guidelines

- <guideline 1>
- <guideline 2>

## Workflow

1. <step 1>
2. <step 2>

## Constraints

- <constraint 1>
- <constraint 2>

Supported frontmatter fields:

FieldRequiredDescription
nameYesLowercase, hyphens allowed. Used for @-mention.
descriptionYesWhat the agent does and when to use it. Shown in the participant list.
targetNoTarget environment: vscode or github-copilot (defaults to both)
toolsNoList of allowed tools/tool sets
modelNoLLM name or prioritized array of models
user-invocableNoShow in agents dropdown (default: true)
disable-model-invocationNoPrevent subagent invocation (default: false)
mcp-serversNoMCP server configs for GitHub Copilot target
metadataNoKey-value mapping for additional arbitrary metadata.
argument-hintNoHint text guiding user interaction (VS Code only)
agentsNoList of allowed subagents (* for all, [] for none, VS Code only)
handoffsNoList of next-step agent transitions (VS Code only)

Tips for instructions:

  • Use Markdown links to reference other files
  • Reference tools with #tool:<tool-name> syntax
  • Be specific about agent behavior and constraints
Step 3: Configure tools

Specify which tools the agent can use:

yaml
tools:
  - search              # Built-in tool
  - fetch               # Built-in tool
  - codebase            # Tool set
  - myServer/*          # All tools from MCP server

Common tool patterns:

  • Read-only agents: ['search', 'fetch', 'codebase']
  • Full editing agents: ['*'] or specific editing tools
  • Specialized agents: Cherry-pick specific tools
Step 4: Add handoffs (optional, VS Code only)

Configure transitions to other agents:

yaml
handoffs:
  - label: Start Implementation
    agent: implementation
    prompt: Implement the plan outlined above.
    send: false
    model: GPT-5.2 (copilot)

Handoff fields:

  • label: Button text displayed to user
  • agent: Target agent identifier
  • prompt: Pre-filled prompt for target agent
  • send: Auto-submit prompt (default: false)
  • model: Optional model override for handoff
Step 5: Create an extension-based chat participant (VS Code only)

For full control, implement a VS Code extension with a chat participant:

  1. Define the participant in package.json:
json
"contributes": {
    "chatParticipants": [
        {
            "id": "my-extension.my-agent",
            "name": "my-agent",
            "fullName": "My Agent",
            "description": "Short description shown in chat input",
            "isSticky": false,
            "commands": [
                {
                    "name": "explain",
                    "description": "Explain the selected code"
                }
            ]
        }
    ]
}
  1. Register and implement the request handler in extension.ts:
typescript
export function activate(context: vscode.ExtensionContext) {
    const agent = vscode.chat.createChatParticipant('my-extension.my-agent', handler);
    agent.iconPath = vscode.Uri.joinPath(context.extensionUri, 'icon.png');
}

const handler: vscode.ChatRequestHandler = async (
    request: vscode.ChatRequest,
    context: vscode.ChatContext,
    stream: vscode.ChatResponseStream,
    token: vscode.CancellationToken
) => {
    const model = request.model;
    const messages = [
        vscode.LanguageModelChatMessage.User(request.prompt)
    ];
    const response = await model.sendRequest(messages, {}, token);
    for await (const fragment of response.text) {
        stream.markdown(fragment);
    }
};
  1. Declare the extension dependency in package.json:
json
"extensionDependencies": ["github.copilot-chat"]
  1. Add tool calling (optional)

Agents can invoke language model tools registered by other extensions:

typescript
const tools = vscode.lm.tools.filter(tool => tool.tags.includes('my-domain'));
const result = await chatUtils.sendChatParticipantRequest(request, context, {
    prompt: 'You are an expert in <domain>.',
    tools,
    responseStreamOptions: { stream, references: true, responseText: true }
}, token);
return await result.result;
Show full SKILL.md (321 more words)Show less
Step 6: Create a GitHub App (Copilot Extension) for cross-surface availability (optional)

If the agent should be available on GitHub.com, Visual Studio, JetBrains, and VS Code simultaneously, implement a GitHub App that acts as a Copilot Extension. The app registers a webhook endpoint, receives chat requests, and streams responses back.

Key considerations:

  • The GitHub App must be installed on the user's account or organization
  • Responses are streamed via Server-Sent Events (SSE)
  • Use the GitHub Copilot Extensions documentation for the full integration guide
  • For VS Code-specific features (editor access, file trees, command buttons), prefer an extension-based participant instead
Step 7: Validate

After creating or modifying an agent, verify:

  • name is lowercase, uses hyphens (no spaces), and is unique
  • description clearly describes what the agent does and when to invoke it
  • Frontmatter YAML is valid (no syntax errors)
  • Declarative agent file is in .github/agents/
  • Tools list contains only available tools
  • Extension-based agent: participant ID matches in package.json and createChatParticipant call
  • Agent does not duplicate functionality of built-in agents (@workspace, @vscode, @terminal)
  • Handoff agent names match existing agents
  • Agent instructions don't include secrets, tokens, or internal URLs

Common Pitfalls

PitfallSolution
Agent name conflicts with built-in participantsUse a unique prefix (domain name)
Description is too vagueInclude specific keywords users would naturally say
System prompt is too longKeep instructions to essential behaviors; move reference material to Agent Skills
Agent requires VS Code API but is authored as declarativeSwitch to extension-based participant
Using isSticky: true unnecessarilyOnly set sticky if the agent should persist between turns by default
No extensionDependencies on github.copilot-chatAdd it; otherwise the contribution point may not be available
Agent invoked as subagent unexpectedlySet disable-model-invocation: true
Subagent appears in the dropdownSet user-invocable: false

References

© dotnet, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/make-custom-agent of dotnet/efcore.

Open the folder on GitHubat commit 7adff35

Compare with similar skills

Make Custom Agent next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Make Custom Agent compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Make Custom Agent this skilldotnet/efcore15k—~2.3kAutomated safety check: PassMIT
ReleasePowerShell/vscode-powershell1.9k—~1.1kAutomated safety check: PassMIT
Release Roslynatordotnet/roslynator3.5k—~1kAutomated safety check: PassCustom licence
Promotion Branches E2E Testhardisgroupcom/sfdx-hardis400—~4.7kAutomated safety check: NotesAGPL-3.0
Capture As Gh IssuetwentyTwo/vsc-ext-coding-time-tracker151—~1kAutomated safety check: PassMIT
Unicliolo-dot-io/Uni-CLI273—~3.8kAutomated safety check: NotesApache-2.0

Similar skills

  • Release

    PowerShell/vscode-powershell

    Guide for preparing a release of the PowerShell VS Code extension.

    1.9k GitHub stars~1.1k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed

  • Release Roslynator

    dotnet/roslynator

    Official

    A skill your agent uses when shipping a roslynator release, rolling CHANGELOG.md [Unreleased], updating the VS Code extension changelog, creating a GitHub v release, or optionally tagging cli-v.

    3.5k GitHub stars~1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Promotion Branches E2E Test

    hardisgroupcom/sfdx-hardis

    Runs a full end-to-end test of sfdx-hardis promotion branches and backpromote against real Salesforce orgs and a throwaway repository, then writes a report.

    400 GitHub stars~4.7k tokensUpdated today
    Testing & QAAuto-check: notes

  • Capture As Gh Issue

    twentyTwo/vsc-ext-coding-time-tracker

    Capture the idea, concept, or bug being brainstormed in the current chat and file it as a GitHub issue in the current repository.

    151 GitHub stars~1k tokensUpdated 2 days ago
    Auto-check passed

  • Unicli

    olo-dot-io/Uni-CLI

    Comprehensive guide to Uni-CLI — the open Agent-Computer Interface runtime for real software.

    273 GitHub stars~3.8k tokensUpdated 2 days ago
    Productivity & AutomationAuto-check: notes

  • Release

    signageos/vscode-sops

    Releases the vscode-sops extension end-to-end: determines the next version from the bump history, updates CHANGELOG.md and package.json/package-lock.json, builds via vscode:prepublish, publishes to…

    122 GitHub stars~2.2k tokensUpdated 6 mo ago
    DevelopmentAuto-check: notes

More from dotnet/efcore

All 17 skills in this repo

  • Make Skill

    dotnet/efcore

    Official

    Create and evaluate new Agent Skills for GitHub Copilot. An agent skill from dotnet/efcore.

    15k GitHub stars~2k tokensUpdated today
    Auto-check passed

  • Make GitHub Actions Workflow

    dotnet/efcore

    Official

    Create GitHub Actions workflows for CI, automation, or PR management.

    15k GitHub stars~1.7k tokensUpdated today
    Auto-check passed

  • Make Instructions

    dotnet/efcore

    Official

    Create and evaluate VS Code file-based instructions (.instructions.md files).

    15k GitHub stars~1.3k tokensUpdated today
    Auto-check passed

  • Model Building

    dotnet/efcore

    Official

    Implementation details for EF Core model building. An agent skill from dotnet/efcore.

    15k GitHub stars~1.4k tokensUpdated today
    Auto-check passed

  • Run Apichief

    dotnet/efcore

    Official

    Run ApiChief in the EF Core repo to emit baselines, summaries, deltas, review files, or breaking-change checks.

    15k GitHub stars~1.3k tokensUpdated today
    Auto-check passed

  • Servicing PR

    dotnet/efcore

    Official

    Create EF Core PRs targeting servicing release branches (release/).

    15k GitHub stars~833 tokensUpdated today
    Auto-check passed

Works with

Questions about Make Custom Agent

What does Make Custom Agent do?

Create custom GitHub Copilot agents. An agent skill from dotnet/efcore. Make Custom Agent is an agent skill from dotnet/efcore, published by the product's own GitHub organization. Create custom GitHub Copilot agents.

When should I use Make Custom Agent?

Make Custom Agent fits situations like: asked to create; configure a custom agent; declarative agent; @-invokable chat participant for GitHub Copilot.

How do I install Make Custom Agent in Claude Code?

Run `npx skills add dotnet/efcore --skill make-custom-agent -a claude-code`. Or copy the skill folder (.agents/skills/make-custom-agent in dotnet/efcore) into .claude/skills/make-custom-agent in your project. Claude Code loads it when a task matches its description.

How do I install Make Custom Agent in Codex?

Run `npx skills add dotnet/efcore --skill make-custom-agent -a codex`. Or copy the skill folder (.agents/skills/make-custom-agent in dotnet/efcore) into .agents/skills/make-custom-agent in your project. Codex loads it when a task matches its description.

Can I use Make Custom Agent in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add dotnet/efcore --skill make-custom-agent -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/make-custom-agent, .gemini/skills/make-custom-agent, .github/skills/make-custom-agent and .opencode/skills/make-custom-agent in your project.

What does Make Custom Agent need to run?

SKILL.md names no scripts, command-line tools or credentials: Make Custom Agent is instructions for the agent only.

Does Make Custom Agent access the network?

SKILL.md names 4 domains. As links in the text: docs.github.com, code.visualstudio.com, github.com and agentskills.io. This is read from the text; nothing was executed.

Is Make Custom Agent safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Make Custom Agent use?

Make Custom Agent is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Make Custom Agent use?

About 2.3k tokens (SKILL.md is roughly 9.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Make Custom Agent?

Skills that share tags, products or a category with Make Custom Agent: Release (PowerShell/vscode-powershell, 1.9k stars), Release Roslynator (dotnet/roslynator, 3.5k stars), Promotion Branches E2E Test (hardisgroupcom/sfdx-hardis, 400 stars) and Capture As Gh Issue (twentyTwo/vsc-ext-coding-time-tracker, 151 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Make Custom Agent?

dotnet (a GitHub organization, an official publisher) maintains it in dotnet/efcore, which has 14,800 GitHub stars. The repository holds 17 skills in this directory. The repository was last updated on October 7, 2026.

Source: dotnet/efcore on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.