Skip to main content

ProConcepts Pro SDK AI Features for GitHub Copilot

Language:      C#
Subject:       Copilot
Contributor:   ArcGIS Pro SDK Team <arcgisprosdk@esri.com>
Organization:  Esri, https://www.esri.com
Date:          11/05/2026  
ArcGIS Pro:    3.8
IDE:           Visual Studio 2026, Visual Studio Code

Abstract

This ProConcept document describes the AI capabilities packaged in arcgis-pro-sdk-copilot, a new ArcGIS Pro SDK repo for use by our 3rd parties, for ArcGIS Pro SDK for .NET development at 3.8. The repo and associated plugin package combines GitHub Copilot repository instructions, specialized agents, reusable skills, deterministic scripts and assets, and curated technical references. Together, these components help developers understand ArcGIS Pro extensibility, select an appropriate extensibility pattern, locate authoritative SDK resources, create supported projects and framework items, and generate or review code against ArcGIS Pro SDK best practices.

The design does not replace the ArcGIS Pro SDK, its API reference, or engineering review. It supplies Copilot with domain-specific context and controlled workflows so that a general-purpose AI assistant can operate more consistently with the ArcGIS Pro SDK and ArcGIS Pro's architecture and threading model.

The ArcGIS Pro SDK extension for VS Code also provides the @prosdkhelper chat participant*, allowing developers to request SDK assistance in natural language through GitHub Copilot. It combines installed SDK templates for efficient, repeatable project and item creation with Copilot's AI capabilities for explanations, workflow code generation, and best-practices review.

*Chat participants are not supported in Visual Studio as of the current version, 18.10, at the time of this writing.

Table of Contents

GitHub Copilot in the Development Workflow

GitHub Copilot is an AI development assistant that can explain code, answer technical questions, propose and edit code, review changes, and perform multi-step tasks with tools. Its capabilities range from assistive interactions, where a developer reviews individual suggestions, to agentic interactions, where Copilot researches a repository, plans work, edits files, runs commands, and validates results.

Copilot is available through multiple development surfaces. These include Visual Studio Code, Visual Studio, JetBrains IDEs, Eclipse, Xcode, GitHub.com, the GitHub Copilot desktop application, and GitHub Copilot CLI. On Windows, Copilot CLI can be run from PowerShell; PowerShell is the command shell hosting the CLI rather than an IDE. GitHub also provides Copilot experiences through its web and mobile applications, although supported customization and agent features vary by client, Copilot plan, product version, and organization policy.

This repository is designed and validated primarily for GitHub Copilot in Visual Studio Code. Support for VS Code is new at Pro 3.8. Some content, particularly repository instructions and general guidance, can be useful in other copilot, as well as other AI IDE, clients. The complete agent, skill, plugin, and extension-tool workflow should not be assumed to behave identically outside of VS Code.

The .github Folder as an AI Customization Layer

Use of a .github folder is the common convention for a repository-level GitHub configuration. GitHub Copilot also recognizes defined locations within this folder for AI customization. The .github folder acts as a version-controlled knowledge and orchestration layer alongside the source code on which Copilot works.

The entry point is .github/copilot-instructions.md. Repository-wide instructions are automatically made available to supported Copilot requests made in the repository context. This file keeps the high-level policy concise and routes requests, i.e. natural language prompts, to the component that owns the required behavior. For example, a question about choosing an extensibility pattern routes to pattern help, while a request to create a project routes to the project-creator agent and skill.

More specialized content is organized under predictable locations:

