AI Artifacts (In)Compatibility

AI Artifacts are file-based inputs that define what an AI knows, how it behaves, and what it is allowed to do in a project. They are the primary entities; IDE or tool support is just one way to discover and apply them.

Note: Throughout this article, "Copilot" refers to GitHub Copilot, which is available as an extension in multiple IDEs including Visual Studio Code, JetBrains IDEs, and others. The implementation details described here apply to Copilot across all supported IDEs.

Most modern tools converge on a similar set of artifacts.

Glossary

• Knowledge Artifacts - define what the AI knows: project context, instructions, and prompts
• Capability Artifacts - define what the AI can do: skills, agents, and external tools
• Distribution Artifacts - package and distribute capabilities across projects and teams

Knowledge Artifacts

Knowledge artifacts provide context and instructions to the AI - they define what the model knows about your project, coding standards, and common tasks.

Instructions

Instructions provide persistent context and behavioral guidelines to the AI, automatically applied based on scope. Usually contains project description, coding standards and environment details

Project-wide Instructions

Context injection model: AUTO / GLOBAL (Context is auto-injected into all agent sessions)

Scoped Instructions

Context injection model: AUTO / SCOPED (Context is auto-injected into specific parts of the project)

• Could be applied to specific dirs, files or filetypes.

• Scoped via filesystem hierarchy or glob patterns in frontmatter

• Filesystem-based scoping: Place context files (AGENTS.md, CLAUDE.md) in subdirectories to apply them only to files within that directory and its children. Claude Code automatically pulls CLAUDE.md files from parent directories (for monorepos) and child directories (on demand).

• Pattern-based scoping: Use applyTo glob pattern in frontmatter (for *.instructions.md) to inject instructions only when working with matching files.

Placement:

Docs: AGENTS.md spec | VS Code | Claude Code | Cursor

Action-scoped Instructions

Targeted settings that append instructions to specific Copilot actions.

• Manually wired through settings keys, not file-based
• Applied only at generation time for the relevant feature (commits, reviews, PRs)
• Instructions are injected verbatim into the prompt

Context injection model: SETTINGS-BASED / ACTION-SCOPED

Available settings:

• Commit message generation (github.copilot.chat.commitMessageGeneration.instructions) – commonly used to enforce commit formats, tone, and length (e.g. Conventional Commits).
• Review-on-selection (github.copilot.chat.reviewSelection.instructions) – used to define review rubrics, focus areas, exclusions, and output structure for quick code reviews.
• Pull request title and description generation (github.copilot.chat.pullRequestDescriptionGeneration.instructions) – typically aligned with PR templates, required sections, and stylistic rules.

Docs: VS Code

Commands

Reusable chat requests for recurring development tasks.

• Encode concrete tasks or questions, not behavioral rules
• Must be explicitly invoked via slash commands or chat attachment
• Never applied automatically

Context injection model: USER-initiated (Commands are explicitly invoked by the user via slash commands)

Placement:

Docs: VS Code | Cursor | Claude Code

Capability Artifacts

Capability artifacts extend what the AI can do - they define specialized skills, custom agents with specific roles, and integrations with external tools.

Skills

Conditionally loaded capability bundles providing specialized knowledge.

• Load automatically when agent determines relevance to current task
• Defined by SKILL.md + optional supporting files in a directory
• Inject context only for duration of relevant request

File structure:

SKILL.md consists of:

• YAML frontmatter describing the skill’s purpose and activation criteria
• A Markdown body containing detailed instructions or domain knowledge

Additional files in the same directory may be referenced by the skill.

Scope of application:

When activated, the skill’s contents are injected into the agent’s prompt context for the duration of the relevant request only.

Context injection model: MODEL-DETERMINED / GRANULAR

• Skills are not always active.
• A skill is loaded only when the agent determines it is relevant to the current request.
• Relevance is inferred primarily from metadata in SKILL.md.

Placement:

VS Code supports custom skill locations via chat.agentSkillsLocations setting.

Docs: Skill spec | VS Code | Claude Code

Tools

Built-in capabilities the agent can invoke natively, without any configuration files.

• Available automatically in agent/agentic mode — no MCP setup required
• Each tool has a defined input schema; the model decides when and how to invoke them
• Set is fixed per platform; extend via MCP Servers (see below)

Capability coverage:

* Copilot browser tools are experimental and may change in future releases.

Docs: VS Code | Cursor: terminal | Cursor: search | Cursor: browser | Claude Code

MCP Servers

External tool integrations configured via Model Context Protocol

• Allow AI agents to perform actions outside the language model
• Configured in mcp.json with server connection details

Configuration model:

• MCP servers are declared under a top-level servers object.
• Each server entry specifies connection details such as url or command.
• Servers may expose multiple tools to the agent.

Authentication and inputs:

• Sensitive values are provided via an inputs section.
• Tool authentication is handled by the host environment (e.g. OAuth flows).
• Secrets are not intended to be stored directly in plaintext files.

Development mode:

Optional development configuration may include:

• watch: file globs that trigger server restarts
• debug: debugger attachment settings

Project placement:

• Copilot: Workspace-local configuration: .vscode/mcp.json (VS Code) or IDE-specific location
• Claude Code: Project-level: .mcp.json (can be checked into git for team sharing)
• Claude Code: Global config: available in all projects via global settings

Scope of application:

Configured tools are available to the agent only in tool-enabled or agent execution modes.

Docs: MCP spec | VS Code | Cursor | Claude Code

Custom Agents

Active personas with specialized roles, tools, and instructions.

• Explicitly selected by user. Not automatically active
• Each agent defines behavior, available tools, model preferences
• Can be invoked as subagents programmatically when infer: true

Context injection model: USER-initiated, SUBAGENT

• Custom agents are not automatically active - they must be explicitly selected by the user via agents dropdown in Chat view.
• Unlike project-wide context files, custom agents are active personas rather than passive background context.
• Built-in chat participants (like @workspace, @terminal, @vscode) are IDE-native features, not user-definable.
• Programmatic: used as subagent via APIs when infer: true

Placement:

VS Code supports custom agent file locations via chat.agentFilesLocations setting.

Docs: VS Code

Distribution Artifacts

Plugins

Distributable bundles packaging skills, agents, hooks, and MCP servers for sharing across projects and teams.

• Standalone directories installed from marketplaces or loaded via --plugin-dir
• Skills are namespaced to prevent conflicts: /plugin-name:skill-name
• Complement per-project .claude/ configuration: use plugins when sharing across projects or with the community

Structure (Claude Code):

Docs: Claude Code | VS Code | Cursor

Additional Sources

• Claude Code Best Practices
  • Anthropic's guide to effective agentic coding workflows and best practices for using Claude Code