GitHub Copilot for SAP Developers Workshop

Duration: ~2 hours 30 minutes (150 min)
Format: Presentation + Live Demo + Discussion
Audience: SAP developers, technical leads, architects, BTP/extension developers, and integration engineers
Focus: Where GitHub Copilot fits in SAP development today — ABAP in Eclipse, SAP-adjacent workflows in VS Code, and the path toward SAP-connected agents
Reference repos: capire/bookshop (CAP bookshop — runs locally, no live backend) · Eclipse Marketplace: GitHub Copilot (ABAP-in-Eclipse track)
Companion documents: Slides · Lab Guide

Note: This workshop is intentionally designed to avoid a fake ABAP hands-on demo when no live SAP development environment is available. It builds credibility by showing the supported ABAP story (now a real, documented integration), demoing genuinely SAP-native workflows live in VS Code with the SAP CAP framework, and separating present reality from future-state architecture.

Workshop Overview

This workshop helps SAP-focused development teams understand where GitHub Copilot improves productivity today — even across teams at different levels of GitHub maturity. Copilot is a productivity accelerator and code-understanding partner rather than an autonomous SAP expert, and the workshop provides a credible, practical experience that can be delivered confidently without a live SAP backend.

The session is built around three honest pillars: the current ABAP support story in Eclipse, realistic SAP-adjacent workflows demoed live in Visual Studio Code, and a clear future-state architecture for SAP-connected copilots and agents.

Learning Objectives

• Understand where GitHub Copilot fits in SAP development today
• Understand the ABAP support story in Eclipse at a high level, including its limitations
• See how Copilot accelerates SAP-adjacent workflows — BTP, APIs, services, tests, and documentation
• Understand how prompt quality and context shape output quality
• Use Copilot for planning, code explanation, documentation, and review workflows
• Understand the future-state architecture for SAP-connected Copilot and agent scenarios through SAP BTP and exposed APIs

Prerequisites

Important: The ABAP-in-Eclipse integration is real and documented (announced by GitHub, May 2025). With the ABAP sample repos imported, you can demo Copilot explaining, modernizing, and testing real ABAP source without a live SAP backend; a live SAP system additionally unlocks execution, ATC, and live-data steps. Do not improvise ABAP syntax — always work from the sample source. The live demo center of gravity remains Visual Studio Code with the SAP CAP framework.

Reference Environments

This workshop supports two complementary tracks. Pick based on what you can show authentically:

Why SAP CAP? The SAP Cloud Application Programming Model (CAP) is a first-party SAP framework for building services and extensions. The bookshop sample runs entirely on your laptop with an in-memory database — so the demo is genuinely SAP, not just "SAP-adjacent," yet needs no live backend. This is the most credible way to show Copilot on real SAP development without an S/4HANA connection.

Session Agenda

Total: ~150 min (~2h 30min) including break

Note: A condensed 90-minute version is provided in the Appendix. Use it for leadership, architects, and mixed audiences.

1. Welcome & Context Setting (15 min)

Key Points

• This is not a fake ABAP coding lab — it is a practical workshop on where GitHub Copilot fits for SAP teams
• We will show supported ABAP scenarios conceptually and demo adjacent workflows live in VS Code
• Copilot is a productivity accelerator, not an autonomous SAP expert
• Copilot has real strengths and real limitations for SAP work

What This Session Is — and Is Not

🖥️ Demo: None (discussion-led opener)

Presenter Note: "I want to be transparent: today I'm not going to fake a live ABAP demo without a real SAP development system. Instead, I'll show where GitHub Copilot fits for SAP teams, what the ABAP support story looks like, and then I'll demo the modern workflows around SAP that many teams can adopt immediately."

Discussion Points

• What are your team's biggest productivity bottlenecks today?
• Where do your teams sit on the GitHub maturity curve — and does that vary by team?
• Why does SAP deserve a dedicated enablement track rather than a generic Copilot intro?

2. Where GitHub Copilot Fits in SAP (20 min)

Key Points

