Skip to main content
Super Durable
English
English简体中文
GitHubLog inSign up Cloud
Menu

Dex App Builder

View as Markdown

Dex App Builder is the primary skill for creating a Dex application or process product. It covers the whole path: working out the business process, choosing the UI, building the Go backend, testing locally, and handing off the result.

Install and use​

Choose your current host. On one host, use either the Plugin or standalone Skills, not both.

Plugin (recommended)

Install

This path does not require a separate Codex CLI installation.

  1. Open the plugin browser, open the add menu, and select Add a marketplace.
  2. Use the repository below as Source, main as Git ref, and leave Sparse paths empty.
https://github.com/superdurable/dex-skills
  1. Add the marketplace, open Super Durable, select Dex, and install it.
  2. Open a repository or empty project, then start a new task.

Use

Type @, select Dex from the picker, then enter the request. Plain @Dex text does not create a Plugin binding.

@Dex Design and build an event-registration application.

Update

Find Super Durable in the plugin browser marketplace manager and select Upgrade. Restart the desktop app and start a new task.

Standalone Skills

Do not also install the Plugin when using this path. Install all three Skills together.

Install

npx skills add superdurable/dex-skills --skill '*' --agent codex --global

Use

$dex-app-builder Design and build an event-registration application.

Update

npx skills update dex-app-builder dex-sdk dex-connector-contributor --global

If the installed skills CLI does not support update, rerun the installation command above.

When to use it​

Use App Builder when the request includes any of these:

  • discovering or refining a business process;
  • defining roles, permissions, approvals, waits, retries, and recovery;
  • deciding whether Dex Web is enough or a custom UI is needed;
  • building a new Dex application from the supported template;
  • using released Connectors, or finding a Connector that is missing;
  • building and testing one complete feature, from UI to backend.

For a narrow SDK debugging task or a standalone official Connector contribution, invoke Dex SDK or Dex Connector Contributor directly instead.

Before implementation​

App Builder first checks that the coding-agent host gives it a writable repository or project, file-editing tools, and command execution.

Without them, App Builder can still work out the process, design the architecture, and write a plan for implementation. It cannot create files, run tests, build artifacts, or deploy an application.

Workflow​

1. Confirm the business process​

The skill starts by talking with you, not by writing code. It works out:

  • who maintains, manages, operates, approves, and takes part in the process;
  • what each role can do, and the stable permission each human action requires;
  • triggers, inputs, outputs, deadlines, waits, retries, recovery, audit, and which data is sensitive;
  • the external systems, and the released Connector capabilities they need;
  • whether an existing host application signs users in and maps their roles to permissions it trusts.

This step ends with a table of roles, operations, and permissions, a proposed lifecycle, a UI decision, and a table of the Connector capabilities needed. The skill settles every open question that matters with you before any code is written.

2. Choose the application surface​

App Builder picks one of two ways to manage the process:

ModeWhen it fitsWhat gets built
Dex WebRuns, Work Queue, search, fields, and Actions cover what the users need.Dex Web is the process UI. The application adds only a small shell with no business screens, plus the endpoints that external systems call.
Custom UIThe product needs business screens or interactions that Dex Web does not offer.The skill builds a React and TypeScript prototype on mock data. You try it and approve it before it is connected to the real backend.

Dex Web is the default. A Hello World page left over from the template, or a generated API client, is not by itself a reason to build a custom UI.

3. Design and implement the Flow​

The backend uses the supported application template and the Dex Go SDK. App Builder loads Dex SDK for the general SDK rules, then adds stricter rules of its own:

  • write the application backend in Go;
  • target strict Dex Web and Flow Definition Graph 2.0 rendering;
  • call external providers only from Execute;
  • keep provider calls and Dex changes out of WaitFor;
  • model each human operation as a typed Action with an explicit permission;
  • keep credentials inside Connectors or the runtime environment, not in application code;
  • use released Connector capabilities instead of adding provider clients to the application.

Before it writes code, the skill states the Flow's identity, typed input and output, Steps, transitions, Attributes, Channels, RPCs, Timers, retries, recovery, and Connector boundaries.

4. Verify and hand off​

While it works, the skill runs the tests related to each change. At the end, it runs the template's full check. This covers the chosen UI mode, generated code, the production build, behavior against a real Dex Server, recovery paths, and the FDG 2.0 analysis.

The handoff lists the product decisions you confirmed, what was built, the exact test results, the status of any Connector release or contribution, and known limitations. The work ends in a clean Git commit.

How Connector gaps are handled​

Before it writes integration code, App Builder checks what the released Connectors can do. An official Connector may be missing, or an operation, Trigger, or configuration UI unit the application needs may be missing or broken. App Builder then loads Dex Connector Contributor.

While the contribution is in review, the application can test against a local copy of the Connector module. The application is not ready for production until that Connector is released with an exact version. The skill never commits a branch, commit SHA, pseudo-version, or local replacement as a production dependency.

Expected result​

When App Builder finishes, you have:

  • a confirmed process and permission model;
  • a clear choice between Dex Web and a custom UI;
  • a Go Dex application built on the supported template;
  • test evidence from local runs and a real Dex Server;
  • a list of Connector releases that still block production, if any;
  • a repository ready for review.

Return to Dex Skills overview and installation.