Single field with obvious clear and Save controls; success is simply committing an empty string.


Single field with clear Save/Cancel ActionIcons in a clean scene; only a short string must be entered and committed.


Strict formatting constraints combined with reduced contrast in dark theme raise both precision and target acquisition difficulty.


Requires extracting the exact target from a visual reference, but interaction remains a simple single-field edit with a clear Save action.


Requires editing a nested path and correctly disambiguating between two similar JSON editor instances.


Single revert action with immediate state change in a single editor.


Single boolean change in a single editor with a clear Save action.


Requires matching multiple fields to a reference while avoiding edits to a similar second editor; also requires using the correct Save button.


Adds a required confirmation step and a reversible pending state; the agent must notice that dragging alone does not commit.

DESIGN-5 Update icons
Done
Apply changes


The modal adds overlay layering and focus management; otherwise the card move is straightforward.

Project board
PROJ-2 Draft proposal
Review


The reset control is clearly labeled and immediately restores a known default state; minor toolbar clutter is the only distractor.


Single, clearly labeled link with immediate route/heading feedback and no distractors.


Many identical "View" links in a compact table require precise target acquisition and correct row-based disambiguation.


Same-label links in different regions under dark theme require correct-instance selection and robust state verification.


Requires scrolling within a card to locate an off-screen link; non-central placement can affect acquisition and attention.


Transfer has a denser row layout than a plain checkbox list and includes non-required affordances (move buttons), but the option set is small and inline.


Single, clearly labeled Checkbox.Group with few options and immediate inline state visibility.


Large option set with filtering and two similar list instances increases both within-component steps and disambiguation demands.


Requires cross-referencing a separate preview element with the listbox items, but the option count is moderate.


Two identical lists require correctly disambiguating by label before selecting the option.


Uses an explicit reset control and provides clear textual feedback for the empty-selection state.


Short visible list with immediate selected highlighting and no distractors.


Two stacked listboxes in dark theme require disambiguation by label; selection is immediate but errors are easy to make when targets look similar.


There is some form clutter, but only one markdown editor and the target text is simple.


Requires locating the correct reset affordance and verifying a multi-line template; otherwise there are no overlays or distractors.


A dark-themed modal introduces layering and explicit cancel/commit dynamics; success depends on correctly discarding edits rather than saving them.


Single visible masked field with a common phone format; the main challenge is typing digits and letting the mask format them.


Requires both correct masked entry and an additional in-field confirmation step; small icon targets add interaction risk.


Small control size plus editing a prefilled masked value increases the likelihood of cursor and partial-mask errors.


The string is long and punctuation-sensitive; the agent must accurately copy a visually presented hex value into the masked field.


Clearing is straightforward with a visible clear control; success is an unambiguous empty state.


Single instance with a short suggestion list; straightforward mention insertion.


High clutter plus multiple similar instances increases disambiguation load, and inserting two mentions with exact punctuation raises precision demands.

Follow up with @Isabella Garcia and @Daniel Park.


Mixed guidance reduces ambiguity, but exact punctuation (em dash) and two correct mentions are required in a dark theme.


Requires multi-level submenu navigation to a specific leaf item; the correct path is explicit and the selected breadcrumb provides strong feedback.


Single toggle within a short menu; state is clearly visible via check indicator and mirrored text.


Straightforward single menu selection with clear highlighting and mirrored text feedback.


Two-step commit is required; selecting the correct option without applying does not change the committed state.


Requires a two-step commit (select then Apply); staged vs applied state increases the chance of stopping early.


Combines text entry within the menu overlay and subsequent selection, adding interaction steps and potential focus/scroll issues.


A simple single-selection menu with immediate feedback; reset target is explicitly labeled.


Single click on a clearly labeled, top-level item with immediate visible highlight feedback.


Requires matching a visual reference icon among multiple icon-labeled items and operating in a corner placement.


Requires performing horizontal scrolling within the header to reveal an off-screen target, with smaller click targets in compact mode.


Requires matching a visual reference icon among similar icon+label buttons and activating the correct one.


Only one toggle within a single meter; slightly harder because the target state is an animation/text change in dark theme.


Single meter with explicit numeric feedback and immediate updates.


Success depends on a visual style mode (striped + animated) and selecting a small control, which can be less obvious to verify than numeric value.


Requires scrolling to find the correct section amid moderate clutter; once found, setting the value is straightforward with visible feedback.


Requires opening a drawer, using search, and disambiguating between very similar titles; expansion state is visible but list density is moderate.


Single bulk action button with immediate, highly visible aggregate feedback (unread count goes to 0).


Single target IconButton with a numeric badge; success is purely the drawer-open state with clear feedback.


High disambiguation load from two similar instances plus an exact aggregate-count target; multiple action sequences are possible and require careful instance scoping.


Requires locating the correct section via scrolling and then setting a stepped value; otherwise straightforward.


Formatted numeric entry with fixed decimals and thousand separators can introduce parsing/caret complexity compared to plain integers.


Single field, but success requires reaching an empty/null state rather than a numeric target.


Direct page number click with clearly visible numbered buttons.


Pagination within modal adds depth; must interact with overlay content.


Dark theme requires careful visual targeting.


Clearing requires hitting a small in-field control; the masked nature of the field reduces observability of partial clearing mistakes.


Single field entry is straightforward, but the password is masked by default.


Compact layout makes the eye toggle harder to click, and two similar fields plus synced state can confuse instance-based reasoning.


Requires exact transfer from a visual reference while the input is masked and located away from the viewport center.


Two visually similar OTP instances require correct label-based disambiguation; otherwise interaction is straightforward.

Two-factor verification
Email code
SMS code


Resetting to empty is straightforward but requires clearing multiple single-character fields.


Short OTP length and centered placement; separator is purely visual and does not add extra steps.


Dark theme and modal context reduce clarity; the agent must choose the correct instance and then commit via Confirm.


Compact spacing and dark theme reduce target salience; otherwise the task is a straightforward open-on-click popover.


Non-central placement requires locating a corner control; otherwise interaction is straightforward.


Requires using a keyboard dismissal (Escape) rather than clicking; the popover state change is immediate and visible.


Single progress bar with visible percentage text; only one obvious action (start) and the bar completes automatically.


Small, dense table-cell targets with scrolling required and multiple similar rows increase both acquisition difficulty and instance disambiguation.


Multi-segment progress requires coordinating several values with discrete step controls while ignoring a distractor progress bar on the same page.


Timing-sensitive pause on a continuously changing determinate value; tolerance allows minor error but still requires monitoring and quick action.


The example includes both icon and text, and there are only three distinct choices.


Simple three-option Radio.Group with clear labels and immediate state visibility.


Multiple identical radio groups embedded in similar dashboard cards create high disambiguation load; a wrong card change is easy to miss.


The reset affordance is separate from the radio options and must be used to satisfy the task; feedback is via a transient snackbar.


Half-star selection increases precision and target acquisition demands while keeping the scene otherwise simple.


Simple whole-star adjustment on a single control; only robustness factor is non-center placement.


Single default MUI Rating control with whole-star steps and immediate feedback in a simple isolated card.


Half-step precision plus non-star iconography can reduce semantic observability and make it harder to map the visual state to the intended numeric value.


The acceptable range reduces precision demands, but the bottom-right placement increases acquisition difficulty near the viewport edge.


Requires visual alignment without explicit numeric feedback, but only involves two columns and one table instance.


Single resize target with numeric feedback; dark theme slightly lowers contrast but not enough to move beyond easy.


Single empty editor with a short plain-text target; no overlays, formatting, or disambiguation.


Requires interpreting a visual example and reproducing simple structure (heading + bullets) without any disambiguation.


Requires selecting content and using a reset control to remove marks without altering the underlying text.


Requires copying a multi-block structure from a visual reference (alignment + heading + ordered list + italic line) within a cluttered dashboard tile.


Uses the built-in clear icon (allowClear) on a single, clearly labeled input; success is an empty value.


Single, default TextInput with a search icon; success is the visible input value.


Requires opening a modal, clearing an existing value, handling accented characters, and confirming via an explicit Search button with loading feedback.


Requires scrolling to find the correct section in a cluttered dashboard; once found, typing is straightforward.


Requires interacting with the correct segmented control inside a table row and ignoring nearby table clutter.


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


Simple exclusive toggle group with three clearly labeled options and immediate feedback.


Two very similar toggle groups in a cluttered, compact dashboard require careful disambiguation and precise clicking on narrow options.


Requires scrolling within the dropdown list and accurately clicking multiple items that may not be initially visible.


The goal is specified via a visual pill row rather than explicit text, requiring the agent to read and reproduce the reference set.


Only one custom value is created and the chip appears immediately, making verification simple.


Single default-size select with a short, distinct option list and immediate feedback.


Requires selecting the correct instance and matching a visual icon reference under dark theme contrast constraints.


Long list requires scrolling inside a small, compact dropdown; targets are smaller and easier to misclick.


Requires scrolling within the menu and discriminating among similar category names near the bottom.


Clear/reset action via the placeholder option; otherwise a straightforward native select.


Long option list with compact/small styling increases both acquisition difficulty and choice interference.


Same simple selection, but the smaller visual scale increases target acquisition slightly.


Dense dark dashboard with three similar selects increases disambiguation and click precision demands.


Two same-type Selects require choosing the correct labeled instance within a realistic form. Options are still short and feedback is immediate.


