Module To Process by babamba2 — AI Skill for Any LLM

Overview

Publisher	babamba2
Repository	`superclaude-for-sap`
Skill name	`module-to-process`
Stars	69
Forks	26
Bundled files	8
License	MIT
Links	Skill source Repository Homepage

Markdown instructions

A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

Works with any LLM

AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

8 bundled files

Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

Open source

Published by babamba2 on GitHub. Read the source before you install it.

Installation

Install the Module To Process AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

Open the app and go to Plugins → Skills.
Choose "Install from GitHub".
Paste the skill folder URL below and confirm.
https://github.com/babamba2/superclaude-for-sap/tree/main/skills/module-to-process
Enable the skill in any chat where you want it available.

Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills

git clone --depth 1 https://github.com/babamba2/superclaude-for-sap.git /tmp/superclaude-for-sap
mkdir -p .claude/skills
cp -r /tmp/superclaude-for-sap/skills/module-to-process .claude/skills/module-to-process

Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Module To Process in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Module To Process on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Module To Process is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

Loaded only when it is needed

The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

Switch models mid-chat

Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

SC4SAP Module → Process Map

Reads the CBO packages of one module via MCP, places every Z entry point on the module's standard process backbone, and writes one HTML page a module consultant reads on day one of a project: which processes run, who runs each task, in which system, through which standard TCodes and which CBO programs, which variants exist, and what a conversion touches.

<Response_Prefix>Every response triggered by this skill MUST begin with [Model: <main-model> · Dispatched: <sub-summary>] per ../../common/model-routing-rule.md § Response Prefix Convention.</Response_Prefix> <Target_Object>Packages and TCodes are looked up on the active profile's system only. Not found → stop and ask per ../../common/multi-profile-artifact-resolution.md § Target object not on the active system — never substitute a similar name, never switch profiles on your own.</Target_Object>

<Phase_Banner> Multi-phase skill. Before each Agent(...) dispatch, emit ▶ phase=<id> (<label>) · agent=<name> · model=<Opus|Sonnet|Haiku> per ../../common/model-routing-rule.md § Phase Banner Convention. Resolve the dispatch mode first per ../../common/model-dispatch-mode.md and the cost mode per ../../common/cost-mode.md (eco → pass BOTH model and effort on every Agent(...) call, Skill("sc4sap:eco", "--attach") first and on every continuation turn). </Phase_Banner>

<Progress_Bar> Every Step entry prints one line: Step X/9 · <label> [<20-char bar>] NN% — filled cells = floor(X × 20 / 9), NN = floor(X × 100 / 9), █ / ░, no colors. Table and sub-progress lines: workflow.md § Progress Reporting. A skipped or resumed Step still prints its line with (skipped — <reason>) / (resumed — <file>). </Progress_Bar>

<Use_When>

"module to process", "모듈 프로세스", "프로세스 맵", "BPH 만들어줘", "모듈 업무 흐름 파악", "conversion 전에 프로세스 정리", "process map of SD", "業務プロセスマップ"
Project start (conversion, enhancement, AMS takeover): the consultant needs the module's processes as this system runs them
Fit/Gap preparation: standard vs CBO per task, used vs unused
The user names a module and one or more packages / Z TCodes </Use_When>

<Do_Not_Use_When>

Reusable-object catalog of one package → /sc4sap:analyze-cbo-obj
One program in depth → /sc4sap:program-to-spec · end-user steps → /sc4sap:program-to-manual
Configuration (IMG) of a module → /sc4sap:config-to-document
Code quality → /sc4sap:analyze-code
No Z package and no Z TCode at all (nothing to place; the standard backbone alone is SAP documentation) </Do_Not_Use_When>

<Session_Trust_Bootstrap> MANDATORY — Step 0, before any MCP call or user interaction. Invoke /sc4sap:trust-session with parent_skill=sc4sap:module-to-process. Skip silently if .sc4sap/session-trust.log has a line within the last 24h. Full spec: ../trust-session/SKILL.md. </Session_Trust_Bootstrap>

<Decisions_Fixed> Settled at design time (2026-10-27) — do not ask the user again:

Topic	Decision
Scope	One module, or one process area of several modules (e.g. SD + MM + LE); one or more CBO packages, plus loose Z TCodes
Usage source	Measured usage is saved under `<SCOPE_DIR>` and can be reused as a submitted file (no live productive-system access needed on later runs)
Usage-first	Only TCodes users actually run (ST03N of the productive system via `SAP_USAGE_RFCDEST`, or a submitted export) are analysed; unused ones are counted per package, never fetched. Batch programs join only from a job list
Hierarchy	BPH form: L1 mega process > L2 process chain > L3 process > L4 task; variants under L4 (org unit / document type / scenario)
Backbone	Standard SAP tree from `configs/<MODULE>/process-backbone.json`; CBO objects attach to L4 tasks; CBO-only tasks are added where no standard task fits
Output	ONE self-contained HTML page (no PPT, no xlsx export) with a built-in edit mode (texts, BPH rows, list items, undo, autosave, Save embeds the model; `build-process-doc.mjs --import` reads it back)
Pictures	Per L3 a scenario swimlane (lanes = owners, fill = system, border = type, double border = interface) + variant matrix; per L4 a step swimlane next to the decision flow
Existing BPH	Optional: a customer BPH / BPML workbook is read (`bph-import.mjs`) for wording and reconciled with the result (proposed matches, BPH-only, document-only)
Per L4	Task sheet in PDD form: header (owner, system, type, output, timing), definition, variants, business rules with source lines, steps, related objects with usage, interfaces, related tasks, conversion notes, to-be-confirmed items
Owners	Organisations / roles as lanes; user-supplied when given, else estimated and marked `(estimated)`
Reference material	Customer decks or BPH workbooks the user shows are structure references only — none of their names, numbers or labels go into any artifact of the plugin
Location	`<ARTIFACT_BASE>/processes/<MODULE>/<MODULE>-process-v<ver>-<lang>.html` + `_src/` + history (paths in `paths-and-state.md`)
</Decisions_Fixed>

