Manage Interfaces with Composer

Composer is available from AI mode in interface objects, so you can create and modify design objects while designing your interfaces.

Whether from an interface object or the Build view, Composer can generate, configure, and manage interfaces. Describe what you need, and Composer generates a working interface and automatically configures rule inputs, local variables, and record type references.

Use Composer in AI mode

You can access Composer in an interface object from AI mode. Interface objects have three editing modes: AI mode for natural-language interaction with Composer, Design mode for drag-and-drop, and Expression mode for writing expressions directly. For more details, see Editing modes.

To use Composer in AI mode:

1. In the interface header, click AI mode .
2. In the live view, click Preview interface to preview the interface itself or Preview expression to preview the interface expression. The previews are not editable.
3. To manually edit the interface, in the interface header, click Design mode or Expression mode .

Composer uses your permissions. If you cannot create or edit an object, Composer cannot do it for you. Composer follows the same object-level security as manual edits.

What Composer can do with interfaces

Composer can perform the following operations on interfaces:

• Generate new interfaces: Create full interfaces from a description, including configuring functions, components, and local variables in the interface expression.
• Manage rule inputs: Create, modify, and reference rule inputs in an interface.
• Reference record types: Reference record types to query record type data, configure records-powered components, and more.
• Build forms and dashboards: Create input forms with validation and submit logic and dashboards to display key information from your application.
• Create record views: Create record views that show record data using related record types and custom record fields.
• Add record actions: Add record actions to interfaces that coordinate with process models.

Example prompts for interfaces

The following examples show effective prompts for interface tasks. For general prompting guidance, see Composer Best Practices.

Goal	Example prompt
Interface creation	Create an interface with a form for new support cases. Include fields for title, description, priority, and an assignee dropdown that pulls from the User record type.
Grid configuration	Add an editable grid to the AT_TaskHome interface that shows open tasks from the Task record type, with columns for name, due date, and status.
Dashboard creation	Create a summary dashboard that shows a bar chart with total cases by status and a list of recent cases below the chart.
Record actions	In AT_CasesDashboard, add an edit button to each row in the cases grid that opens an inline form for editing the case record.
Conditional visibility	Show the approval section of AT_ExpenseReport only when the request amount exceeds $5,000.

How Composer uses interface context

Composer reads the following context from your app when generating or updating an interface:

• Existing interfaces: The current interface expression, as well as other interfaces referenced in the interface expression.
• Record types: Record types, their fields, and relationships.
• Related objects: Process models, expression rules, and other design objects referenced in the interface.
• Rule inputs: Rule inputs in the interface.

Review and apply interface changes

After Composer generates or updates an interface, review the changes by comparing object versions in the diff view. The diff shows what Composer added or changed in the interface expression.

To review interface changes:

1. In the interface object, go to Settings > Versions.
2. In the versions grid, click Compare with latest to review the changes.

If the generated configuration does not match your intent, ask Composer to adjust it. You do not need to repeat your original request—Composer retains the conversation context.

All Composer changes go through Appian's versioning system. You can undo them with the same version history tools you use for manual edits. Each update creates a new object version, so you can compare diffs and roll back.

The developer owns the outcome of all Composer changes. Treat Composer output the same way you would treat any other change you make: review it, test it, and take responsibility for it.

Feedback