Compact spacing plus many confusable SKU codes increases choice interference; target is provided via a reference panel rather than direct text-only instruction.


Two visually similar table instances with confusable IDs significantly increases disambiguation load.


Requires scrolling within a virtualized grid to reach a distant target row.


Typing a short substring into a single input; the preview highlight reduces ambiguity and the Search button gives clear apply feedback.


Single dropdown selection in a visible filter toolbar with immediate feedback and no overlays beyond the select menu.


Requires reading target state from visual reference chips and mapping them to three different controls, then applying; errors are easy if values are misread.


Two similar DataGrid instances require selecting the correct toolbar and filter panel; otherwise it is a straightforward single-select filter.


Requires opening a small header control, choosing among similar options, and confirming in the dropdown menu.


Single header interaction with visible indicator; only the correct column and direction matter.


Simple single-instance footer navigation (Next page) with immediate feedback in the displayed-rows label.


Requires opening a modal, disambiguating between two similar grids, and setting both page size and page number correctly.


Goal is given via a mixed visual/text reference, requiring the agent to map the reference cue to the correct sortable column.


Dense layout and horizontal scrolling make the target header harder to acquire; still single-column sorting with immediate feedback.


Requires toggling to a specific direction and relies on understanding the displayed direction cue for a categorical column.


Single, large date input with an explicit placeholder and immediate visible feedback after typing.


Multiple small, similar date inputs inside a dense table require precise target acquisition and correct row disambiguation.


Strict validity constraints with automatic revert on invalid input increase feedback dynamics and require careful formatted entry.


Custom formatting increases precision requirements and can trip agents that assume the default MM/DD/YYYY layout.


The current value is visible in the input and clearing is a single direct action.


Single default DatePickerInput; only requires opening the popover.


Target is specified visually via highlight rather than explicit text, reducing semantic observability and increasing interpretation load.


Tests layered modal/dialog interaction and explicit cancel semantics; value remains empty if cancel is used.


Two nearby date pickers in a compact form increase disambiguation and target acquisition difficulty while the date selection itself remains standard.


Single clear action using a standard clearable affordance with immediate, visible state change.


Default single-instance desktop date picker with immediate commit and clear visibility of the selected value.


The target must be inferred from a reference card and then confirmed via the mobile action bar, adding both disambiguation and multi-step interaction depth.


Goal is specified via an on-page reference (visual read) rather than directly in the instruction, but the picker interaction remains standard with an OK commit.


Target is provided via an on-page reference rather than in the instruction; otherwise interaction is standard with two clear fields.


Only requires opening the popper overlay; no selection or confirmation is needed.


Single default-sized picker with clear text label and visible input value; requires one popover interaction and an OK confirmation.


Three near-identical small pickers plus distractors create high disambiguation and target acquisition difficulty; requires OK confirmation.


Second-level precision in dark theme increases precision and acquisition demands despite a simple layout.


Involves opening the picker and using a specific action-bar control to clear, within a small form with mild distractors.


Only one modal is present; the close icon is visible and is the intended primary affordance.


Single clearly labeled trigger opens one modal; success is simply the modal becoming visible.


Requires scrolling inside the modal to reveal an off-screen action and then selecting the correct close control rather than the header close button.


Requires a short sequence of within-dialog actions (opening the dialog and advancing steps) and verifying the correct internal step state while keeping the dialog open.


Requires opening a dropdown overlay and selecting the correct item among several similar options. Clear labels reduce ambiguity, but there are multiple interactables and one overlay layer.


Small icon target with a nearby distractor icon increases acquisition difficulty slightly, but labeling and immediate feedback keep it in the easy range.


Single large contained button with clear label; minimal clutter and direct feedback via snackbar.


Requires opening a drawer overlay before the download controls are available and then choosing the correct download among multiple options. Overlay layering and instance disambiguation increase difficulty.


Requires multiple cross-list moves while using a visual/text reference to determine the correct final membership.


Requires precise placement within the destination list (insertion between two items), increasing precision and drag control compared to simple membership changes.


Uses a visual reference (chip preview) rather than explicit text target, but only requires a single additional item to be moved.


Short list with large row targets and immediate feedback; only a single move is required.


Requires matching a visually provided target ordering and disambiguating between two sortable lists.


Must interpret a visual reference ranking and reorder multiple items using a handle-only drag affordance.


Handle-only dragging plus a required save step increases both motor difficulty and feedback dependence.

Quick settings
Billing
Profile
Save changes


Requires clicking outside the drawer on the mask, but otherwise a simple single-step dismissal.


Single clear trigger with one drawer instance and immediate feedback.


Nested confirm modal adds depth and requires correct option selection to reach the closed state.


Small-scale header close control is harder to acquire, and backdrop click does not help, increasing interaction precision demands.


Requires interacting with a search control and waiting for filtered results amid mild form clutter; the correct result must then be selected.


A single visible reset control returns the feed to a clear top-of-list state.


A straightforward scroll-within-list task with a uniquely labeled target and no confirmation or competing instances.


Virtualized endless scrolling increases depth and can complicate observability; the target is specified by a combination of visual avatar color and initials rather than unique text.


Requires a drag-and-drop gesture and accurate target acquisition in a corner-anchored layout; otherwise feedback is clear via filename in the upload list.


Although easy to execute, it tests a reset path that agents sometimes miss; the Clear all control is small compared to the dropzone target.


Single explicit Clear control with immediate feedback; the empty state is visually obvious and easy to verify.


Single-step removal in a short list; the main challenge is clicking the correct row’s small Remove icon.


The target is specified visually, requiring reliable perception and matching among many similar-looking rows; deletion must hit the correct row action.


Compact small mode makes the drag handle a tiny target and increases risk of dropping in the wrong insertion position, while success requires an exact final order.


Introduces an interruptive modal confirmation step; success depends on confirming the right action rather than just clicking the delete icon.


Single file to remove with a direct remove affordance and immediate visible state change.


Single FileButton with straightforward single-file selection and clear textual feedback.


Multiple similar instances plus very small per-instance Reset controls create high disambiguation and target acquisition difficulty.

Banner image
Reset
Avatar image
Document


Adds one overlay step (opening a preview dialog) with clear UI affordance and no file selection required.


Two similar instances require choosing the correct labeled trigger; mild hover delay increases the need for stable pointer control.


Requires clicking a specific action within the hover card before it closes; otherwise the scene is simple and uncluttered.


Single, clearly labeled hover target; the only challenge is triggering the hover-based overlay.


Three near-identical instances plus a small in-card pin control create high disambiguation and acquisition demands.


The primary challenge is locating the control via scrolling within a moderately cluttered dashboard; once found, the button is clearly labeled.


Visual matching among multiple icons plus non-central placement increases acquisition and perceptual load.


Small set of three adjacent choices with clear labels and immediate selection feedback.


Single large target in a clean, centered card; only one short string to enter and a clear Save control to commit.


Dark theme reduces contrast for small icon controls, and the value must match an exact formatted pattern with validation gating the Save action.


Combines visual reference extraction with instance disambiguation across two same-type fields, while keeping the overall scene low clutter.


Still a single field, but requires an explicit Save action and exact string entry; overall remains low-interference.


Short JSON snippet replacement in a single editor; Code mode makes the target state directly observable as text.


Single inline text edit in one editor with an explicit Save button.


Requires adding a new nested object with multiple fields in a cluttered dashboard scene, ideally using search to locate the correct insertion point.


Nested-path edit within a cluttered form section; requires selecting the correct nested field and saving.


Requires an extra overlay-opening step and interacting inside a modal, which adds layering and potential focus/scroll constraints.

Sprint Board
DEP-7 Deploy to staging
Review


Single clearly labeled reset action restores a known default state; light header clutter only.


Single board, few columns, unique card title, and no confirmation step.

Release Board
REL-4 Update changelog
In progress


High dashboard clutter increases disambiguation and target acquisition load, and the task requires tracking and completing two separate card moves.

OPS-19 Rotate logs
In progress
FIN-2 Approve budget
Done


Two visually similar reset links require selecting the correct instance based on section context and verifying state change via disabled styling.


Requires visual matching (color dot) across multiple similar link rows; labels exist but are not used by the instruction.


Single overlay opened from one link with immediate visible feedback.


Single list with 6 clearly labeled options, inline with immediate visual feedback and no disambiguation.


High clutter and multiple similar checkbox lists create substantial disambiguation load even though selection itself is straightforward.


Dark theme and dashboard clutter make it harder to focus on the correct card grid; preselected items must be corrected to an exact set.


Small, right-aligned secondary-action checkboxes in a dense list increase pointing/target acquisition difficulty.


Still a short list, but placed in a busier dashboard with more visual clutter and a smaller click target in the sidebar.


Short list with clear text labels and immediate active highlight.


Non-center placement in dark theme increases miss-click risk, and success requires an explicit save/commit action.


Two-phase commit (Apply) with additional distractor controls and transient toast feedback.


The task is only to change a mode toggle; dark theme slightly reduces contrast and icon salience but the target label is explicit.


Requires correct bracket/parenthesis syntax for a markdown link while navigating moderate dashboard clutter.


Tables require precise markdown structure (pipes + header separator) and typically involve small toolbar targets; even minor formatting errors break the rendered result.


High form clutter increases the chance of editing the wrong field, and the target requires precise indentation and list syntax for a nested list.


