SkillSkilltypeA procedure an agent follows. Indexed here, never written here.See every one →What this type is →independently maintainedindependently maintainedoriginPublished by one person or a small company outside SAP. Says nothing about quality; the readings say that.See every one →

abap-offstack-aunit

An agent skill that bootstraps off-stack ABAP Unit tests and an abaplint gate onto an abapGit-serialised repository, with no live SAP system.

The skill hands a coding agent a procedure and a scaffold to copy into an abapGit repository: the abaplint transpiler and open-abap-core turn serialised ABAP into JavaScript, and the repository's existing ABAP Unit tests then run on Node.js. It names three judgement calls the agent must make, and must put to the developer where it cannot infer them: the dialect to pin as syntax_version, shim or factory for each class under test that drags in a database, BAPI or HTTP adapter, and the minimal DDIC fixtures, discovered by following compileError. The scaffold is a test-offstack/ runner, a GitHub Actions workflow and an abaplint.json, and once it is in the repository it runs without the agent: npm test locally, and in CI abaplint first with the off-stack tests behind needs: lint, where a red job blocks the pull request. Beside SKILL.md sit four reference files, on dialect pinning, shim against factory, DDIC fixtures and CI wiring. The maintainer records that the skill itself was written with AI assistance and reviewed by hand, and that the abaplint and open-abap tooling it leans on is MIT and fetched at build time rather than redistributed.

Facts

Last pushLicenceApache-2.0

Where it sits

Lives in
Provides
Agent guidanceABAPAgent guidancecapabilityPackaged knowledge you hand a coding agent so it gets a framework right unprompted — skills, rule files, instruction packs. Distinct from agent tooling, which is about building agentic features into your application, and from [agent access to your code](capability:agent-code-access), where the agent reads the real project instead of being handed a file about it.
Requires
Node.jsNode.jsoutside the atlasThe transpiled ABAP and the ABAP Unit tests run as a Node process, both on a developer's machine and in the CI job the scaffold installs.abaplintabaplintartifactThe transpiler and the static-analysis gate both come from the abaplint toolchain, which the scaffold installs from npm rather than bundling.abapGitabapGitartifactThe ABAP under test must be abapGit-serialised into a Git repository for the scaffold to run against it.@abaplint/transpiler@abaplint/transpilerartifactTranspiles the serialised ABAP to JavaScript so the existing ABAP Unit tests can run on Node.open-abap-coreopen-abap-coreartifactSupplies the ABAP runtime library the transpiled code runs against on Node.

Who is behind it

alokm3hta-staralokm3hta-starPersonMaintains this
In the atlas: maintains 1, contributes to 1
@alokm3hta-star
maintainer

Before choosing this

Conditions

PracticalFunctional boundary

Not a substitute for testing in a system: the README states that any class calling the database, classic BAPIs or HTTP is shimmed out and stays an on-stack ATC and ABAP Unit concern, and that an off-stack green is CI-grade provenance rather than an in-system pass. It also assumes a particular shape of project. The ABAP has to be abapGit-serialised into a Git repository, Node.js 22 or later has to be available locally and in CI, and the CI has to be GitHub Actions.

What it declares

Every artifact

Type
Skill
Origin
Independently maintained

As a skill

Distributed through
npm

For agent guidance

Installs into
Claude CodeCursorCodexOpenCode
System reach
None needed

Tasks this contributes to1Beta

Work on ABAP with an agent and no system connectionA developer wants to review, write or test ABAP with an agent on a machine that has no connection to an SAP system — a serialised repository checked out, or source pasted into the session, and nothing else.Standard ABAP, ABAP CloudCoversa test harness that runs the existing ABAP Unit tests off the system
What it does

The skill sets up a harness and then gets out of the way: the abaplint transpiler and open-abap-core turn serialised ABAP into JavaScript and the repository's own ABAP Unit tests run on Node, locally and in a CI job the scaffold installs. Its README states that nothing requires a provisioned SAP system, which is the plainest answer to this outcome in the corpus.

Remaining work

The ABAP has to be abapGit-serialised into a Git repository, Node 22 or later available locally and in CI, and the CI has to be GitHub Actions. The agent also makes three judgement calls the README names, and puts them to the developer where it cannot infer them.

All options on the Agent guidance page →

Connections6