• GitHub Copilot complements SAP-native experiences rather than replacing them
• The strongest near-term value is often around the SAP ecosystem, not only the ABAP core
• Copilot supports the full development lifecycle: explanation, build, test, document, review
• In May 2025, GitHub announced ABAP support in GitHub Copilot for Eclipse — ABAP is now a documented, supported scenario, not just an experiment

A Real Milestone for SAP Developers

Note: GitHub's announcement — "Introducing ABAP Support in GitHub Copilot for Eclipse" (May 2025) — and Microsoft's follow-up, "Eclipse + GitHub Copilot = Lightspeed SAP ABAP Development," mark the point where ABAP, the core language of SAP ERP and S/4HANA, gained first-class AI assistance inside its native IDE. See References.

Where Copilot Adds Value Across the SAP Landscape

Present vs. Future

🖥️ Demo: Optional — quick chat tour

1. Open the chat panel and ask @workspace to explain the sample project
2. Show how Copilot understands service structure without manual file-by-file reading

Discussion Points

• Which of these areas is the most painful for your team right now?
• Where do you spend the most time understanding code others wrote?
• How much of your work is ABAP core vs. SAP-adjacent (APIs, extensions, integrations)?

3. ABAP Support Overview (20 min)

Key Points

• GitHub Copilot supports ABAP in Eclipse through ABAP Development Tools (ADT) — first shipped May 2025 and expanded substantially since
• The Eclipse plugin now includes the full agentic stack: Ask/Agent/Plan modes, custom instructions, MCP, prompt files, skills, custom agents, and delegate-to-Coding-Agent — not just completions + chat
• The current model is not specifically fine-tuned for ABAP — review remains essential
• Copilot is a productivity accelerator, not an autonomous SAP expert
• Setup is straightforward: a standard Eclipse Marketplace plugin install, then GitHub sign-in

Setting Up GitHub Copilot for ABAP in Eclipse

This is the documented, supported path. Use it live only if you have a real SAP system; otherwise walk through it with screenshots.

Note: GitHub Copilot Free includes roughly 2,000 code completions and 50 chat messages per month — enough for a developer to evaluate the ABAP experience before adopting a paid plan.

Supported ABAP Capabilities

Agentic Capabilities in Eclipse (plugin 0.20.0+, July 2026)

Note: The Eclipse plugin has reached near-parity with VS Code on customization and agents. These work at the plugin level; on ABAP specifically, verify behavior on ADT's generated/virtual files and keep the review requirements below.

Limitations & Review Requirements

Governance for Enterprise ABAP Teams

• Copilot Business/Enterprise adds policy controls: disable public-code matching, manage org-wide access, and review usage
• Treat AI-generated ABAP as a draft — keep it inside existing transport, ATC (ABAP Test Cockpit), and code-review gates
• Establish a team standard for when Copilot output is acceptable (boilerplate, explanation) vs. where extra scrutiny is required (financial logic, authorizations)

MCP for ABAP: Built-In Support + Community Servers

Note: MCP is now built into the Eclipse plugin (Agent mode, stdio + remote servers, MCP registry), so you can wire external tools into Copilot directly in Eclipse. On top of that, the community has built a dedicated MCP server for ABAP (Marian Zeis, "Finally: An MCP Server for ABAP") that pulls authoritative ABAP knowledge — including SAP documentation — into Copilot on demand. Projects like aravindhkce/abap-copilot go further, wiring Copilot into an integrated workflow spanning code, SAP GUI execution, debugging, ATC findings, runtime dumps, performance traces, and transports. These point to where SAP-connected agents are heading (Section 6).

Important: If you do not have SAP or Eclipse available, do not improvise live ABAP syntax. Use the setup table above, screenshots, and official references. Authenticity protects credibility.

🖥️ Demo: ABAP in Eclipse — now a real, runnable demo

With Eclipse + ADT + the Copilot plugin and the SAP ABAP sample repos imported (see Facilitator Setup: ABAP in Eclipse in the Appendix), most of this demo runs live over real ABAP source — no live SAP backend required. The plugin now supports Ask, Agent, and Plan modes, so you can go beyond chat.