Requires opening a modal layer before interacting, and the short mask demands correct digit positions for month/year.


Requires copying an exact visually provided code into a masked field with a fixed literal prefix.


Still a single field, but the alternating letter/digit pattern and required space increase formatting precision compared to digits-only.


Single instance with a short suggestion list; the main challenge is opening the dropdown and selecting the correct option.


Requires precise caret placement in existing text within a cluttered dashboard, then selecting the correct mention without leaving extra spaces.

ask
to
Please ask @Noah Patel to review this.


Small targets near the viewport edge plus a long, scrollable list with similar prefixes increase the difficulty of acquiring the correct option.


Small table-cell inputs and multiple similar instances create disambiguation pressure; the agent must open the correct Popper without accidentally selecting an option.


Requires using the disclosure affordance on a single submenu; labels are distinct and the expanded state is visually obvious.


Simple open-and-select pattern with a short list; the result is mirrored in a dedicated status line.


Exact multi-selection with confusable tag names (Integrations vs Integration tests) requires careful checking and deselection of any extras.


Requires scrolling inside a small table-cell container to reach the target option; the scrollable region can be confused with page scrolling.


Requires matching a visual reference (icons), which may be less explicit in accessibility representations than plain text labels.


Simple selection, but the presence of two similar menu buttons requires choosing the correct labeled instance.


Single overlay open action, but the icon-only trigger makes target acquisition slightly harder than a text button.


Dense, long scrollable list inside a small popup increases both target acquisition difficulty and choice interference among similarly numbered items.


Requires recognizing overflow behavior and finding a hidden target among many similarly styled top-level items.


Straightforward tab-like navigation, with mild distraction from nearby form controls.


Single toggle within a small dropdown; requires noticing checkbox state and changing it once.


Single large target with visible numeric feedback and immediate updates; no disambiguation or overlays.


Multiple similar meters in a cluttered dashboard, visual matching without printed numbers, plus an explicit Save step and pending/committed state.


Vertical mapping (y-position to value) and corner placement in dark theme increase acquisition and control difficulty.


Requires opening a drawer and committing via Apply; otherwise a single meter with readable state.


Requires selecting the correct row among similar titles and using a small per-row action, but the read/unread state is strongly observable.


Single obvious bell control with unread indicator; success depends only on drawer-open state.


Small-scale controls increase acquisition difficulty and there are three near-identical instances; the agent must scope the sort change to the Work widget only.


A straightforward scalar choice in a settings panel; mild interference from nearby similar controls but the target is clearly labeled.


Although the scene is simple, the field starts in an invalid/error state and requires correcting it to a valid in-range value.


Clearing to an empty state requires correct deletion behavior but remains a single labeled component.


Single labeled number field; only minor difficulty comes from native number input affordances varying by browser.


Target is provided only via a reference badge and the scene contains three similar fields plus dashboard clutter, increasing disambiguation and observability demands.


Single click on previous button with clear visual feedback.


Must identify first-page button among other navigation controls.


Only one field must be filled, but the password is masked by default so visual confirmation is limited.


Dense table UI with three similar password inputs and small row-level Apply controls creates high disambiguation and target acquisition demands; masked text hurts observability.

Environment Secrets
Staging
Stage!4400
Apply


Exact formatted entry is required, and dynamic feedback (popover + progress) changes on each keystroke, increasing feedback dynamics and overlay layering.


Two similar masked fields require selecting the correct label and typing an exact mixed-format string.


The goal is simply to return the OTP value to empty; interaction is straightforward but requires deleting across multiple boxes.


Default Mantine PinInput with short length and explicit target; minimal UI and no disambiguation.


Small, compact targets increase acquisition difficulty, and per-character restrictions increase the chance of silent input rejection and recovery cost.


Requires scrolling to locate the correct section and uses small inputs that are harder to click precisely.


Two visually similar targets require choosing the correct labeled instance in a realistic form section.


Popover starts open with focus already inside, so a single Escape keypress should close it.


Single clearly labeled button opens a single popover with immediate feedback.


Small-scale dense table cells make correct icon acquisition and instance disambiguation difficult.


Requires matching to a reference with two similar progress bars; the target bar hides its numeric label, increasing reliance on visual comparison and correct-instance selection.


The progress bar is hidden behind a disclosure control and must be revealed before it can be started to a target value.


Immediate reset of a single determinate progress bar; the target state (0%) is clearly visible.


Three clearly-labeled options with immediate feedback and only one radio group on the page.


Dense table layout with multiple row-level radio groups requires careful row disambiguation; mistakes often affect the wrong row.


The target group is hidden behind an accordion and a second radio group in the Basics panel increases disambiguation risk.

Advanced delivery
Delivery window
Evening


Requires interacting with a drawer overlay and committing the choice with an explicit Apply button.


The target is visually specified but still maps directly to a small set of 5 options with immediate on-control feedback.


Single default Mantine Rating in an isolated card with whole-star increments and immediate feedback.


High clutter plus three similar instances increases disambiguation load; the target instance also requires half-step precision.


Requires scrolling to locate the target component within a dashboard before performing a standard whole-star selection.


Two similar resizable tables increase the chance of resizing the wrong instance, but the target has a clear label and live width readout.


One clear reset action with explicit default targets; minimal interaction complexity.


Single grid with a clear width monitor; modest interference from header icons but otherwise default behavior.


Three nearly identical grids create heavy instance disambiguation load, and matching a multi-column layout requires multiple accurate drags.


Single block with one formatting toggle (alignment) in a slightly non-central placement.


Requires scrolling to locate the editor within a cluttered settings page and setting a multi-line value.


Nested list structure requires multi-step list editing (create list → create second item → indent third item), which is error-prone in compact toolbars.


Single, default-size search input with an explicit label; only needs typing a short word and submitting once.


Dense list of highly similar alphanumeric options makes selection error-prone and requires exact matching.


Dark theme plus three near-identical instances increases disambiguation; the value is a strict formatted code and must be submitted via the field’s Search button.


Requires filtering suggestions by typing and then selecting the correct city from a moderate list.


Still simple, but includes a reset affordance and requires recognizing the default target from helper text.


Single SegmentedControl with clear text labels and immediate selection feedback.


Small, compact segmented controls inside a table cell require precise clicking and correct row identification.


Requires scrolling through a settings panel to find the correct toggle group; selection itself is simple.


Requires disambiguating between two identical multi-selects and producing an exact 3-item set while removing a preselected distractor.


The control exposes a clear-all affordance and the empty state is unambiguous once all pills disappear.


A short, distinct option list with immediately visible chips makes the interaction straightforward.


The drawer adds an extra interaction layer and requires an explicit Apply action; producing an exact set from a moderate list (including removing a preselected chip) makes the task error-prone.


Long alphabetical list requires controlled scrolling inside the dropdown and accurate option acquisition near the end of the list.


Requires using the searchable input to locate one item in a long, similarly formatted list, plus non-centered placement.


The menu is already open, so the only action is to click the correct option.


Single native select with four simple options and clear label; no clutter or extra steps.


Requires scrolling to locate the setting within a dense panel, then making a straightforward selection.


Still a simple single-select, but the off-center placement slightly increases target acquisition demands.


The target option is specified via a visual reference tile instead of direct text in the instruction.


Requires locating and clicking the clear control, but the scene is otherwise simple and the empty state is obvious.


Single Select with a very small option set and clear feedback; minimal interaction complexity.


A long within-dropdown scroll in a table-cell context increases navigation and acquisition difficulty, with moderate clutter competing for attention.


A long scrollable option list inside a moderately cluttered dashboard increases within-component navigation and option interference compared to baseline.


Two similar sliders in a form with other inputs increases disambiguation; values snap to step=5 so precision is moderate.


One-click reset achieves the target without requiring precise thumb positioning.


Single default MUI range slider with immediate feedback and a clear textual selected-range display.


High clutter and multiple similar sliders require careful disambiguation, and the filter popover adds layering with a required Apply commit.


The goal is specified visually (reference bar) and the numeric value is not persistently visible, increasing observability and precision demands despite a simple layout.


The slider is inside a modal (overlay step) and uses fractional values, but step=0.05 and clear feedback keep it manageable.


A dedicated reset control sets a known default, and the current value is always visible as formatted text.


Single split button with a large primary target; success is immediate after one click with persistent feedback.


Requires multi-level menu navigation (submenu reveal) in dark theme with corner placement, increasing layering and acquisition difficulty.


Two near-identical split buttons with identical menus require careful selection of the correct labeled instance.


Requires understanding that the main segment toggles state (ascending/descending) rather than selecting from the menu.


Still a simple 3-step selection, but the dark theme slightly reduces contrast and can make the target harder to visually acquire.


Single Mantine Stepper with three clearly labeled steps and direct click-to-activate behavior; feedback is immediate and unambiguous.


Small table-cell steppers reduce target size and increase density; the agent must select the correct row’s stepper and match it to a reference indicator.


Two similar steppers require selecting the correct labeled instance; otherwise the interaction itself is simple and feedback is immediate.


Two visually similar switches require label-based disambiguation; otherwise interaction is straightforward.


Uses a visual reference but involves only one interactive switch with immediate feedback.


Single labeled switch with immediate visual feedback and no competing controls.


Adds a confirm/cancel branching step and transient modal focus management before the switch state is committed.


Requires matching a mixed visual/text reference against several similar-looking rows with confusable numeric values.


