v0.7.2 · public on GitHub · GPL-3.0

Ship SAP faster.

Spend less on rework.

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

Install in 60 seconds

v0.7.2

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

Where SAP development burns time

Six pain points every team recognises

Transaction hopping

SE11 → SE38 → SE37 → SE16N for every fix. Context switching kills focus and steals hours per day.

Transport chaos

Manual TR creation, mis-assignment, and the dreaded "object locked" error after a typo.

Spec ↔ code drift

Excel and PDF specs are hand-translated to ABAP. Field length, type, and key flags drift on every revision.

Late-cycle defects

Naming, type, SQL field, and FM-argument issues found at review. Each round costs half a day.

Tribal know-how

"Save before check, then activate." Hidden rules live only in senior heads. New hires take weeks to ramp up.

Throw-away VBScript

Every project rewrites GUI scripts that nobody maintains. No reuse, no standards, no tests.

See it in 60 seconds

A real spec, parsed → generated → checked → deployed — all driven by natural language.

Want a live walkthrough on your sandbox? Tell us about your project →

What sapdev.ai does

AI-orchestrated ABAP development on SAP GUI Scripting + RFC — now spanning the full delivery lifecycle

Generate

Excel / PDF specs become DDIC objects, programs, FMs, classes, RFC wrappers, and ABAP Unit scaffolds.

Validate

Naming, types, SQL fields, FM args, ATC 4-stage quality gate — all checked against the live SAP system.

Automate

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.

One toolkit, the whole SAP delivery lifecycle

From a design spec to a governed release — and now S/4HANA migration and production support too.

Develop

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.

Assure

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.

Operate

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.

Migrate new

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

Meet the abap-developer agent

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

"Build a program from this Excel spec." Reads brief, validates DDIC, generates ABAP, runs ATC, deploys — then offers a live runtime verification.

FIX

"Fix Z<PROG>." Syntax + naming + type checks, patches, re-activates. Runtime defects route diagnose → gated fix.

DEPLOY

"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

One conversation, many SAP landscapes

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.

  • Multiple saved profiles, each with DPAPI-encrypted password
  • AI-session pin — each Claude conversation tied to one SAP system
  • Per-connection dev defaults (TR / package / function group)
  • RFC load-balanced login (Message Server + Logon Group) for big landscapes
  • Server release captured on login (S/4HANA 2022, ECC 6.0 EhP8 …)
  • Session broker enables parallel agents — up to 6 SAP sessions concurrently

What's in the box

4 plugins · 70 skills · 2 agents · v0.7.2

sap-dev-core

52 skills + agent · The foundation

  • Multi-profile login + DPAPI credential store
  • TR resolution + SE01 transport authoring
  • SE11 / SE21 / SE38 / SE37 / SE24 / SE91 / SNRO
  • SE16N query · SP02 spool · SE54 maintenance views
  • ABAP check + fix, with a headless compiler-level syntax gate
  • ATC 4-stage gate · ABAP Unit · activator · where-used
  • Run reports (foreground / background) · job lifecycle · app-server file transfer
  • Delivery assurance: transport-readiness · impact analysis
  • Transport movement to production: DEV → QAS → PRD (sap-stms)
  • Incident diagnose → gated, test-first fix (sap-fix-incident)
  • Environment doctor + authorization preflight + golden-screen drift check
  • Skill authoring: gui-probe + gui-skill-scaffold
  • Self-improving error KB that steers code generation (sap-error-kb)
  • abap-developer agent (build / fix / deploy)

sap-gen-code

8 skills · Spec → ABAP

  • Excel / Word / PDF spec extraction
  • Spec-template layout customisation per customer
  • Spec check: DDIC + process (sap-docs-check)
  • ABAP source generation with FM-signature pre-fetch
  • ADT-free clean-core CDS view generation (sap-gen-cds)
  • AI semantic + security review (sap-review-abap)
  • Generate ABAP Unit tests + run to green (sap-gen-abap-unit)
  • Driven by the Customer Brief

sap-migrate

7 skills + agent · S/4HANA custom-code migration

  • Run a brownfield ECC → S/4HANA conversion as a tracked campaign
  • Inventory custom (Z/Y) objects over read-only RFC
  • Overlay usage data (SCMON / UPL / workload) → flag dead code
  • Retire unused code behind a signed, audited decommission ledger
  • S/4HANA-readiness ATC + triage into remediation tiers
  • Auto-remediate mechanical fixes on a sandbox — dry-run first, revert-able
  • cc-migration-engineer agent

sap-tcd

3 skills · Business transactions

  • BP — Business Partner
  • MM01 / MM02 / MM03 — Material Master
  • VA01 / VA02 / VA03 — Sales Orders
  • CSV-driven bulk create / update
  • Custom screen field support
  • Error-row capture & rerun

S/4HANA migration