Single component with clear open/closed visual state; no disambiguation or dense options.


A single Autocomplete with few options; typing filters immediately and the chosen value is displayed in the text field.


Dense table layout plus three similar instances raises disambiguation and acquisition demands; region strings are visually similar, increasing selection errors.


The target is specified visually rather than numerically, requiring perceptual matching; a text preview provides post-action observability.


Requires perceptual alignment to a visual band rather than following explicit numeric targets, with live readout for confirmation.


A single Reset button provides a direct, low-precision path to the target default state.


Discrete step=10 with visible marks makes the target value easy to reach, and the current value is clearly shown with immediate feedback.


Fine step (0.01) combined with a small vertical slider increases motor precision demands even though the scene has minimal clutter and only one instance.


Dark theme plus a drawer overlay and two similar sliders increases disambiguation and requires an explicit Apply step, even with default sizing.


The target is a fractional value and marks are hidden, so the agent must use transient feedback (value label) to land on the correct step.


Simple open-and-select with a short, distinct option list and immediate label update.


Single large primary button; one-step activation with persistent feedback.


Combines a two-step nested overlay flow with icon-only guidance, increasing layering and reliance on visual semantics.


Requires selecting a special reset item rather than the default option directly, adding mild interpretation load.


Two similar steppers appear in the same form section; the agent must disambiguate the correct labeled instance and then select the right step among several options.


Simple navigation among three steps; dark theme introduces a mild robustness variation affecting visual salience.


A straightforward linear stepper with a single Next action; state change is immediate and clearly indicated.


Many tightly packed steps plus within-component horizontal scrolling significantly increase acquisition difficulty and choice interference.


Requires an overlay step (open drawer) before the switch can be accessed; otherwise the toggle is simple.


Dark theme reduces contrast and can make the switch state less salient compared to baseline.


Requires interpreting purely visual ON/OFF state (thumb position) but involves only one interactive switch.


Single table instance with a uniquely identifiable row label and immediate highlight feedback.


Adds overlay layering (open modal then interact) and darker theme contrast, with multiple similar workspace names.


Dark theme reduces contrast and the visual reference must be matched within a denser table with repeated badge patterns.


Requires disambiguating the correct table instance and matching a mixed visual/text reference among similar rating patterns.


Single tab set with short labels; only non-baseline factor is placement in the viewport.


Default Mantine Tabs with clear labels and immediate panel feedback.


Small icon-only targets plus a purely visual goal increase target acquisition difficulty and reduce text-based observability.


Goal is specified via icon matching rather than text; semantic observability may vary depending on whether the agent relies on pixels or aria-labels.


Requires using in-dropdown search among similarly named options within a busier form, increasing interference and disambiguation load.


Goal is empty; slight target-acquisition difficulty to hit the clear button or remove multiple pills.


Single chip creation with immediate visual feedback in a clean single-instance card.


Table-cell sized targets plus multiple instances and a long scrollable option list make correct acquisition and disambiguation difficult.


Requires reading the target string from an on-page reference badge (not provided verbatim in the instruction) and copying it exactly into the input in dark theme.


Requires entering an exact punctuation-heavy phone format and clearing an initial error state.


Goal state is empty, but without a dedicated clear affordance the agent must correctly clear existing content.


Single empty textarea in an isolated card; success is a short exact sentence with minimal ambiguity.


Nested overlay (drawer) plus an explicit apply step; target text includes multiple lines and numbering that must match exactly.

Edit release notes
Release notes
Apply changes


Requires exact multi-line structure with bullets in a compact/small UI where visual verification is harder.


Requires opening a dialog and explicitly confirming with “Add note”; validation and dialog actions add interaction steps.

Customer requested a callback on Tuesday.


Requires only opening the correct overlay; the control is clearly labeled but the click target is relatively small.


Single native time input with clear label; minimal interaction depth.


Multiple same-type instances in a darker, busier settings context increases disambiguation and acquisition difficulty.


Requires reading a separate reference display and copying it into the field; otherwise interaction is simple.


Requires an explicit OK confirmation step in a dark theme; otherwise the interaction is a standard single TimePicker.


Only requires opening the dropdown popover via focusing the input; no selection or disambiguation needed.


Single desktop time picker in an isolated card; the target value is explicitly given and can be verified in the text field.


Adding seconds introduces a dense third step, and two similar fields plus an explicit OK step raise disambiguation and layering demands.


Two highly similar toasts require careful disambiguation and precise clicking on the correct close control.


Undo control is embedded inside the toast content and requires correctly interacting within the notification rather than using external controls.


Two adjacent buttons can be confused, but the snackbar text is explicit and the interaction is a single click.


Single large toggle button with immediate feedback and no distractors.


Small per-row toggle targets inside a dense table require precise acquisition and correct row disambiguation.


Small icon targets in a compact dark-themed row increase acquisition difficulty and state visibility challenges.


A blocking dialog adds depth and requires an explicit confirm step before the toggle state commits.


Small option set with clear text labels; requires simple add/remove toggling from a single preselected item.


Simple 2-of-4 chip selection with clear text labels and immediate visual feedback.


Two similar instances in dark theme increase disambiguation load; the target set requires both adding and removing selections precisely.


More options and a small vertical layout increase target acquisition and choice interference compared to baseline.


Requires opening a dropdown menu from the toolbar and selecting the correct item among several, while ignoring a similar dropdown elsewhere in the form.


Single exclusive choice with clear labels and explicit text feedback.


Single labeled button inside a standard MUI Toolbar; immediate textual feedback confirms success.


Precise drag-and-drop reordering plus an explicit Save commit step makes the interaction failure-prone, especially for agents with coarse actions.


Requires opening and comparing among multiple similar tooltips using a visual reference, increasing disambiguation and choice interference.


Two similar tooltip triggers in a realistic form require correct-instance selection and accurate hover on small icons.


The tooltip starts open, but closing relies on correct dismissal behavior (e.g., Escape or click-away) under a controlled open state.


Single instance, centered default Tour; success is just opening to the first step.


Introduces a secondary footer action and requires recognizing reset semantics, but still low density and single instance.


Requires aligning a visual reference with the Tour's step cover while still providing supportive text caption.


Small, dense indicator targets plus more steps substantially increase acquisition and selection difficulty.


Clearing the target list is a straightforward inverse transfer with a small number of items and no overlays or ambiguity.


A small set of clearly named items must be moved in a single inline transfer list with no extra confirmation steps.


Multiple similar instances in a cluttered dashboard require strong disambiguation, and an explicit Save step adds feedback and state-commit complexity.


Two near-identical transfer lists require careful instance disambiguation while selecting and transferring the correct repositories.


Two nearly identical tables require careful instance disambiguation; the target is nested two levels deep.

Archived Projects
Q2 Launch
Marketing → Campaigns
Marketing → Campaigns → Q2 Launch


Two-item checkbox selection with clear feedback; limited depth and option count.


Straightforward single-row selection with clear highlight; only one small expansion action is needed.


Requires precise formatted numeric entry and correct edit/commit mechanics in a small dark UI.


Requires multi-selection with checkboxes and avoiding extra selections; tags provide clear feedback but more steps are needed than single-select.

Enabled apps
Workspace / Gmail
Workspace / Calendar
Workspace / Drive


Exact-set multi-selection with checkboxes requires care to avoid extra leaves; indeterminate parent states can confuse partial selections.

Folders to sync
Sync / Photos / 2024
Sync / Docs / Taxes
Sync / Music / Playlists


Single-step clear interaction with immediate visible feedback in the TextField.


Single tree with one obvious expandable target and immediate visual feedback when expanded.


Drag-and-drop within a tree requires precise drop placement and interpreting the drop indicator feedback.

Company
Invoice
Tasks list
Meeting notes


Requires multi-step expansion and selection based primarily on a visual breadcrumb reference, with exact expansion constraints.


High clutter and two visually similar tree panels require careful instance disambiguation before selecting the correct leaf.


Target row is visible and the toggle provides immediate, local visual feedback; only modest precision is needed to hit the star icon.


Single visible target with one-click selection and clear textual confirmation.


The target is specified only visually and requires scrolling until the correct avatar row is rendered; text cues are intentionally insufficient.


Requires opening a drawer and explicitly confirming with Done; the list is large but the target label is unambiguous.


Vertical resizing is slightly less common and the target is more specific; additional surrounding settings add mild distraction.


Wide acceptable pixel range with explicit readout; basic dragging is sufficient.


Single handle with continuous feedback and a generous tolerance; core challenge is basic dragging.


No textual state is visible; matching is purely visual with a tight acceptance window.


Requires scrolling to reach the component and then selecting the correct panel among several similar topics.


Requires selecting two items in a multiple-open accordion and ensuring no extra items are expanded.


Only requires toggling the already-expanded section closed; state is obvious.


Requires opening a drawer overlay and then selecting the correct accordion item within the constrained drawer area.


Small icon triggers and compact Popconfirm controls near a viewport edge increase misclick risk; two near-identical actions raise confusion.


Visual reference requires matching pixels; two similar options increase the chance of opening the wrong modal before confirming.


Icon-only row actions and multiple similar invoices require careful row targeting before confirming the dialog.


No overlay to open; the only challenge is dragging the correct (opacity) slider among other visible controls.


Requires operating in a drawer, selecting the correct instance among two similar sections, and remembering to click Save to commit.


