GitHub Copilot for SAP ABAP in VS Code: Setup Guide for On-Premise Teams

[shaikferoz]

How I Got Here — My Personal Experience

I’ve been working in SAP for close to 20 years now. Over that time, I’ve seen the development landscape evolve from SE38 and SE80 to Eclipse ADT, from classical ABAP to ABAP OO, and now RAP. But nothing has shifted the day-to-day developer experience as quickly as AI-assisted coding.

When our team started discussing AI tools for ABAP development, the first name that came up was SAP Joule. It looked promising, deeply trained on SAP code, integrated into Eclipse ADT, and purpose-built for ABAP. But when I dug into the availability details, I hit a wall: Joule for Developers is not available for on-premise S/4HANA systems. Our landscape is on-premises, and that wasn’t going to change overnight.

So I started exploring what else was out there. I looked at Amazon Q Developer, which has strong ABAP capabilities and an impressive ABAP Accelerator MCP server. But it required standing up AWS infrastructure. Then I checked GitHub Copilot and realized our organization already had Copilot Business licenses under our GitHub Enterprise agreement. The path of least resistance was clear.

I set it up on a Friday afternoon. By Monday morning, I was using it in real development work. The speed at which I became productive surprised me. I honestly expected a longer ramp-up.

What Surprised Me Most

I initially set up Copilot in both Eclipse ADT and VS Code, expecting roughly the same experience. I was wrong. The Eclipse plugin gives you solid code completions and a useful chat panel, but VS Code with Agent Mode is on a different level entirely. The first time I described a multi-step task in natural language and watched the agent plan its approach, create files, and iterate on errors autonomously, I knew this was going to change how my team works.

One moment that stood out: I pointed Agent Mode at a legacy report that nobody on the current team had written. Within minutes, it had analyzed the entire program, generated a functional description, flagged two performance issues with nested SELECTs, and suggested refactored code with JOINs. That single interaction would have taken a developer half a day to do manually.

Another area where I’ve seen real value is unit test generation. Let’s be honest, ABAP Unit tests are often the first thing that gets cut from project timelines. With Copilot’s /tests command, you can generate a solid test scaffold in seconds. It’s not perfect, you still need to review and adjust, but it removes the biggest barrier, which is the blank-page problem of writing test classes from scratch.

The AI Landscape for On-Premise ABAP Teams

If you’re on an on-premise SAP system, here’s where things stand today:

Solution	On-Premise?	IDE Support	Key Consideration
SAP Joule	No	Eclipse ADT	Cloud only (BTP / S/4HANA Cloud)
Amazon Q Developer	Yes	Eclipse, VS Code, BAS	Requires AWS ecosystem
GitHub Copilot	Yes	Eclipse ADT, VS Code	Broad model choice, mature Agent Mode

I went with GitHub Copilot because we already had the licenses. Your mileage may vary, if your organization is on AWS, Amazon Q Developer is absolutely worth evaluating. The important thing is that on-premise ABAP teams are no longer locked out of AI-assisted development.

Eclipse vs. VS Code — What I Found

For AI-powered development tasks, VS Code with Copilot Agent Mode is in a different league.

Eclipse ADT + Copilot: Good code completions, a helpful chat panel, and basic agent support that’s been improving with each release. For day-to-day ABAP work, it’s a meaningful step forward.

VS Code + Copilot: Everything Eclipse has, plus fully autonomous Agent Mode with multi-step planning, terminal integration, and direct SAP system awareness through the ABAP FS extension. This is where I do my complex development work now.

Installation Steps

Here’s the exact setup I followed. The whole process took me about 30–45 minutes, and I was productive immediately after.

Step 1:  Install Visual Studio Code

Download and install the latest version of VS Code from code.visualstudio.com. I’d recommend getting the latest stable release — older versions may not support all Copilot features.

Step 2:  Install ABAP Remote Filesystem Extension

This is the extension that makes VS Code talk to your SAP system. Without it, Copilot has no ABAP context — with it, the AI can see your actual system objects.

•   Open VS Code and navigate to Extensions (Ctrl+Shift+X)
•   Search for and install ABAP Remote Filesystem

•   Click on the extension settings to configure

•   Click on Abapfs: Remote to add your SAP system

Add the SAP system connection details. I configured both our DEV and SBX systems here. Use placeholder values if you’re just testing the setup initially.

Step 3:  Install SAP Web IDE Adapter for VS Code

This extension enables SAP-specific development workflows within VS Code. It’s a small addition but it rounds out the SAP development experience.

•   From the Extensions marketplace, install SAP Web IDE Adapter

Step 4:  Install SAP Joule Studio Code Extension