Requires choosing the correct instance among two similar resource tables and then selecting the correct row.


Low-density visual matching with a single instance and clear row selection feedback.


Large, clearly labeled tabs with immediate visual/ARIA feedback and no distractors.


High disambiguation load due to three similar tab sets with repeated labels; the target is in a non-central viewport location.


Inverted placement makes the tab list less obvious and surrounded by distractor form controls, increasing search and targeting difficulty.


Non-baseline layout with extra settings UI nearby; vertical orientation can change target acquisition and scanning.


Single instance; success is an empty set. Slight target-acquisition cost to hit the clear icon or remove chips.


Default TagsInput with two short tags; immediate pill feedback and no distractors.


Must correctly commit each tag (Enter required) and resolve validation feedback; mistakes leave the component in an error state.


Requires comparing to a reference row and editing chips (remove + add). Still single-instance and highly observable.


Requires disambiguating between two similar text inputs and editing the correct one; otherwise straightforward entry.


Single prefilled field; main challenge is correctly clearing all characters without a one-click clear affordance.


Single visible TextField with explicit target string and immediate feedback.


Requires opening a dialog, editing the correct field, and confirming via Save so the committed preview updates.

Edit status message
Status message
In a meeting


Requires scrolling to locate the Incident report card in a right-aligned dashboard; once found, entering a single sentence is straightforward.

Service outage lasted 12 minutes; users recovered after a restart.


Two similar textareas in a cluttered form require careful label-based selection to avoid modifying the customer-facing field.

Escalate to Tier 2 if unresolved by EOD.


Requires correct newline separation and hyphen bullets, but the textarea is isolated and easy to access.


Single, clearly labeled time field with minute-level precision and an obvious textual value display.


Dense table layout with multiple similar time inputs and distracting row actions makes selecting and editing the correct cell challenging.


The agent must navigate a scrollable dashboard with multiple cards to locate the correct time input.


Requires correct AM/PM selection in addition to hour and minute entry.


Clearing uses a single in-field affordance and success is immediately visible as an empty input.


A small preset list reduces choice density; selecting a preset directly sets a visible HH:mm value in a single instance.


Clearing requires handling a multi-input validity rule (only all-empty commits), making recovery/feedback dynamics tricky despite a simple layout.


Adds an AM/PM decision on top of hour/minute selection; otherwise remains a single, uncluttered picker.


Requires acquiring a small close icon inside the toast; otherwise straightforward with a single visible notification.


Single click shows a single notification with explicit title; no in-toast interaction required.


Single button opens a single snackbar; the message is explicit and success triggers immediately on appearance.


Icon-only triggers plus small/dark UI require mapping a visual reference to the correct severity variant.


Requires interpreting a separate visual reference and then setting the toggle state to match it.


The agent must consult a reference indicator and then set the toggle accordingly.


Small icon target with a couple of neighboring icons, but still straightforward and immediate.


Few clearly labeled options with immediate visual selected-state feedback and only one instance on the page.


Requires scrolling to find the correct section plus disambiguating between two similar toggle groups with identical options.


Requires editing a preselected set and completing a confirmation step where changes are only applied after Confirm; dark theme can reduce contrast.


Icon-only options raise choice interference and make semantic observability harder; matching to a visual reference adds interpretation load.


A single exclusive choice with clear textual labels and an explicit status line makes the goal unambiguous.


Simple labeled button activation with immediate textual feedback.


High disambiguation load from three similar toolbars in a cluttered dashboard, plus multiple sub-control changes (two toggles + one segmented choice).


Focuses on reliably opening an overlay from a small icon target; success requires detecting the open menu state.


Requires selecting the correct info icon among two similar instances in a realistic form layout; small targets increase acquisition difficulty.


Single tooltip instance; the only added challenge is the smaller icon target compared to a full button.


Single tooltip instance and a clear hover interaction; the tooltip text is short and easy to verify.


Requires navigating a drawer overlay before interacting with a small tooltip trigger; dark theme and drawer layering increase difficulty.

Open drawer
Auto-renew
Automatically renews your subscription


Slight disambiguation from nearby settings controls, but still a straightforward open-to-first-step action.


Near-edge placement makes the close control harder to acquire, but the intended action is still a single click.


High disambiguation (3 similar tours) plus more steps in a cluttered dashboard increases both selection and navigation error risk.


Only two uniquely named items must be transferred in a single, default Transfer component with no overlays or extra steps.


Targets are far down a long scrollable list with many similar items, requiring controlled scrolling and careful selection to avoid off-by-one mistakes.


Small-scale targets and many near-duplicate role labels make accurate matching difficult; the correct set must be inferred from a visual reference.


The agent must correctly use a filter input to reduce options and then transfer the right items from a moderately sized list.


Only two targets and clear checkbox feedback; minor hierarchy navigation to reveal both rows.


Simple disclosure + single selection with clear highlight feedback in a low-clutter scene.

API Gateway
Platform
Platform → API Gateway


Multiple sub-states must be cleared in a small, corner-placed UI where targets are harder to acquire.


Virtualized scrolling plus compact targets and a multi-level path create moderate-to-high acquisition and depth demands.

Operations → Data Centers → US-West → Rack 21


Requires navigating a deeper hierarchy with several expansions, and the component is placed away from center which increases acquisition cost.

Policy page
Handbook / Security / Access / VPN


A single clear action with immediate observable state change in the TextInput.


A straightforward composite: open popover and click a single leaf in a small tree; the chosen label is echoed in the TextField.

Catalog / Hardware / Laptops / Ultrabooks


Visual-only specification and dark theme increase interpretation and target acquisition difficulty, even though the tree itself is small.


Requires scrolling inside a virtualized list of many similarly named items and selecting the correct one.


Two similar tree instances in a settings panel create high disambiguation load before performing a simple selection.

Notification channels
Daily digest
Email


Single visible checkbox target with immediate visual update.


Target is visible without scrolling and selection is single-click with immediate, clearly labeled feedback.


Compact spacing makes checkbox targets smaller and closer together; success requires an exact 5-item set amidst many similar labels.

PERM-013 View reports
PERM-027 Edit reports
PERM-031 Export data
PERM-044 Manage users
PERM-048 Billing access


Multi-step modal flow with an explicit confirm button; missing the final confirmation is a common failure mode in component interaction.


Adds a filter-typing step and moderate settings clutter that competes for attention; the list itself remains single-select with clear feedback.


The intent is simple (restore default), but the reset control is a smaller target embedded on the divider.


Single resizer with continuous percent readout and a generous tolerance; basic drag suffices.


Visual-only target with tight tolerance; dark+compact+small reduces contrast and increases acquisition difficulty.


Adds modal layering and requires an explicit save to commit the new layout, increasing feedback/commit complexity.


Still straightforward, but requires noticing that two panels start open and both must be closed.


A simple one-click switch to another clearly labeled item in a single accordion.


Multiple accordion instances in a cluttered dashboard require strong disambiguation to act on the correct card and item.


Small, compact styling plus many closely spaced options increases target acquisition difficulty and confusion among similar topics.


Multiple similar table-row delete actions create disambiguation pressure, and Popconfirm buttons are small within a dense table context.


Two similar danger actions require selecting the correct instance; otherwise the confirm modal interaction itself is straightforward.


Single dialog with clear Cancel button; minimal clutter and no instance ambiguity.


Nested overlays (a dialog on top of another modal) increases depth layering and focus-trap complexity; the agent must interact with the topmost dialog actions.


Multiple similar instances in a busy dashboard require correct disambiguation plus reasonably precise slider setting.


Requires disclosing an accordion section before interacting with the slider; adds one layer of UI depth and distractors.


Presence of a similar distractor slider and a small reset control increases the chance of mis-targeting.


Requires opening the suggestion popup and choosing one clearly labeled option. The reference pill reduces ambiguity and the option list is short.


Requires an exact string with diacritics and interacting with a long, scrollable dropdown in a small component placed near the viewport edge.


Dark theme and several near-identical reviewer names increase selection errors; auto-select-on-blur behavior adds nontrivial feedback dynamics.


Requires matching a short hyphenated code that is visually referenced, with several similar options that can cause off-by-one mistakes.


The correct choice is clearly shown by a nearby reference pill and the option set is very small.


Straightforward clear action on a single Select; minor difficulty due to small clear control.


Combines opening a modal overlay with extracting a visual reference tier and selecting the matching option; fewer instances reduce disambiguation.


Small-scale control combined with a long, similarly formatted list requires careful scrolling and accurate option selection.


Requires visual comparison of separator styles across three similar breadcrumbs.


Single icon target; requires recognizing home icon.


Must distinguish between identical labels in different sections.

Primary Navigation
Sales
Secondary Navigation


Small icon-only buttons inside a compact dark table increase acquisition difficulty and require correct row-to-action mapping among multiple similar instances.


Requires reaching a specific toggle state (ON) but the control is large and clearly labeled with visible status text.


Requires selecting the correct option among three similar toggle buttons and verifying the active/pressed state.


The goal is purely to change the visible month using obvious header navigation; success is clearly observable via the month header and the 'Viewing' label.


Reaching a far future year requires scrolling within a compact dropdown list and then accurately selecting the correct day in the resulting month.


Small/compact rendering reduces target sizes for month and year options, and the multi-level navigation path (year→month→day) increases layering and interaction steps.


