Skip to content
Skills Library
Programming · Building & coding

create-process-adapter

/create-process-adapter

Adds one call from the application to the process engine (start a process, correlate a message, send a signal, complete a user task) as an outbound port and process adapter method. Use when code has to start or continue a BPMN process.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
9
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Adds one call from the application to the process engine (start a process, correlate a message, send a signal, complete a user task) as an outbound port and process adapter method. Use when code has to start or continue a BPMN process.

Arguments

/create-process-adapter <start|message|signal|user-task> <process id, message, signal or element id>
Original author description

Adds one call from the application to the process engine (start a process, correlate a message, send a signal, complete a user task) as an outbound port and process adapter method. Use when code has to start or continue a BPMN process.

How it works

  1. IMPORTANT
  2. Step 1: Identify the call
  3. Step 2: Detect the stack
  4. Step 3: Choose the port
  5. Step 4: Write the call
  6. Step 5: Verify and hand over
Original SKILL.md headings · 79 lines, 511 words
SKILL.md preview
---
name: create-process-adapter
description: "Adds one call from the application to the process engine (start a process, correlate a message, send a signal, complete a user task) as an outbound port and process adapter method. Use when code has to start or continue a BPMN process."
argument-hint: "<start|message|signal|user-task> <process id, message, signal or element id>"
allowed-tools: Read, Write, Edit, Glob, Grep, Bash(./gradlew *), Bash(mvn *), Bash(./mvnw *), Bash(bpmn --version), Bash(bpmn show *), Bash(bpmn find *), Bash(npx -y @miragon/bpmn-cli@0.7 *)
---

# Skill: create-process-adapter

Write one outbound call to the engine. The application talks to a port in its own language (domain types, business verbs). The adapter turns that into the engine command. The engine-specific command shape lives in `resources/`.

## IMPORTANT

- **Names come from the generated API only:**
  - `<Process>ProcessApi.PROCESS_ID`
  - `Messages.X`
  - `Signals.X`
  - `FlowNodes.<UserTask>`
  - `FlowNodes.<Node>.Variables.X`

  No string literals. A missing name means the model does not declare it: say so and stop.
- **Ports speak domain:** parameters are domain types, and the adapter converts them to engine values.
- **Never edit generated files.**

**bpmn-cli:** run `bpmn --version` once. If it fails, use `npx -y @miragon/bpmn-cli@0.7` wherever this skill says `bpmn`. Without Node, read the BPMN XML instead.

## Step 1: Identify the call

Resolve `$ARGUMENTS` to one of these:

| Call | Generated name | Read from the model |
|---|---|---|
| start | `PROCESS_ID`, or `Messages.X` for a message start event | the start event's variables |
| message | `Messages.X` | the catching element: `bpmn show <file> <id> --context` shows its correlation key |
| signal | `Signals.X` | the catching elements (`bpmn find <file> <signal>`) |
| user task | `FlowNodes.<UserTask>` | its output variables |

Without `bpmn`, read the BPMN XML.

## Step 2: Detect the stack

Pick the style by the first match in the build files:

| Dependency | Style |
|---|---|
| `dev.bpm-crafters.process-engine-api` | `process-engine-api` |
| `…external-task-client…` or a generated engine REST client (Camunda 7, CIB seven, Operaton) | `c7-external-task` |
| `…bpm-spring-boot-starter…` of Camunda 7, CIB seven, Operaton or Fluxnova | `c7-delegate` |
| `io.camunda:camunda-spring-boot-starter` / `spring-boot-starter-camunda-sdk` | `zeebe` |

Language: Kotlin if the existing adapters are `.kt`, else Java. Then read `resources/<style>-<kotlin|java>.md`, for example [resources/process-engine-api-kotlin.md](resources/process-engine-api-kotlin.md).

## Step 3: Choose the port

Look in `application.port.outbound` first and **follow the existing pattern**:

| Project has | Do |
|---|---|
| one port per process (e.g. `LeasingProcess` with several methods) | add a method to it |
| one port per call | add a new port |
| nothing yet | **recommend one port per call**, and let the user decide |

**One port per call:**
- A small interface with one method named after the business event, e.g. `StartBikeLeasingPort.startBikeLeasing(applicationId)` or `NotifyContractSignedPort.notifyContractSigned(applicationId)`.
- The method name must be unique across the process's ports, because one adapter implements them all. Generic names such as `notify` would clash, and in Java `notify` collides with `Object.notify`.
- The application service depends only on what it uses.
- Use the suffix the project's architecture rules allow (`Port` / `Process`).

**Adapter:** one `<Process>ProcessAdapter` per process in `adapter.outbound.<engine>` implements every port of that process.

## Step 4: Write the call

Follow the resource for the call type. It covers:
- the correlation key versus the business key
- variables
- transactions
- the engine-specific pitfalls

Call the port from the application service after the domain state is saved.

## Step 5: Verify and hand over

1. Compile.
2. Name the next step: `/test-process-adapter <AdapterClass>`. A test of the process path the call triggers is `/test-process`.
Files in this package (9)
  • SKILL.md 4 KB
  • resources/c7-delegate-java.md 6 KB
  • resources/c7-delegate-kotlin.md 6 KB
  • resources/c7-external-task-java.md 6 KB
  • resources/c7-external-task-kotlin.md 6 KB
  • resources/process-engine-api-java.md 7 KB
  • resources/process-engine-api-kotlin.md 6 KB
  • resources/zeebe-java.md 6 KB
  • resources/zeebe-kotlin.md 5 KB

Versions

The database has no other skills named create-process-adapter.

Database snapshot: 13.11.2026 · package version b732d55b4a02 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100test-process-adapter
    Writes the unit test for one process adapter method and asserts the engine command: process, message or signal name, correlation and variables. Use when testing a process adapter or after create-process-adapter.
  • 90setup-bpmn-to-code
    Sets up bpmn-to-code in an existing project with the Gradle plugin, the Maven plugin or the CLI, so the build generates a type-safe Process API from the BPMN models, with an optional GitHub Actions check that the committed API is up to date. Use when adding bpmn-to-code or BPMN…
  • 100automate-process
    Change an executable CIB seven BPMN model of this repo (bike-leasing.bpmn, cancel-bike-order.bpmn) and wire its glue code across the hexagon: edit the model with bpmn-cli, regenerate the typed process API, add ports, services, delegates and process-adapter methods, cover the new…
  • 100automate-process
    Change an executable Fluxnova BPMN model of this repo (bike-leasing.bpmn, cancel-bike-order.bpmn) and wire its glue code across the hexagon: edit the model with bpmn-cli, regenerate the typed process API, add ports, services, delegates and process-adapter methods, cover the new…
  • 100bpmn-generator
    Generate BPMN 2.0 compliant XML files from natural language process descriptions OR from structured markdown business process documents. Use this skill when a user wants to create a BPMN workflow, convert a business process to BPMN XML, model a workflow diagram, or generate…
  • 100bpmn
    Writes valid bpmn diagram source for uml-mcp (diagram_type=bpmn). Business Process Model and Notation Use when the user asks for bpmn or that notation; then call validate_uml / generate_uml / generate_uml_image.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.