# Sc4sap:create Program

> Create ABAP programs (Report/CRUD/ALV/Batch) with Main+Include structure, OOP or Procedural, and full agent-driven coding/QA pipeline

- Skill: `babamba2/sc4sap-create-program` (Agent Skill, multi-file: 14 files)
- Install (CLI): `npx skillmds@latest add babamba2/sc4sap-create-program`
- Raw SKILL.md: https://api.skillmd.com/api/skills/babamba2/sc4sap-create-program/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: babamba2 (https://skillmd.com/u/babamba2)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/babamba2/sc4sap-create-program

---


# SC4SAP Create Program

Core ABAP program creation skill. Generates a Main Program wrapped with conditional Includes following the sc4sap template convention. Supports both OOP (two-class split: Data + Screen/ALV) and Procedural (PERFORM) paradigms. Full pipeline: SAP version preflight → Socratic interview → planner → writer spec → user confirm → executor/qa/reviewer.


<Purpose>
sc4sap:create-program is the flagship skill for creating new ABAP programs. It handles a wide range of purposes (Report, CRUD, ALV list, Batch, Interface). Before coding starts, it runs an internal Socratic interview to resolve ambiguity, then produces a confirmed spec, then orchestrates coding and QA agents to deliver activated, tested ABAP objects following sc4sap conventions.
</Purpose>

<Response_Prefix>Every response triggered by this skill MUST begin with `[Model: <main-model> · Dispatched: <sub-summary>]` per [`../../common/model-routing-rule.md`](../../common/model-routing-rule.md) § Response Prefix Convention.</Response_Prefix>

<Phase_Banner>Multi-phase skill. Before each `Agent(...)` dispatch, emit `▶ phase=<id> (<label>) · agent=<name> · model=<Opus 4.7|Sonnet 4.6|Haiku 4.5>` per [`../../common/model-routing-rule.md`](../../common/model-routing-rule.md) § Phase Banner Convention.</Phase_Banner>

