v0.7.2 · public on GitHub · GPL-3.0
An AI ABAP developer agent — now across the whole delivery lifecycle — backed by 70 Claude Code skills and 2 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, 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.
70 skills · 2 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-tcd@sap-dev — BP / MM01 / VA01 automation 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 ST22 / SM13 / SM12 / SLG1 / SM37 — safe to point at production — then close the loop with a gated, test-first fix in DEV.
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.
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.
"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 · 70 skills · 2 agents · v0.7.2
52 skills + agent · The foundation
8 skills · Spec → ABAP
7 skills + agent · S/4HANA custom-code migration
3 skills · Business transactions
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-run The "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 ST22 / SM13 / SM12 / SLG1 / SM37, correlates evidence, and ranks hypotheses — read-only, safe on production. Then a gated, test-first fix in DEV closes the loop (custom code only).
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.7.2, 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. It is the newest part of the toolkit and we run it with you on a sandbox first.
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 latest release (v0.7.2) adds the runtime lane — run an ABAP report foreground or background over an RFC fast-path with variants and ad-hoc values (sap-run-report), manage the background-job lifecycle end to end (sap-job: schedule / status / log / spool / cancel / delete over SM36 + SM37 + RFC), and transfer files between workstation and application server (sap-file-transfer, CG3Z / CG3Y) to close the file-interface test loop: upload → run → download → diff. All of it sits behind a new confirm-to-run rule — a report is never assumed read-only — and was verified live on S/4HANA and ECC, Japanese logon included. The same release synced the abap-developer agent to the current catalogue (an offer-only runtime verification after deploy, AI semantic review, module-pool completion, a runtime-defect fix lane) and made the Japanese customer brief first-class: the quality-bar gate now parses JA briefs natively. Before that, v0.7.1 was a discoverability consolidation — overlapping skills folded into mode/flag dispatch for a sharper catalogue with fewer commands to learn — plus a headless compiler-level ABAP syntax gate the deploy skills run before an object is inserted. v0.7.0 added execution + assurance to the S/4HANA migration campaign (signed, audited decommission; workload usage fallback; drift detection; unit-test exit gate; scripted revert; batched ATC), the first clean-core codegen lane (sap-gen-cds, ADT-free CDS views), and enterprise-adoption hardening (authorization preflight, documented security model, governance gates enforced in code). Before that (v0.5.0–v0.6.8): the sap-migrate engine, the diagnose → fix closed loop, transport-to-production, AI semantic + security review, ABAP Unit generation, a self-improving error knowledge base with a first-pass-yield KPI, and broad false-success hardening across ECC + S/4HANA and EN/JA/ZH logons. Next: deeper SD/MM agent coverage, RAP behaviour + OData generation on top of the CDS lane, and a managed ATC / readiness dashboard.
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