No numeric feedback forces pure visual matching in dark theme; semantic observability is the main difficulty driver.


Finding the correct section requires scrolling through distractors; once found, setting 40% is moderately precise.


Single tags input with one tag to add. Dark theme slightly reduces contrast but the target string is short and feedback is immediate as a visible tag pill.


Short suggestions list with a clearly labeled target and standard dropdown interaction.


Two near-identical TagsInput instances require correct targeting, and the maxTags constraint increases recovery cost if extra tags are added.


Grouped, scrollable suggestions with many similar metric names in compact spacing increase choice interference and selection accuracy requirements.


Two near-identical Select instances require correct label-based disambiguation before choosing the target option.


Requires using search filtering among many similar options while ignoring adjacent form inputs.


Only requires opening the listbox overlay for a single clearly labeled Autocomplete.


Requires opening a drawer and extracting a short visual code before selecting the exact matching option; fewer instances reduce disambiguation but the visual+overlay demands remain high.


High clutter from file list items increases visual noise; breadcrumb navigation is still straightforward.


Recognizing and clicking ellipsis expander.


One labeled trigger button; the only extra step is that the desired state is an opened popover overlay.


Requires a two-step confirmation flow with a layered popover and small confirm/cancel buttons; mistakes are easy due to proximity and similar affordances.


Small, identical icon buttons repeated across table rows require precise clicking and correct row association under compact density.


The main challenge is locating the button via scrolling within a long panel; the button itself is clearly labeled once visible.


The target is clearly specified by both text and a matching visual marker, making it easy to identify and click the correct day.


The task is a straightforward month navigation with clear visible state in the header and the mirrored 'Viewing' label.


Three similar instances plus dashboard clutter create high disambiguation load, and the staged global Apply changes step adds depth and feedback complexity.


The agent must navigate to a far year and manage a two-phase commit (pending selection vs confirmed value) by pressing OK in dark mode.


Requires a continuous drag gesture and choosing among more slides; animation/settling can cause overshoot.


Small carousels inside a dense table increase acquisition difficulty and the risk of editing the wrong row's carousel.


Requires matching a visual reference among several similar photo angles; state is less observable than text-only slides.


Drawer layering plus two similar carousels and many distractors create high disambiguation; the target is specified via a reference preview.


Tests basic ability to open an overlay without making any selection; otherwise a simple single-instance setup.


Small scale increases pointing difficulty, while the hierarchy remains moderate and unambiguous.


Requires interpreting a visual reference (target chips) and matching an exact multi-selection set within a hierarchy.


Still a single checkbox, but dark theme slightly reduces contrast cues for some agents.


Small table-cell checkboxes and multiple similar rows increase target acquisition and instance disambiguation demands.


Target checkbox starts off-screen and must be located among similar integration permission labels after scrolling.


The goal is specified via a visual preview rather than explicit text, requiring interpretation before toggling a simple checkbox.


Small number of checkboxes; the only challenge is unchecking the ones that start selected.


Only three options; the main requirement is ensuring only one remains checked.


Drawer overlay plus two checkbox-group instances and a Save step make targeting and committing the correct group challenging.


Dark, compact modal with a long scrollable checkbox list demands careful search, exact set matching, and an Apply step.


Compact spacing and small scale increase target acquisition demands, but only one enabled tri-state checkbox is evaluated.


Requires selecting the correct labeled instance among two similar tri-state checkboxes in a small form section.


Only one checkbox is present; the goal is conveyed via a nearby visual preview, but the target control is easy to acquire.


Requires opening a drawer and scrolling within it to reach the target checkbox; nested scrolling and overlay context increase interaction complexity.


Small copy targets inside a dense table and three similar rows require careful disambiguation; URLs are visually truncated with ellipsis.


Requires matching a reference suffix to one of several similar keys and clicking the correct row’s small copy icon.


Copy control is hidden until hover and requires precise acquisition of a small icon inside a code block.


A single obvious Reset control restores a known default; no typing or multi-step overlays required.


Requires exact matching to a visually provided reference snippet and an explicit Apply step; dark dashboard layout adds moderate distraction.


Nested overlay flow (drawer + confirmation dialog) with two editor instances; user must select the correct destructive action and end in the restored state.


Dropdown selection with several similar language options; success depends on setting the correct editor mode.


Two similar accordions require selecting the correct instance, but the target label is explicit and all headers are visible.


Only one disclosure item is present; the task is a direct toggle, with dark theme as a robustness factor.


Small toggle control in a cluttered settings panel makes target acquisition and disambiguation harder than a plain accordion list.


Exact expanded-set constraint plus compact spacing increases risk of leaving extra panels open or mis-toggling.


Achieving a specific color without presets requires continuous dragging on small thumbs and interpreting live feedback from the panel.


The custom icon trigger is small and embedded in a busy dashboard toolbar, and the target color must be achieved via continuous dragging without presets.


Setting a specific opacity requires fine slider control; it's easy to accidentally modify hue/saturation if the wrong sub-control is dragged.


The agent must navigate a drawer overlay and then set a very low alpha value precisely using a slider, which is sensitive to small movements.


Multiple identical instances increase disambiguation load even though each picker is individually simple.


Single labeled ColorInput with a small fixed swatch list; open dropdown and click the target swatch.


Requires scrolling within the dropdown to reach an offscreen swatch, but the exact hex is provided and tooltips expose the value.


Same interaction as a basic HEX entry, but placed away from center and with a visual reference element.


The target is provided visually without a textual value; agents must infer the intended color and then correctly enter a valid color string.


The component preserves invalid input, so agents must actively correct the malformed value and use validation feedback to reach a valid final state.


Compact table-cell text fields are smaller targets and require selecting the correct row among similar inputs.


Requires light search disambiguation among similar options, but only two selections and immediate chip feedback.


Single free-text tag creation with immediate visible pill feedback.


Large grouped option list in a cluttered dark dashboard increases search/scroll burden and option confusability (similar city names), with moderate observability.


Small compact target plus long unfiltered list forces manual scrolling and careful clicking among dense options.


A long scrollable dropdown increases search and motor demands; typing does not filter, so the agent must locate the item by scrolling.


Requires entering a specific free-text value that is not available as a suggestion, but the UI is otherwise simple and uncluttered.


Only requires opening the Autocomplete listbox; no selection or typing.


Async loading introduces latency and transient feedback, and the target includes a diacritic that must be selected correctly within a modal layer.


Requires scrolling through a long list of similar table actions inside a context menu to find an item near the bottom; table context adds targeting noise.


Requires scrolling within a long, grouped menu inside a cluttered dashboard layout near the viewport edge.


Requires picking the correct instance (Task A) and setting a radio-style selection within the menu.


Single numeric value change in an inline editor with exact target and immediate visible feedback.


Requires interpreting a visual reference and mapping it to the correct dropdown option in the targeted row.


A straightforward single-select edit with a small option set; the main complexity is entering and exiting edit mode.


Success depends on using the Cancel control to exit edit mode without committing changes; dark theme reduces contrast slightly for some agents.


Uses the built-in select-all checkbox in a tiny table; no disambiguation or overlays.


Two explicit row checkboxes in a small table; success depends on selecting exactly the targets.


Dark, cluttered dashboard plus mixed reference matching and an Apply commit step increases both error likelihood and recovery cost.


Two grids with similar ID patterns create high disambiguation risk; selecting the wrong instance is easy.


Requires entering an exact numeric range into two small fields and applying; mistakes require resetting/retyping.


Requires multi-selecting two tags and remembering to click Apply; missing the apply step is a common failure.


Single visible text field with immediate feedback; no menus or multi-step interactions.


High clutter dashboard makes it harder to locate the correct grid and filter controls; matching multiple reference chips requires careful reading and multi-step setup in the filter panel.


Requires accurate multi-selection across several pagination changes in a dense, compact/dark presentation.


Requires recognizing a pre-filtered state and clearing an input via a small clear affordance.


Requires using a toolbar search control and then selecting the correct row; the target is not visible initially.


Requires toggling to the correct sort direction on a single column with clear arrow feedback.


Requires opening a modal overlay and interacting with a compact table header in dark theme; overlay layering increases interaction depth.


Requires opening a modal overlay and performing a precise header interaction in a smaller-scale table.


Requires horizontal scrolling plus accurate header interaction in a non-centered placement.


Single field with an explicit format hint; success is an exact semantic date match.


Requires replacing an existing value but remains a single isolated date input with clear feedback.


Requires handling a drawer overlay and explicitly saving; the date input is straightforward once located.

Edit subscription
Next billing date
Save changes


Multiple-layer interaction (open dialog, edit date, then explicitly save) with dark theme reduces contrast and increases layering/feedback demands.

New appointment
Appointment date
Save appointment


Requires repeated navigation actions and recognizing month/year in a dark theme; no precise date selection needed.


Requires finding and clicking the correct preset item; small risk of choosing a similar preset.


Straightforward two-click range selection with visible textual feedback in the field.


Small/compact targets plus a wide, cross-year range and a required OK confirmation increase both acquisition and sequencing difficulty.


Disabled dates create dense interference in the calendar grid and require the agent to distinguish clickable vs non-clickable days with subtle visual feedback.


Small control size and off-center placement increase target acquisition difficulty compared to baseline, but selection remains a single-step calendar click.


Two similar date pickers in a cluttered settings panel increases disambiguation and the chance of modifying the wrong field.