The selection is simple, but two identical instances require correct target disambiguation and avoiding changes to the non-target calendar.


Dark theme slightly reduces visual contrast, but there are few slides and each has a clear label/alt text.


Many highly similar slides and a dense vertical dot stack in compact/small mode create high acquisition and interference difficulty.


Small scale increases acquisition difficulty slightly, but the goal slide is clearly labeled.


A large number of similar slides combined with looping behavior and small indicators increases interference and overshoot risk.


Selection is straightforward, but there are two identical cascaders so the agent must target the correct labeled instance.


The dashboard context adds competing interactive elements and a moderately dense taxonomy, but the target leaf is still easy to identify.


Hover-based expansion is harder for agents than click expansion, and compact spacing reduces target size while navigating multi-column menus.


Visual reference matching in dark theme requires accurately interpreting the on-page breadcrumb and selecting the corresponding leaf among similar siblings.


Requires opening a modal overlay, toggling the checkbox inside it, and committing with OK (multi-step with overlay depth).


Involves an overlay modal and an explicit commit button, adding a small multi-step flow to a binary checkbox toggle.


Corner placement plus two nearby checkbox targets increases pointing and disambiguation load compared to a single centered checkbox.


Only three options with a simple on/off change from the default selection.


High clutter dashboard with three similar filter groups requires correct disambiguation plus an Apply step.


Dark theme with small, compact checkboxes and many similarly named privacy options increases mis-clicks and confusion.


Requires matching the selection to a reference panel while ensuring no extra alerts remain selected.


Dark theme slightly reduces contrast, but the task remains a direct single-checkbox state change with clear feedback.


Simple single-checkbox clear action; the only requirement is recognizing and reaching the Unchecked state.


Requires scrolling to reach the target plus disambiguating between two nearly identical tri-state checkboxes in a high-clutter dashboard, making wrong-instance errors likely.


Multiple similar tri-state checkboxes inside a modal plus a required Apply step increases both disambiguation and feedback/commit complexity.


Requires opening a modal overlay before the copy control is available; feedback is transient and the overlay adds interaction depth.


The copy affordance is only disclosed on hover and is a small icon within the code block.


Large, clearly labeled button with a single obvious target value; feedback via snackbar confirms success.


Requires a confirmation dialog to complete copying, and the secret is visually masked, reducing semantic observability in dark theme.


Small/compact controls and two similar editor instances increase disambiguation and targeting difficulty; formatted YAML must match.


Opening the target overlay requires a dropdown menu selection (extra layering) and choosing the correct item among similar actions.


Multi-line formatted input with strict indentation requirements, but otherwise a clean single-instance scene.


Accordion mode reduces ambiguity (only one can be open), and the target header is directly visible.


The disclosure header is a small target inside a dense table cell with nearby distractor controls.


Exact expanded-set requirement with multiple initially open items increases the cost of mistakes and requires careful toggling.


The goal is specified by a visual reference rather than explicit text, and there are multiple similar icon-labeled options.


Clearing uses a dedicated affordance (allowClear) and the cleared state is directly observable on the trigger.


The target is a small table-cell swatch among multiple similar instances, and matching a reference requires fine control and correct row disambiguation.


This is a single click on a discrete swatch option with clear immediate feedback.


Entering an 8-digit hex value demands high formatting precision, and invalid input triggers fix-on-blur behavior that can reset progress.


The target picker is embedded among other form controls, adding mild disambiguation and visual clutter while keeping interaction steps simple.


Drawer + popover layering with explicit Save confirmation and two similar instances creates higher depth and disambiguation demands.


Requires opening a modal, selecting a swatch in a dropdown, and explicitly saving to commit the change.


The editable control is embedded in a tight table cell with small affordances, increasing target acquisition difficulty while keeping the palette manageable.


Dark theme reduces visual contrast and there are three near-identical instances, increasing disambiguation and target acquisition difficulty.


Compact spacing and dense swatches increase interference and target acquisition, even though a direct HEX entry path exists.


Requires correcting an existing invalid value and confirming the error state clears, adding recovery/validation dynamics.


Single tag creation via typing and Enter; minimal choice complexity and clear visible result.


Max-count constraint forces correct removal before additions; mistakes can temporarily block further input and require recovery.


Max-tags constraint forces correct removal and replacement under compact/small rendering, increasing error recovery cost.


Goal is specified visually, requiring correct reading and matching of reference chips; otherwise interaction is standard.


Very small option set with clear labels; opening the dropdown and clicking the target is sufficient.


Simple dropdown selection with a very small option list and no clutter or disambiguation.


Requires an exact formatted string containing special characters (+) on a small-scale control, with nearby confusable suggestions like C++14/C++20.


The target is an inline table cell editor with small hit targets and multiple identical instances across rows, making correct row/column disambiguation difficult.


Requires opening a submenu and selecting a nested item; the correct semantic state is a two-level activated path.


Two similar instances require disambiguating the correct folder before selecting a common action.


Single target message with a short three-item menu; success is a simple top-level item activation.


Small, compact targets plus a deep three-level submenu path with similar rotate options makes this interaction sequence error-prone.


Requires navigation within the table (pagination) to locate the correct row before performing a standard inline edit.


Single text cell edit in a single DataGrid with clear row key and immediate visible update after commit.


Two similar editable grids increase disambiguation load even though the edit itself is simple.


A small, visible list requires selecting multiple checkboxes without selecting extras.


Dark theme plus pagination introduces extra substeps; maintaining a multi-row selection across pages is error-prone.


Requires managing a large selection set and correctly leaving out two specific rows; compact density raises misclick risk.


Overlay depth plus an explicit Apply action increases complexity compared to inline selection.


Goal is to remove a single active filter; UI provides a dedicated Reset control and clear applied-state indicator.


Single prominent text input with live feedback and high observability of the entered query.


Three compact mini-table instances inside table cells make target acquisition and disambiguation very difficult; controls are small and Apply is required.


Requires picking the correct multi-value operator and selecting three values in a denser multi-select UI; dark theme and corner placement add friction.


Requires using a visual/text reference, navigating pages, and selecting the correct row among similar IDs.


Requires using a text filter control and then selecting the correct row; the reference card adds a match step.


One dropdown selection in a standard footer control with clear numeric options.


Thin drag handles plus small scale make precise column resizing difficult; success depends on achieving a minimum width/visibility threshold.


Requires configuring a two-key sort state (multi-sort) and keeping both columns active with the correct priority and directions.


Visual reference requires interpreting a header+arrow preview and applying the equivalent sort to the table.


Requires disambiguating between two similar DataGrids and sorting the correct Role column.


Requires replacing an existing value, but the field is still isolated with clear visual confirmation.


Requires reading a visual reference, editing the correct field among two similar instances, and committing via an explicit Apply action.

Backup deadline
Reference calendar
Apply changes


Small inputs embedded in a compact table increase pointing precision needs and disambiguation across multiple similar instances.


Requires scrolling within a settings pane to locate the correct labeled field amid moderate clutter before performing the usual date entry.


Selecting a clearly labeled preset is a straightforward path; minor risk of choosing the wrong chip among a few.


Simple date range selection in the currently visible month with immediate input feedback.


High clutter and multiple table-row instances plus a cross-year range and modal opening require careful instance targeting and navigation.


Goal is specified via an external reference card and requires applying with OK; selection spans many similar day cells.


Small embedded input inside a table increases target acquisition difficulty and adds realistic clutter, but the date choice is straightforward once opened.


Compact spacing and multiple date-related fields increase disambiguation load despite a standard single-date selection interaction.


Requires handling the mobile dialog action bar and confirming with OK, but otherwise uses a single, clear date picker.


Nested overlays (drawer + picker popover) combined with visual-only target specification and multiple similar instances significantly increases interaction depth and disambiguation load.


Requires precise second-level time selection and a cross-midnight date boundary; dark theme can reduce contrast for small time-column targets.


Modal-based pickers add an extra layer and larger context switches (Start modal then End modal), while the target values remain straightforward.


Adds a commit step: the agent must recognize that OK is required to apply the draft range; otherwise the interaction is standard.


Straightforward single field but requires exact formatted text entry and commit behavior without an explicit OK button.


Small table-cell targets with two similar editors plus a visual reference create high acquisition and disambiguation load; requires OK confirmation.


Small/compact UI plus far-year navigation increases target acquisition and depth compared to baseline.


Requires extracting a datetime from a visual reference element and applying it to the picker; otherwise standard desktop interaction.


The modal is already open and the mask is a large target, but the agent must click outside the dialog rather than pressing Escape.


The modal is already open and the close button is visible in the header; only a single click is required.


High clutter and three similar 'Customize' triggers require careful instance disambiguation, and the target is specified via a mixed visual/text reference that must be matched to the modal header.


The required control is off-screen inside a scrollable dialog and the dark theme reduces contrast, increasing the likelihood of scrolling the wrong container or missing the bottom button.


Two-step flow with an inline confirmation overlay; the download only starts after confirming. Placement in the bottom-left slightly increases acquisition difficulty.


Requires opening a menu and selecting the correct format among several options. Labels are clear but an overlay layer and multiple choices add complexity.


Small link target but only one true download link is present, with immediate textual feedback.


Small overflow icon plus a two-layer menu/submenu interaction increases depth and misclick risk, especially in compact dark mode where spacing and contrast cues are reduced.