<Companion_Files> MANDATORY: read before executing.

Companion	Scope
`paths-and-state.md`	Path variables, `_state/` checkpoints, resume, escalation
`workflow.md`	Progress table + Steps 0–4 (trust, intake, inventory per package, merge + attach, hierarchy)
`workflow-build.md`	Steps 5–9 (task sheets, consultant review, model, build, validation + handoff)
`dispatch-analyst.md`	Step 4 hierarchy + Step 5 task-sheet prompts (`sap-analyst`)
`dispatch-review.md`	Step 6 optional consultant review prompt + Step 7 assemble command
`model-schema.md`	`process-model.json` shape, values, checks
`workflow-scale.md`	Scopes with more than 300 used entries: G1 batches, Step 4 placement parts + consolidation + `merge-placements.mjs`, Step 6 review slices, companion after edits
`workflow-integration.md`	Cross-module integration map (asked at Step 1): boundary stubs, `cross-module.mjs` touchpoints, E2E scenarios (`sap-analyst`), `build-integration-doc.mjs` page
</Companion_Files>

<Agent_Composition> The main thread follows the session model; every subagent_type uses the plugin prefix sc4sap:.

Main thread — Steps 0–3, 8, 9: intake, usage calls (GetTcodeUsage, GetTransaction), gates, usage-scope.mjs / backbone.mjs / build-process-doc.mjs runs, state checkpoints, user approvals.
sap-checker × N (Haiku) — Step 2: sources of the used programs only (graph-usage G1 / G3), 10 per checker; then usage-scope.mjs + build-package-graph.mjs on the main thread.
sap-analyst (Opus) — Step 4 hierarchy (backbone + attach proposals → L1–L4 rows, variants, lanes) and Step 5 task sheets (parallel parts of ≤ 8 tasks). Returns JSON as text; the main thread writes it once.
sap-<module>-consultant (frontmatter model) — Step 6, optional (the user chooses), one per module in scope, in parallel: wording, owners, std-task sheets, conversion notes, glossary, open questions. Writes its own patch file.
No writer agent — Step 7 assembles process-model.json with scripts/process/assemble-model.mjs (deterministic). </Agent_Composition>

<Language_Policy> Output language chosen at Step 1: ko / en / ja only (page labels and backbone labels exist for these three). SAP identifiers stay literal. One language per page; an English companion page is built as well (Step 8b, companion.mjs + parallel Sonnet translators) unless the language is English or the user opts out. </Language_Policy>

<MCP_Tools_Used>

Discovery: SearchObject (DEVC, TRAN), GetPackage, GetPackageContents, GetObjectInfo, GetTransaction
Usage scope: GetTcodeUsage (with destination = SAP_USAGE_RFCDEST), GetJobUsage (connected system only), GetTransaction (≤ 100 per call)
Through graph-usage G1 / G3: GetProgFullCode (sources to files), GetTable / GetStructure / GetDataElement (DDIC)
Step 5 on demand: GetProgram, GetInclude, GetFunctionModule, GetClass, GetAbapSemanticAnalysis
NEVER: GetTableContents, GetSqlQuery </MCP_Tools_Used>

<Data_Extraction_Safety> Source, DDIC metadata, TCode metadata and usage statistics only. No row data — if the user asks for sample rows to illustrate a flow, refuse per ../../common/data-extraction-policy.md and record the request under open questions. </Data_Extraction_Safety>

<Related_Skills>

/sc4sap:analyze-cbo-obj — inventory + graph.json per package (reused or produced in Step 2)
/sc4sap:program-to-spec / /sc4sap:program-to-manual — drill into one program of a task
/sc4sap:config-to-document — the module's configuration behind the business rules
/sc4sap:ask-consultant — follow-ups from the open questions
/sc4sap:package-to-process — previous single-package skill; redirects here for one release </Related_Skills>

Task: $ARGUMENTS

Frequently asked questions

What does the Module To Process AI skill do?

Map how one SAP module (or a process area of several modules) runs in the connected system — one HTML page for a module consultant starting a project (conversion, enhancement, AMS takeover). Walks every CBO package of the module, lays the CBO programs onto the standard process backbone (L1 mega process > L2 process chain > L3 process > L4 task, with variants), and writes a BPH table plus one task sheet per L4 (owner, system, business rules with source lines, steps, related standard / CBO / enhancement objects with usage, interfaces, conversion notes). Replaces package-to-process.

Why use Module To Process on TypingMind?

Because you install it once and use it with any model. Module To Process is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Module To Process in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/babamba2/superclaude-for-sap/tree/main/skills/module-to-process. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Module To Process?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Module To Process?

As many as you like. As long as a model supports skills, you can use Module To Process with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Module To Process AI skill free?

Yes. It is published on GitHub by babamba2 under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

Overview

Installation

Install in TypingMind

Install in another agent

Use it in TypingMind

Works with any AI model

Skill instructions

SC4SAP Module → Process Map

Bundled files

Frequently asked questions

Related AI Skills

Set up your own AI workspace now