Target is explicit and time choices are on coarse 30-minute steps; the main added challenge is smaller hit targets due to small scale and corner placement.


Requires scrolling to locate the correct table section and disambiguating among multiple identical RangePickers. The target range spans across months/years, increasing navigation steps before confirming with OK.


Second-level precision increases the likelihood of small errors; the agent must correctly set hours, minutes, and seconds for both Start and End.


Two identical range pickers in a form require correct instance selection; otherwise the range is simple and same-day.


Goal is purely to expose the popover; requires locating the input and triggering the correct overlay.


Selecting a clearly labeled preset is low precision and low depth; the value becomes visible in the input immediately.


Requires entering a drawer flow before interacting with the picker, increasing layering and context switching.


Dark + compact layout with two similar instances and an explicit OK commit step increases both disambiguation and feedback complexity.


Outside click and Escape are disabled and the header close icon is removed, so the agent must use the correct footer button and wait for the close animation after a short loading state.


Two similar triggers in a compact layout require selecting the correct instance before the overlay opens.


Dialog is already open and the required action button is clearly labeled in the actions row.


The target is specified visually and there are multiple similar dialog triggers dispersed in a cluttered layout, increasing disambiguation and visual verification demands.


Small icon trigger plus a nested submenu increases acquisition difficulty and interaction depth. Compact spacing in dark theme reduces visual separation between menu items.


Modal confirmation adds an extra layer and a required second click. Clear button labels keep it manageable but depth/feedback dynamics increase.


Requires handling a modal dialog overlay and choosing the correct confirm action. Modal layering and extra step raise depth and feedback dynamics compared to a single click.


Requires not just moving an item between lists but also placing it in a specific position (top) with otherwise simple UI.


Requires selecting the correct instance among two similar cards, performing multiple cross-list moves with exact ordering, then committing with a Save control.


Small-scale UI shrinks drag handles and drop targets, significantly increasing target acquisition difficulty even for a single transfer.


Requires opening a modal, transferring an item between lists, and committing via a Done button (staged state), introducing overlay depth and feedback dependence.


Short, uncluttered list; moving one clearly labeled item to the top is straightforward.


Very short list and a simple adjacent move; state is obvious from the displayed order.


Requires triggering and correctly handling a discard confirmation after making a reorder change; drawer context adds layering and clutter.


Long scrollable list inside a cluttered dashboard; dark theme and handle-only dragging increase interaction difficulty.


Requires finding a smaller footer Cancel button; common easy exits (mask click, header X) are disabled.


Dark theme plus a less-common top-position drawer can make targets and boundaries slightly harder to perceive.


Two similar icon triggers require light disambiguation using the provided preview, but the choices are few and feedback is clear.


Requires coordinating multiple drawer variants and ensuring the final global drawer state is fully reset.


Requires precise multi-item checkbox selection in compact rows, correct feed disambiguation, and an explicit Apply step to commit the state.


Requires opening an overlay to reach the feed and then scrolling/loading to the target entry before selecting it.


Requires typing and submitting in a header search field and then selecting the correct result amid mild surrounding form clutter.


Only a few visually similar image choices; the target file name is explicitly given and the final state is visible via filename + thumbnail in the upload list.


Requires correctly targeting the remove icon in the right instance, handling a transient confirmation popover, and selecting ‘Cancel’ without changing the final file state.

Signed contract
contract-signed.pdf
Cancel


Small table-cell targets and compact spacing make acquisition difficult, and the visual reference requires careful thumbnail comparison among similar options.


Must precisely identify and remove the correct row in a small list with similar filenames, within a busier form context.


A single toggle flip in an isolated table; the key is targeting the correct row.


One-step removal in a short, uncluttered list.


Exact formatted text entry with validation increases precision and feedback complexity, and the duplicate filenames raise disambiguation risk.


Requires a precise drag-and-drop reorder to achieve an exact adjacency relation, with dark theme reducing visual contrast for small handles.


Requires extracting the target filename from an on-screen reference and then completing a standard upload with visible list feedback.


Two similar FileInputs require correct instance selection; otherwise the interaction is straightforward with clear in-field feedback.


Small IconButton target increases acquisition difficulty, but only one uploader and a single explicit file are required.


Requires finding a specific item among many similar filenames in a scrollable list and clicking a small remove icon without deleting the wrong file.


Requires scrolling within a dense table and accurately hovering the correct row’s small cell target among many similar entries.


Corner placement plus hover delay and two similar instances increases timing and disambiguation load compared to baseline.


Small help icon plus a deliberate hover delay makes timing and stable acquisition more difficult than baseline.


Single toggle icon button with an explicit On/Off text indicator; immediate feedback and no distractors.


Requires selecting the correct icon button embedded in a table row, with multiple near-identical pin controls and high disambiguation load.


Small target in dark mode plus the need to reach a specific overlay-open state increases acquisition and feedback complexity.


Requires correctly triggering an overlay state (popover open) and interpreting overlay feedback, but still involves only one clearly labeled icon button.


The target value is explicitly stated and there is only one field; the preview chip is an extra confirmation cue rather than a disambiguation challenge.


Single target; success is just a mode switch to show the input field.


Adds an overlay layer (drawer) plus two same-type instances in a smaller scale UI, increasing layering and disambiguation demands alongside normal text entry and commit.


Two same-type instances increase disambiguation load; otherwise the edit is straightforward with clear controls.


Requires using an in-editor search affordance and then editing a specific key in a moderately sized JSON tree.


Requires working in a modal and replacing the JSON content precisely in Code mode before saving.


Single numeric edit with an explicit Save button; minimal clutter and no disambiguation.


Combines overlay depth (drawer), validation-gated saving, and a small-scale code editor requiring precise numeric entry.


Small dense targets, drag-handle-only interaction, and many similar card titles increase both acquisition difficulty and the chance of ordering mistakes.

In progress
BUG-210 Fix footer overflow
BUG-205 Fix navbar
BUG-212 Fix dropdown


The target is initially off-screen within a scrollable column, requiring scroll management during search and drag.

BUG-9 Fix notifications
To do
In progress


Two boards look similar; the agent must correctly target the labeled instance before performing a simple move.


Single inline disclosure link with immediate expanded-state feedback via aria-expanded and visible panel.


Requires two-step interaction across overlay layers (popover then drawer) and verifying the correct link inside the popover was selected.


High clutter and multiple similar reset links require robust section identification and correct instance activation under compact spacing.


Two links share the same label; the agent must incorporate the badge shown in the reference chip to select the correct instance.


A single, prominent master control selects the entire list; state is immediately visible.


Two similar checkbox groups exist, so the agent must correctly target the "SMS topics" instance.


Two similar groups each with their own Select all control plus small, compact targets create high disambiguation and pointing demand.


Dark theme plus a cluttered dashboard and multiple similar list instances make it easy to interact with the wrong filter section.


Target is specified visually and the theme is dark, but icons are distinct and the list is short.


Two visually similar listboxes require choosing the correct instance by its label.


List is simple but placed in a busier layout with competing content.


Small, repeated listboxes inside table cells require careful row disambiguation and precise click targeting.


The goal is visually specified, but the target formatting is simple and can be achieved by typing a short markdown string.


Requires internal scrolling to reach an off-screen line and a precise local edit without altering surrounding markdown.

Sprint notes
TODO: add screenshots
TODO
DONE


Internal scrolling plus a precise, localized edit in a dense editor increases the risk of altering surrounding text or missing the correct field.

Product copy
Metadata
Release date: TBD
Release date: 2026-06-15


Straightforward masked typing into a single, clearly labeled field; common grouping with immediate visual feedback.


Requires scrolling in a cluttered settings page to acquire the correct field, then entering a long fixed-width masked value exactly.


Combines an overlay layer with a long, grouped masked value and an explicit in-field confirmation step.


Editing a small input embedded in a table row requires careful target acquisition and row identification amid moderate visual clutter.


Only requires triggering the dropdown; no selection is needed, but the agent must avoid accidentally choosing an option.


A single mention in a short sentence with a small list of options.


Requires copying a multi-line reference exactly and inserting three mentions with precise punctuation and line breaks.


Small/compact UI reduces target sizes and a long, scrollable Popper list with many similar prefixes increases search and selection difficulty.


Two similar menus appear in the same area, so the agent must disambiguate the correct instance before selecting the target item.


Two similar menus require selecting the correct instance (Folder actions) before choosing the target item.


Single button-to-menu interaction with immediate visual feedback when the popover appears.


A deep cascading menu requires maintaining the correct open submenu chain across multiple popovers and selecting a specific leaf in a compact, small layout.


Requires interacting with a nested submenu (multiple overlay layers) where the target is in the second layer and may require precise pointer movement.


Exact multi-selection with an initially selected distractor requires both selecting targets and deselecting non-targets.


Requires cross-referencing a separate on-page reference with right-aligned menu metadata (shortcuts), which increases choice interference.


One submenu layer with three clearly named options; selection is immediately reflected by highlight/state.


Compact dark menubar with hover-triggered nested submenus increases pointer control demands and overlay layering complexity.


Two similar header instances with overlapping labels make correct instance selection the primary challenge.


Popover selection is straightforward, but dashboard clutter increases the chance of mis-clicks and distractor interaction.


Requires choosing the correct instance and matching a visual reference without a printed number, but still in a simple layout.


Requires matching a visual reference and selecting the correct meter instance, but in a simple uncluttered scene.