<Team_Mode>Four teamMode integration points — Type A: **Phase 1A** (post-interview cross-module consistency) + **Phase 2** (planner conflict resolution) — see [`team-mode.md`](team-mode.md). Type B: **Phase 4 Wave 2/3** (executor's novel code gets live consultant review) — see [`team-mode-b.md`](team-mode-b.md). Type D: **Phase 1A↔1B bridge** — **user-chosen** at Phase 1A close (legacy sequential 1B vs Type D team synthesis); analyst + architect + consultant parallel synthesis replaces sequential 1B when selected — see [`team-mode-d.md`](team-mode-d.md). Base protocol: [`../../common/team-consultation-protocol.md`](../../common/team-consultation-protocol.md).</Team_Mode>

<Use_When>
- User says "create program", "new report", "ALV program", "CRUD program", "make me a batch program", etc.
- A new ABAP executable program (REPORT) needs to be created from scratch
- Program requires the Main+Include wrapping convention
- ALV display is needed (full CL_GUI_ALV_GRID or simple SALV popup)
</Use_When>

<Do_Not_Use_When>
- Creating a single class/interface/table — use `/sc4sap:create-object`
- Modifying an existing program — use direct `UpdateProgram` / `UpdateInclude` MCP calls
- Creating a RAP business object / OData service — use `/sc4sap:create-object` (with service binding + behavior definition)
- User wants only scaffolding without coding — use `/sc4sap:create-object` with type=program
</Do_Not_Use_When>

<Shared_Conventions>
The following rules are **shared across sc4sap skills** and live in `sc4sap/common/`. Load and apply them during the relevant phases of this skill:

| Convention | Reference File | Applied In |
|------------|----------------|------------|
| Include structure (t/s/c/a/o/i/e/f/_tst) | `../../common/include-structure.md` | Planner, Executor |
| OOP two-class pattern (LCL_DATA + LCL_ALV) | `../../common/oop-pattern.md` | Executor (OOP mode only) |
| ALV rules (Full vs SALV, field catalog standard) | `../../common/alv-rules.md` | Executor, Reviewer |
| Text element rule (no hardcoded display literals) | `../../common/text-element-rule.md` | Executor, Reviewer |
| Constant rule (no magic literals in logic) | `../../common/constant-rule.md` | Executor, Reviewer |
| Procedural FORM naming (`_{screen_no}` suffix) | `../../common/procedural-form-naming.md` | Executor (Procedural mode only), Reviewer |
| Naming conventions (program/include/class/screen) | `../../common/naming-conventions.md` | Planner, Executor, Reviewer |
| ECC DDIC fallback (Table / DTEL / DOMA on ECC) | `../../common/ecc-ddic-fallback.md` | Planner (gate), Executor (program generation), Reviewer |
| Clean ABAP — shared baseline | `../../common/clean-code.md` | Executor, Reviewer (always) |
| Clean ABAP — **OOP paradigm** | `../../common/clean-code-oop.md` | Executor, Reviewer — **only when Phase 1B `paradigm = OOP`** |
| Clean ABAP — **Procedural paradigm** | `../../common/clean-code-procedural.md` | Executor, Reviewer — **only when Phase 1B `paradigm = Procedural`** |
| **Mandatory main-program template (OOP)** | `../../common/oop-sample/zrsc4sap_oop_ex.prog.abap` (+ companion includes / screens in same folder) | Executor Wave 3 (starting skeleton) + Reviewer B3 bucket (structural match) — OOP paradigm |
| **Mandatory main-program template (Procedural)** | `../../common/procedural-sample/main-program.abap` | Executor Wave 3 + Reviewer B3 bucket — Procedural paradigm |

Paths are relative to this skill's directory (`sc4sap/skills/create-program/`).

**ECC DDIC fallback gate.** When the planner's object list includes a new Table, Data Element, or Domain AND `SAP_VERSION = ECC`, Phase 4 (Executor) must not call `CreateTable` / `CreateDataElement` / `CreateDomain`. Instead, follow [`../../common/ecc-ddic-fallback.md`](../../common/ecc-ddic-fallback.md): generate a helper report in `$TMP` using the matching template under `skills/create-object/ecc/`, activate the helper, then emit the mandatory user message (SE38 run → uncheck dry-run → SE11 activate + assign transport). Do not treat the DDIC object as created until the user confirms activation. Remaining objects (classes, includes, screens, …) proceed on the normal flow; the plan should sequence the DDIC helpers first so the user can create them before code that depends on them is activated.
</Shared_Conventions>

<Preflight_SAP_Version_Check>
**MUST run BEFORE the Socratic interview starts.** The entire development approach (tables, BAPIs, CDS availability, ABAP syntax, RAP eligibility) depends on the SAP platform and release.

Steps:
1. Read `.sc4sap/config.json` for `sapVersion`, `abapRelease`, and `activeModules`
   - Also read `.sc4sap/sap.env` → `SAP_ACTIVE_MODULES` as fallback
   - Load `common/active-modules.md` and precompute the cross-module concern list for the program's primary module. Every downstream phase (planner, writer, executor) receives this list and must factor in integration fields (e.g., MM primary + PS active → add `PS_POSID`).
2. If missing or stale, ask the user to confirm:
   - **ECC** (ECC 6.0) — classical DDIC, LFA1/KNA1/BKPF/BSEG/MKPF/MSEG world, SAPGUI only
   - **S/4HANA On-Premise** — ACDOCA, MATDOC, Business Partner (BUT000), CDS/AMDP preferred, Fiori possible, ADT-first
   - **S/4HANA Cloud (Public)** — **no classical Dynpro**, **no SE80 custom dev**, only **Developer Extensibility** / **Key User Extensibility** (RAP managed, Custom Fields/Logic, Custom Business Objects)
   - **S/4HANA Cloud (Private)** — similar to On-Premise but with extensibility-first mindset
3. Confirm `abapRelease` (e.g. `750`, `756`, `758`) — drives allowed syntax

Branching consequences:
- **ECC**: no RAP, no ACDOCA, no Business Partner; inline decl only if 740+; CDS/AMDP typically unavailable (<750)
- **S/4HANA On-Prem**: prefer CDS + AMDP, RAP where applicable, Business Partner APIs, ACDOCA for finance
- **S/4HANA Cloud Public**: **REJECT classical Dynpro / custom screen + GUI Status requests**. The standard Full-ALV path (CL_GUI_ALV_GRID + Docking Container) is not executable on Cloud Public — must redirect to RAP + Fiori Elements, `if_oo_adt_classrun`, or SALV-only output. Fail-fast with an explanation. **Full prohibited-statement list and Cloud-native API replacements**: see [`../../common/cloud-abap-constraints.md`](../../common/cloud-abap-constraints.md).
- **S/4HANA Cloud Private**: classical Dynpro technically possible but discouraged; warn user and confirm intent before proceeding.

Outputs:
- `.sc4sap/program/{PROG}/platform.md` — resolved platform, release, and constraints
- Interview dimensions pre-filtered by platform (e.g., ALV-Full hidden on Cloud Public)
</Preflight_SAP_Version_Check>

<Inventory_Lookups>
**Runs immediately after package + module are resolved during the interview** (Phase 1 dimension #6) and feeds every downstream phase. Two sequential inventory passes: **CBO Inventory** (reusable Z*/Y* objects in the target package — delegated to `sap-stocker` on cache miss) then **Customization Inventory** (existing BAdI impls / CMOD projects / form-based exits / appends per module).

Full procedure (when-to-stock, three-option prompt, dispatch template, persistence paths, reuse-gating rules) lives in **[`inventory-lookups.md`](inventory-lookups.md)**. Read and follow literally. Output files consumed by planner / writer / executor:
- `.sc4sap/program/{PROG}/cbo-context.md`
- `.sc4sap/program/{PROG}/customization-context.md`
</Inventory_Lookups>

<Interview_Gating>
**MANDATORY — never skip, never shortcut, never merge.** Phase 1 runs as **two sequential sub-phases** (1A then 1B) on every `sc4sap:create-program` invocation.

Full procedure — two-stage rule, lead agents, dimension lists, skip rules, gates, output files, and enforcement contracts — lives in **[`interview-gating.md`](interview-gating.md)**. Read that file and follow it literally before asking the first question.

**One-line summary**:
> Phase 1A `sap-{module}-consultant` interviews business context (purpose / reason / company rules / reference assets / standard-SAP alternatives) → file `module-interview.md`, gate ≤ 5% → Phase 1B `sap-analyst` + `sap-architect` interview technical dimensions (purpose-type / paradigm / display / screen / data / package / test) → file `interview.md`, gate ≤ 5% → proceed to `<Spec_Approval_Gate>`. Phase 1B never starts before 1A closes; Phase 2 planner refuses to run if either file is missing.
</Interview_Gating>

<Spec_Approval_Gate>
**MANDATORY — never skip, never shortcut.** After `<Interview_Gating>` closes (ambiguity ≤ 5%) and Phase 2 (Planning) produces `plan.md`, the skill MUST run a spec-approval gate before any `Create*` / `Update*` MCP call.

Full procedure — required steps, enforcement contract, rationale, spec template, and the verbatim user-facing approval prompt — lives in **[`spec-approval-gate.md`](spec-approval-gate.md)**. Read that file and follow it literally.

**One-line summary** (the full text lives in the companion file):
> Invoke `sap-writer` → produce `spec.md` → display to user → wait for an **explicit approval keyword** (`승인` / `approve` / `ok` / `proceed` / `go ahead` / `confirmed`). "yes" / "빨리" / "해봐" / silence are NOT approval — loop with revisions. Phase 4 Executor refuses to run if spec.md is missing, unapproved, or modified after approval.
</Spec_Approval_Gate>

<Session_Trust_Bootstrap>
**MANDATORY — runs at the very start of Phase 1A, BEFORE the module consultant asks the first question.** Invoke `/sc4sap:trust-session` with `parent_skill=sc4sap:create-program` to pre-grant MCP tool + file-op permissions for the entire session. This ensures interview-time MCP calls (consultant SPRO lookups, `SearchObject`, `GetWhereUsed`) and downstream Phase 4–8 activity both run without permission prompts.

- If `.sc4sap/session-trust.log` already has a line within the last 24h, skip silently.
- **Exception**: `GetTableContents` and `GetSqlQuery` are NEVER auto-approved — they require explicit per-call user consent. See [`../trust-session/SKILL.md`](../trust-session/SKILL.md) Layer 1.
</Session_Trust_Bootstrap>

<Execution_Mode_Gate>
**MANDATORY — runs between `<Spec_Approval_Gate>` and Phase 4.** After spec approval, the skill prompts the user to pick an execution cadence: `auto` / `manual` / `hybrid`. Persists the choice to `.sc4sap/program/{PROG}/state.json` under `execution_mode`.

`trust-session` is NOT re-invoked here — it already ran at the start of Phase 1A.

Full procedure — verbatim mode-prompt text, per-mode semantics, state.json schema (also drives C-2 resume support), and manual-mode phase-transition prompt — lives in **[`execution-mode.md`](execution-mode.md)**. Read that file and follow it literally before dispatching Phase 4.
</Execution_Mode_Gate>

<Agent_Pipeline>
**The full phase-by-phase pipeline (Phase 0 – Phase 8) lives in [`agent-pipeline.md`](./agent-pipeline.md) in this skill folder.**

Read that file before dispatching any agent. It is the authoritative source for:
- Phase 0 — SAP Version Preflight
- Phase 1A — Module Interview (`sap-{module}-consultant`, business context)
- Phase 1B — Program Interview (`sap-analyst` + `sap-architect`, technical dimensions)
- Phase 2 — Planning (`sap-planner` + consultants, CBO reuse gate, SPRO lookup)
- Phase 3 — Spec Writing (`sap-writer`)
- Phase 4 — Implementation (`sap-executor`)
- Phase 5 — QA (`sap-qa-tester`, OOP mode)
- Phase 6 — Review (`sap-code-reviewer`, **mandatory**, see `phase6-review.md`)
- Phase 7 — Debug escalation (`sap-debugger`)
- Phase 8 — Completion Report (gated on Phase 6 PASS)

Do not inline or paraphrase phase logic here — update `agent-pipeline.md` instead so the pipeline stays single-sourced.
</Agent_Pipeline>

<MCP_Tools_Used>
- `SearchObject` — existence check
- `ListTransports` / `CreateTransport` — transport management
- `GetPackage` — package validation
- `CreateProgram` + `UpdateProgram` — main program
- `CreateInclude` + `UpdateInclude` — all includes (TOP/SEL/CLASS/ALV/PBO/PAI/EVENT/FORM/TEST)
- `CreateScreen` + `UpdateScreen` — custom screens (ALV full mode)
- `CreateGuiStatus` + `UpdateGuiStatus` — PF-Status for custom screens
- `CreateTextElement` + `UpdateTextElement` — text-xxx resources
- `GetAbapSemanticAnalysis` — pre-activation syntax check
- `GetInactiveObjects` — post-activation verification
- `RunUnitTest` / `GetUnitTestResult` — QA (OOP mode)
</MCP_Tools_Used>

<State_Files>
- `.sc4sap/program/{PROG}/platform.md` — Phase 0 preflight output
- `.sc4sap/program/{PROG}/module-interview.md` — Phase 1A business interview (consultant-led: purpose / reason / company-specific rules / reference assets / standard-SAP alternatives)
- `.sc4sap/program/{PROG}/interview.md` — Phase 1B technical interview (analyst+architect-led: 7 dimensions Q&A log)
- `.sc4sap/program/{PROG}/cbo-context.md` — CBO reuse candidates (written by `<Inventory_Lookups>` / [`inventory-lookups.md`](inventory-lookups.md))
- `.sc4sap/program/{PROG}/customization-context.md` — Z*/Y* BAdI impl / CMOD / form-exit / append reuse candidates (written by `<Inventory_Lookups>` / [`inventory-lookups.md`](inventory-lookups.md))
- `.sc4sap/program/{PROG}/plan.md` — planner output
- `.sc4sap/program/{PROG}/spec.md` — writer output (requires user confirm)
- `.sc4sap/program/{PROG}/state.json` — execution_mode + per-phase status/timing (schema in `execution-mode.md`, drives resume support)
- `.sc4sap/program/{PROG}/review-bucket-{B1|B2|B3|B4}.md` — Phase 6 per-bucket reviews (merged into review.md, see `phase6-buckets.md`)
- `.sc4sap/program/{PROG}/review.md` — Phase 6 consolidated review
- `.sc4sap/program/{PROG}/report.md` — final completion report
- `.sc4sap/program/{PROG}/{spec,report}.html` — optional single-file HTML copies, offered after Phase 8
- `.claude/settings.local.json` — permissions allowlist (written by `/sc4sap:trust-session` during Phase 3.5)
- `.sc4sap/session-trust.log` — audit trail of `trust-session` invocations
</State_Files>

Task: {{ARGUMENTS}}