Handle-only dragging with compact spacing and small scale makes target acquisition and drag initiation error-prone even for a single move.


Requires opening a drawer, transferring the correct item, and committing via Apply—introducing overlay depth and a staged confirmation step.


Requires choosing the correct component instance among two similar selectors (both include 'Price'), then performing a simple transfer.


Single adjacent move in a short list; labels are distinct and the final order is easy to verify.


Small drag handles in a compact table require precise targeting; exact full ordering plus an Apply commit step is required.


Dense, small-scale scrollable list in a cluttered dashboard requires precise handle dragging and scrolling to reach the target item.


Requires matching a visually provided reference order rather than a fully textual target, but the list is short and inline.


Same simple open interaction as baseline, but the trigger is anchored in the corner of the viewport.


Only one open drawer and a single close control; minimal ambiguity.


Two-step nested drawer flow increases depth and requires correct instance tracking.


Requires a continuous drag gesture with a threshold/snap behavior; partial states and motion feedback increase dynamics difficulty.


Requires opening an overlay (modal) to access the feed and then scrolling/loading until the target entry is reachable and opened.


The filter control is embedded in a busier settings panel and requires correctly targeting the feed’s header control rather than unrelated toggles.


Single click expands a clearly visible preview in a single list; no disambiguation or waiting.


Requires handling an overlay confirmation dialog correctly and preserving an existing multi-selection state.


Requires scrolling to find the target section, then selecting the correct zip among multiple similar filenames in a compact/small UI with more distractors.

Diagnostics
logs-2026-02-01.zip
Diagnostic logs


Disambiguating two similar instances is the main challenge; otherwise the outcome is clearly visible via per-instance file rows.


Corner placement and a drag gesture increase target acquisition difficulty; however, the file set is small and feedback is explicit via the resulting filename chip.


Selecting a single checkbox is straightforward; success requires choosing the correct row in a small table.


Requires locating the correct row in a cluttered table, opening a nested popover, and setting the exact sort direction using small header targets.


Requires visual thumbnail matching and correct use of a small star control to set Primary, with dark theme reducing contrast.


Requires disambiguating between two managers and similar filenames, using search, and correctly toggling the Primary (star) state.


Requires choosing the correct instance among two labeled uploaders, but labels are clear and the target file is explicit.


Single labeled FileInput with direct in-field filename display and no additional steps.


A small details icon increases target acquisition difficulty; success depends on opening the correct overlay and verifying the file identity inside it.


Selecting an exact set of multiple files with highly similar names increases precision and interference, especially in compact/small dark UI.


Requires visually matching the correct trigger among multiple similar options; the state is visible but not purely text-based.


Three similar options require visual matching; group-synced delays add modest timing sensitivity.


Adds a small in-overlay toggle that must be clicked while keeping the hover card open (interactive hover).


Requires reversing a persistent pinned state and ensuring the overlay is fully dismissed, with small controls under compact dark styling.


Two near-identical toolbars create disambiguation pressure, and the compact/small icon buttons increase targeting difficulty.


Requires iterating through a cyclic state machine to reach the default; feedback is clear but may require multiple actions.


The disclosure control is small and located in the top-right, requiring accurate acquisition and header scanning in a slightly cluttered card.


Only one editable target and success is achieved as soon as the component visibly enters edit mode.


Small, dense table targets in a corner placement increase acquisition difficulty, and the user must correctly locate the one editable cell before entering and committing the exact value.


Requires scrolling within a settings panel to locate the correct row amid distractors, then performing an exact inline edit and commit.


The agent must handle delayed commit and transient UI states (disabled Save + snackbar) while still ensuring the final committed text matches exactly.


Single reset action with immediate feedback; no multi-instance disambiguation.


A single boolean toggle in a clearly labeled, single-instance editor.


Requires a full JSON replacement in an overlay plus an additional confirmation dialog before the change is committed.

mode strict sampling sampleRate tags prod


Order-sensitive drag-and-drop reordering inside the JSON editor with an explicit Save step.


The move itself is simple, but two near-identical boards are present and the agent must correctly target the labeled instance.

Engineering
Marketing
ENG-21 API pagination
To do


Correctly selecting the target board instance is the main difficulty; the card move itself is straightforward.

Work
Home
WORK-10 Prepare invoice
In progress


A straightforward within-column reorder among only three items with clear drop-position feedback.


Requires interpreting a visual reference and completing multiple moves, including one exact positional constraint (REL-9 must be first in Done).

REL-7 Cut release branch
In progress
REL-8 Tag v1.2.0
Done
REL-9 Announce release


Requires disambiguating between same-label links in different regions under dark theme and dashboard clutter; success must confirm the sidebar instance was used.


Single off-screen link inside a long scroll container; the primary challenge is search/scroll rather than choice.


Selecting one among multiple similar links requires correct choice; state is observable via aria-current and the panel header.


Two similar checkbox lists appear simultaneously; overlapping option names increase the chance of selecting in the wrong instance.


Requires mapping a visual reference (chips) to the correct items within a longer, partially similar option list.


Requires scrolling within a modal list, adjusting preselected items, and confirming via an Apply button to commit state.


Requires opening a dialog and committing via Save; must replace an initial selection with an exact set.

Sharing settings
Who can see my calendar
Save


Clearing requires using a small auxiliary control but the resulting state is clearly indicated as “No active project selected”.


Simple list selection but placed in a busier dashboard layout.


Three similar stacked listboxes require careful instance disambiguation; the target option is easy to misapply to the wrong list.


Long dense list in a small scroll area demands within-component scrolling and careful selection among many similar rows.


It’s a single explicit mode switch with immediate visual feedback and no competing instances.


A modal overlay adds layering and requires an explicit Save to commit; the markdown itself is short and easy to verify.


Requires precise text selection or correct link syntax, often via a nested link popover with small targets and multiple fields.


Compact dark UI makes toolbar targets harder to acquire, and the task requires multiple markdown constructs (blockquote + italic + correct blank line) with strict disambiguation between two instances.


Small control size plus editing a prefilled masked string increases the chance of cursor/selection mistakes and partial mask states.


Two same-type instances require selecting the correct labeled field; off-center placement adds minor acquisition cost.


Disambiguation between two nearly identical masked fields and off-center placement increases the chance of selecting the wrong instance.


Requires entering a short sentence with one mention and basic punctuation; suggestions list is still small and unambiguous.


Multiple similar instances in a settings panel require careful disambiguation, and the final sentence demands precise punctuation plus three correct mention insertions.

Escalating to @Ava Chen, @Ethan Brooks, and @Isabella Garcia.


Requires a drawer interaction step before the component is reachable and then a mention selection inside a nested overlay (Popover within drawer).


Multiple instances require correct targeting and the agent must complete two mention insertions without affecting the other field.


Simple menu with an explicit 'Clear selection' action; success is clearly observable via no highlighted item and the mirrored text.


Menu is already open and contains only three clear options; selection feedback is immediate and textual.


Three similar menus require careful instance disambiguation, and the goal is provided as a mixed visual+text reference rather than a simple label-only instruction.


Dense checkbox list with many options requires precise selection/deselection to match an exact target set; similar labels increase interference.


Multi-selection increases state dimensionality and error likelihood (extra options accidentally toggled), while feedback is split between checkmarks and the count in the trigger.


Icon matching adds ambiguity and can be less accessible-tree friendly than purely textual targets.


Straightforward open-and-select with a small set of distinct textual options and immediate label feedback.


Icon-only triggers in a cluttered dark toolbar plus multiple similar instances create high acquisition and disambiguation load.


The core challenge is selecting the correct menubar instance; both contain similar menu structures and the wrong instance change must not count.


Visual icon matching plus corner placement increases acquisition and disambiguation demands compared to pure text tabs.


Still a single-step disclosure, but corner placement can affect target acquisition and visibility of the anchored popover.


Single obvious reset affordance with immediate feedback and no overlays or competing instances.


Requires selecting the correct row’s meter in a dense table and performing a drag interaction with fairly tight tolerance.


High clutter with three similar meters, visual matching without numbers, reliance on tooltips for exactness, and a required Save step.


Opening a hover tooltip can be tricky for agents and requires precise pointer placement, but there is only one meter and no value setting.


A single visible 'Reset filters' control restores default state with immediate feedback; no multi-instance ambiguity.


A simple tab selection with clear active styling and immediate filtering feedback.


Requires setting a scalar value and committing via Apply (feedback dynamics), with dark theme slightly reducing visual clarity of the pending/applied distinction.


Layered overlay interactions (drawer + dialog) in dark mode plus destructive confirmation; feedback includes transient snackbar and persistent list-empty state.


Dark theme reduces contrast and can make targets slightly harder to acquire, but the task remains a single labeled input with a coarse step.


The task is visually simple, but begins with an invalid value and requires correcting it while confirming the error clears.


Single number field with explicit increment/decrement buttons and a small integer target.


Requires handling an overlay dialog and using the correct confirmation action (Save) to commit the numeric change.


Small controls in corner with simple mode requires more clicks or jumper use.


The only action is clicking the small eye toggle; state becomes clearly visible once revealed.


The compact dark UI makes the visibility toggle harder to target, and ending in a masked state reduces visual confirmation of the final value.


Requires scrolling within a cluttered dashboard to locate the correct card, then entering an exact mixed-format masked value.


Requires opening a dialog, entering a masked value, and confirming via Save; overlay layering increases step count.