Small compact targets inside a drawer, drag-based adjustment, two similar instances, and a required Apply step make this a high-difficulty interaction.


Small target with hidden numeric state; requires precise setting and likely use of hover/keyboard to confirm the exact percent.


Multi-select checkboxes in compact spacing increase click precision demands, and the bulk bar introduces an extra step with visible feedback.


Requires using search to disambiguate between similar invite-related notifications and opening the correct row's expandable details.


One labeled switch with immediate state feedback; minimal interference aside from a secondary unrelated switch.


Dashboard clutter plus a long scrolling list and small archive affordances make locating and acting on the correct security row interaction-heavy.


Inline table-cell editing creates small targets and multiple similar instances; success additionally requires the correct row’s Save action to commit.


Dark theme reduces contrast; otherwise a single stepped integer field with clear labeling.


Single field, but it begins in an error state with an out-of-range value, requiring correction and feedback verification.


Sequential navigation with clear arrow buttons; requires two clicks.


Requires visual reference matching to determine target page.


Multiple clicks or ellipsis navigation needed.


TablePagination uses arrows only; must click multiple times.


Still a simple single-field interaction, but success also depends on clicking a clearly labeled confirmation button.


A single small toggle control changes visibility, and the revealed text provides immediate feedback.


Small table-cell inputs with embedded Save actions require very precise targeting and correct-row disambiguation, while the lack of a visibility toggle makes the masked value hard to verify.

API credentials
Secondary
Sec-2026*Key
Save


Finding the correct section requires scrolling and possible accordion interaction; the final value is masked and must match exactly.

Integration
Integration password
Integrate%55


Requires an overlay step and an explicit confirmation click; the Verify button state provides feedback but adds an extra dependency.


Two nearly identical PinInputs require selecting the correct labeled instance within a form layout.

Two-factor verification
Authenticator app code
Email code


Explicit code is provided in text; the extra reference panel is redundant and does not introduce disambiguation.


Per-character validation and error feedback increase recovery cost; precision is higher because any invalid character is dropped and the final string must match exactly.


Requires a multi-step, nested overlay interaction: open an outer popover, then acquire and trigger a second popover inside it.


Dark theme reduces contrast for a small icon target; otherwise it is a simple open popover.


Two similar instances require interpreting a reference cue (text+color) to select the correct card's popover.


A single labeled progress bar with a dedicated Reset control; state change is immediate and clearly visible.


Discrete step-based progress requires exact granularity (3 of 5) and correct-instance selection in a settings panel with another progress bar present.


Non-standard orientation plus small/compact rendering increases perceptual difficulty and target acquisition while still requiring timing-sensitive pausing near a target percent.


Two-dimensional progress state (value and buffer) must be matched visually across two similar instances, increasing observability and disambiguation demands.


Requires using a small reset affordance rather than only selecting an option; otherwise the choice set is simple.


Only two options; slightly smaller targets due to scale, but the choice is unambiguous.


Two-layer commit (Save then Confirm) introduces depth and feedback dynamics; missing the confirm step is a common failure.

Change data sharing
No
Share usage data?
Save


Eight near-identical options in a small, compact layout demand precise target acquisition and careful label discrimination.


Two similar instances require correct label-based disambiguation, even though each control is otherwise simple.


Fractional selection (0.5) increases precision requirement and makes the click targets smaller than whole-star ratings.


Visual reference still maps directly to an unambiguous 2/5 selection on a single control with immediate feedback.


Overlay depth plus a required confirm step and the presence of a similar read-only distractor instance increases disambiguation and feedback dependency.

Rate support call
Issue resolution
Confirm rating


Small resize handles plus three precise target widths require repeated accurate dragging and careful monitoring of live feedback.


Range target reduces precision requirements; top-left placement increases acquisition difficulty near window chrome/edges.


Two similar grids require correct-instance disambiguation; header icon density modestly increases acquisition difficulty.


Clearing existing content is straightforward and immediate; the only challenge is selecting and deleting the whole text.


Adds one overlay layer and a required confirmation click, but the target value is short and the editor is the only interactive element inside the modal.


Visual-only guidance requires inferring structure (blockquote vs paragraph) and reproducing it; compact toolbar increases acquisition difficulty.


Requires opening and working within a drawer overlay and completing a required confirmation action to commit the editor state.

Compose message
Message
Send
Meeting moved to 4 PM.


Small suggestion list and clear labels, but requires interacting with the dropdown suggestion panel.


Short list of suggestions; requires interacting with the dropdown but low density and clear targets.


Requires scrolling to a bottom-of-page search field and matching a visually presented phrase; fewer distractors but higher navigation/observability demand.


Small, compact field plus strict formatted input with validation (must match the exact pattern) increases precision and feedback dynamics.


Finding the control requires scrolling through a cluttered settings panel; selection itself is straightforward once found.


Requires interpreting a default target and using (or ignoring) a reset affordance; otherwise simple selection.


Straightforward three-way toggle group with unambiguous labels.


Requires handling a blocking confirmation dialog; canceling reverts the selection, so the committed state must be verified.


Small/compact targets plus a long list of highly similar options increases misclick and confusion risk; tag overflow reduces immediate observability of the full set.


Several targets are not visible at first and require scrolling within the dropdown, increasing acquisition effort.


Two similar fields require selecting the correct instance; the list is moderate-sized and requires three precise selections.


Clearing requires acquiring a small clear icon target, but the state change is immediate and unambiguous.


Requires an extra layer (open modal, then open dropdown) and selecting from visually rich, multi-line options.


Three similar selects in a dark settings panel require careful disambiguation and accurate control selection.


A simple reset intent, but it requires reopening the select and choosing the explicit “None” item within a form context.


Target provided by a simple on-page reference chip; options are few and distinct.


Three similar selects inside a cluttered dashboard plus required confirmation significantly increase disambiguation and feedback dynamics.


The target is given via an on-page preview reference, but the select is isolated with few options.


More options and grouping increase choice interference and require careful selection within a longer native dropdown list.


Dark theme slightly reduces visual clarity, and several near-duplicate options require careful choice even after filtering.


Two same-type Selects in a form require selecting the correct instance and choosing from a moderately dense list of similarly formatted airport options.


Short option list and clear label; the main challenge is opening the popup and clicking the desired item.


Visual-only goal specification requires linking the reference icon to the correct option; corner placement slightly increases acquisition demands.


Requires recognizing and using the draggable-track affordance to shift both endpoints together, with less obvious grab targets than the thumbs.

Quiet hours
You can drag the selected range


Small thumbs and decimal endpoints raise precision and acquisition difficulty, but the state remains directly observable via the readout.


The small size and compact spacing reduce target size, increasing acquisition difficulty while keeping straightforward semantics.


step=null restricts movement to a small set of labeled marks, and the current numeric setpoint is displayed explicitly.


The slider is off-screen in a cluttered dashboard with multiple similar sliders, so the main challenge is finding and disambiguating the correct instance while still hitting an exact value.


Very fine step size (0.01) requires precise control, and reduced real-time feedback (no floating label) makes it harder to converge quickly.


Two small sliders in a table require correct row targeting and precise integer setting, but feedback is clear via percent readouts.


Requires recognizing the reset affordance in the menu and verifying the primary label updates to the default.


Only requires clicking the smaller chevron segment to open a single dropdown layer.


Requires selecting the correct row instance and completing a two-step destructive flow while choosing Cancel instead of Confirm.


Three similar instances in a dashboard increase disambiguation load; the rollback options are semantically similar.

Production deploy
Rollback to previous version


Vertical orientation and off-center placement require scanning and accurate selection among five steps, but the target label is explicit and feedback is immediate.


Requires selecting the correct labeled stepper instance in a realistic form section before choosing the target step.


Clickable step labels make navigation direct; only mild interference from having four options.


Combines visual reference matching with high dashboard clutter and multiple similar steppers, driving up disambiguation and observability demands.


Dense, repeated switches inside a table require correct row association and precise target acquisition within a cluttered layout.


Requires opening a modal overlay to access the switch, adding depth/layering and focus management.


Two similar switches require correct label-based selection; targets are close together.


Requires clicking the correct cell but with a small, low-density table and clear cell focus feedback.


Multi-select requires accumulating a specific set of rows in compact density, with several similar user IDs as distractors.


Small targets plus horizontal scrolling to reveal an off-screen column makes precise cell selection challenging.


Requires locating a small toolbar control in a mildly cluttered settings layout and verifying the empty-selection end state.


Disambiguation is required between two clearly titled tab groups, but targets are large and unambiguous.


Large pill-shaped targets and only one tab set; only robustness change is placement.


Selection is gated behind a confirmation overlay; handling the prompt correctly is required to reach the target tab.


Confusable short labels increase choice interference; dark theme reduces visual contrast and can increase selection mistakes.


Small, compact control increases target acquisition difficulty; tokenization requires committing formatted input correctly.


Requires entering correctly formatted tokens and relying on split-on-paste/tokenization behavior; compact layout reduces visual breathing room.


Short, distinct option list with straightforward open-and-click interactions and visible chips.


Three instances (one disabled) in a small, corner-placed panel increases disambiguation and target acquisition difficulty.


Multiple similar text inputs are embedded in a dense table; success requires selecting the correct row/instance and editing only that cell.


Requires extracting the target phrase from an on-page visual reference in dark theme and copying it exactly into the input.