abap-offstack-aunit connectionsabap-offstack-aunitPROVIDES→ provides1provides stated Carries the off-stack testing procedure as agent-facing guidance with a copyable scaffold: dialect pinning, class isolation, DDIC fixtures and the GitHub Actions wiring, so the agent sets the harness up rather than being told the steps each time. abap-offstack-aunit — README, Two layers: https://github.com/alokm3hta-star/abap-offstack-testing abap-offstack-aunit — README, Using it once installed: https://github.com/alokm3hta-star/abap-offstack-testingAgent guidanceNEEDS→ needs5needs stated Transpiles the serialised ABAP to JavaScript so the existing ABAP Unit tests can run on Node. abap-offstack-testing README: https://github.com/alokm3hta-star/abap-offstack-testing@abaplint/transpilerneeds stated The ABAP under test must be abapGit-serialised into a Git repository for the scaffold to run against it. abap-offstack-testing README: https://github.com/alokm3hta-star/abap-offstack-testingabapGitneeds stated The transpiler and the static-analysis gate both come from the abaplint toolchain, which the scaffold installs from npm rather than bundling. abap-offstack-aunit — README, What it does: https://github.com/alokm3hta-star/abap-offstack-testingabaplintneeds stated The transpiled ABAP and the ABAP Unit tests run as a Node process, both on a developer's machine and in the CI job the scaffold installs. abap-offstack-aunit — README, Requirements: https://github.com/alokm3hta-star/abap-offstack-testingNode.jsneeds stated Supplies the ABAP runtime library the transpiled code runs against on Node. abap-offstack-testing README: https://github.com/alokm3hta-star/abap-offstack-testingopen-abap-core

Install

npx skills add alokm3hta-star/abap-offstack-testing --skill abap-offstack-aunit

Copied from abap-offstack-aunit — README, Install, read . Not run by the atlas.

README

quoted from alokm3hta-star/abap-offstack-testing under Apache-2.0, read
alokm3hta-star/abap-offstack-testing/README.mdOn GitHub

abap-offstack-aunit

An AI coding-agent skill that bootstraps off-stack ABAP Unit testing plus an abaplint static-analysis gate onto an abapGit-serialised ABAP repository — running entirely in CI (GitHub Actions) with no live SAP system.

It is structured for registration with the SAP AI Skills Library (SAP/ai-skills-library, bring-your-own-repo model).

What it does

The skill transpiles serialised ABAP to JavaScript with the abaplint transpiler and open-abap-core, then runs the repo's existing ABAP Unit tests on Node. It covers dialect pinning, breaking a class-under-test free of heavy DDIC drag (shim vs factory), minimal DDIC fixtures, a reproducible npm ci setup, and wiring the off-stack job beside the abaplint lint job in GitHub Actions.

It is grounded entirely in open-source tooling (abaplint and open-abap are MIT, by Lars Hvam and the open-abap organisation) plus GitHub Actions. Nothing requires a provisioned SAP system.

Two layers: the skill vs the scaffold

This is an AI-agent skill, not a standalone CLI. Two things are distinct:

  • The skill (SKILL.md + references/ + assets/) is guidance for a coding agent. You install it into the agent.
  • The scaffold (test-offstack/, the workflow, abaplint.json) is what the agent copies into your ABAP repository. That is what actually runs the tests.

The agent is the consumer; your abapGit repo is the target.

Requirements

  • Your ABAP is abapGit-serialised into a Git repository (.clas.abap etc.).
  • Node.js 22+ and npm available locally and in CI.
  • CI is GitHub Actions.

Skills in this repository

SlugDescription
abap-offstack-aunitBootstrap off-stack ABAP Unit + an abaplint CI gate onto an abapGit repo, with no live SAP system.

Install

Once this repository is public on GitHub, install the skill into a coding agent (Claude Code, Cursor, Codex, OpenCode, and others) with the skills CLI:

npx skills add alokm3hta-star/abap-offstack-testing --skill abap-offstack-aunit

Using it once installed

You do not call a command. You ask your agent, in natural language, from inside your ABAP repo:

"Set up off-stack ABAP Unit tests and an abaplint gate in CI for this repo, targeting S/4HANA 2025."

The skill's description triggers, the agent loads SKILL.md, and it:

  1. Detects greenfield vs existing CI and copies the right assets into the repo.
  2. Makes the three judgement calls, asking you where it cannot infer them: the dialect (syntax_version, e.g. v816); shim vs factory for each class-under-test that drags in a database / BAPI / HTTP adapter; and the minimal DDIC fixtures (discovered iteratively via compileError).
  3. Runs npm ci && npm test locally to prove the harness is green before handing back.

After that the harness stands on its own, no agent required:

  • Locally: cd test-offstack && npm test (exit 0 = all passed).
  • In CI: every push and pull request runs abaplint, then the identical off-stack tests (needs: lint); a red job blocks the PR.

Scope boundary (important): this verifies orchestration and pure-ABAP logic only. Any class calling the database, classic BAPIs, or HTTP is shimmed out and stays an on-stack ATC + ABAP Unit concern. An off-stack green is CI-grade provenance, not an in-system pass. See skills/abap-offstack-aunit/SKILL.md for the full agent-facing detail.