Edit credentials
Service password
Service@3080
Save


Interaction is simple, but the target code must be read from a visual reference rather than being spelled out in text.


Single default-sized Mantine PinInput with explicit numeric target; the oneTimeCode attribute does not add interaction complexity.


Requires opening a modal, selecting the correct instance among two PinInputs, filling a longer (8-digit) code, and committing via Verify.


High disambiguation load from three similar OTP inputs inside a busy form, plus a required Apply step with enable/disable feedback.


Requires scrolling to locate the correct row among distractors, then clicking a small info icon to open the popover.


Two visually similar instances in a form require selecting the correct labeled help icon.


Requires hovering the correct target, but the target is large and unique.


Targets are unlabeled icons requiring visual matching and precise acquisition; Popper behavior (toggle-only close) adds interaction brittleness.


Multiple same-type instances in a cluttered dashboard require correct card selection plus timing-sensitive pausing near a target percent.


Visual-only matching with fine-step adjustments across two similar instances increases precision and disambiguation requirements.


Requires opening a dialog overlay and using an in-dialog Start control; progress changes dynamically and must reach a mid-way target.


Single radio group with short, distinct labels and an immediate state indicator.


Requires a two-step commit (Apply then Confirm) with an overlay confirmation prompt; failures often come from not confirming.

Change retention policy
Delete after 90 days
Apply


Visual matching among multiple icon/card options in dark mode increases choice interference and reduces semantic observability from text alone.


The radio group is gated behind an accordion disclosure and is surrounded by distractor controls.


Still a single whole-star rating, but embedded in a realistic form with a read-only distractor rating that increases selection/disambiguation slightly.


Visual reference mapping to a small discrete set (1-5) with immediate and visible star feedback.


Requires scrolling to locate the target section and then interacting with a small-sized rating control with reduced hit targets.


Half-star precision combined with small targets and a compact table layout makes both acquisition and correct-row disambiguation challenging.


Resizing occurs among nearby form controls and sortable headers, increasing the chance of mis-clicks; the width badge keeps observability reasonable.


Correct-instance selection across two similar tables is the main challenge; resizing itself is straightforward with numeric feedback.


A wide acceptable range reduces precision; the main challenge is grabbing the correct header separator amid minor icon clutter.


Requires opening a modal, performing precise resizing in an overlay, and committing changes with Save (draft vs committed feedback).


Still a single straightforward operation, but compact spacing and small controls increase target acquisition difficulty.


Requires finding the editor in a busier dashboard layout and producing an exact short target string.


Three similar small editors in close proximity require careful instance selection and precise substring formatting.


Default AntD search with a clear, large “Search” button; short phrase entry with a single confirmation click.


Requires opening a modal, replacing an existing value, and confirming within an overlay; feedback is delayed with a loading state.


Large, dense suggestion list with similar city names may require scrolling within the dropdown; high surrounding clutter increases interference.


Exact phrase matching from a reference tag plus explicit Enter submission; dark theme slightly reduces contrast of the adornment icon.


Two similar segmented controls require choosing the correct labeled instance, but options are large and unambiguous.


Two-option segmented toggle with clear labels and no clutter.


A confirmation dialog must be handled correctly; canceling reverts the control, so committed state is not trivial.


Small icon-only targets in compact spacing require precise acquisition and visual matching.


The goal is specified visually via a reference chip row, and the option list includes similar badge names that can be confused.


Two similar MultiSelect instances require careful disambiguation; the target set needs both adding and removing items.


The only requirement is to reach an empty chip list; the clear icon provides a simple one-step reset.


Editing inside a dense table cell increases acquisition difficulty and raises the cost of mistakes; the agent must transform a preselected set into an exact new set from a moderately large list.


Small table-cell controls with three identical selects require precise target acquisition and correct row disambiguation.


Requires matching a visual badge icon to the correct option while options also contain text and icons.


Two adjacent selects require choosing the correct labeled instance; otherwise the menu is small and easy.


Simple single selection; only minor added difficulty from off-center placement.


Row-level disambiguation inside a table increases interaction complexity compared to a standalone select.


Requires selecting a sentinel reset option, but the control is isolated and feedback is immediate.


Selecting the correct dropdown inside a table cell requires precise target acquisition and row-level disambiguation.


Single component; success is achieved by opening the popover overlay, which provides clear visual feedback.


Central single searchable Select with a short list; the target is easy to find and selection feedback is immediate.


Visual-only goal specification (avatar without name) increases observability demands; selection requires matching the correct custom-rendered item.


Async loading with delayed feedback plus a cluster of visually similar options increases error risk; the modal adds another interaction layer before selection is possible.


Compact spacing and top-right placement reduce target size and increase acquisition difficulty, but the state remains readable via the numeric readout.


Two similar range sliders require selecting the correct labeled instance; step=50 makes precision moderate but still discrete.


Discrete step/marks reduce precision burden while value labels and a Selected readout provide clear feedback.


Requires precise numeric entry with commit semantics (Enter/blur) and handling potential validation, with both text and a visual reference present.


Two visually similar sliders inside a modal require correct instance selection and an explicit Apply confirmation; default sizing keeps targeting reasonable but still non-trivial.


Compact spacing and a shorter track make targeting slightly harder, but the value is an integer with a clear live readout and only one slider instance.


The slider is behind a drawer overlay (extra step) and requires an exact integer value, but the drawer content is otherwise simple and labeled.


Requires acquiring the smaller chevron segment and opening a single-layer dropdown; no selection is needed.


Requires opening a constrained, scrollable menu to find a bottom option, then completing an inline confirmation step inside the dropdown.

Row 12 actions
Delete permanently…
Confirm


Requires scrolling within a constrained dropdown in dark theme and selecting a lower-list item among many actions.


Adds an additional text input step inside the overlay and increases option count, making the interaction multi-step.


Single instance with a clearly labeled Reset control; success is a discrete, easily observable state change to the first step.


Single clear action (Next step) in a simple linear layout; the stepper state change is immediately visible.


High clutter and multiple similar steppers require correct instance selection; resetting from a Completed mode adds a feedback-mode transition that must be recognized.


Requires opening a modal overlay and then correctly selecting among two similar steppers within the modal before choosing the correct step.


Dark theme reduces contrast and can make ON/OFF affordances slightly harder to perceive compared to baseline.


Multiple similar switches increase disambiguation load even though the action is a simple toggle.


Single visible switch with immediate state change and no distractors.


Requires scrolling to a lower-viewport target and selecting a small switch among multiple similar toggles in a dense dashboard.


Requires a horizontal drag/scroll interaction to reveal an off-screen column and then precise cell targeting on a smaller table.


Adds an overlay step (open modal) and requires interacting within a layered container.


Internal scrolling plus compact row density increases scanning difficulty and target acquisition cost.


Still a straightforward click on a clearly labeled tab; mild extra form clutter adds small distraction.


Tab switch is gated behind a confirmation overlay; missing the confirm leaves the tab unchanged, increasing feedback/recovery complexity.


Small, compact tab strip plus horizontal scrolling increases acquisition difficulty and adds an extra sub-step before selection.


Requires opening a drawer and then selecting a tab inside an overlay container.


Requires reading a visual reference and editing chips (remove one, add two). Still a single clean instance with direct feedback.


Short suggestions list and straightforward dropdown selection; highly observable pills.


Two instances in a small, compact corner panel plus a maxTags limit requires correct delete-then-add sequencing and careful disambiguation.


Dialog layering and an explicit Save step introduce extra substeps and failure modes; dark theme can reduce visual contrast for small controls.


Requires entering an exact 6-character formatted code in a small/compact input while reacting to inline validation feedback.


Requires choosing the correct instance between two similar labeled TextInputs and entering punctuation correctly.


Simple single-field edit: replace an existing value with a short target.


Exact, mixed-case PIN entry is required while the password field masks input, reducing observability for agents.


Target must match a multi-line message from a visual reference (not selectable text), increasing transcription and observability difficulty.


Exact two-line reproduction with a visually indicated line break; mixed reference reduces ambiguity but still requires precise formatting.


Disambiguation between two similar textareas in a busy form increases the chance of editing the wrong field.

Leave at reception desk. Do not require signature.


Clearing a single prefilled field is straightforward; the only mild challenge is locating the clear affordance.


Requires handling an overlay drawer flow and completing an explicit Save/Cancel decision after setting the time.


Dense table with multiple similar small time inputs requires careful target acquisition and row-level disambiguation.


Adds validation dynamics: the agent must correct an initially invalid value and ensure the field leaves the error state.


The task only requires opening the picker overlay; success is visible from the presence of the dropdown panel.


Simple two-field entry (hours/minutes) with immediate visible feedback in an isolated single-instance layout.


12-hour mode requires correctly setting AM/PM and completing all inputs to commit; having two instances adds disambiguation load.


Requires selecting a non-round minute (05) in a mobile dialog and explicitly confirming with OK, with reduced contrast from dark theme.


Requires selecting the correct in-toast action among two buttons and observing the follow-up success toast.


Main challenge is acquiring the toast’s close control; otherwise the target toast is unambiguous and persistent.


A single click shows a snackbar with explicit text; a nearby distractor button adds minor interference.


Three similar snackbars require precise identification and closing of only the targeted instance; closing any other snackbar fails the task.


Requires opening a modal, toggling the correct control inside it, and committing via a separate Save action.