Even though Joule isn’t available for on-premise ABAP, I installed the Joule Studio Code Editor extension anyway — it’s useful if you also work with BTP environments, and it doesn’t interfere with Copilot.

•   Install SAP Joule (Joule Studio Code Editor) from the Extensions marketplace

Step 5:  Install GitHub Copilot Extension

This is the main event. Install the GitHub Copilot extension and sign in with your company’s GitHub account.

•   Install GitHub Copilot from the VS Code Extensions marketplace

•   Sign in using your Company GitHub account and ensure Copilot is enabled

A tip from my experience: if your company uses SSO for GitHub, make sure you complete the authentication through the browser window that pops up. I initially missed this and spent 10 minutes wondering why Copilot wasn’t activating.

Step 6:  Activate ADT Service on SAP System

This is the SAP Basis step. Make sure the ADT service is active in transaction SICF. If your Basis team hasn’t already enabled this for Eclipse ADT, you’ll need to request it.

Step 7:  Connect to the SAP System

Now connect VS Code to your SAP system. This is the moment where everything comes together.

•   Open the Command Palette (Ctrl+Shift+P)
•   Run: ABAP FS: Connect to an ABAP system

•   Select the SAP system to connect

Step 8:  Verify SAP System Connection

Once connected, you should see your SAP system’s object tree in the Explorer pane. When I first saw our $TMP package, Core Data Services, and Source Code Library appear in VS Code, it felt like two worlds merging.

•   Confirm the connected SAP system appears under ABAP Remote Filesystem
•   You should now be able to browse SAP objects remotely

Step 9:  Verify GitHub Copilot and Model Availability

Finally, confirm that Copilot is active and check which AI models your organization has approved. In our case, we have access to Claude Haiku, Claude Opus, Claude Sonnet, and GPT models. I primarily use Claude Haiku for quick tasks and Claude Sonnet for complex agent work.

•   Confirm that GitHub Copilot is active in the editor
•   Verify that your company-approved AI models are available

Quick Start: Using Copilot for ABAP in VS Code

Once installed, open the Copilot Chat panel (Ctrl+Alt+I) and choose your mode. Here’s how I use each one in practice:

Ask Mode — My Go-To for Quick Answers

I use this multiple times a day. Instead of searching SAP Help or opening a browser, I just ask Copilot directly in the IDE. It’s especially useful for BAPIs and function modules I don’t work with regularly.

“Explain how BAPI_USER_GET_DETAIL works”

“Best practices for exception handling in ABAP OO?”

Edit Mode — For Targeted Refactoring

When I have existing code open and want specific changes, I select the code, press Ctrl+I, and describe what I need. This has been particularly useful for modernizing older code patterns.

“Refactor this to use NEW instead of CREATE OBJECT”

“Optimize this to use a JOIN instead of nested SELECTs”

Agent Mode — Where the Magic Happens

This is the feature that changed my workflow. I describe a complex task and let the agent figure out the approach. It plans, generates, reviews its own output, and iterates. Not every result is perfect on the first try, but the starting point it gives you is usually 70–80% there.

“Create an ABAP class ZCL_BP_VALIDATOR with unit tests for BP number validation”

“Analyze program ZSALES_ORDER_REPORT — generate documentation and flag performance issues”

“Create a complete RAP application for insurance claims with CDS views, behavior definition, and service binding”

Slash Commands I Use Daily

These are quick shortcuts in the chat panel that I’ve made part of my routine:

•   /explain — I use this constantly on unfamiliar legacy code
•   /fix — Helpful when I get a syntax error I can’t immediately spot
•   /tests — My favorite — generates unit test scaffolds in seconds
•   /doc — Generates inline documentation for methods and classes

Creating and Searching Custom Objects

One thing I didn’t expect was how smooth object creation is directly from VS Code. Enter the ‘>’ command to list options, then select ABAP Create Object.

•   Select the object type to be created

•   Enter the object name

•   Enter the description

•   Enter the package and transport number to save

For searching existing objects, use the ABAP Search for Object command. The filter option is handy when you’re looking for a specific object type.

Custom Instructions — This Is a Game-Changer

If you set up only one additional thing beyond the basic installation, make it this. Custom Instructions tell Copilot how your team writes code — your naming conventions, your preferred patterns, your performance rules. Without them, Copilot gives you generic ABAP. With them, it gives you code that looks like your team wrote it.

Create a file called .github/copilot-instructions.md under each connected system. You define your rules in plain English, and Copilot follows them automatically across all suggestions.

The instructions I set up for our team enforce:

