v0.8.1 · public on GitHub · GPL-3.0
An AI SAP team — developers, consultants, and migration engineers — backed by 123 Claude Code skills and 3 agents. Turn design specs into deployed, ATC-clean ABAP and run what you ship (reports, background jobs, file interfaces — confirm-gated), generate clean-core CDS and RAP, explain authorizations and triage IDocs, sequence releases and track cutovers, move and retire custom code toward S/4HANA, and diagnose, fix, and ship production incidents, with live RFC validation across any number of SAP systems, from one conversation.
123 skills · 3 agents · 4 plugins · multi-system · ECC + S/4HANA
Three commands inside Claude Code — no signup, no setup wizard.
# 1. Add the marketplace
/plugin marketplace add https://github.com/sapdev-ai/sap-dev
# 2. Install the core plugin
/plugin install sap-dev-core@sap-dev
# 3. Login + bootstrap
/sap-login --add → /sap-dev-init
Optional add-ons:
/plugin install sap-gen-code@sap-dev — spec → ABAP pipeline /plugin install sap-migrate@sap-dev — S/4HANA custom-code migration /plugin install sap-project@sap-dev — delivery & operations: authorizations, IDocs, release, testing, test data Six pain points every team recognises
SE11 → SE38 → SE37 → SE16N for every fix. Context switching kills focus and steals hours per day.
Manual TR creation, mis-assignment, and the dreaded "object locked" error after a typo.
Excel and PDF specs are hand-translated to ABAP. Field length, type, and key flags drift on every revision.
Naming, type, SQL field, and FM-argument issues found at review. Each round costs half a day.
"Save before check, then activate." Hidden rules live only in senior heads. New hires take weeks to ramp up.
Every project rewrites GUI scripts that nobody maintains. No reuse, no standards, no tests.
A real spec, parsed → generated → checked → deployed — all driven by natural language.
Want a live walkthrough on your sandbox? Tell us about your project →
AI-orchestrated ABAP development on SAP GUI Scripting + RFC — now spanning the full delivery lifecycle
Excel / PDF specs become DDIC objects, programs, FMs, classes, RFC wrappers, and ABAP Unit scaffolds.
Naming, types, SQL fields, FM args, ATC 4-stage quality gate — all checked against the live SAP system.
SE01 / SE11 / SE16N / SE37 / SE38 / SE24 / SE91 / CMOD / SNRO / MM01 / BP / VA01 driven by natural language — plus report runs, background jobs, and app-server file transfer.
From a design spec to a governed release — and now S/4HANA migration and production support too.
Specs → DDIC, programs, FMs, classes — now including clean-core CDS views (ADT-free). Generate, validate against live RFC, and drive SE11 / SE38 / SE37 / SE24 by natural language.
ABAP Unit, the 4-stage ATC gate, impact analysis, a transport-readiness GO / NO-GO check, transport movement to production, and an audit-ready evidence pack.
Run reports and background jobs (confirm-gated) and transfer app-server files. Read-only incident triage across 7 readers — dumps, updates, locks, app log, jobs, tRFC/qRFC queues, OData gateway — safe to point at production, plus a baselined morning health sweep. Then close the loop with a gated, test-first fix in DEV.
The sap-project lane for functional, security, release, and test teams: explain roles and diagnose SU53 failures, reprocess IDocs, generate CAB release notes, sequence transports, track a cutover against its runbook, replay golden-master regression tests, and create test data (BP / materials / sales orders / an O2C chain).
Run an S/4HANA custom-code conversion as a tracked campaign: inventory, retire unused code behind an audited ledger, readiness ATC, triage, and reversible sandbox remediation — plus SPDD/SPAU adjustment triage, function-exit → BAdI modernization, and ABAP Cloud readiness tiers.
New
A senior ABAP developer that reads your Customer Brief on every run
The abap-developer agent is your end-to-end SAP delivery partner. It reads your Customer Brief, sets MODE flags (modern ABAP, OOP, unit tests, performance band, authorisation strictness), and orchestrates the right skills for the job — never bypasses ATC, never deploys without confirmation. Subagents inherit the same brief and the pinned SAP connection. Two more agents ship alongside: sap-consultant (incident / health / access / release / test / config lanes for functional teams) and cc-migration-engineer (S/4HANA custom-code campaigns).
"Build a program from this Excel spec." Reads brief, validates DDIC, generates ABAP, runs ATC, deploys — then offers a live runtime verification.
"Fix Z<PROG>." Syntax + naming + type checks, patches, re-activates. Runtime defects route diagnose → gated fix.
"Deploy this .abap file." Resolves TR, deploys DDIC dependencies first, activates, gates on ATC.
# abap-developer agent
name: abap-developer
modes:
- BUILD # spec → deployed code
- FIX # repair existing object
- DEPLOY # push .abap with TR + ATC
reads: customer_brief.md
sets: MODE_OOP
MODE_UNIT_TESTS
MODE_PERF_BAND_HIGH
MODE_AUTHZ_STRICT
guards: never bypasses ATC
always asks before deploy# multi-system
# manage profiles
/sap-login --list
/sap-login --add
/sap-login --switch dev-eu
# agent runs against the
# pinned connection only
@abap-developer
"deploy ZHK_REPORT
to DEV-EU"Switch profiles with one command. The agent + skills follow the pin.
Multi-system
Multi-profile login, AI-session pin, parallel sessions
Most SAP consultants juggle DEV / QAS / PRD, plus sandbox environments per region. sapdev.ai now saves a separate profile for each SAP system (DPAPI-encrypted), pins each Claude Code conversation to one of them, and enforces connection isolation at the session-broker level so a DEV claim never accidentally hits QAS. Subagents inherit the pin.
4 plugins · 123 skills · 3 agents · v0.8.1
61 skills + agent · The foundation
12 skills · Spec → ABAP
40 skills + agent · Delivery & operations (new)
10 skills + agent · S/4HANA + clean core
S/4HANA migration
Mainstream maintenance for SAP ECC ends in 2027. The hard part of a brownfield conversion is the thousands of custom Z/Y objects — many no longer used.
The sap-migrate plugin runs the conversion as a tracked campaign with a state ledger. It inventories your custom code over read-only RFC, overlays runtime usage (SCMON / UPL / ST03N workload) so you retire what is unused instead of paying to remediate it, runs the S/4HANA-readiness ATC, triages every finding into a remediation tier, and auto-fixes the mechanical ones on a sandbox after a mandatory dry-run. It also executes the retirement of the unused objects behind a signed sign-off gate and an audit ledger, with a scripted revert if a fix ever needs rolling back.
Newest part of the toolkit — we run it with you on a sandbox before any target system is touched.
# custom-code migration campaign
# one tracked campaign
/sap-cc-campaign init
/sap-cc-inventory
/sap-cc-usage --usage-file scmon.csv
# ↳ retire unused, don't remediate
/sap-cc-analyze # S/4 readiness ATC
/sap-cc-triage # R1…R4 tiers
/sap-cc-remediate # sandbox, dry-runThe "share retired without remediation" figure is the headline a migration lead wants — and the campaign computes it from your own usage data.
Each capability shaped by an actual SAP delivery pain — not a toy demo
Inventory custom code, retire what is unused, run S/4 readiness ATC, triage and auto-remediate mechanical fixes — as a tracked campaign with a state ledger.
Execute the retirement of unused custom code behind a HARD sign-off gate: where-used re-verify → source backup → transport → delete → verified-gone, every step appended to an audit ledger. Deletions stay blocked until a named owner approves.
Generate classic CDS DDL or view entities from a spec and deploy them to a live system without ADT — release-gated (SAP_BASIS ≥ 7.50) and RFC-verified. The clean-core codegen lane, live on S/4HANA 7.54 + 7.57.
Read-only toolchain and connectivity preflight (READY / DEGRADED / BLOCKED) that now also probes which SAP authorizations the logged-in user holds against a documented capability matrix (docs/security.md) — least-privilege gaps surface before a run, not halfway through.
Run what you ship: execute a report foreground (SA38) or background over an RFC fast-path — variants plus ad-hoc values (select-options, ranges, checkboxes) — manage the background-job lifecycle (schedule / status / log / spool / cancel), and close file interfaces with an upload → run → download → diff loop (CG3Z / CG3Y). Every run or schedule is confirm-gated: a report is never assumed read-only. Verified live on S/4HANA + ECC.
Incident root-cause triage fans out across 7 readers — ST22 dumps, SM13 updates, SM12 locks, SLG1 app log, SM37 jobs, tRFC/qRFC queues, and the OData gateway — correlates evidence, and ranks hypotheses, read-only and safe on production. Then a gated, test-first fix in DEV closes the loop (custom code only).
A 40-skill plugin for the rest of the project team: authorizations, IDoc and interface operations, output and document-flow diagnosis, release notes and transport sequencing, cutover tracking, regression testing, config compare, and test data — with the sap-consultant agent delegating across six lanes.
Who can do what, and why: SUIM-style reporting over RFC, a per-role dossier with critical-grant matching, SU53 / authorization-trace diagnosis with a classified fix proposal, and gated PFCG role writes verified by authoritative re-reads.
Interface operations without transaction-hopping: find, decode, and triage IDocs then reprocess behind a confirm gate; snapshot tRFC/qRFC queues with clustered causes; per-service OData gateway status and error-log analysis.
Render a complete, consistent managed RAP business object (root + projection CDS, behavior definitions, behavior pool, service definition) from a base table, package it as an abapGit repo for a no-ADT import, and verify every artifact with authoritative RFC re-reads. Dialect-forked for 7.54 and 7.55+.
A morning health sweep (IDocs, queues, spool, jobs, dumps) with a per-system baseline separating NEW findings from known-recurring noise — and a cutover runbook tracker that stamps every step with machine-read RFC evidence and renders delta-to-plan.
Release gate for a transport: unreleased tasks, inactive objects, local objects — rolled up to GO / GO-WITH-WARNINGS / NO-GO before it moves to QA.
Before you change an object: where-used, forward dependencies, entry points, transport history — with a transparent LOW / MEDIUM / HIGH risk band.
Runs ABAP Unit on a deployed program or class with a verdict gate and optional code coverage — closes the generate → deploy → test loop.
Object Set + Run Series + Monitor + Manage Results. Severity threshold blocks risky deploys.
Closes the loop from a root cause to a test-verified fix: reproduces the defect in a RED ABAP Unit test, patches, proves GREEN, deploys to DEV behind a transport. Custom code only, never production — proposes the diff first.
AI semantic + security review (dynamic-SQL injection, AUTHORITY-CHECK) with adversarial self-verification — plus ABAP Unit test generation that runs to green with coverage.
A team-shared catalog of recurring FM / method / codegen mistakes and their fixes. A failed deploy or ATC run auto-records a candidate; once a developer confirms the remedy, every later generation avoids it — so the toolkit stops repeating your team's known mistakes. Paired with a derived first-pass-yield KPI (/sap-log-analyze --builds) that shows whether a change actually moved the needle.
Move a released transport through DEV → QAS → PRD and read the import return code. Read paths work today; the production import is gated (typed-SID echo + double-confirm) and ships fail-safe. Newest — calibrated with you.
Probe an unknown transaction with natural-language scenarios → scaffold a working skill draft. Custom screens in days, not weeks.
Diff the same object across two systems, or get a structure + call-map dossier for an unfamiliar program. Read-only.
DPAPI-encrypted profiles per SAP system; each conversation pins to one; subagents inherit the pin.
Live RFC fetch of FM interfaces kills the most common AI hallucination class.
One-page project profile applied across every skill, with MODE flags for the agent.
Every skill emits start/step/stop. Run-id propagation across PS1 + VBS. Audit-ready.
Customer Brief
Every SAP shop runs differently — namespace, packages, message class, naming rules, quality bar, performance gates, authorisation handling. The Customer Brief captures all of it in one Markdown file. The abap-developer agent reads it on every run; every skill respects it; every generated artefact follows it. No more "the senior dev does it differently" — your standards become the engine.
Want help authoring yours? That is exactly what onboarding is for.
# customer_brief.md
project: HK-Manufacturing
abap_release: 7.57
namespace: ZHK
packages:
- ZHK_MM
- ZHK_SD
message_class: ZHK
naming_overrides:
custom_url: \\share\sap-dev\hk\
quality_bar:
atc_max_priority: 2
unit_test_min: 80%Pilot programme
We are running a heavily-discounted pilot programme to build production case studies
Every engagement is a quotation — these are the shapes most projects take
1 week, 1 add-on, before/after metrics. Heavily discounted for early reference customers.
Author your project profile, install the toolkit, train your team. 2-3 weeks.
Your MM02 has 6 custom screens? /sap-gui-probe + skill-scaffold cuts the work to days.
Inventory your custom code, find what is unused, and get a readiness + remediation plan before you commit to the conversion.
1-2 day workshops. Hands-on with your real codebase, not generic demos.
For teams who deploy to production. SLA-backed help when things break.
Every engagement is by quotation. Tell us about your project →
Yes. The toolkit is GPL-3.0 open source on GitHub (v0.8.1, July 2026). We earn money helping you deploy, customise, and operate it.
Encrypted with Windows DPAPI on the developer's machine, per saved profile. They never leave your network. The Claude API call is the only outbound traffic.
Each Claude conversation pins to one SAP system; switch profiles between conversations with /sap-login --switch. Subagents inherit the pin, and the session broker enforces connection isolation so a DEV request never hits QAS.
Yes. We detect Unicode vs non-Unicode and convert CJK source via ADODB so uploads never garble.
Yes — and /sap-gui-probe + /sap-gui-skill-scaffold lets us build the supporting skill in days. We probe your custom screen with natural-language scenarios and scaffold a working draft from the captures.
Everything runs on your developer workstation. The Claude API is the only outbound call (and you control which model and key).
So you can audit it, fork it, never be held hostage. Your operational dependency is on your team, not on us.
SAP GUI Scripting enabled (server + client). Optional: SAP NCo 3.1 for RFC features. RFC load-balanced login (Message Server + Logon Group) is supported for large landscapes.
It reads your Customer Brief and runs in three modes: BUILD (spec → deployed code), FIX (open + repair an existing object), DEPLOY (push a .abap file with TR + DDIC + ATC handled). It always asks before deploying and never bypasses ATC findings.
Yes — the sap-migrate plugin runs a brownfield custom-code conversion as a tracked campaign: it inventories your custom (Z/Y) objects, overlays runtime usage (SCMON, UPL, or ST03N workload) so you retire what is unused instead of paying to remediate it, runs the S/4HANA-readiness ATC, and triages findings into remediation tiers — auto-fixing the mechanical ones on a sandbox after a dry-run review. It also executes the retirement of the unused objects behind a signed sign-off gate and an audit ledger, and can revert a deployed fix if one needs rolling back. v0.8.0 extends the lane past the conversion itself: SPDD/SPAU upgrade-adjustment triage, function-exit → BAdI modernization, and an ABAP Cloud readiness classification (TIER_1_READY / TIER_2_WRAPPABLE / TIER_3_CLASSIC) for clean-core planning. We run it with you on a sandbox first.
Yes — that is exactly what the new sap-project plugin (40 skills + the sap-consultant agent) is for. It covers the non-developer work of an SAP project: explaining who can do what (SUIM reports, role dossiers, SU53 diagnosis), keeping interfaces healthy (IDoc triage and reprocessing, tRFC/qRFC queues, OData gateway status), diagnosing business documents (output determination, O2C document flow, workflow), running releases (CAB release notes, transport sequencing, cutover runbooks with evidence ledgers), testing (golden-master regression, scripted replays, test plans), creating test data (Business Partners, materials, sales orders, a full BAPI order-to-cash chain), and morning health checks with a baseline that separates new findings from known noise. Reads are unrestricted; every write sits behind the owning skill's confirm gate.
Yes — that is what the v0.7.x hardening releases set out to satisfy. Reads stay read-only; every mutation goes through SAP's own write APIs; executing or scheduling a report always asks for explicit confirmation first (a report is never assumed read-only); the migration campaign's human gates (scope sign-off, dry-run review) are enforced in code, not just prompts, so a skipped review cannot be recorded as progress; retiring custom code writes a signed audit ledger (object · backup · transport · verified-gone · owner) behind a hard approval gate; and /sap-doctor probes which SAP authorizations the logged-in user holds against a documented capability matrix (docs/security.md), so least-privilege gaps surface before a run rather than after. Credentials are DPAPI-encrypted on the workstation and never leave your network.
The /sap-diagnose suite is read-only and safe to point at production. From a single anchor (a time window, user, job, or short dump) it fans out across ST22 dumps, SM13 update failures, SM12 locks, SLG1 application logs, and SM37 jobs, correlates the evidence, and ranks root-cause hypotheses. From there /sap-fix-incident can close the loop — but only on custom (Z/Y) code, and never on the production system itself: it reproduces the defect in a failing ABAP Unit test, applies a minimal patch, proves it green, and deploys the fix to a DEV system behind a transport, proposing the diff before it writes anything.
Driven by paying customers' needs. The v0.8.0 release is the largest yet — 53 new skills (70 → 123) and a third agent. It ships the new sap-project plugin (40 skills + the sap-consultant agent): the delivery & operations lane for functional consultants, security, release, AMS, and test teams — authorizations (SUIM reporting, role dossiers, SU53/trace diagnosis, gated PFCG writes, DEV test users), interface operations (IDoc triage & reprocess, tRFC/qRFC monitoring, OData gateway, interface inventory), business-document diagnosis (output determination, O2C document flow, workflow, SAPconnect), release & cutover (CAB release notes, transport sequencing, transports-of-copies, cutover runbooks with evidence ledgers, dual-track retrofit, post-refresh verification, SAP Note status), testing & test data (golden-master regression, scripted test replay, mass load, FI postings, a BAPI order-to-cash chain — plus the BP / MM01 / VA01 family absorbed from the retired sap-tcd plugin), config & docs (cross-system config compare, gated SM30, IMG activity finder, SE63 translation, generated user guides, weekly delivery reports), and health & ops (baselined health checks, data-volume growth, change-document forensics). sap-dev-core grew to 61 skills (SM12 locks, version history, API discovery, ad-hoc SQL, a scratch-run ABAP REPL, forms, abapGit-style snapshots, SE14, VOFM routines), sap-gen-code to 12 (managed RAP business objects without ADT, inbound IDoc handler generation, test plans, transparent effort estimation), and sap-migrate to 10 (SPDD/SPAU triage, function-exit → BAdI modernization, ABAP Cloud readiness tiers). Incident diagnosis now fans out across 7 readers including queues and the gateway, with IDoc triage in the dedicated /sap-idoc skill. Earlier releases: v0.7.2 added the runtime lane (reports, jobs, file transfer — confirm-gated); v0.7.1 consolidated the catalogue and added the headless syntax gate; v0.7.0 added migration execution + assurance, the CDS lane, and enterprise hardening. Next: a Playwright-driven browser backend for web-only SAP surfaces (Fiori launchpad designers, LTMC, key-user extensibility apps) and deeper SD/MM agent coverage.
No. sapdev.ai uses your developer's own SAP Dialog license through the standard GUI Scripting and RFC interfaces — exactly the same way the developer would interact with SAP manually. The plugin is just a faster keyboard. No service accounts, no cloud-side caching, no aggregated indirect access. We recommend confirming this with your SAP licensing team before formal engagements.
Tell us about your project. We respond within one business day.
or email directly: hello@sapdev.ai