Credible live without a backend (reasoning over sample source):

1. Explain (Ask) — open a class from abap-platform-refscen-flight and ask What is this program doing? Draw the execution flow.
2. Modernize — open a file from abap-cheat-sheets and ask Refactor this using modern ABAP 7.5+ syntax, then explain each change.
3. Test — on a class with business logic ask Generate ABAP Unit tests and identify edge cases.
4. Agent mode — ask Copilot to apply a small refactor across the class and review the edits before accepting (spot-check behavior on ADT's virtual files).

Needs a live SAP system (show as screenshots if unavailable):

1. Comment-driven completion — * TODO: select all flights for a given carrier from SFLIGHT into an internal table
2. Optimize this SELECT query and explain why — then validate through ATC and code review

Important: Reiterate the review-required and governance message — treat generated ABAP as a draft inside transport, ATC, and code-review gates.

Discussion Points

• How much legacy ABAP does your team maintain, and how well is it documented?
• Where would code explanation save the most onboarding time?
• What review standards would you require before trusting generated ABAP?
• Would an ABAP MCP server (pulling SAP docs into Copilot) change how you'd adopt it?

☕ Break — 10 Minutes

4. Live Demo: SAP-Adjacent Development in VS Code (30 min)

Key Points

• This is the operational center of the session — real, smooth, and relevant
• Use the SAP CAP bookshop sample so the demo is genuinely SAP, not generic
• Demonstrate the full loop: understand → build → validate → test → document → review

Presenter Note: "This is the SAP Cloud Application Programming Model — a first-party SAP framework. It runs on my laptop with an in-memory database, so everything you see is real SAP development, no backend required."

Demo Setup (run once before the session)

git clone https://github.com/capire/bookshop
cd bookshop
npm install
npm install -g @sap/cds-dk
cds watch

Note: cds watch serves the bookshop OData service locally (default http://localhost:4004) backed by an in-memory SQLite database. No SAP system or cloud account is required.

Demo Flow

🖥️ Demo: SAP CAP Service Development

1. Explain: @workspace Explain this CAP project — the data model in db/, the services in srv/, and how they connect.
2. Build: In srv/, add a custom action 'submitOrder(book, quantity)' to the CatalogService that reduces stock and rejects orders that exceed available stock.
3. Harden: Add validation and a clear error message when quantity is not a positive integer or the book does not exist.
4. Test: Generate tests for the submitOrder action using the CAP test runtime (cds.test), including a package.json test script and the out-of-stock edge case.
5. Document: Generate a README section documenting the submitOrder action, its parameters, and example HTTP requests.
6. Review: Summarize the changes I made and suggest review comments or follow-up tasks for a CAP code reviewer.

Presenter Note: If you prefer not to use CAP, any service-based project framed as an SAP side-by-side extension works — but CAP gives you a credible, genuinely-SAP story for the same effort.

Success Criteria

• ✅ Copilot accurately summarized the CAP project structure (db / srv / app)
• ✅ A new submitOrder action was generated and refined through follow-up prompts
• ✅ Validation and error handling were added without manual boilerplate
• ✅ Tests with the out-of-stock edge case were generated and run
• ✅ Documentation and a change summary were produced for review

Going Further: The SAP MCP Ecosystem (optional extension)

Note: SAP and the UI5 community now publish official Model Context Protocol (MCP) servers that plug SAP-specific tooling directly into Copilot. Three work together for SAP application development, and they complement the ABAP MCP server from Section 3 (which brings backend ABAP knowledge into Eclipse):

• @sap-ux/fiori-mcp-server — generates and modifies SAP Fiori elements apps from prompts, including a Fiori UI on top of the CAP bookshop service from this demo, or on an existing OData / ABAP RESTful (RAP) service. Part of SAP/open-ux-tools.
• @ui5/mcp-server — the SAPUI5 / OpenUI5 development server: scaffolds UI5 apps, fetches UI5 API references, provides UI5 coding guidelines, validates manifest.json, and runs the UI5 linter. From the UI5/mcp-server project.
• @cap-js/mcp-server — the companion CAP server for the backend service layer: it searches the compiled CDS model (entities, services, HTTP endpoints) and the CAP documentation, so Copilot grounds its answers in this project's CAP model — directly useful for the bookshop demo.

All three use stdio transport and run via npx — no global install required. To register them with Copilot in VS Code, add them to your MCP configuration:

{
  "servers": {
    "fiori-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["--yes", "@sap-ux/fiori-mcp-server@latest", "fiori-mcp"]
    },
    "ui5-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@ui5/mcp-server"]
    },
    "cds-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@cap-js/mcp-server"]
    }
  }
}

