Generate ABAP and Its Unit Tests, Then Run ATC

Tier: Core · Workflow area: ERP Development & Testing · ~40 minutes

ABAP is late to the AI party and arriving fast: Joule for Developers sits in ABAP Development Tools and generates code, unit tests and explanations against clean-core rules. The professional stance is neither refusal nor faith — it is the loop this playbook drills: AI drafts, ABAP Unit proves behavior, ATC proves standards, and a human owns the transport. Nothing reaches the transport queue on the model's word alone.

When to use

• Net-new custom development in S/4HANA or BTP ABAP Environmentnew classes, RAP behavior implementations, wrappers around released APIs; generation shines where there is no legacy context to misread.
• The test-coverage debt on your custom code is embarrassinggenerating ABAP Unit tests for existing, well-understood classes is often the highest-value, lowest-risk use of ABAP AI: the tests either pass against real behavior or teach you something.
• You need first-party evidence for the AI-tooling decisionone measured transport (time with, time without, findings caught) beats any vendor benchmark in your steering-committee deck.

When NOT to use

• Modifying poorly-understood legacy with hidden side effectsa 4,000-line include with global state and implicit DB commits will mislead the model exactly where it misleads humans. Characterization tests first (generate those), changes second.
• Skipping ATC because "it's generated, it's modern"generated ABAP happily produces SELECTs in loops, missing authority checks and non-released API usage. Generation changes who types, not what must be checked.
• Where clean-core rules bar the object entirelyno AI output justifies a modification to SAP objects or use of unreleased APIs; the checker that catches this (ATC) is the gate, not a formality.

The recipe

1. 1.

   Write the spec as if for a junior developer. Joule in ADT (or Claude/GPT if your org lacks Joule licensing) performs in proportion to spec precision:

   Copy

   Generate an ABAP class ZCL_CREDIT_EXPOSURE for S/4HANA on-premise,
   clean ABAP style, no direct SELECT on database tables — data access
   through a private method I can later replace (constructor injection
   of an interface for testability).
   
   Behavior: method GET_EXPOSURE(customer id, currency) returns the sum
   of open sales order values plus open AR items, converted to the
   requested currency. Raise a class-based exception ZCX_CREDIT_INPUT
   for an initial customer id. Amounts use type CURR handling — never
   float arithmetic.
   

   The testability constraint (injectable data access) is the line that makes step 2 possible; ask for it explicitly, always.

2. 2.

   Generate the ABAP Unit test class against behavior, not implementation.

   Copy

   CLASS ltc_credit_exposure DEFINITION FINAL FOR TESTING
     DURATION SHORT RISK LEVEL HARMLESS.
     PRIVATE SECTION.
       DATA cut TYPE REF TO zcl_credit_exposure.
       METHODS setup.
       METHODS sums_orders_and_ar      FOR TESTING.
       METHODS initial_customer_raises FOR TESTING.
       METHODS zero_open_items_is_zero FOR TESTING.
   ENDCLASS.
   

   Ask the model for the test cases as a list first, review the list for missing edges (currency with no conversion rate? negative AR from credit memos?), then have it implement with a test double injected for data access. A generated test suite that only covers the happy path is the most common failure — the review-the-list step catches it.

3. 3.

   Run the tests and believe only the runner. Execute ABAP Unit in ADT (Ctrl+Shift+F10). First-run failures are normal and are the point: read each red case and decide whether the class is wrong or the test encodes a wrong assumption. Do not let the model "fix" tests to green without you adjudicating which side was correct — that laundering step is where silent bugs enter.

4. 4.

   Run ATC and treat findings as the syllabus. Check the class with your org's ATC variant (Ctrl+Shift+F2 in ADT, or transaction ATC centrally). Typical findings on generated code: performance patterns (SELECT in loop), missing AUTHORITY-CHECK, naming-convention violations, and — decisive for clean core — usage of unreleased objects flagged by cloud-readiness checks. Paste any finding you don't recognize into the assistant with "explain this ATC finding and show the compliant rewrite," then verify the rewrite reruns clean and the unit tests still pass.

5. 5.

   Remediate, re-run both gates, and only then release. The exit condition is mechanical: ABAP Unit green, ATC clean (or findings formally exempted through your normal exemption workflow — never self-approved), code reviewed by a human who read every line they are signing. Then release the transport. If you use abapGit, commit the class and test class together; generated code without its tests in version control is half an artifact.

6. 6.

   Record the measurement. Two numbers with the transport: wall-clock time for the full loop, and your honest estimate for the manual equivalent. Plus one count: defects the gates caught in generated code. Three transports of this and your team has an evidence-based position on ABAP AI — which is the deliverable SAP's marketing can't ship you.

Make it yours

• SAP BTP ABAP Environment (Steampunk)same loop, stricter gates: only released APIs compile at all, so generation errors surface earlier; keep DURATION SHORT discipline since test runs gate pipelines.
• Oraclethe sibling workflow is PL/SQL generation with utPLSQL as the unit gate and PL/Scope plus your linting standards as the ATC analogue; the spec-tests-static-checks-human ordering is identical.
• Microsoft Dynamics 365 F&OX++ with Copilot: unit tests via SysTest framework, and Customization Analysis Report (CAR) playing the ATC role before any deployable package ships.

Quality check

• Test cases were reviewed as a list before implementationcoverage judgment is yours; the model defaults to happy paths.
• Every red-to-green transition was adjudicated by a humanknow, for each fixed test, whether the code or the test was wrong.
• ATC ran with the org variant, not a defaulta clean run against the wrong check variant is a compliance costume.
• Currency and quantity arithmetic was eyeballed specificallygenerated ABAP mishandles CURR/QUAN semantics often enough that this line item earns its place.
• The effort measurement was written downan unrecorded verification is an anecdote by Friday.