Two visually similar fields require selecting the correct labeled TextField and entering a punctuated phrase.


Requires overwriting an existing short value; the live preview provides clear feedback but no extra steps.

Thanks for reaching out. We'll reply tomorrow.


Strict multi-line JSON formatting with exact indentation is required; compact/small styling makes entry and verification harder.

event
order.created
id
priority
high
Webhook payload


Transcribing a two-line technical command from an image in dark theme increases observability and precision demands.


Must reproduce an exact two-line message where the line break is primarily communicated visually; mixed reference reduces but does not eliminate ambiguity.


Still a single field, but the target is framed as matching a separate reference element, adding a small observability step.


Simple minute-level formatted entry into a single field.


The target is not stated in text; the agent must extract the time from a separate visual reference element and transfer it.


Requires scrolling within a cluttered settings panel to locate the target field before performing a standard time edit.


Two same-type instances in a realistic form require selecting the correct labeled field before interacting with the dropdown.


Two same-type instances in a form require correct field selection; interaction otherwise follows standard dropdown hour/minute selection.


Only requires opening the picker overlay; no value selection, no clutter, single instance.


Editing a specific row’s picker in a dense table near the viewport edge increases instance confusion and target acquisition difficulty; 23:59 is a high-precision target.


Small icon-only table actions plus an in-toast action choice (Undo vs Dismiss) create a multi-step interaction with higher target acquisition demands.


Requires matching a simple visual/text sample to choose between two similar notification variants.


The primary difficulty is acquiring and clicking the small close icon inside the snackbar.


One large toggle; the task is simply to flip it to the opposite state.


Requires scrolling to find the correct section and selecting the right toggle among several similarly styled options in a compact layout.


Non-central placement and dashboard clutter increase search costs; matching a separate visual preview adds observability burden.


The desired state is given by a separate visual preview rather than stated directly in the instruction.


Still a simple 2-of-3 selection, but small targets in compact spacing increase click accuracy requirements.


Few large chips and an explicit Clear button make resetting straightforward.


High clutter with multiple similar chip groups plus a visual-reference matching requirement increases disambiguation and choice interference.


Two-step commit (Save then Confirm) increases depth and feedback dynamics; dark styling can reduce state visibility.


Requires updating multiple toggles and disambiguating between two near-identical toolbars, aided by a mixed text+visual reference.


Requires opening a dropdown menu and selecting the correct item among several, while ignoring an unrelated menu elsewhere.


One clear toggle among a small group; state is visible via aria-pressed and a text readout.


Requires visual icon matching among multiple small, similar icon-only controls; the goal is not provided as text.


Dense small targets inside a table plus a non-default right-click trigger increases acquisition difficulty and interaction depth compared to hover tooltips.


Requires comparing among three similar options using visual reference and managing a group delay, increasing choice interference and feedback dynamics.


A long enter delay requires stable hovering and timing, increasing feedback dynamics difficulty despite a single instance.


One-step navigation using a large, clearly labeled “Next” control with minimal clutter.


Same basic open-to-first-step behavior, but targets are near the viewport edge and slightly smaller.


Introduces scrolling to reveal a later step because the Tour does not auto-scroll to off-screen targets.


Dense table + nested scrolling + small row action targets make this a high-acquisition, high-clutter scroll-find task.


The transfer operation is simple, but there are two visually similar Transfer components and the agent must modify the correctly labeled instance.


All items must be transferred, which can be completed using a dedicated move-all control in a simple scene.


The agent must understand filtered views vs. underlying list membership and use a specialized 'move all results' control to achieve an exact final set.


Dense, near-duplicate alert labels in compact dark styling require careful target discrimination and precise checkbox interactions to achieve an exact final set.


Requires operating a header filter overlay and remembering to confirm; options are moderately confusable.


Requires using an in-component search field and then selecting the correct nested match among similar campaign rows.


Single disclosure action on a clear affordance with immediate visual result.


Multiple independent sub-states must all be cleared, and some controls are in an overlay panel.


Strict checkbox semantics increase error risk (parent/child independence), compact dark UI reduces target size/contrast, and success requires an exact two-item set.

Teams to notify
Company / Engineering
Company / Engineering / Frontend / Web


Requires mapping a mixed (chip + breadcrumb) reference to the correct tree leaf and disambiguating between two similar instances.


Requires coordinating two inputs (open popover and use filter) and then selecting within a moderately large tree embedded in a busier settings panel.

Default permission
Permissions / Finance / Invoices


Requires expanding one branch and clicking a clearly labeled leaf; selection is visibly highlighted.


Requires multi-step expansion plus selecting the correct leaf, under compact dark styling and with a primarily visual reference target.


Requires achieving a specific semantic checkbox state (indeterminate parent) by selecting an exact subset of children while leaving a sibling unchecked.


Requires keyboard-only navigation and understanding focus vs. selection while expanding a branch.


All targets are visible, but success requires an exact multi-selection set, making omission/extra checks the main risk.

Ticket 0002 — Broken link
Ticket 0004 — UI glitch
Ticket 0006 — Email not sent


Simple scrolling task with a unique textual identifier; no selection or confirmation required.


Compact spacing makes controls harder to hit, and the agent must clear selections that may be offscreen and then remember to commit with Save.


High disambiguation burden: three similar virtual lists and heavy dashboard clutter with overlapping ID patterns; the agent must act in the correct list.


Requires selecting the correct splitter among two similar instances; otherwise the resizing itself is straightforward.


Snapping introduces discrete motion and may require multiple small adjustments to land on the exact target.


Reset is a single action with clear hinting; the only nuance is performing a double-click on the handle.


Tight numeric target (33%) combined with a thin visible handle and non-central placement increases both precision and acquisition difficulty.


Dark theme plus additional nearby controls add mild distraction; user must pick the correct section in a longer list.


Target is defined by a visual symbol rather than a unique label, requiring visual matching among several similar headers.


Requires closing more than one open accordion item, but all targets are clearly visible and labeled.


Single instance with clearly labeled Confirm/Cancel buttons; the only challenge is opening the modal and clicking the obvious primary action.


Requires navigating a drawer overlay before opening the confirm modal, adding layering and focus-management complexity even though the final buttons are clear.


Small icon-only triggers under compact spacing plus three similar instances in a dashboard create high misclick and disambiguation risk; dark theme further reduces contrast.


Requires scrolling to locate the trigger before performing a straightforward Cancel in the dialog.


A dedicated reset control is provided and the target is the default full opacity state.


Single standalone AlphaSlider with explicit numeric feedback makes reaching 50% easy.


Nested overlays (modal + ColorInput popover) and required Save confirmation create layered interaction and feedback challenges.


Small slider in a corner requires more careful pointer control to reach a low opacity target (15%).


The target is embedded in a realistic form with nearby distractor inputs and multiple similar company options that require careful selection.


Single component reset using an explicit clear button; the end state (empty tags) is visually obvious.


Single freeSolo Autocomplete with a short, lowercase target and no surrounding clutter.


Managing multiple chips requires precise interactions with small targets (chip delete icons) and maintaining an exact set of values.


Adds one layer of UI (open a modal) and uses slightly denser options with similar UTC formatting, but still a single instance.


Two similar instances increase disambiguation load; otherwise the options are straightforward.


Clearing uses a smaller icon but the component is the only interactive target with a simple state.


Simple navigation with clearly labeled breadcrumb items; minimal disambiguation needed.


Two-step dropdown interaction in dark theme.


Only two clearly labeled modal buttons; the main challenge is selecting the correct instance (Discard vs Cancel).


Single labeled button with immediate visible state change; minimal clutter.


Destructive confirmation requires a multi-step overlay interaction with small targets in dark theme, increasing layering and acquisition difficulty.


Requires mapping the correct row label to its adjacent action button in a compact table where buttons look identical across rows.


Selecting a date is easy, but the agent must correctly disambiguate between two nearly identical calendar instances and avoid modifying the wrong one.


A single explicit reset control clears a visible existing selection with immediate feedback.


Single-date selection in an inline calendar with immediate highlight and a textual value readout is low-friction.


Small-scale rendering tightens day targets and header controls, and the surrounding table UI adds distractors that increase misclick and disambiguation risk.


Many similar options increase interference; the page has light clutter but the slide title is clearly observable.


Requires opening a drawer, finding the correct carousel among multiple similar sections, and avoiding many distracting controls.

Customize homepage
Header Banners
Minimal


Two similar carousel pickers in one form require careful instance selection and avoidance of distractor inputs.

Shipping options
Payment methods
Express


Small option tree with clear labels and a single instance; the main challenge is completing the full 3-level path selection.


Compact spacing reduces click target size slightly, but the hierarchy is shallow and the options are few.


Search narrows the list but introduces many confusable results; the agent must pick the correct full path from the filtered suggestions.


Duplicate leaf labels combined with leaf-only display reduces observability; correctness requires selecting the right branch in the dropdown, not trusting the input text alone.


A single checkbox, but it is positioned near the viewport corner which can slightly increase pointing difficulty.


A single checkbox with immediate feedback; the only added complexity is dark-theme contrast.


Repeated small checkboxes in table rows require precise row identification and accurate clicking.


Requires opening a drawer overlay and committing the checkbox via a Save action, adding depth and feedback dependencies.


Requires opening a modal and pressing Save to commit the checkbox-group state.


Clearing an existing selection in a small checkbox group with immediate state visibility.