Move custom code to S/4HANA — as a campaign, not a guess

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.

  • Inventory + classify every custom object from TADIR / TRDIR
  • Usage overlay (SCMON / UPL / ST03N workload) → REMEDIATE / DECOMMISSION / REVIEW
  • S/4HANA-readiness ATC + tiered triage (R1 mechanical … R4 redesign), batched for large estates
  • Retire unused code behind a signed sign-off gate + an audit ledger
  • Sandbox-only auto-remediation of R1 fixes — dry-run first, with scripted revert
  • Driven by the cc-migration-engineer agent

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.

Built for real projects

Each capability shaped by an actual SAP delivery pain — not a toy demo

/sap-migrate — S/4HANA campaign

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.

/sap-cc-decommission — retire dead code

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.

/sap-gen-cds — clean-core CDS

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.

/sap-doctor — preflight + authorizations

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.

/sap-run-report · /sap-job · /sap-file-transfer

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.

/sap-diagnose → /sap-fix-incident

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).

/sap-transport-readiness

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.

/sap-impact-analysis

Before you change an object: where-used, forward dependencies, entry points, transport history — with a transparent LOW / MEDIUM / HIGH risk band.

/sap-run-abap-unit

Runs ABAP Unit on a deployed program or class with a verdict gate and optional code coverage — closes the generate → deploy → test loop.

/sap-atc — 4-stage pipeline

Object Set + Run Series + Monitor + Manage Results. Severity threshold blocks risky deploys.

/sap-fix-incident

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.

/sap-review-abap + /sap-gen-abap-unit

AI semantic + security review (dynamic-SQL injection, AUTHORITY-CHECK) with adversarial self-verification — plus ABAP Unit test generation that runs to green with coverage.

/sap-error-kb — self-improving trap KB

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.

/sap-stms — transport to production

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.

/sap-gui-probe + skill-scaffold

Probe an unknown transaction with natural-language scenarios → scaffold a working skill draft. Custom screens in days, not weeks.

/sap-compare + /sap-explain-object

Diff the same object across two systems, or get a structure + call-map dossier for an unfamiliar program. Read-only.

Multi-profile + AI-session pin

DPAPI-encrypted profiles per SAP system; each conversation pins to one; subagents inherit the pin.

FM-signature pre-fetch + cache

Live RFC fetch of FM interfaces kills the most common AI hallucination class.

Customer Brief profile

One-page project profile applied across every skill, with MODE flags for the agent.

Structured JSONL logs

Every skill emits start/step/stop. Run-id propagation across PS1 + VBS. Audit-ready.

Customer Brief

The Customer Brief is your secret weapon

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.

  • Defined once per project, evolves with your codebase
  • Override naming rules, type maps, conversion rules per customer
  • Drives MODE flags (OOP, unit tests, perf band, authz strictness) for the agent

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

Be among our first reference customers

We are running a heavily-discounted pilot programme to build production case studies

  • Heavily discounted 1-week pilot scoped to one add-on
  • Or scope it to an S/4HANA custom-code migration assessment
  • On-site or remote (Tokyo / Beijing / Shanghai / global)
  • Full Customer Brief, custom skills if your screens need them
  • You keep everything — GPL-3.0, no lock-in
  • Limited to 3 pilots before we move to standard pricing
Apply for the pilot →

How we work with you

Every engagement is a quotation — these are the shapes most projects take

Pilot engagement

1 week, 1 add-on, before/after metrics. Heavily discounted for early reference customers.

Onboarding + Customer Brief

Author your project profile, install the toolkit, train your team. 2-3 weeks.

Custom skills

Your MM02 has 6 custom screens? /sap-gui-probe + skill-scaffold cuts the work to days.

S/4HANA migration assessment

Inventory your custom code, find what is unused, and get a readiness + remediation plan before you commit to the conversion.

Team training

1-2 day workshops. Hands-on with your real codebase, not generic demos.

Annual support

For teams who deploy to production. SLA-backed help when things break.

Every engagement is by quotation. Tell us about your project →

Frequently asked

Is it really free? +

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.

Where do my SAP credentials go? +

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.

Can it drive multiple SAP systems in one session? +

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.

Will it work with our non-Unicode kernel / Japanese codepage? +

Yes. We detect Unicode vs non-Unicode and convert CJK source via ADODB so uploads never garble.

We have heavily customised MM/SD screens — does it still work? +

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.

On-premises only — no cloud? +

Everything runs on your developer workstation. The Claude API is the only outbound call (and you control which model and key).

Why GPL-3.0? +

So you can audit it, fork it, never be held hostage. Your operational dependency is on your team, not on us.

What's required SAP-side? +

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.

What does the abap-developer agent actually do? +

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.

Can it help with our S/4HANA migration? +

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.

Is it safe to adopt under strict enterprise change control? +

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.

Can it help when something breaks in production? +

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.

What's on the roadmap? +

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.

Does sapdev.ai trigger SAP Indirect Access licensing for our SAP system? +

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.

Let's talk

Tell us about your project. We respond within one business day.

or email directly: hello@sapdev.ai