Returning to the documented default requires reading the UI hint; nearby restore control adds mild interference.


Two nearly identical toggles require selecting the correct instance based on surrounding labels.


Only one group with four distinct labels; clearing to an empty state is straightforward and feedback is immediate.


High clutter with multiple similar groups and many options increases both disambiguation and dense-choice interference; targets are smaller and more crowded in the dashboard layout.


Scrolling plus compact small chips and a larger option set increase both target acquisition difficulty and dense-choice interference.


Requires identifying the correct table row among multiple similar groups; embedded controls have smaller targets and higher disambiguation load.


Still a single click, but requires recognizing that multiple sub-controls must return to default; the page explicitly shows the default target state.


Icon target is smaller than a text button, but the control is labeled via tooltip/aria-label and state is echoed in text.


Requires executing a two-step confirmation flow and verifying the resulting state change (order reset) rather than a single click.


Compact icon targets in a dark app bar plus horizontal scrolling to reveal the goal action significantly increase acquisition and search difficulty.


Small targets in a compact panel plus a long hover delay increase motor control and timing demands, but there is only one tooltip instance.

Data retention
Logs are kept for 30 days.


Delayed feedback (openDelay) requires timing and stable hover, increasing feedback dynamics difficulty.

Generate token
Token expires in 24 hours


Large, easy-to-acquire button and immediate tooltip feedback; arrow styling does not add interaction complexity.


Follow-cursor motion and two similar large targets increase control demands and disambiguation; tooltip position changes continuously during hover.


Adds a small amount of target acquisition (indicator chips) but still low option count and clear labels.


Medium clutter increases visual distraction, but the Tour step title provides a clean textual target.


Visual-only goal with similar icon distractors and two tour instances increases observability and disambiguation difficulty.


The goal is to transfer every item; there is no need to discriminate among options, and the component is in the default inline configuration.


The target Transfer is one of several near-identical instances inside a drawer with heavy clutter, and success requires an explicit save/confirm step.


Targets are far down a long, highly uniform list requiring in-component scrolling and careful selection to avoid off-by-one errors.


The agent must operate within a dialog overlay and include an explicit Save step; mistakes require extra transfers before confirming.


Single header target and immediate visual feedback; no deep hierarchy or disambiguation.


Single expand action with obvious visual feedback and no disambiguation.


Requires opening a drawer to reach the component and disambiguating between two similar permission grids while selecting an exact set.

Manage permissions
Write permissions
Deploy
Rotate keys
Operations → Security


High disambiguation load with two near-identical grids plus precise set selection (exactly two rows) in the correct instance.

Production Environment
Platform
API Gateway
Auth Service


The primary difficulty is disambiguating between two identical TreeSelect instances and ensuring the correct labeled instance is modified.

Backup office
Company / Sales / Americas / Canada


Deeper hierarchical navigation plus non-central placement increases acquisition effort; otherwise the tree is moderately sized and labels are clear.

Policy
Handbook / IT / Devices / Laptops


Only requires clicking the correct trigger to open the popover; no selection is needed.


Nested interaction in a table-cell editor plus an explicit Apply step increases layering and feedback dynamics; mistakes require reopening the editor to correct.

Escalation path
On-call / Platform / Database
Apply


Requires editing a small set of checkboxes among multiple similar permission items, including unchecking a pre-checked distractor.


Selecting the correct item requires scrolling within a nested scroll container and disambiguating similarly numbered options.


Requires multi-selection with exact membership constraints across different parts of the tree.


Requires only straightforward vertical scrolling with a clearly labeled textual target and no confirmation step.


The agent must clear only the target list (not the adjacent distractor list) and must remember to commit via “Save changes”, a frequent omission failure.


Two visually similar virtual lists plus a preselected distractor; dark theme can reduce contrast, making correct-instance selection harder.


The target is specified visually (icon match) under dark theme, which can reduce contrast and accessibility-tree observability compared to pure text selection.


Uses a wide acceptable range and provides a pixel readout; the main action is a simple drag.


A single double-click action resets the layout with immediate feedback; minimal precision is required once reset occurs.


Requires locating the correct card in a high-clutter, scrollable dashboard and then performing a vertical resize to a specific target.


Two similar handles must be manipulated to satisfy three simultaneous targets; compact+small increases acquisition difficulty and makes fine control harder.


Requires selecting two specific panels in a longer list and leaving the rest closed; still no overlays.


Easy interaction, but success requires reaching the empty expanded-set state rather than just opening another item.


Single accordion group with three clearly labeled summaries and immediate feedback on expansion.


Purely visual target specification (color dot) in dark theme plus multiple similar items makes the correct selection less observable.


The goal is specified visually, so the agent must match dialog content/title from pixels; two similar actions increase confusion even though buttons are large.


Multiple similar rows and icon-only triggers require careful targeting; the modal interaction is easy but instance disambiguation is moderate/high.


Only requires opening a single dialog; no need to choose between actions.


Single instance with clear label and visible percent readout; only moderate precision is needed to reach 80% opacity.


Dark theme plus lack of numeric readout forces reliance on visual comparison, increasing semantic observability demands.


Embedded table-cell sliders are small and there are two similar instances; requires precise adjustment on the correct row.


User must visually match transparency using the preview; numeric value is not the primary guidance.


Single field with an explicit clear control and a binary end state (non-empty vs empty).


Single Mantine Autocomplete with a simple text target; bottom-left placement slightly changes cursor travel but the interaction remains straightforward.


Requires interacting through a modal layer and completing an explicit Save confirmation step after entering the exact participant name.


Opening (but not selecting) requires controlling overlay state; the component is placed near the viewport edge which can affect popup placement.


Requires using search in a longer, confusable city list within a small form section with other nearby inputs.


Only the open/closed state matters for a single Select with a short option list.


Single Autocomplete with a short, distinct list; standard open-and-click interaction.


Three visually similar instances appear in a dense dashboard context; success requires correct association with the Sales chart.


Compact spacing and small scale increase target acquisition difficulty.


Two-step interaction with menu open and selection.


Single large labeled button in an uncluttered card; success is triggered by one click with immediate visible feedback.


Requires recognizing and achieving a specific toggle state (aria-pressed=true) while avoiding a nearby distractor button.


Small icon-only ActionIcons in a compact header increase target acquisition difficulty and require correct icon disambiguation.


All options share the same label, so the agent must use visual cues (outlined border and icon position) to disambiguate among four similar buttons.


The state is clearly visible and clearing requires a single obvious action with immediate feedback.


Single-date selection in a single embedded calendar with a visible readout is a basic interaction.


Multiple precise selections must be accumulated without extras, and dashboard clutter increases the chance of off-target interactions.


The agent must navigate several months and resist interacting with nearby form controls, while relying on the calendar highlight and readout for confirmation.


Compact spacing makes indicators smaller, but the carousel is isolated and slide titles are explicit.


Vertical drag gestures can be confounded with page scrolling; the carousel must settle on the exact target day slide.


Many similar slides increase interference; light page clutter adds minor distraction.


Small tile carousels in a cluttered dashboard make it hard to acquire the right controls and avoid modifying the wrong carousel.


Requires mapping a visual breadcrumb reference to the cascader selection, but the option set is small and there is only one field.


Requires managing overlay open/close while preserving the existing selection; success depends on both value and popup visibility.


Multiple selection requires exact set matching and careful checkbox interactions across different branches of the tree.


One plainly labeled checkbox with immediate visual feedback and no distractors.


The target checkbox starts off-screen and is surrounded by other similar checkbox rows and form clutter, requiring scrolling and careful label matching.


Disabling requires handling a confirmation dialog, increasing depth and feedback dependence beyond a simple toggle.


Smaller checkbox visuals and compact spacing raise target acquisition difficulty even though the goal is binary.


Selecting a single option is straightforward, but requires ensuring the other checkboxes are off.


Small Mantine Checkbox.Group with three clear options and immediate visual feedback.


High-clutter dashboard context plus a dense widget list and an Apply step make exact matching error-prone.


Exact two-item selection with an error helper state encourages careful correction and prevents over-selecting.


Requires disambiguating between two similar tri-state checkboxes in a small form section and setting a non-default (indeterminate) state.


One checkbox with a clear nearby visual target; minimal distraction and no layering.


Single checkbox with explicit label and immediate feedback; only needs selecting the indeterminate state.


Small/compact rendering in a dense grid increases pointing accuracy demands, and the goal uses a mixed reference (chip) rather than only text.


Requires scrolling and locating the correct section among several similar settings sections before performing a standard copy action.


Requires opening a drawer overlay to reach the copy control; otherwise a standard copy action with clear copied feedback.


Two similar copy icons require selecting the correct labeled row, but the values are short and clearly displayed.


Single-line text entry with one editor instance and no overlays; success is a straightforward exact-content check.


Requires substantial in-editor scrolling to reach a specific line and precise insertion at the correct location in a dense, long file.


Exact matching to a visual reference plus selecting the correct editor instance in a dashboard layout with two similar editors.


Overlay-based replace plus an explicit Apply requirement; content has multiple occurrences to ensure 'replace all' behavior.


Requires closing more than one open panel, but the component is isolated and labels are clear.


Clear labels, single instance, and no extra UI—just expand one item.


Non-central placement plus several similarly named options increases search and selection difficulty; target is specified by a reference preview.