•   Use of modern ABAP syntax (7.55+) — no legacy patterns in new code
•   Our naming conventions (ZCL_*, ZIF_*, ZCX_* prefixes)
•   Performance-safe data access patterns (CDS-first, no SELECT *)
•   Domain-specific knowledge for our business context
•   Under each system, add a folder ‘.github’ and a file ‘copilot-instructions.md’

•   You can deploy centrally or explore global deployment options with your GitHub Administrator
•   Below is a sample of the instruction file I created for our team

A personal observation: after deploying Custom Instructions, I noticed the quality of Copilot’s ABAP suggestions improved dramatically. It stopped suggesting CREATE OBJECT and started using NEW. It stopped generating SELECT * and started using explicit field lists. These are small things individually, but across a team of developers, they add up to consistently better code.

How My Team Uses This Daily

Here are the five ways GitHub Copilot has become part of our regular workflow:

•   Agent Mode for direct development — Writing ABAP code directly into the SAP system. This is the use case that saves the most time, especially for generating boilerplate like data declarations, ALV setup, and standard SELECT patterns.
•   Documentation generation — Pointing Copilot at legacy code and getting clear, readable documentation. For a team maintaining 15+ years of custom ABAP, this alone justified the setup effort.
•   Code reviews — Using Copilot to review code for quality, performance patterns, and best practices before peer review. It catches things humans miss when they’re deep in the logic.
•   Unit test generation — Creating ABAP Unit test scaffolds with /tests. We’ve gone from almost zero test coverage on new code to having at least basic test classes for every new method.
•   Code modernization — Refactoring older ABAP to modern syntax and OO patterns. This is especially useful during S/4HANA preparation work.

Honest Limitations — What I’ve Learned the Hard Way

I want to be transparent about where Copilot falls short for ABAP, because I think setting realistic expectations is important:

•   The AI models are not fine-tuned for ABAP. ABAP has far less training data on GitHub compared to languages like Python or JavaScript. Copilot sometimes suggests almost-but-not-quite right syntax, especially for SAP-specific APIs and BAPIs.
•   Module-specific business logic still needs human expertise. Copilot doesn’t know your company’s custom tables, your specific process flows, or your regulatory requirements. Custom Instructions help, but they don’t replace domain knowledge.
•   Always review the generated code before activating. I’ve caught subtle issues with incorrect table key definitions and missing authority checks. The AI gets you 70–80% there; the last 20–30% is where your experience matters.
•   This is a developer productivity tool, not an enterprise transformation platform. It complements the specialized tools organizations use for large-scale migration and conversion programs.

Bottom Line

AI-assisted ABAP development works on-premise today. GitHub Copilot in VS Code, especially Agent Mode, has genuinely changed how I work and how my team approaches development tasks. The setup takes an afternoon, and the productivity gains start from day one.

If your organization has GitHub Copilot licenses and an on-premise SAP landscape, I’d encourage you to try this setup. 

I’d love to hear from others in the community who are exploring AI tools for ABAP development. What’s working for you? What challenges have you faced? Let’s keep the conversation going.

#SAP #ABAP #GitHubCopilot #VSCode #AgentMode #AI #OnPremise #S4HANA #GenAI

[Aravindh_Ganapathi95]

Great article! I’m a contributor to ABAP FS and have a few pointers:

1. It’s recommended to always use Agent mode with ABAP FS. Ask mode cannot use the tools that ABAP FS provides which means Copilot can’t access your SAP system and will only depend on the knowledge it was trained on.

2. I think vs code is about to deprecate Edit mode. It’ll only be Ask and Agent soon

3. Copilot can also create objects (you choose the TR for non-local objects)

4. I recommend skills over custom instructions as they’re hot-loaded when needed as opposed to instructions files which are always loaded, even when it’s not needed.
ABAP FS can do a lot more - subagents, skills, heartbeats, SAP Data Notebooks, Debugging with replay, dependency graphs, cross system object comparison etc., 

I recommend going through the walkthroughs added in the latest version to get an idea of what else it can do. Feedback welcome!! 

[aaron_thomas]

@Aravindh_Ganapathi Is there an available link to the mentioned walkthroughs for ABAP FS ?

[Aravindh_Ganapathi95]

@aaron_thomas The Walkthroughs are built into ABAP FS. Go to Help menu in VS Code and choose Open Walkthrough and you will see 4 of them for ABAP FS. You can pick which ones you want to go through one by one. 

[Atul_Joshi85]

Hi @shaikferoz   I did some research and I feel this is prerequisite to achieve. Please correct me if I am wrong. I want to try this.

To achieve this, we need to have some pre-requite Even with SAP GUI 800, you can achieve this setup. The key point is that the GitHub Copilot for ABAP workflow does not depend on the SAP GUI as a development environment. Instead, it relies on the ADT (ABAP Development Tools) communication layer exposed by your SAP backend.