Three clearly labeled checkboxes in a single FormGroup with immediate feedback.


High-clutter dashboard with multiple checkbox groups and a dense 'Visible columns' list requires correct targeting and exact matching to a visual preview.


Requires a disclosure step to reveal the checkbox, adding UI layering while keeping the target state change simple.


An accordion disclosure step is required to reveal the checkbox; after disclosure, the state change is straightforward.


Corner placement makes the control slightly less central to acquire, but the task remains a straightforward single-checkbox toggle.


Single visible value with a standard inline copy icon; success is immediate with clear 'Copied' feedback.


Dark theme plus compact/small styling makes the copy affordance harder to acquire, and the two similar references increase disambiguation load.


Requires opening a menu and selecting the correct copy format among several similar options; target is an exact JSON string.


Requires opening a popover overlay to access the copy control; small icon target and transient snackbar feedback.


Requires opening a dropdown and choosing one option; otherwise the scene is simple with one instance.


Single-line edit with one clear insertion point; minimal UI and immediate feedback.


Requires setting an exact non-default scalar (13) via small slider/step controls; minor off-by-one errors fail.


Requires setting a scalar to an exact value using a compact stepper; state is visible but small controls increase acquisition difficulty.


Requires scrolling within an inner container and choosing among many similar section titles.


Requires closing multiple open items in a multi-open accordion, but the UI is simple and centered.


A small number of clearly labeled accordion summaries in a single, uncluttered card.


Small click target inside a crowded table cell increases accidental interactions and mis-targeting.


The task requires setting a continuous alpha value with moderate precision; small slider thumbs and live-updating feedback can cause overshoot.


In a cluttered settings panel with two similar instances, the agent must precisely target the correct clear affordance without altering the other instance.


Typing the value is simple, but the agent must disambiguate two similar inputs and avoid modifying the wrong one.


Single labeled picker with a small, clearly named swatch set; only one popover layer and changes apply immediately.


Requires matching to a labeled visual reference among several similar warm swatches, within a moderately cluttered settings panel.


Inline swatches remove overlay depth; single component with clear target color.


Mixed guidance with moderate dashboard clutter; inline swatches reduce depth, but multiple green options require careful matching.


Typing a HEX value is straightforward, but the agent must correctly disambiguate between two similar instances.


Single visible input with preview feedback; entering a standard HEX value is straightforward.


HSLA requires precise punctuation and percent signs, plus alpha; dark theme reduces visual salience of validation cues.


Dark theme reduces contrast for focus/error cues; otherwise the task is a straightforward HEX entry with a visual reference.


Two near-identical instances increase disambiguation load; otherwise the selection is straightforward.


Empty target state with dedicated clear control and straightforward feedback.


Simple multi-select with a short list; state is clearly visible as chips.


Requires replacing an existing chip with two exact free-text values and committing via a dialog Save action.

Edit allowed domains
Allowed domains
Save


The target is specified visually via an on-page reference badge rather than in the instruction text, increasing observability demands despite a small option set.


The target is provided via a visual reference element and must be transferred to the Autocomplete field; otherwise the choice set is small.


A single clear action with immediate feedback; no searching or disambiguation.


Only requires opening a single context menu on a large target with a small, simple menu. Success is purely the menu-open state with no item selection.


Adds a multi-step confirmation interaction inside the context menu overlay; success requires completing the confirm step, not just selecting the menu item.


Compact spacing and multiple required toggle changes (including turning one off) inside a submenu increase error risk even in an otherwise uncluttered scene.


Requires scrolling within a long context menu on a dashboard widget to find an item near the bottom.


A single dropdown selection inside a cell editor with a small option set and clear text labels.


Requires a multi-layer interaction (modal + date picker popover) and an explicit Apply confirmation to finalize the grid state.


Single boolean toggle in a clearly labeled row with immediate feedback.


Small-scale rendering plus single-click editing increases the chance of misclicks and unintended focus/edits.


Requires internal scrolling to reveal the target row before selecting its checkbox.


Dedicated clear control and clear selected-count feedback make reset straightforward.


Direct row click selects a single row in a small grid with clear labels.


Pagination adds substeps and requires maintaining the correct selection set while switching pages.


Requires opening and applying two separate column filter popovers; managing multiple overlays increases depth and chance of partial completion.


Selecting an exact start and end date in a calendar UI is a multi-step interaction, and apply/commit adds an extra required step.


Clearing is explicit (remove filter item and clear quick-filter text) with immediate feedback; no disambiguation or precise values required.


Single table with visible page numbers; one direct click updates the page immediately.


Two visually similar table instances require careful disambiguation before using pagination controls.


High clutter and two near-identical table instances require careful targeting plus multiple pagination-related state changes.


Requires pagination plus a small checkbox target among similar row IDs.


Requires reaching the neutral (unsorted) state from an initially sorted header; still a single table with immediate feedback.


Single table with a simple clickable header control and immediate visual feedback.


Requires disambiguating between two similar tables and changing an existing sort to a different column/direction in a constrained bottom-right placement.


Visual guidance requires mapping a non-text reference badge to the correct column and direction; interaction remains a single-column sort.


Two identical date inputs require disambiguation by label; otherwise the interaction is direct typing with immediate feedback.


Clearing relies on a small right-section control, but the rest of the scene is minimal and the cleared state is obvious.


Single date field with a clear placeholder; no overlays or extra confirmations.


Dense table layout with multiple small, similar date fields creates high disambiguation load and target acquisition difficulty.


Requires selecting the correct instance among two similar pickers in a cluttered filter bar and selecting a cross-month range.


Adds a modal layer and requires recognizing month navigation state; no precision date selection required.


A single visible Clear control resets the value; state is clearly observable.


Single default DatePicker with one-step selection from the open calendar; state is visible directly in the input.


The target is specified visually via a reference card and requires navigating to a far future month/year while disambiguating between two similar date pickers.


Inline calendar requires extensive within-component navigation to reach a date decades in the past, increasing depth and the chance of selecting an adjacent year/month.


Structured formatted input requires precise digit entry in the correct sections; validation feedback can block progress until the format is correct.


Single prefilled field with a standard clear affordance; success is simply the empty state with immediate visual feedback.


Clear labeled Start/End inputs with straightforward same-day values; composite structure is simple and state is visible in both fields.


Small, tightly spaced controls raise acquisition difficulty and selecting uncommon minutes (09:07, 09:59) increases the chance of near-miss errors.


Requires precise formatted keyboard entry and successful parsing of both endpoints; small format mistakes can leave the component in an invalid/partial state.

Editing range
Press Enter to start editing


Requires using an on-screen reference plus confirming with OK in a mildly cluttered settings panel.


Clearable input makes reset direct; success is an empty state.


Single desktop picker with clear label; selecting date and time is sufficient without extra confirmation.


Seconds-level precision combined with small-scale targets and sectioned editing raises both precision and acquisition difficulty.


The required button is out of view inside a scrollable modal body, so the agent must scroll within the dialog (not the page) and then click the correct close control.


The dialog must be closed using a keyboard action (Escape) because other dismissal routes are disabled, testing keyboard interaction and focus management.


The dialog is already open and has no buttons; pressing Escape is the single required action, but it relies on correct keyboard interaction.


Single large primary button with clear label; no overlays or competing download controls. Feedback is a simple toast confirming the filename.


Target is a small icon and the correct choice is specified visually rather than by text, increasing observability and disambiguation difficulty. Two similar instances require selecting the correct card.


Compact dense table with multiple similar rows and small per-row icons increases both target acquisition difficulty and disambiguation load.


Requires opening a menu and selecting among multiple visually similar items based on a reference thumbnail. Reduced textual anchoring increases observability difficulty.


Still a simple single-item move, but embedded among other form controls and copy that can distract and increase disambiguation.


Straightforward single transfer with clear labels and immediate feedback in a minimal layout.


Requires scrolling within a list to locate an off-screen target and then completing a cross-container drag without losing context.


Constrained table-cell embedding and a reset confirmation dialog add target acquisition and layering complexity beyond a basic drag move.


Two same-type lists require selecting the correct instance; otherwise the drag interaction is straightforward.


Simple one-item move in a four-item list; no overlays or distractors.


Short MUI list with large row targets; immediate visual feedback and only one move needed.


Tiny drag handles in compact table rows demand precise targeting; full exact ordering plus Apply commit is required.


Adds a second decision layer (confirm dialog) in dark theme; the agent must choose the correct confirmation option to close.


Multiple similar triggers increase disambiguation even though titles are textually clear once opened.


Simple one-step dismissal with obvious state change.


Only requires scrolling within a single feed until a uniquely labeled item is visible; no selection, confirmation, or multi-instance disambiguation.

ART-008 — City council approves new park


The target is specified visually via an icon reference rather than unique text, increasing confusability and reliance on pixel-level perception during scrolling.


Two similar compact feeds increase disambiguation and target acquisition difficulty; the target event is deeper and requires scrolling with lazy-loading.

Secondary timeline
EVT-077 — Database failover


Requires opening a drawer to access the feed, then locating a deep item and clicking a small per-row control with immediate state change.


Requires selecting an exact set of two files, but options are few and the upload list gives explicit filename feedback per item.


Single centered dropzone with a small file picker; the chosen filename is clearly listed under the component.


Requires handling a transient modal confirmation and selecting the correct cancel control; the final state matches the initial state, so the checker must confirm the cancel interaction occurred.