Navigation-like sidebar context adds mild clutter, but the target group is clearly labeled and visible.


The user makes a single discrete choice among a few format options; the resulting state is visible as text in the panel.


A small, compact control plus the need to set both a specific hue and a low alpha value makes this a high-precision continuous manipulation task.


Reaching a specific RGBA requires coordinated continuous adjustments across multiple sub-controls, even with a textual readout.


Small table-cell triggers and a dense swatch grid increase acquisition and choice interference, and the agent must modify the correct row among similar instances.


Requires a two-layer interaction (open modal, open swatch popover) and explicit confirmation to commit changes.

Customize theme
Cyan (#13c2c2)
Apply changes


A dense set of subtly different grayscale swatches makes the target hard to visually discriminate and click accurately.


Smaller sizing and compact spacing increase click precision and warm-color confusability, but there is still only one picker and a fixed palette.


Single instance in a clean card; the user only needs to open the popover and type an exact HEX value.


Requires switching to HSB mode and entering a more complex formatted string with percent symbols; small formatting errors prevent parsing.


Alpha channel and exact 8-digit formatting raise precision requirements; small mistakes keep the component invalid.


Longer formatted input and alpha channel increase precision and validation sensitivity compared to basic 6-digit HEX.


Goal is an empty state; the component exposes a dedicated clear control and immediate visible feedback.


Short fixed option list with clear pill feedback; no free-text creation reduces ambiguity.


Requires opening a drawer, making three selections, and committing via Apply within a cluttered dashboard context.


Opening a drawer and choosing the correct one of two similar Autocomplete instances increases disambiguation demands in a dense filter panel.


Two similar AutoComplete fields are present; the target name is confusable with similar spellings, increasing disambiguation and choice interference.


Single clear action with visible affordance and immediate state change.


Small, unambiguous option list with a single Autocomplete instance.


A cluttered dark-themed dashboard and multiple nearly identical city names increase acquisition and choice interference.


Compact spacing and small scale make target acquisition harder, and selecting a nested submenu item adds an extra interaction layer.


Nested submenu selection plus icon-based disambiguation between similar options (public vs private link).


A single checkable state must be set correctly with immediate visual feedback; otherwise the scene is simple.


Single inline text cell edit in a single table instance with clear labels and immediate feedback.


Two similar editable tables require correct instance selection before performing a simple dropdown edit.


Single numeric edit with a clear target value and immediate feedback after commit.


Requires mapping a visual reference chip to the correct dropdown option in the correct row.


Goal is an all-clear state with a dedicated clear control and clear on-screen selected-count feedback.


Single checkbox selection in a small composed table with immediate visual feedback.


Small-scale controls plus a search/filter step and confusable names increases acquisition difficulty and selection mistakes.


Requires mapping a visual legend to rows; status is not expressed as text inside the grid cells.


The correct option is in a long, dense list; using the small filterSearch input and selecting the right matching item is the main challenge.


A single explicit reset button restores defaults; success is unambiguous and highly observable.


Single filter criterion using a standard DataGrid filter panel; immediate feedback and one instance keep it straightforward.


Correctness depends on setting the filter logic operator to OR (a semantic state that is easy to miss) in addition to configuring multiple filter rows.


Requires recognizing an already-filtered state and using the correct control sequence to remove the filter.


Requires pagination plus accurate checkbox selection among visually similar SKU values.


Single header interaction with visible sort indicator; only one column needs to be set correctly.


Single table, single-column sort, immediate feedback via the header sort indicator.


High disambiguation: multiple similar tables and similar date/time columns in a cluttered dashboard; requires sorting the correct instance without altering others.


Dark, high-clutter dashboard with three similar tables; requires precise target acquisition and correct-instance disambiguation.


Compact spacing makes the sort target smaller; still a single-column sort with immediate feedback.


The main challenge is acquiring the small clear control; otherwise the task is straightforward with immediate feedback.


Single Mantine DateInput with explicit placeholder and immediate visible value after typing.


Dark theme plus three similar inputs requires careful disambiguation, extracting the date from a reference banner, and committing via Apply.

Secondary window
Reference banner
Apply schedule


The instruction omits the exact date, requiring the agent to extract it from a visual preview before entering it.


Requires precise formatted keyboard entry in a compact/small control; feedback is immediate but format mistakes are likely.


Clear button provides a direct reset action and the current value is visible.


Single date range picker; only requires opening its popover.


High clutter and multiple same-type instances require careful disambiguation and precise selection within a dense filter row.


Selecting a specific date decades in the past requires multi-step year/month navigation within the picker, increasing depth and interaction complexity.


Dark theme and realistic settings clutter add modest target acquisition and disambiguation difficulty while keeping the interaction path short.


A short, structured flow (open picker -> Clear) with explicit action bar controls and clear end-state visibility.


Single, clearly labeled RangePicker with time; target is fully specified and the chosen range is within the currently visible month. Requires a straightforward OK confirmation.


Open-ended ranges are error-prone: the agent must set only the start, ensure the end remains truly empty, and still confirm with OK.


Cross-year navigation requires careful month/year changes in the calendar for Start and End, and dark theme can reduce contrast for small navigation controls.


Target must be read from an on-page reference and the component is placed in a corner, slightly increasing acquisition difficulty.


Single field with built-in clear affordance; success is empty state.


Single default Mantine DateTimePicker with visible input; selecting date and time completes the task without extra confirmation.


Three similar instances with overlapping values create high disambiguation; user must adjust the correct one.


Requires scrolling within the year-selection control to reach a far year, then completing date+time selection.


Two similar dialog triggers appear in the same header; the agent must choose the correct labeled instance (using both text and the badge cue).

Security settings
Secondary
Account settings


Overlay click is a large target, but the agent must click outside the modal (and Escape is disabled) to produce the correct close reason.


Single clear trigger button opens a single dialog; success only requires the dialog to become visible.


Dragging requires sustained control and the final position must satisfy a geometric constraint that is not explicitly visible in text.


Requires scrolling to reveal the target and selecting the correct link among multiple similar attachment downloads. No overlays, but disambiguation and search-by-label are required.


Requires scrolling to reveal the attachments and selecting the correct link among multiple downloads. Otherwise straightforward.


Single download button within a realistic form; some extra controls increase clutter but the label is explicit.


Single item move with large targets in a clean, single-instance layout and immediate feedback.


Combines within-component search filtering with drag between containers, under dark-theme contrast and a moderately dense option list.


Dark theme plus highly similar option labels (TLS versions) increases confusion and observability demands, even though the action is a single transfer.


Adds within-component search and moderate list density in a form context with distractor inputs, increasing choice interference and observability demands.


All items are visible and the target is uniquely labeled; only moving one item to the end is required.


Short list with clear labels and immediate feedback; a single move completes the task.


Compact table row handles require precise acquisition; success needs an exact full reordering plus Apply commit.


Requires opening a modal, using handle-only dragging within it, and committing via the Done action.


Requires locating a small link-style trigger within a form section that contains unrelated distractor controls.


Two similar options require simple visual matching, but the choice set is small and feedback is immediate.


Single prominent trigger opens a single drawer with clear visual feedback.


Adds a layered confirm dialog and requires selecting the correct option to reach the closed state.


Two visually similar feeds require correct disambiguation; the target alert is deeper in the list and may require triggering lazy loading.

System alerts
ALERT-042 — High memory usage


Requires correct interaction with the in-feed search input and selection of the right result; non-centered placement modestly increases target acquisition load.


Single labeled switch with immediate visible effect and no competing components.


Large, central dropzone with a tiny candidate set; success is clearly visible as a filename in the upload list, with only a brief upload-progress wait.


The goal is specified visually, requiring the agent to compare thumbnails; multiple similar candidates increase interference and the correct outcome must be an exact file match.


Requires scrolling within a drawer to locate the component and choosing the correct zip among several similar options; upload completion must be observed.

Support
Support bundle
support-bundle-2026-02-01.zip


Multiple required targets and compact checkbox spacing raise interference and precision demands, but the component remains centered with clear filename feedback.


Requires entering an exact new filename and committing it with Save, but the UI is otherwise simple and isolated.


A single per-row toggle in a small table; minimal layering and clear label.


Finding a specific target requires scrolling within a long list amid high dashboard clutter, then precisely interacting with a per-row dropdown.


The agent must recognize the reset affordance and return the manager to a specific baseline state; the placement variation adds mild acquisition overhead.


Requires hitting a small remove icon and then correctly interacting with a confirmation pop-up in a slightly cluttered form context.


Single clearable control with an obvious reset affordance and immediate visual state change.


Single large button with immediate visible filename feedback; straightforward single-file selection.


Dense table layout with multiple similar per-row uploaders increases target acquisition and disambiguation; replacement requires ensuring the old file is no longer selected.


Adds an extra in-card disclosure step while requiring the card to remain open during interaction.


An additional in-dropdown expansion step is required while maintaining hover, in a mildly cluttered form context.


Only two choices, but requires matching against a reference (visual and/or initials) and selecting the correct instance.


Single large, clearly labeled icon button in a clean card; immediate feedback and no competing instances.


Small targets on a dark theme combined with purely visual matching makes both acquisition and observability challenging.


Two nearly identical icon buttons require correct instance selection based on nearby labels; mis-clicking the wrong row is a common failure mode.


Visual comparison among four options increases choice interference; the target is not described in text.