All patternsPrompt actions
Inline Action
Description
Design considerations
Related patterns
Examples

Inline Action

Sometimes a user only wants to adjust or respond to a small part of a larger piece of content or canvas without regenerating the entire response. Inline actions provide a direct way to target specific content, whether by replying, editing, or inserting new material, without breaking the flow of interaction. This gives people more precise control and positions AI as a copilot rather than a system that must always be directed wholesale.

Common actions

What distinguishes inline actions from similar patterns like inpainting is their opinionated nature. These are preset actions, hard coded or recommended contextually as follow ups, that cover a variety of prompt types:

  • Suggested prompts that open a conversational thread or new line of discussion
  • Restructuring actions to rewrite, reframe, or otherwise adjust the underlying structure of the content
  • Restyling actions that change the tone or aesthetic quality of the content
  • Transformational actions that change the modality of the content (e.g. highlighting text for the AI to read out loud)

In essence, these act as shortcuts: a pointer to constrain the AI's focus and an associated prompt to make action easy.

Multi-modality

Inline actions are not limited to text. In multimodal systems, targeted prompts can be applied to images, audio, or even live conversations. For example, during the GPT-4o launch demo, a presenter redirected the model mid-interaction by instructing it over video to forget an earlier statement and focus on the current question.

Press play on the video below if the YouTube controls don't appear.

This last example illustrates the real strength of inline actions: when users can fully direct the AI’s attention, they shift from training the system to using it as a tool to accomplish specific goals.

Design considerations

  • Offer concise, high-value defaults. Include a few dependable one-click actions like shorten, expand, summarize, or translate that can be applied instantly. These reinforce the product’s core utility and make it feel responsive. Broader commands belong in side panels or full editors where users can customize them.
  • Rely on context to make actions relevant. Consider the history of the interaction thus far and the overall context of the content on the page when prioritizing actions to show instead of providing a large, generic list of choices.
  • Enable granular selection and scoping. Let users decide the level of detail—word, sentence, section, or block—before invoking the AI. This prevents over-generation and preserves authorship. Fine-grained control is especially important for longform or multimodal content where replacements can cascade.
  • Preview before commit. Always show the AI’s result inline as a suggestion layer, not an overwrite. Require verification to accept, reject, or refine. This creates a continuous sense of authorship and accountability.
  • Surface reasoning when stakes are high. For edits that alter factual claims, citations, or data, include a quick “see how this was changed” view. This supports trust and makes AI rewriting traceable within context rather than hidden behind logs.

Related Patterns

Transform

Give prominence to common transformational actions, such as expand, shorten, or remix.

Footprints

Maintain accountability in collaborative workflows by showing footprints of inline modifications so others can distinguish AI-assisted changes from human edits.

Verification

Give users confidence that inline edits improve quality by allowing them to verify the AI’s changes before accepting them into the final output.

Examples

‍

This example from Atlassian intelligence shows a distinct benefit of inline actions: they allow users to see a preview of the AI’s output targeted to specific part of the canvas without updating the canvas as a whole
Figma Make allows users to select a specific area on the canvas, where inline actions appear to take input with that specific focus.
Github Copilot allows multiple inline actions like /explain to allow the AI to focus where the user wants them
Inline actions like this simple nudge from Grammarly make it easy to get started, and benefit from giving context to the AI from step 1. If I only had an open input to describe what I wanted changed, it’s likely I wouldn’t get my target result. Instead, Grammarly’s AI now knows specifically what I want re-written, and the user had quick access to have it take action.
Hubspot combines the ability to take quick action inline, see the result, and verify it. This is similar to how Github CoPilot operates, positioning the AI as an active assistant or intern.
Isaac shows the example of a large panel of inline actions appearing when text is highlighted
Lovable follows a familiar pattern of showing inline actions when individual items are selected on the canvas
Inline actions are not limited to writing. Here in Sourcetable the user can take action on a single cell’s content easily from the spreadsheet itself instead of relying on chat
Wordo shows another example of inline actions appearing when text is selected

© Emily Campbell 2025 | Sharable under CC-BY-NC-SA | Contact

Sharable under the Creative Commons CC-BY-NC-SA license