Two very similar dropzone instances increase disambiguation load; the rest is straightforward with clear file-name feedback.


Requires selecting an exact set of rows, using a bulk action, and confirming in a popover amid light form clutter.


Requires exact text entry and an explicit save action, but in a simple isolated table.


Single click deletion on an isolated list; low density and clear filename make it easy.


The target must be identified by visual thumbnail matching among many similar items; small delete buttons add acquisition difficulty.


Requires performing a drag-and-drop interaction on a large target area; compact spacing slightly increases interaction tightness.


The primary challenge is extracting the target from the reference panel; interaction itself is a simple FileButton upload.


Single visible chip delete affordance clears the selection with immediate feedback and no extra steps.


Single, large hover target with immediate visual feedback and no distractors; success is simply opening the hover card.


Requires keeping a hover-triggered overlay open long enough to click a specific action button, in a darker, lower-contrast panel near the viewport edge.


Requires scrolling a dense sidebar list in compact dark mode and accurately hovering a small target among many similar options.


Requires keeping an interactive hover card open while clicking an in-card disclosure control to reveal additional content.


A single disclosure icon button with clear expanded/collapsed feedback; minimal interaction depth.


Single large ActionIcon with clear label and immediate feedback; no distractors.


High clutter and required scrolling dominate difficulty; the target itself is straightforward once located.


Requires scrolling to a specific section in a moderately cluttered panel and locating a small icon target in dark mode.


Requires exact formatted entry with validation and a disabled Save state on errors, but still a single, well-labeled field in a simple layout.


Single inline editor with an explicit clear affordance; committing an empty string is straightforward.


Single inline editor with clearly labeled Save/Cancel controls in a clean scene; only a short name string must be entered.


Exact formatted entry with validation plus dark-theme icon/button contrast makes acquisition and feedback handling more demanding.


Requires interacting with a modal layer and resolving a validation state before the Apply action becomes possible.


Nested-path string edit combined with disambiguation between two similar JSON editor instances.


A single inline string edit, but requires noticing that changes are committed automatically without a Save button.


Single-board, few cards, and the goal only requires placing one uniquely titled card into a clearly labeled column with immediate feedback.


Multiple moves are required and one card must land at an exact position; the goal is primarily conveyed through a visual reference, increasing interpretation and tracking load.

PM-2 Draft Q2 roadmap
To do
QA-12 Smoke test signup
Review
SEC-9 Rotate API keys
Done


Dark theme and dense similar card titles increase confusability; handle-only dragging adds precision and acquisition difficulty to achieve an adjacency constraint.

Done
REL-12 Ship hotfix
REL-13 Write postmortem


Interacting inside a drawer adds layering and constrained space, increasing the chance of mis-clicks and scroll issues compared to an inline board.

Board drawer
BUG-51 Fix crash on start
In progress


One overlay layer triggered by a single link; success is immediately observable via the popover opening.


Single clearly labeled Anchor with immediate navigation feedback.


Many identical action links in a small-scale table require precise clicking and correct row selection, compounded by non-central placement.


Compact layout increases risk of clicking the wrong identical Reset link; success requires correct section-based disambiguation.


More options (20) and a search sub-control increase within-component steps; selection must be exact.


Clear end-state with an explicit reset control and immediate feedback.


Short list with clearly labeled checkboxes and immediate visual feedback in a simple, uncluttered scene.


Large option set with an additional search sub-control requires careful state tracking while filtering and selecting an exact set.


Requires understanding a two-phase commit (select then Save) amidst moderate settings clutter.


Visual matching is required but the list is short and the dot colors are distinct.


Requires using a dedicated clear control and confirming the empty selection state, which is explicitly shown.


Single editor, no overlays, and the target text is short and fully visible as plain text.


Compact spacing slightly increases targeting difficulty, but it’s still a single, short markdown line with immediate feedback.


Multiple similar editor instances inside a cluttered settings panel create disambiguation load; the action itself is a simple mode toggle.


Three similar editor instances in a dashboard card create high disambiguation load, and the target markdown is multi-line with list structure.


Requires using an in-field clear affordance or selecting and deleting, but the target field is clearly labeled and prefilled.


Single, clearly labeled masked input with immediate formatting feedback.


Editing a small masked input inside a busy dashboard table requires careful row targeting and exact fixed-width entry.


Requires opening an overlay layer (drawer) to access the field, then performing a short but exact masked entry.


Compact density makes targets tighter and the '@ma' query yields multiple similar options, increasing selection interference.


Direct clear control provides a simple path to an empty, easily checkable state.


Single field with a short Popper list; basic mention insertion.


The dropdown options are extremely confusable (Ann/Anna/Anne) and the mention must be inserted into a specific gap in existing text.

Please check with @Ann Lee before merging.


Goal is specified visually via an icon reference rather than text, requiring correct visual matching and accurate clicking in a compact menu.


Target is specified purely by a visual color cue on a dark theme; the agent must open the menu and visually match the indicator.


Simple checkbox-style toggle within a single menu; state is clearly visible and mirrored.


Only requires opening a single dropdown menu; there are no similar instances or dense choices.


The target is far down a long, dense list inside a constrained popup, requiring correct in-menu scrolling and careful choice among similar labels.


Long, dense scrollable list in a small popup increases the chance of near-miss selections and requires correct in-menu scrolling.


Requires exact multi-selection (must also deselect a preselected item) and correct instance selection within a table header.


Requires opening a submenu and toggling a single labeled option with immediate visible checkmark feedback.


Single click on a clearly labeled header link with immediate active-state feedback.


High disambiguation (three similar headers) plus a pending-vs-committed state that requires an explicit Save action.

Editor header
View settings
Show line numbers
Save


Two highly similar headers require careful instance disambiguation; otherwise the interaction is simple.


Requires disambiguating between two similar meters inside a form with mild clutter, but value feedback is explicit.


Single meter with an explicit reset action and immediate feedback.


Single large target and explicit text feedback; no competing instances or overlays.


Dense table environment with multiple identical meters and a drag interaction; high disambiguation and target acquisition load.


Dropdown selection inside a realistic billing form section; mild distraction from other form inputs, but only one Notification Center instance.


A single labeled switch in a compact control row; moderate interference from a second switch but state feedback is immediate.


Single view selection with strong visual selection feedback; no overlays or confirmations.


Single labeled InputNumber in an isolated card with a small integer target and immediate feedback.


Target value is given only via a reference badge (visual guidance) and there are multiple similar inputs; the agent must parse/locate the reference and apply it to the correct instance.


Target value must be extracted from a reference chip and applied to the correct instance among multiple similar fields.


Dark theme can reduce target salience; the target value is reachable via coarse stepping and is clearly labeled.


Requires text input and keyboard action (Enter) after typing.


Dropdown selection with multiple options.


Two similar password fields require careful label-based disambiguation, and the entered value is masked by default.

AdminGate-77!
Admin console password
Login password


Clearing is a single click, but the masked rendering makes it harder to notice partial leftovers if the reset action fails.


Very simple layout but the password is fully masked with no reveal control, making state observability relatively poor.


Inline editing within a dense table requires precise row targeting and multiple small controls (Edit, input focus, Save), with high disambiguation among similar rows.


Requires tab navigation to reveal the OTP and uses compact spacing that makes each input slightly harder to target.


Requires reading the target from a visual reference element; otherwise the PinInput interaction is standard.


Simple reset-to-empty requirement, but the agent must clear across multiple single-character fields.


Single, clearly labeled trigger opens one popover with immediate visual feedback and no confirmation step.


Multiple similar targets in a dense table require matching against a reference and selecting the correct instance.


Nested popovers require an ordered multi-step interaction and careful target acquisition inside an already-open overlay.


Requires scrolling through cluttered settings to locate the correct labeled row and then opening a small-icon popover.


Simple binary toggle with immediate visual feedback (percent text disappears) and only one progress bar instance.


Single Mantine Progress instance with a clear Start action; completion at 100% is unambiguous.


Dark theme reduces contrast and the settings panel contains two similar progress instances; success requires selecting the correct section and monitoring progress to a high target value.


Requires navigation to the correct tab to reveal the progress bar and then triggering it to reach a mid-way target.


Two similar radio groups appear in the same form section; the agent must select the correct instance by label.


Card-style radios are larger click targets, and the example includes text; mild added complexity from matching reference.


Single RadioGroup with three distinct labels and immediate preview feedback.


Requires locating the correct section by scrolling in a dark, cluttered settings panel and selecting among several frequency options.


Requires opening a modal overlay and confirming via a submit action; multiple steps increase depth and feedback dependencies.

Write a review
Overall rating
Submit review


Two similar instances embedded in a form require careful label-based disambiguation while keeping interaction simple.


Large clickable targets reduce acquisition difficulty; otherwise a straightforward whole-star selection.


Single table with a live pixel readout makes the target state easy to observe; only one resize handle interaction is required with a generous tolerance.


Requires aligning multiple column widths to a reference without per-column numeric badges, plus selecting the correct table instance.


Small compact grips plus three strict target widths make this a high-precision repeated drag task.


Requires horizontal scrolling to bring the target header into view and then performing a drag-resize among many columns.


Requires selecting a specific word and toggling one formatting control; otherwise a simple single-instance scene.


Requires two separate selections and applying two different marks while keeping the rest of the content unchanged.


Disambiguation dominates: three similar editor instances with only one target, plus a small list-structure requirement.