Program To Manual logo

Program To Manual

Community
babamba2
program-to-manual

Write an end-user manual (one self-contained HTML file) for one ABAP program — scenario-by-scenario steps drawn on selection / ALV / popup screen mockups with numbered callouts, check points derived from the source validations, field reference, messages with actions, glossary and revision history. Web document on screen, one step per A4 landscape page in print.

Overview

Publisherbabamba2
Repositorysuperclaude-for-sap
Skill nameprogram-to-manual
Stars
69
Forks
26
Bundled files
3
LicenseMIT
Links
  • 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.

  • 3 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 Program To Manual AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

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.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/babamba2/superclaude-for-sap/tree/main/skills/program-to-manual
  4. 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.
2

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/program-to-manual .claude/skills/program-to-manual
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Program To Manual 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 Program To Manual 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 Program To Manual 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 Program → User Manual

Reads one ABAP program via MCP and writes the manual a business user follows to run it: which screen to open, what to enter, which button to press, what the result means and what to do when a message appears. Output is one HTML file — a scrolling web document with a contents sidebar on screen, and one scenario step per A4 landscape page when printed or saved as PDF.

<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>The target object is 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: auto (default) uses the model in Agent_Composition below; user-defined asks the user Opus / Sonnet / Haiku (recommended one first) before each dispatch group. Resolve the cost mode too per ../../common/cost-mode.md (standard default; eco → pass BOTH model and effort on every Agent(...) call per its lever-A table (omitting effort silently runs the agent at its frontmatter effort, usually high), Skill("sc4sap:eco", "--attach") first and on every continuation turn, and this skill's eco recipe).</Phase_Banner>

<Team_Mode>No teamMode integration. One program, one module consultant for business context — no cross-module synthesis.</Team_Mode>

<Use_When>

  • User says "user manual", "manual for this program", "매뉴얼 만들어줘", "사용자 매뉴얼", "현업 매뉴얼", "操作マニュアル", "training material for "
  • Go-live / hypercare: key users need step-by-step instructions for a custom report or transaction
  • Help-desk handover: messages and what to do about them must be written down </Use_When>

<Do_Not_Use_When>

  • User wants a functional / technical specification → /sc4sap:program-to-spec
  • User wants a process map of a module (many programs) → /sc4sap:module-to-process
  • The object has no user interface (class, FM, CDS, RAP without UI) — there is nothing to click through; suggest program-to-spec
  • The program does not exist yet </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:program-to-manual. 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> These were settled when the skill was designed — do not ask the user about them again:

TopicDecision
UnitOne program = one manual (all its screens, options and follow-up screens)
FormatOne self-contained .html; web document on screen, print CSS = one step per A4 landscape page
EditingThe page has a built-in edit mode (no install, no network): edit text, reorder / duplicate / delete steps, add / delete / drag callouts, add / delete rows of the field, message and glossary tables; add / delete / reorder items of the business rules, each scenario's check points (⇄ moves one to another scenario), step note lines and callout details; fill an empty result, paste real screenshots, redraw the process flow (drag shapes, draw / reconnect arrows, add / delete steps, change shape kind and text), undo, autosave, save a copy. The copy embeds its manual.json and is imported back (workflow Step 0)
Cross-linksGlossary terms in the prose link to their glossary row (dotted underline, meaning as tooltip; once per step / check-point box / section). Message codes (E07, Q01 …) link to their row in Messages and Actions every time they appear, check-point sources included (tooltip = the message text only). Re-linked when edit mode ends
ScreensDrawn from source with the program-to-spec renderer (selection screen, output ALV, every follow-up screen and popup the scenarios pass through), inlined as SVG
CalloutsNumbered marks on the drawn screen, tied to screen elements by anchor key; the same numbers head the step's instruction list
Body structureBy usage scenario ("to do X") — radio options, execution modes and buttons that start a distinct task each become a scenario
Business contextModule consultant drafts it; low-confidence items go to a 1–3 question interview
Check pointsDerived from source validations, mandatory fields, confirmation popups and irreversible processing (posting, sending); business rules added from the interview
Extra sectionsField reference (selection + output) — the selection screen and the output grids drawn above their tables, each listed field numbered on the picture and in the table's # column (automatic, follows edits) — and Messages & actions
Front / back matterCover, revision history (automatic), glossary
LanguageOne language per manual file (ko / en / ja); mixed prose is rejected by the build check. An English companion is always built as well (Step 8) unless the manual language is English or the user opts out
Cover / footerAuthor, team, company, confidentiality notice from the active profile's config.json → manual, asked once
Location<artifact-base>/manuals/<PROGRAM>-v<version>-<lang>.html (artifact base per ../../common/multi-profile-artifact-resolution.md)
</Decisions_Fixed>

<Workflow_Steps> MUST read workflow-steps.md and execute its steps in order whenever this skill runs. </Workflow_Steps>

<Manual_Schema> MUST read manual-schema.md before writing manual.json (Step 5) — JSON shape, anchor keys, callout and check-point rules. The screen specs inside it follow ../program-to-spec/selection-schema.md and ../program-to-spec/alv-buttons-schema.md. </Manual_Schema>

<Agent_Composition> The main thread follows the session model (model: inherit); each dispatch carries its own model. Every subagent_type uses the plugin prefix sc4sap:.

  • Main thread — Steps 0–2 and 6–8: interview, config, MCP inventory, build, review loop, English build.
  • sc4sap:sap-analyst × 1 (Opus, frontmatter) — Step 3: scenarios, steps, screens per step, check points with their source, fields, messages. Returns text; never writes files.
  • sc4sap:sap-<module>-consultant × 1 (frontmatter model) — Step 3, in parallel with the analyst: purpose, background, business rules, users, glossary, and the user action for each message. Marks each claim it inferred rather than read.
  • sc4sap:sap-writer × 2 (model: "sonnet" override) — Step 5: writes manual.json with the Write tool; Step 8: translates the final one into the English companion. User-facing instructional prose needs Sonnet; Haiku drifts into spec language. </Agent_Composition>

<Output_Format>

Manual generated: ZMMR_GR_3PL  v1.0 · ko
Scenarios: 3 · Steps: 8 · Screens drawn: 4 (selection, 0100, 0200 popup, 0300)
Callouts: 21 (all anchored) · Check points: 7 · Messages: 9 · Glossary: 6
File: .sc4sap/work/DEV/manuals/ZMMR_GR_3PL-v1.0-ko.html
English: .sc4sap/work/DEV/manuals/ZMMR_GR_3PL-v1.0-en.html
History: .sc4sap/work/DEV/manuals/ZMMR_GR_3PL-ko.history.json · ZMMR_GR_3PL-en.history.json

To be confirmed (shown with a badge in the manual): 1
Next: "add a scenario", "Japanese version", "new version after the change in TR <n>", "import the edited HTML"

</Output_Format>

<MCP_Tools_Used>

  • SearchObject, GetObjectInfo, GetTransaction
  • GetProgFullCode, GetIncludesList, GetInclude
  • GetScreensList, GetScreen, GetGuiStatusList, GetGuiStatus, GetTextElement (language: "E" first)
  • GetSqlQuery — T100 message texts only (see Data_Extraction_Safety)
  • GetAbapSemanticAnalysis (optional, for validation branches) </MCP_Tools_Used>

<Data_Extraction_Safety> Same rule as program-to-spec: only source, DDIC metadata and screen definitions are read — never GetTableContents. The one exception is T100 through GetSqlQuery with explicit fields (ARBGB, MSGNR, TEXT), SPRSL = the manual language (fall back to 'E') and only the message classes / numbers the source uses; the normal approval prompt applies. Sample values in screen mockups are invented (4500000015, KR01, 100234) — never business data, never real customer, vendor or company names. Refuse requests to fill mockups with real rows and say why. </Data_Extraction_Safety>

<Related_Skills>

  • /sc4sap:program-to-spec — the specification of the same program (shares the screen renderer and schemas)
  • /sc4sap:module-to-process — process map of the module the program belongs to
  • /sc4sap:analyze-cbo-obj — CBO inventory that enriches the business context </Related_Skills>

Task: $ARGUMENTS

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Program To Manual AI skill do?

Write an end-user manual (one self-contained HTML file) for one ABAP program — scenario-by-scenario steps drawn on selection / ALV / popup screen mockups with numbered callouts, check points derived from the source validations, field reference, messages with actions, glossary and revision history. Web document on screen, one step per A4 landscape page in print.

Why use Program To Manual on TypingMind?

Because you install it once and use it with any model. Program To Manual 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 Program To Manual in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/babamba2/superclaude-for-sap/tree/main/skills/program-to-manual. 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 Program To Manual?

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 Program To Manual?

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

Is the Program To Manual 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.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