With this, while the approach is valid, there are a few important prerequisites and practical points to ensure success in an on-premises ECC landscape.

1. Foundation Check (Critical Prerequisite)

Before starting, confirm your backend supports ADT:

• Recommended: SAP NetWeaver 7.40+ (EHP7 or higher)
• Ensure:
• ADT services are available
• Required authorizations are in place
• HTTPS/ICF access is enabled

Note, Without ADT compatibility, this setup will not work regardless of GUI version. This is first major requirement to meet.

2. Activate ADT Services

Visual Studio (VS) Code communicates with SAP using ADT services (same as Eclipse).

Steps:

• Open SAP GUI (800)
• Go to transaction SICF
• Navigate to: “/sap/bc/adt “if this folder is not there you can create. Sicf
• Activate the service (if not already active)

Also verify:

1. User has proper ICF and ADT authorizations
2. Service is accessible via browser (test URL if needed)    

3. Now set up the Bridge: VS Code + ABAP Integration

Installation:

• Visual Studio Code
• ABAP Remote FileSystem

This extension allows you to browse and edit ABAP objects directly from VS Code by connecting to ADT services.

Note:

• This is community-supported (not SAP official)
• Works well for development, but not a full replacement for Eclipse ADT

4. Connection Setup (On-Premise)

In VS Code:

• Open Command Palette → ABAP FS: Connection Manager
• Add new connection:
  • Find port via SMICM → Services
• URL: http(s)://<host>:<port>
• Client: e.g., 110
• Credentials: SAP user/password

In enterprise environments, also consider:

• VPN / firewall access
• SSL certificates
• SSO/SNC configuration

5. Add AI Capability (Copilot)

Installation:

• GitHub Copilot extension in VS Code

Once ABAP objects are opened via ABAP FS, Copilot can read and assist with code.

Important Tip (Highly Recommended)

For ECC systems, guide Copilot behavior:

Create:

.github/copilot-instructions.md

Add:

We are working on an SAP ECC system. Use traditional ABAP syntax.
Avoid 7.40+ inline declarations unless explicitly requested. This significantly improves output relevance.

6. Development Workflow (Hybrid Model)

You will follow a dual-tool workflow:

In VS Code:

• Edit ABAP code
• Use Copilot for:
• Autocomplete
• Code explanation
• Refactoring suggestions

In SAP GUI:

• Execute programs (SE38, transactions)
• Handle:
• Debugging
• Transports (SE09/SE10)
• Functional testing

Saving in VS Code writes directly to the backend system.

7. Limitations to Be Aware Of

This setup is powerful but not complete:

• No full debugging support in VS Code
• Limited refactoring vs Eclipse ADT
• Performance may vary on older ECC systems
• Copilot may suggest modern syntax not supported in your system

8. Why This Approach Still Adds Value

Compared to SE80:

• Faster development with AI-assisted coding
• Better readability and navigation
• Ability to understand legacy ABAP quickly
• Supports gradual modernization mindset

9. Recommended Approach (Do This First)

Instead of full rollout:

Run a pilot with 1–2 developers

Validate:

• ADT connectivity
• Object editing from VS Code
• Copilot usefulness in real scenarios
• Network/security constraints

Final Summary

You do not need to upgrade SAP GUI or move to cloud to use Copilot with ABAP.

However, success depends on:

• ADT availability in your backend
• Proper system configuration
• Accepting a hybrid development model (VS Code + GUI)

[Atul_Joshi85]

@shaikferoz  @Aravindh_Ganapathi95  @aaron_thomas   Pls help if you have any idea or anyone from Moderator team can guide us. 

[Aravindh_Ganapathi95]

@Atul_Joshi85 I am not sure what guidance you’re looking for. Any specific questions? 

[Atul_Joshi85]

@Aravindh_Ganapathi95   Thanks for your response.

I’ve reviewed the article and my understanding is that achieving this functionality requires completing certain prerequisite steps within the standard SAP GUI. I’ve outlined the steps as I see them and wanted to confirm whether anything additional is needed.

If you have further insights or see any gaps in my approach, I would appreciate your guidance.

[Aravindh_Ganapathi95]

@Atul_Joshi85 Yes these steps seem fine but I’m not sure about the minimum SAP version that supports ADT, you’ll have to check in SICF. If /sap/bc/adt path is available, it should be supported. 
And for versions less than 7.51, you’ll also need to install an extension in your DEV system (not in vs code) for write support (code reading will work without it). Details here: https://github.com/marcellourbani/vscode_abap_remote_fs#prerequisites