Layout

skills/
└── abap-offstack-aunit/
    ├── SKILL.md                 # the skill (name + description frontmatter)
    ├── references/              # deep-dive guidance
    │   ├── setup-and-dialect-pinning.md
    │   ├── cut-isolation-shim-vs-factory.md
    │   ├── ddic-fixtures.md
    │   └── ci-wiring.md
    └── assets/                  # copyable scaffold
        ├── test-offstack/       # runner, config, package + lockfile, README
        ├── workflows/           # greenfield workflow + mergeable off-stack job
        ├── abaplint.json        # greenfield root abaplint config
        └── gitignore-snippet

Author

Alok Mehta.

Provenance

This skill was authored with AI assistance and reviewed by a human maintainer, who takes responsibility for its content. It is grounded in open, publicly documented tooling (the abaplint / open-abap ecosystem and GitHub Actions) and contains no proprietary, customer-specific, or SAP-internal material. Disclosed in line with SAP's guidance on AI-generated contributions.

Licence

Apache-2.0. See LICENSE. This repository is REUSE-compliant.

The bundled scaffold depends on third-party open-source tools that are not redistributed here (fetched at build time): the abaplint toolchain (@abaplint/core, @abaplint/transpiler, @abaplint/runtime, @abaplint/cli) and open-abap-core, all MIT-licensed. The transitive npm dependencies are all permissive (MIT / ISC / BSD-3-Clause / BlueOak-1.0.0); there is no copyleft. See NOTICE for provenance and third-party attributions.

Trademarks

SAP and ABAP are trademarks or registered trademarks of SAP SE (or an SAP affiliate). "abaplint" is an independent open-source project. These names are used here nominatively to describe interoperability only. This skill is an independent work and is not affiliated with, sponsored by, or endorsed by SAP SE or the abaplint project.

Apache-2.0, read
Agent guidance
  1. abap2UI5 for VS CodeVS Code extension to preview, activate and lint abap2UI5 apps
  2. sap-basis-opsRunbook skills for Basis operations at the OS and database layer
  3. ARC-1 SkillsTwenty-two agent skills shipped with arc-1
  4. sapskillsAgent skills for Clean ABAP, ADT in VS Code and guardrails
  5. SuperClaude for SAPClaude Code plugin with an ABAP MCP server and write guards
  6. claude-abap-devFive ABAP workflows for Claude Code on existing MCP servers
  7. DanKromp/skillOverflowCollection of 41 agent skills, 37 for SAP development tasks
  8. sap-ai-dev-toolkitMCP proxy pinning an agent's ABAP tools to one SAP system
  9. sapcli Claude Code PluginAgents and skills that drive sapcli instead of ADT
  10. sap-odata-explorerRust CLI and desktop app for exploring SAP OData services
  11. abap-skillsSeventeen agent skills for ABAP development
  12. ABAP remote filesystemVS Code extension editing ABAP systems over ADT as a filesystem
  13. WerkbankLocal desktop workspace for AI conversations with SAP connectors
  14. claude-abap-skillsClaude Code plugins with Clean ABAP rules and templates
  15. SAP Power for KiroSAP skills for the Kiro IDE
  16. SAP Developers MCPHosted MCP server of developers.sap.com tutorials and missions
  17. secondsky/sap-skillsForty SAP development plugins for coding agents
  18. claude-sap-kitClaude Code plugin adding Custom_* tools to arc-1
  19. rap-skillsRAP skills delivered branch-per-target for each deployment
  20. KlystronMCP server in ABAP inside the application server, with agent skills

Details

Sources3
SAP AI Skills Librarydiscovered here, skills.cloud.sapchecked
github.com/alokm3hta-star/abap-offstack-testingtree, pushes, contributors, CIchecked
README.mdquoted, and what the entry declareschecked

Sources are graph entities: the same page may back several entries, and an unreachable source flags every row that rests on it.

Compatibility and provenance
discovered viaSAP AI Skills Library · skills.cloud.sap
first seen in the atlas
ecosystem and domainabap, ai-and-agents
History in the atlas3
  1. installs_into: Claude Code, Cursor, Codex, OpenCode; system_reach: None needed
  2. In the SAP AI Skills Library registry snapshot since the baseline of 2026-09-18 and never drafted; the registry record for skills/abap-offstack-aunit changed before the 2026-10-09 check, so it enters as a new entry rather than a revision. Written from the repository's own README; hard rule 7: skills are indexed, never authored here. The registry's skillspector scan is its own dated claim and is not carried as a field.
  3. First seen.
For your agent
Ref
artifact:alokm3hta-star-abap-offstack-testing
JSON
/artifacts/alokm3hta-star-abap-offstack-testing.json
MCP
Connecting an agent