Presenter Note: "On top of the CAP service we just built, I can ask Copilot to 'add a Fiori elements list report app to my CAP project' and the Fiori MCP server scaffolds a real, governed SAP UI — not a generic web page. The UI5 server adds SAPUI5/OpenUI5 expertise: API references, guidelines, and linting. SAP recommends pairing the Fiori server with @cap-js/mcp-server and @ui5/mcp-server for the full stack."

Note: Beyond application development, community and platform-focused MCP patterns and servers are emerging for SAP BTP (subaccount and service management), ABAP via ADT (connecting to a live SAP system's ADT APIs), SAP HANA Cloud (database queries), and SAP Datasphere / analytics. These are powerful but require a live SAP or BTP connection, so they fall outside this laptop-only demo — worth knowing they exist as your SAP-connected agent strategy matures (Section 6).

Discussion Points

• Which of these steps would save your team the most time today?
• How does framing the demo as an SAP extension change how you see Copilot's value?
• What would it take to run this workflow on your own SAP-adjacent repositories?
• Where would an official MCP server (ABAP backend, CAP, Fiori, or UI5) fit into your toolchain?

5. Prompting & Context Engineering (20 min)

Key Points

• Context quality is the single biggest driver of output quality
• Repository structure and clear instructions help Copilot produce better results
• Knowing when to ask for a plan vs. an implementation changes outcomes

Why Some Users Get Better Results

Vague vs. Context-Rich Prompts

🖥️ Demo: Context Quality Comparison

1. Run a vague prompt — note the generic, assumption-heavy response
2. Re-run with @workspace, #file, and a specific instruction — note the precision
3. Show asking for a plan first, then implementing from the approved plan

Discussion Points

• What context do you most often forget to give Copilot?
• When would you want a plan before any code is written?
• How could repository instructions encode your team's SAP coding standards?

6. Future-State Architecture: SAP-Connected Copilots & Agents (20 min)

Key Points

• The roadmap is conceptual — these scenarios are not run live
• SAP-connected scenarios depend on secure API exposure and integration patterns
• Start with read-focused copilots before automating workflows

Reference Architecture

┌──────────────────────────┐
│  Teams / Microsoft 365   │  ◄── User surface
└────────────┬─────────────┘
             │
┌────────────▼─────────────┐
│   Copilot / Agent Layer  │  ◄── Reasoning, orchestration, tools
└────────────┬─────────────┘
             │
┌────────────▼─────────────┐
│  API Management /        │  ◄── Security, throttling, governance
│  Cloud Connector         │
└────────────┬─────────────┘
             │
┌────────────▼─────────────┐
│  SAP BTP / API Exposure  │  ◄── Stable, governed API surface
└────────────┬─────────────┘
             │
┌────────────▼─────────────┐
│   SAP Backend Systems    │  ◄── Systems of record
└──────────────────────────┘

Candidate Use Cases

🖥️ Demo: Architecture walkthrough (diagram-led, no live SAP calls)

1. Walk the diagram top to bottom, naming the responsibility of each layer
2. Emphasize the API exposure and security layers as prerequisites
3. Map one candidate use case onto the architecture

Discussion Points

• Which SAP information would be most valuable to retrieve conversationally?
• What APIs do you already expose through BTP or API Management today?
• What security and governance requirements would gate a read-focused pilot?

7. Q&A and Next Steps (15 min)

Key Points

• Convert interest into a concrete, low-risk next step
• Match the follow-up to the audience's maturity and pain points
• ABAP can be shown as a real, source-based demo; a live SAP environment adds execution and live-data steps

Recommended Next-Step Options

Facilitator Q&A Prep

Discussion Points

• What is the one workflow you'd most want to pilot first?
• Who are the internal champions who could lead adoption?
• What evidence would your leadership need to expand from a pilot?

Appendix

Key URLs

External References & Further Reading

Note: These are the authoritative and community sources behind the ABAP-in-Eclipse content in this workshop. Share them with attendees who want to go deeper.

Facilitator Setup: ABAP in Eclipse

Complete this once before delivering the optional Track B (ABAP-in-Eclipse) demo. It assumes no prior Eclipse experience.

Clone the ABAP sample repos (attendees may choose any folder):

mkdir sap-samples && cd sap-samples
git clone https://github.com/SAP-samples/abap-cheat-sheets
git clone https://github.com/SAP-samples/abap-platform-refscen-flight
git clone https://github.com/SAP-samples/cloud-abap-rap

Note: If Copilot Chat reports a language-server error on first launch, sign in to GitHub and restart Eclipse — it typically clears once authentication completes.

Note: The explain / modernize / test-generation demos run over the imported source files, so no live SAP backend is required. A connected SAP system is only needed for execution, ATC findings, and live-data operations.

Pre-Delivery Checklist

• ✅ Confirm whether a live SAP/Eclipse environment is available — if not, use screenshots for ABAP
• ✅ Clone and run the SAP CAP bookshop sample (cds watch) and verify it serves on localhost
• ✅ Verify the GitHub Copilot + Copilot Chat extensions are working in VS Code
• ✅ Pre-run each demo prompt once to confirm smooth output
• ✅ Prepare ABAP-in-Eclipse screenshots and the official reference links from this appendix
• ✅ Confirm audience maturity to pick the right follow-up offer

Demo Prompt Library

Note: Keep each prompt in its own copyable block during delivery so attendees can reuse them.

Explain this CAP project — the data model in db/, the services in srv/, and how they connect.

Explain what this service handler does and summarize the business logic in plain English.

In srv/, add a custom action 'submitOrder(book, quantity)' to the CatalogService that reduces stock and rejects orders that exceed available stock.

Add validation and a clear error message when quantity is not a positive integer or the book does not exist.

Generate tests for the submitOrder action using the CAP test runtime (cds.test), including the out-of-stock edge case. If package.json does not already have a test script, add one that runs these tests.

Generate a README section documenting the submitOrder action, its parameters, and example HTTP requests.

Summarize the changes I made, list the key risks, and suggest review comments.

ABAP-in-Eclipse prompts (run over the imported sample source — no live SAP backend needed):

What is this program doing? Draw the execution flow.

Refactor this using modern ABAP 7.5+ syntax, then explain every change you made.

Generate ABAP Unit tests for this class and identify edge cases that should be tested.

Explain what this legacy ABAP report does and outline its main processing steps.

ABAP-in-Eclipse prompts (require a live SAP system):

* TODO: select all flights for a given carrier from SFLIGHT into an internal table

Optimize this SELECT query and explain why it is more efficient.

Backup Plan

• If a demo prompt produces a weak result: Acknowledge it openly, refine the prompt with more context, and use it as a teaching moment about context engineering.
• If Copilot is unavailable or rate-limited: Fall back to pre-captured screenshots of each demo step.
• If the Eclipse Copilot language server fails to start: Sign in to GitHub first, then restart Eclipse — the error usually clears once authentication completes.
• If the audience pushes for live ABAP execution: Show the explain / modernize / test demos over the sample source (no backend needed), then redirect execution-dependent asks (ATC, transports, live data) to an architecture or pilot session as the authentic next step.

Condensed 90-Minute Version

Workshop guide for the GitHub Copilot for SAP Developers Workshop