Location Purpose
.github/copilot-instructions.md Repository-wide policy and top-level routing
.github/instructions/*.instructions.md Reusable task- or file-specific guidance
.github/agents/*.agent.md Role-specific agents with focused instructions and tool boundaries
.github/skills/<name>/SKILL.md On-demand, multi-step capabilities
.github/skills/<name>/references/ Detailed knowledge and workflow rules loaded as needed
.github/skills/<name>/scripts/ Deterministic automation used by a skill
.github/skills/<name>/assets/ Maintained templates and other generation inputs
.github/plugin/ Plugin metadata used to distribute the package

The resulting flow is a routing system rather than one large prompt:

flowchart TD
    U[Developer request] --> R[Repository instructions]
    R --> I[Applicable instructions]
    R --> A[Specialized agent]
    A --> S[Task-specific skill]
    S --> K[Bundled references]
    S --> T[Scripts, assets, or extension tools]
    I --> O[Copilot response or code change]
    K --> O
    T --> O

This separation keeps frequently applied policy small while allowing detailed knowledge and automation to be loaded only when relevant.

Instructions, Agents, Skills, and Tools

These customization types cooperate, but they are not interchangeable.

Repository and Specialized Instructions

Instructions modify how Copilot handles requests. Repository-wide instructions apply broadly in the repository context. Specialized .instructions.md files are attached when their applyTo glob (in the YAML frontmatter) matches files being created or modified, when their description identifies them as relevant to the task, when another customization references them, or when a user attaches them manually.

Once an instruction is included in a model request, its content becomes part of the context for that request. It should not be assumed that every discovered instruction is permanently resident in every subsequent request for the lifetime of a chat session. Inclusion depends on the Copilot client, selected agent harness, file match, task relevance, explicit references, and current request. Repository-wide instructions are the closest equivalent to "always-on" project guidance; targeted instructions are selectively applied.

The AI content within the arcgis-pro-sdk-copilot repository uses instructions for concerns that should influence many operations:

  • Routing ArcGIS Pro SDK questions to the appropriate specialist.
  • Applying managed C# and ArcGIS Pro SDK implementation practices.
  • Governing generated or adapted examples.
  • Enforcing version, validation, threading, DAML, and code-quality expectations.

Custom Agents

A custom agent defines a specialized role. Its YAML frontmatter identifies the agent, describes when it is useful, and can restrict its tools or permitted subagents. Its Markdown body defines the role, workflow, constraints, and expected output.

Agents are useful when a task benefits from context isolation or a focused responsibility (i.e. "black box"). Copilot can invoke a subagent from routing instructions, infer one from its description, or use one selected explicitly by a user when the client permits it. The agent operates with its own focused context and returns a result to the parent conversation.

In this package, agents separate pattern education, referral resolution, and project creation from the general-purpose Copilot conversation. They do not carry all implementation detail themselves. Instead, they delegate canonical procedures and knowledge to skills.

Agent Skills

A skill is an on-demand capability represented by a directory containing a SKILL.md and, optionally, references, scripts, and assets. Copilot initially discovers the skill through the name and description in its YAML frontmatter. It loads the body only when the skill is selected as relevant or invoked directly (e.g. from the chat or via an agent), then reads additional referenced resources as the workflow requires.

This progressive loading model is important. It permits the SDK Copilot plugin to contain detailed pattern guides, referral catalogs, item definitions, scripts, and project assets without placing all of that material in every prompt. Skills are therefore appropriate for specialized, multi-step work rather than general coding standards.

Tools, Scripts, and Assets

Tools perform operations. A tool may come from the editor, an installed extension, a Model Context Protocol server, or Copilot itself. Scripts and assets packaged with a skill provide a deterministic alternative to asking a language model to invent scaffolding.

This distinction is central to the generation features in this repository. Copilot interprets intent and orchestrates the workflow, while maintained tools, scripts, pattern definitions, and assets perform or constrain the structural generation.

Pattern Help

ArcGIS Pro SDK supports four primary extensibility patterns:

  • Add-in for commands, tools, panes, controls, and workflows integrated into the ArcGIS Pro application.
  • Managed Configuration for deeper startup behavior and application UI customization, in addition to the extensibility points available to an Add-in.
  • Plugin Datasource for exposing a custom, read-only data format as ArcGIS Pro tables or feature classes.
  • CoreHost for standalone applications using the SDK's geodatabase and geometry capabilities outside the ArcGIS Pro application.

Choosing among these patterns is an architectural decision, not merely a project-template choice. The pattern-help agent and skill provide grounded explanations of purpose, boundaries, limitations, and tradeoffs. They can:

  • Explain what each pattern is designed to accomplish.
  • Compare patterns for a stated workflow.
  • Identify when a pattern does not fit.
  • Explain the overlap and differences between Add-ins and Managed Configurations.
  • Clarify the read-only and non-visual role of Plugin Datasources.
  • Clarify the API and runtime boundaries of CoreHost applications.
  • Provide detailed information about representative UI extensibility points and lifecycle behavior.

The skill selects among a bundled summary, decision guide, and pattern-specific detail references. This allows answers to be grounded in maintained internal material rather than relying only on the language model's general training. Conceptual requests remain explanation-focused; implementation and code-example requests return to the applicable code-generation instructions.

Example questions include:

  • "Should this workflow be an Add-in or a Managed Configuration?"
  • "Can a Plugin Datasource edit the underlying custom format?"
  • "Can I use CoreHost to automate the ArcGIS Pro user interface?"
  • "Which pattern fits a custom start page and role-based UI?"
  • "What framework items can an Add-in contribute?"

Referral to Authoritative SDK Resources

Pattern selection and API-resource discovery are related but different tasks. Pattern help answers architectural questions. Referral maps questions about API domains, SDK features, setup, migration, examples, or additional reading to authoritative resources.

The referral agent invokes a dedicated skill containing canonical matching logic and a maintained catalog of categories, subcategories, descriptions, and URLs. The workflow normalizes a question, scores candidate topics, selects the narrowest useful category, and returns a bounded set of relevant links. Covered areas include framework concepts, map authoring, editing, geodatabase, geometry, layouts, raster, portal, utility network, parcel fabric, tasks, Workflow Manager, installation, migration, snippets, and community samples.

This capability helps two audiences:

  • Developers receive a focused path into a large documentation set instead of an undifferentiated list of links.
  • Copilot receives an explicit boundary between pattern-purpose knowledge and API, or...
  • Feature-domain research, reducing unsupported answers and invented references.

The referral catalog does not replace version-matched API documentation. API availability, signatures, thread requirements, and supported behavior remain governed by the ArcGIS Pro SDK API reference for the target release.

Agentic Project Creation

Project creation is well suited to agentic orchestration because the output has a known structural contract. A supported project can be one of four types: Add-in, Managed Configuration, Plugin Datasource, or CoreHost. Once required inputs are known, generation can follow a repeatable sequence of environment detection, folder creation, file generation, token substitution, reference configuration, and validation.

The project-creator agent translates user intent into this deterministic workflow and delegates execution to the project-creator skill. In VS Code, the skill first checks for the createArcGISProProject language-model tool contributed by the ArcGIS Pro SDK extension vsix (if installed). When available, that extension tool (from the vsix) owns input collection, validation, and project creation. When unavailable, the skill uses its templates, scripts, and verification logic bundled with the SDK Copilot plugin.

The fallback intentionally uses maintained assets rather than asking the language model to compose an entire project freehand. The language model orchestrates the process; deterministic resources establish project structure. This reduces variability in project files, DAML or configuration content, SDK references, build settings, images, and VS Code launch configuration.

Project creation can be low-touch after the user supplies or confirms the required project type, name, and destination. It should not be described as completely unsupervised. Copilot remains an assistant, users remain responsible for reviewing generated output, and the workflow may need clarification when the workspace or destination is ambiguous.

Relationship to Installed SDK Templates

In VS Code, this repository prefers the ArcGIS Pro SDK extension's contributed creation tool when that tool is installed and available. This path is intended to leverage the extension's SDK-aware generators and installed template resources rather than having the language model create the necessary scaffolding. The extension implementation, therefore, rather than the language model, will own the delegated generation. The bundled workflow is the fallback and uses checked-in project assets and scripts.

Visual Studio separately provides ArcGIS Pro SDK project and item templates through the ArcGIS Pro SDK for .NET extension. Those templates are the normal deterministic creation mechanism in Visual Studio. This repository, however, does not currently establish that its custom VS Code agent and skill delegation is available in Visual Studio or that Visual Studio Copilot invokes the installed ArcGIS Pro SDK templates automatically. That behavior should be documented only after it is implemented and validated in the Visual Studio client.

Agentic Framework Item Generation

The item-generator skill adds framework items to an existing Add-in or Managed Configuration. Supported items include buttons, map and layout tools, galleries, menus, dockpanes, panes, property pages, custom controls, custom items, backstage elements, embeddable controls, and tray buttons. ArcGIS Pro item templates do not apply to CoreHost or Plugin Datasource projects.

As with project creation, the VS Code workflow first prefers a contributed ArcGIS Pro SDK extension tool, createArcGISProItem, when available. Otherwise, the skill:

  1. Validates the target project and gathers missing requirements.
  2. Resolves the canonical item pattern.
  3. Identifies every file, resource, identifier, and DAML record to create or modify.
  4. Presents a complete implementation plan.
  5. Obtains explicit confirmation.
  6. Generates the item and validates structure, wiring, placement, and invocation.

The confirmation step is deliberate. Item generation modifies an existing project and may affect DAML declarations, ribbon placement, resources, XAML, code-behind, and project files. Agentic automation removes repetitive manual work, but it does not remove the developer from consequential design and modification decisions.

Canonical item-pattern references constrain the generated structure so the language model does not improvise declarations already defined by the SDK pattern. Workflow behavior remains subject to the example and best-practices instructions.

Best Practices for Generation and Review

The managed C# best-practices instructions guide Copilot whenever applicable C#, project, XAML, or DAML files are authored or modified. Major concerns include:

  • ArcGIS Pro Main CIM Thread, MCT, requirements and appropriate use of QueuedTask.Run.
  • Separation of UI-thread, MCT-bound, asynchronous I/O, and background work.
  • Avoidance of blocking async calls and nested or fragmented queued tasks.
  • Safe application-context capture and validation.
  • Appropriate use of BackgroundTask and progress or cancellation facilities.
  • Synchronization of DAML declarations and code-behind.
  • MVVM, WPF binding, disposal, error handling, null handling, and naming practices.
  • SDK and .NET version compatibility.
  • Verification of examples against current API signatures and threading contracts.

These instructions serve more than code generation. A developer can ask Copilot to review existing third-party or in-house ArcGIS Pro SDK code against the same rules. That makes the package useful for modernization, code review, migration assessment, and diagnosis of common threading or DAML problems.

The example-resource instructions add a source-quality gate. Official snippets and community samples are treated as useful starting points, not automatic proof that code is correct for a particular SDK version. Copilot is directed to verify signatures, target framework, thread affinity, async flow, application context, null handling, and required wiring before describing an example as ready to use.

Typical End-to-End Workflows

Selecting and Creating a Pattern

flowchart LR
    Q[Describe the workflow] --> H[Pattern help]
    H --> D{Pattern selected}
    D -->|Add-in| C[Project creator]
    D -->|Configuration| C
    D -->|Plugin Datasource| C
    D -->|CoreHost| C
    C --> V[Generate and validate project]

A developer can begin with a business or technical objective rather than a project type. Pattern help explains the tradeoffs and recommends a fit. Once the developer explicitly requests creation, routing hands the task to the project creator. The generated project can then be extended through normal development or, for Add-ins and Configurations, through the item generator.

Finding an SDK Capability

A question such as "Where are the APIs for creating layouts?" is an API-domain question rather than a pattern-selection question. Pattern-help routing delegates it to referral, which selects the layout category and returns the most relevant authoritative conceptual and API links.

Reviewing Existing Code

A developer can ask Copilot to inspect existing ArcGIS Pro SDK code for threading, async, DAML, WPF, version, or general implementation issues. Applicable best-practice instructions are added to the request, giving Copilot repository-specific review criteria in addition to its general C# knowledge.

Using This Content in Third-Party Repositories

The ArcGIS Pro SDK AI content is intended to augment the AI capabilities that customers and partners may already maintain. It is not intended as a replacement for an organization's existing Copilot instructions, agents, skills, coding standards, security controls, or review processes. Because the complete source is available, third parties can adopt the entire package or select only the parts that support their workflows.

Install the Plugin for User-Level Availability

The most direct way to use the complete package is to install the Copilot plugin in the user's profile. This makes its agents, skills, scripts, assets, and references available from any VS Code workspace supported by the installed Copilot environment:

copilot plugin marketplace add ArcGIS/arcgis-pro-sdk-copilot
copilot plugin install arcgis-pro-sdk@arcgis

Although this is sometimes described as a "global" installation, its scope is the current user profile rather than every user or machine. The plugin installation directory supplies reusable AI resources; generated projects and edits still target the workspace that the developer has opened. Organizations should use their normal software-distribution and policy controls when making the plugin available to a wider group.

Use a Downloaded Copy in a Local Workspace

A third party can download or clone the repository, including by downloading a ZIP archive, and use the extracted content in a local workspace. The complete repository is useful as a reference workspace, while its .github folder can be copied into the root of another repository or into an appropriate parent workspace scope.

This approach is useful for evaluation, offline inspection, controlled versioning, and environments where user-level plugin installation is not preferred. A copied snapshot does not update automatically; the adopting team is responsible for deciding when to compare with and incorporate later revisions.

Integrate Capabilities into an Existing .github Folder

Most established repositories already contain project-specific Copilot guidance. In that case, adopters should merge the relevant ArcGIS Pro SDK routing statements from .github/copilot-instructions.md into their own file and retain their existing instructions. They can then copy the instructions, agents, skills, references, scripts, and assets required by the selected routes into the corresponding locations within their own .github folder.

This additive approach allows ArcGIS Pro SDK expertise to complement organization-specific architecture, terminology, security policy, testing requirements, and development practices. When selecting a capability, adopters should preserve its dependency chain. For example, a routing statement that names an agent or skill is useful only when that agent or skill and its required references are also available under the expected names and paths.

Name collisions and conflicting policies should be resolved explicitly. Customers may rename local agents or skills, narrow applyTo patterns, or adjust routing language, but references to those names must be updated consistently. Repository-specific security and engineering policies should remain authoritative where they impose stricter requirements.

Reuse Individual Components or Sections

Because all AI content is provided as readable source, third parties may copy and adapt individual components rather than adopting a complete capability. Examples include:

  • Reusing only the ArcGIS Pro SDK threading and QueuedTask review guidance.
  • Adding selected example-validation rules to an existing code-generation instruction.
  • Incorporating one pattern comparison or decision guide into an internal skill.
  • Reusing referral categories and links in an organization's existing documentation agent.
  • Adapting deterministic project assets or validation scripts to an internal project standard.
  • Extracting individual passages as review checklists, prompt guidance, training material, or documentation.

Granular reuse gives adopters full control over context size and behavior however customer teams should retain enough provenance to identify the source version and periodically evaluate whether their customized copy should be updated. Obviously, copied content and/or fragments do not receive fixes or enhancements. These will have to be applied by the customer/consumer manually (from the original source at arcgis-pro-sdk-copilot).

Additional Adoption Models

Organizations can also use this content as a baseline for internal AI capabilities. They may fork the repository, publish an internally reviewed plugin, pin an approved revision, layer organization-specific skills over the SDK skills, or use the source as a transparent example for building similar domain customizations. The readable source supports security review, audit, experimentation, and comparison of AI behavior before broad deployment.

The content can also support non-generation scenarios. Teams can use it to create code-review profiles, migration checklists, onboarding material, architectural decision aids, test prompts, or evaluation suites that measure whether an AI assistant respects ArcGIS Pro SDK threading, version, and extensibility boundaries.

Support and Compatibility

The AI content within the arcgis-pro-sdk-copilot repo is provided AS IS and is subject to change. Files, names, routing contracts, skill procedures, scripts, assets, supported clients, and generated output may be modified at any time to add capabilities, improve quality, correct defects, respond to GitHub Copilot changes, align with ArcGIS Pro SDK releases, or accommodate changes in the surrounding tooling.

The forward-compatibility guarantees associated with ArcGIS Pro SDK public APIs do not apply to the AI customization content. A future revision may require adopters to update copied routing statements, paths, agent or skill names, local integrations, approval flows, or validation assumptions. The content is guidance and automation rather than a public SDK API contract.

Before adopting or updating the content, third parties should review the changes, test the selected capabilities in their supported Copilot client and development environment, and validate generated or modified code against the target ArcGIS Pro SDK version. Teams that require reproducible behavior should pin or archive a reviewed revision and update it through their normal change-management process.

Using prosdkhelper with Copilot in VS Code

Prosdkhelper is a GitHub Copilot chat participant provided by the ArcGIS Pro SDK extension for VS Code. A chat participant is a specialized assistant that you bring into a Copilot conversation by typing @ followed by the participant's name. So to invoke the prosdkhelper, type @prosdkhelper in the VS Code Copilot Chat, followed by a natural-language description of the action or task that you want the "prosdkhelper" to perform. For example, you can ask the "helper" to create an addin, add a button or dockpane to an existing addin or configuration, help implement a workflow, or even review existing code*. Prosdkhelper operates through GitHub Copilot (available in VS Code only with the Pro SDK .vsix extension for VS Code installed), providing SDK-specific assistance with capabilities similar to those supplied by the .github AI components in the SDK copilot repo described previously above.

*Assuming you have the Pro SDK best-practices instructions installed

For routine creation tasks, prosdkhelper will use the installed ArcGIS Pro SDK templates (that come with the VS Code .vsix) directly. For example @prosdkhelper please make me an addin, @prosdkhelper please add a button to my addin, or @prosdkhelper please add a dockpane to my addin. The "helper" gathers the information needed for the task, such as the project or item name, and invokes the relevant SDK templates to create the required files and declarations. This is efficient and repeatable: the language model does not need to be used to write the project or framework item from scratch as the SDK templates already define their structure.

For questions and tasks that require more interpretation, prosdkhelper works through Copilot to provide AI-assisted explanations, workflow code, and code review via the large language model (LLM); Copilot handles the interaction with the LLM with prosdkhelper supplying it the SDK-specific context and guidance. For example, @prosdkhelper how do I update a dockpane when the active map changes?, or @prosdkhelper please generate code for my button to select features in the active map, or @prosdkhelper please review my code for best practices. This ability to either invoke the templates (for those actions already implemented by them) or Copilot to use the LLM, combines the strengths of both approaches: SDK templates handle standard project and item creation, while Copilot leverages the LLM to generate code, workflows, or additional help to develop behavior specific to your application and/or to provide additional insights into the Pro APIs. As always, review, build, and test any generated code.

Reliability and Governance

The package improves consistency by separating natural-language interpretation from maintained knowledge and deterministic operations. It does not make AI output infallible. Several controls remain important:

  • Use version-matched ArcGIS Pro SDK documentation as the final authority for APIs.
  • Review generated changes, especially project configuration, DAML, threading, and data-access logic.
  • Retain confirmation gates for modifications with meaningful project impact.
  • Build and test generated projects in the target ArcGIS Pro and .NET environment.
  • Keep skill references, scripts, assets, routing instructions, and agent contracts synchronized.
  • Treat client support as capability-specific; do not assume every .github customization works identically in every Copilot surface.
  • Review plugin updates before distribution because instructions and skills influence subsequent agent behavior.

The most effective operating model is therefore controlled agentic automation: Copilot handles discovery, orchestration, repetitive structure, and validation, while deterministic SDK-aware resources constrain output and developers retain responsibility for requirements and final acceptance.

Conclusion

The AI content in the arcgis-pro-sdk-copilot repository turns GitHub Copilot from a general coding assistant into a much more specialized ArcGIS Pro SDK "collaborator". Repository instructions establish routing and broad engineering policy. Agents isolate expert roles. Skills load detailed workflows and references only when needed. Extension tools, scripts, and assets provide deterministic generation paths. Pattern help and referral improve architectural understanding, while project creation, item generation, and best-practice review support implementation.

This layered design is particularly valuable for ArcGIS Pro SDK development because successful solutions depend on more than valid C#. They require the correct extensibility pattern, supported project structure, coherent DAML wiring, version-compatible APIs, and adherence to ArcGIS Pro's threading and application-context rules. Encoding those concerns as distributable Copilot customizations makes them available at the point where developers ask questions and perform work.

References