Building AI features that output actionable steps is a UX nightmare waiting to happen. As highlighted in a recent DEV.to post by Samuel Kimama, current Large Language Model (LLM) interfaces fundamentally misunderstand the nature of user tasks. When an AI returns a numbered list of issues to fix, the UI renders it as static text. The moment the user replies, that list scrolls out of context, forcing them to manually reference specific numbers while hoping the model correctly identifies which list they mean.

The Context Window Trap

The core problem is that interfaces treat work items as formatting rather than state. While some tools now display the model's own multi-step reasoning as a checklist, user-facing action items remain just text. This creates a fragile workflow where scrolling up to reread instructions breaks immersion, and ambiguous references fail when multiple numbered lists appear in the same conversation thread. Nothing in the current standard tracks which items the user has actually completed.

Three Tiers of Implementation

Kimama proposes three architectural approaches to solve this, ranging from a quick front-end patch to a deep state integration. The smallest version is a front-end-only fix: a pin control that moves any rendered ordered list into a sticky side panel. This allows users to check items off manually, solving the scrolling issue without requiring model changes. It is the lowest-lift solution for teams who cannot alter the underlying LLM prompt structure.

Adding Stability with IDs

For a more robust solution, the solid version requires the model to mark lists as actionable and assign stable IDs to each item. On subsequent turns, the model reports which specific ID it is addressing and whether the issue is resolved. This allows the UI to highlight and auto-check items. Crucially, clicking an item attaches its unique ID to the user's next message, eliminating the ambiguity of referencing vague terms across multiple turns.

Managing Edge Cases and Mobile UX

The ambitious version treats lists as part of the conversation's persistent state, allowing later messages to split or add items dynamically. However, this approach introduces significant trade-offs. A wrong auto-checkmark is worse than no checkmark, necessitating an obvious undo feature. Furthermore, not every numbered list is a task; ranked options or recipes should not persist as work items. On mobile devices, the sticky panel must collapse into a compact chip to preserve screen real estate.

Key Takeaways

  • Current LLM UIs treat user task lists as ephemeral text, causing context loss and ambiguity.
  • A front-end sticky panel is the quickest fix for tracking user progress without model changes.
  • Stable IDs attached to list items are required for accurate model-to-UI state synchronization.
  • Auto-checking features must include robust undo mechanisms to prevent user frustration.
  • Mobile implementations require compact UI patterns like progress chips instead of full panels.

The Bottom Line

If you are building an AI feature that hands users steps to follow, stop treating their workflow as chat history. Implementing stable IDs and persistent state is no longer optional; it is the baseline for usable agentic tools.