ait-questions.js

// The Agentic Interface Test — question data.
// Every fix string is authored here at build time and never generated.
window.AIT_DATA = (function () {
  'use strict';

  var primitives = [
    { key: 'GI',  name: 'Guide intent',      def: 'Help people understand what is possible and express what they want.',              anchor: 'guide-intent' },
    { key: 'RP',  name: 'Reveal progress',   def: 'Make the agent’s work visible while it happens.',                             anchor: 'reveal-progress' },
    { key: 'SDT', name: 'Show, don’t tell', def: 'Turn responses into usable interfaces, not just text.',                        anchor: 'show-dont-tell' },
    { key: 'KC',  name: 'Keep control',      def: 'Let agents act while people stay informed and in command.',                        anchor: 'keep-control' },
    { key: 'ET',  name: 'Earn trust',        def: 'The interface must earn belief rather than assume it.',                            anchor: 'earn-trust' },
    { key: 'EF',  name: 'Expect failure',    def: 'Assume the agent will fail, and make failure survivable.',                         anchor: 'expect-failure' },
    { key: 'MA',  name: 'Make artifacts',    def: 'Work should produce durable outputs, not evaporate into a transcript.',            anchor: 'make-artifacts' },
    { key: 'BH',  name: 'Build a home',      def: 'Give agentic work a persistent, coherent place that fits the product.',            anchor: 'build-a-home' }
  ];

  // subElement, ceiling, and the primitives' anchor are authoring
  // metadata: they document which framework pattern each question maps
  // to and are not read by the app code.
  function q(id, primitive, subElement, text, opts) {
    opts = opts || {};
    return {
      id: id,
      primitive: primitive,
      subElement: subElement,
      text: text,
      ceiling: !!opts.ceiling,
      tooltip: opts.tooltip || null,
      fix: opts.fix
    };
  }

  var quick = [
    q('Q1', 'GI', 'composer', 'Is there one clear place where a user can type, speak, or upload to say what they want?',
      { tooltip: 'Because one clear place to express intent beats controls scattered across the UI.',
        fix: 'Give users one clear composer for text, voice, and files.' }),
    q('Q2', 'ET', 'disclosure', 'Is AI-generated content clearly labeled as AI-generated?',
      { tooltip: 'Because undisclosed AI erodes trust the moment it is discovered.',
        fix: 'Label AI-generated content as AI-generated, everywhere it appears.' }),
    q('Q3', 'GI', 'zero state', 'When a user opens your product, do they see suggested actions or starting points instead of only an empty text box?',
      { tooltip: 'Because a blank box makes users guess what the agent can do.',
        fix: 'Show suggested actions on open instead of an empty box.' }),
    q('Q4', 'RP', 'execution states', 'While the agent works, does the interface show what it is doing (for example: searching, generating, waiting)?',
      { tooltip: 'Because a named stage turns a silent spinner into a status.',
        fix: 'Show what the agent is doing while it works.' }),
    q('Q5', 'SDT', 'generative UI', 'When the answer is data, does your product render it as a chart, table, or other visual instead of only prose?',
      { tooltip: 'Because data is easier to use as a chart or table than as prose.',
        fix: 'Render data as charts and tables, not paragraphs.' }),
    q('Q6', 'BH', 'navigation', 'Can a user find and return to earlier tasks, threads, or outputs after they navigate away?',
      { tooltip: 'Because work you cannot find again is work lost.',
        fix: 'Let users find and reopen earlier tasks and outputs.' }),
    q('Q7', 'KC', 'approvals', 'Before the agent does something sensitive, expensive, or hard to undo, does it ask the user to confirm first?',
      { tooltip: 'Because sensitive and irreversible actions need an explicit gate.',
        fix: 'Ask for confirmation before sensitive or irreversible actions.' }),
    q('Q8', 'MA', 'static artifacts', 'Does the agent produce durable outputs (a document, dashboard, or report) that persist after the conversation?',
      { tooltip: 'Because the product of the work should outlive the conversation.',
        fix: 'Produce durable outputs that outlive the conversation.' }),
    q('Q9', 'RP', 'streaming', 'When a task takes more than a few seconds, does the response stream in or show live updates instead of freezing until it is done?',
      { tooltip: 'Because live updates prove the system is alive and let users bail early.',
        fix: 'Stream responses and show live updates during long tasks.' }),
    q('Q10', 'SDT', 'interactive controls', 'Can a user interact with what the agent produced (filter, sort, edit a field, drill in) without re-prompting?',
      { tooltip: 'Because static output forces a re-prompt for every tweak.',
        fix: 'Let users filter, sort, and edit results without re-prompting.' }),
    q('Q11', 'KC', 'clarifying questions', 'When a request is ambiguous, does the agent ask a clarifying question instead of guessing?',
      { tooltip: 'Because guessing wrong is more expensive than asking.',
        fix: 'Ask a clarifying question when a request is ambiguous.' }),
    q('Q12', 'ET', 'provenance', 'When the agent states a fact from a source, does it show where that came from (citation, link, or reference)?',
      { tooltip: 'Because claims without sources are unverifiable.',
        fix: 'Cite the source when the agent states a fact.' }),
    q('Q13', 'EF', 'honest errors', 'When the agent fails or cannot finish, does it show a clear error that explains what happened?',
      { tooltip: 'Because an error users can act on keeps failure survivable.',
        fix: 'Show clear errors that explain what went wrong.' }),
    q('Q14', 'EF', 'easy correction', 'Can a user easily correct or redo the agent’s work when it gets something wrong?',
      { tooltip: 'Because fixing the agent should not mean starting over.',
        fix: 'Make it easy to correct or redo the agent’s work.' }),
    q('Q15', 'BH', 'continuity', 'Does your product remember useful context across sessions so users do not start from scratch each time?',
      { tooltip: 'Because restarting cold every session is exhausting.',
        fix: 'Carry context across sessions so users don’t start over.' }),
    q('Q16', 'MA', 'portability', 'Can a user export, download, or share what the agent produced?',
      { tooltip: 'Because value trapped in the app is value lost.',
        fix: 'Let users export, download, or share agent outputs.' })
  ];

  var deep = [
    // Section 1: Guide intent
    q('D1', 'GI', 'zero state', 'When a user first opens the product, are they shown suggested workflows or recommended tasks rather than a blank prompt?',
      { tooltip: 'Because a blank box makes users guess what the agent can do; a zero state teaches capability in one glance.',
        fix: 'Open with suggested workflows, not a blank prompt.' }),
    q('D2', 'GI', 'recent context', 'Does the opening screen surface recent items or where the user left off?',
      { tooltip: 'Because continuity at the start beats a cold prompt.',
        fix: 'Surface recent items and where the user left off on open.' }),
    q('D3', 'GI', 'composer', 'Is there one clear, multimodal place to express intent (text plus at least one of voice, file, or image)?',
      { tooltip: 'Because one composer beats inputs scattered across the UI.',
        fix: 'Offer one multimodal composer: text plus voice, file, or image.' }),
    q('D4', 'GI', 'next-action suggestions', 'After the agent responds, does it suggest relevant next actions?',
      { tooltip: 'Because suggested next steps keep momentum and reveal what else is possible.',
        fix: 'Suggest relevant next actions after each response.' }),
    q('D5', 'GI', 'structured inputs', 'When precision matters, does the agent generate a form or specific fields instead of expecting one long typed prompt?',
      { tooltip: 'Because forms beat free text when parameters must be exact.',
        fix: 'Generate forms with specific fields when precision matters.' }),
    q('D6', 'GI', 'input validation', 'Do generated inputs validate entries (flag a bad date or a missing required field) before the agent acts?',
      { tooltip: 'Because catching bad input up front prevents wasted runs.',
        fix: 'Validate generated inputs before the agent acts on them.' }),

    // Section 2: Reveal progress
    q('D7', 'RP', 'execution states', 'During a task, does the interface name its current stage (planning, searching, generating, acting, waiting, done)?',
      { tooltip: 'Because named stages turn a spinner into a status.',
        fix: 'Name the agent’s current stage: planning, searching, generating, acting.' }),
    q('D8', 'RP', 'streaming', 'Do responses, tool calls, or sub-agent steps stream as they happen rather than all appearing at the end?',
      { tooltip: 'Because streaming proves the system is alive and lets users bail early.',
        fix: 'Stream steps and responses as they happen.' }),
    q('D9', 'RP', 'thinking summaries', 'Can the user see a readable summary of the agent’s plan or reasoning (not raw logs)?',
      { tooltip: 'Because a summary builds trust without dumping a stack trace.',
        fix: 'Show a readable summary of the agent’s plan, not raw logs.' }),
    q('D10', 'RP', 'milestones', 'For multi-step tasks, does the interface show progress against steps or milestones?',
      { tooltip: 'Because milestones make long tasks feel finite.',
        fix: 'Show progress against steps for multi-step tasks.' }),
    q('D11', 'RP', 'effort transparency', 'Does the interface show the cost, time, or effort a task will take or has taken (tokens, minutes, dollars, or steps)?',
      { ceiling: true,
        tooltip: 'Because effort transparency is rare and separates mature products.',
        fix: 'Show the time, cost, or effort a task takes.' }),
    q('D12', 'RP', 'async/inbox', 'Is long-running or background work surfaced through an inbox or notification so the user can leave and come back?',
      { ceiling: true,
        tooltip: 'Because agentic work outlives a single session; most UIs still trap it in one open tab.',
        fix: 'Surface background work through an inbox or notifications.' }),

    // Section 3: Show, don't tell
    q('D13', 'SDT', 'generative UI', 'When a response suits a chart, table, form, map, or timeline, does the product render that instead of prose?',
      { tooltip: 'Because the model is capable of structure; prose wastes it.',
        fix: 'Render charts, tables, forms, and timelines when they fit the answer.' }),
    q('D14', 'SDT', 'generative UI breadth', 'Does the product generate more than one kind of UI depending on the task, not just one hardcoded widget?',
      { tooltip: 'Because one widget is a template; many is generative UI.',
        fix: 'Generate different UI for different tasks, not one hardcoded widget.' }),
    q('D15', 'SDT', 'interactive controls', 'Can users manipulate generated output in place (filters, sliders, inline edits, drill-downs)?',
      { tooltip: 'Because static output forces a re-prompt for every tweak.',
        fix: 'Make generated output manipulable in place: filters, sliders, inline edits.' }),
    q('D16', 'SDT', 'contextual layouts', 'Does the layout adapt to the task instead of defaulting to a chat bubble every time?',
      { tooltip: 'Because not every task is a conversation.',
        fix: 'Adapt the layout to the task instead of defaulting to chat.' }),
    q('D17', 'SDT', 'layout expansion', 'When a task needs more room (a dashboard, a side panel, a full view), does the interface expand beyond the chat column?',
      { tooltip: 'Because complex work needs canvas, not a column.',
        fix: 'Expand beyond the chat column when a task needs room.' }),
    q('D18', 'SDT', 'accessibility of generated UI', 'Is runtime-generated UI keyboard-navigable and screen-reader accessible, the same as your hand-built screens?',
      { ceiling: true,
        tooltip: 'Because most teams cannot say yes; generated UI often ships without labels, focus order, or contrast.',
        fix: 'Make generated UI keyboard-navigable and screen-reader accessible.' }),

    // Section 4: Keep control
    q('D19', 'KC', 'approvals', 'Before sensitive, expensive, destructive, or irreversible actions, does the agent require explicit approval?',
      { tooltip: 'Because irreversible actions need a gate.',
        fix: 'Require explicit approval before irreversible or expensive actions.' }),
    q('D20', 'KC', 'confirmations', 'Before a consequential action, does the user see exactly what will happen (the specific change, not a generic “proceed?”)?',
      { tooltip: 'Because a vague confirm is not a confirm.',
        fix: 'Show exactly what will happen before a consequential action.' }),
    q('D21', 'KC', 'clarifying questions', 'When intent is unclear, does the agent ask rather than guess?',
      { tooltip: 'Because guessing wrong is more expensive than asking.',
        fix: 'Ask a clarifying question when intent is unclear.' }),
    q('D22', 'KC', 'permissions', 'Can a user see and understand the scope of what the agent is allowed to touch (data, tools, accounts)?',
      { tooltip: 'Because legible scope is the basis of trust.',
        fix: 'Show users what data, tools, and accounts the agent can touch.' }),
    q('D23', 'KC', 'interrupt/redirect/rerun', 'Can a user pause, redirect, or rerun a task mid-flight without starting over?',
      { tooltip: 'Because users change their mind mid-task; the UI should let them.',
        fix: 'Let users pause, redirect, or rerun tasks mid-flight.' }),
    q('D24', 'KC', 'respectful surfacing', 'When the agent surfaces something on its own, is it easy to dismiss or defer rather than blocking the user?',
      { tooltip: 'Because agent-initiated does not mean agent-imposed.',
        fix: 'Make agent-initiated surfacing dismissible, never blocking.' }),

    // Section 5: Earn trust
    q('D25', 'ET', 'disclosure', 'Is AI-generated content clearly labeled as AI-generated?',
      { tooltip: 'Because undisclosed AI erodes trust the moment it is discovered.',
        fix: 'Label AI-generated content as AI-generated.' }),
    q('D26', 'ET', 'provenance', 'When the agent states a fact from a source, does it cite or link that source?',
      { tooltip: 'Because claims without sources are unverifiable.',
        fix: 'Cite or link the source behind every stated fact.' }),
    q('D27', 'ET', 'inspectable sources', 'Can a user click through to inspect the underlying source or data behind a claim?',
      { tooltip: 'Because a citation you cannot open is decoration.',
        fix: 'Let users click through to inspect underlying sources.' }),
    q('D28', 'ET', 'honest confidence', 'Does the agent signal uncertainty when it is unsure instead of always sounding equally confident?',
      { tooltip: 'Because uniform confidence hides risk.',
        fix: 'Signal uncertainty instead of sounding uniformly confident.' }),
    q('D29', 'ET', 'memory transparency', 'Can a user view, edit, and delete what the agent remembers about them?',
      { ceiling: true,
        tooltip: 'Because viewable is common; editable and deletable are rare, and all three are needed for a yes.',
        fix: 'Let users view, edit, and delete the agent’s memory.' }),
    q('D30', 'ET', 'consistent identity', 'Does the agent present a consistent identity (name, voice, capabilities) across the product rather than shifting persona per screen?',
      { tooltip: 'Because an inconsistent agent feels like several strangers.',
        fix: 'Give the agent one consistent name, voice, and capability story.' }),

    // Section 6: Expect failure
    q('D31', 'EF', 'honest errors', 'When something fails, does the interface show an honest error that says what went wrong?',
      { tooltip: 'Because silent or fake-cheerful failure destroys trust.',
        fix: 'Show honest errors that say what went wrong.' }),
    q('D32', 'EF', 'graceful degradation', 'When the agent cannot do the full task, does it still deliver partial value or fall back to a simpler mode?',
      { tooltip: 'Because when the agent falls short, the user should lose speed, not agency.',
        fix: 'Deliver partial value or a simpler fallback when full tasks fail.' }),
    q('D33', 'EF', 'easy correction', 'When the agent is wrong, can the user correct it in place quickly?',
      { tooltip: 'Because correction should not mean starting the whole task over.',
        fix: 'Let users correct the agent in place, not restart the task.' }),
    q('D34', 'EF', 'undo vs rollback', 'Are user actions (undo) and agent actions (rollback) both recoverable, and are they distinct?',
      { ceiling: true,
        tooltip: 'Because undoing your own edit is common; rolling back what the agent did is rare, and you need both for a yes.',
        fix: 'Add rollback for agent actions, not just undo for user edits.' }),
    q('D35', 'EF', 'refusal surfaces', 'When the agent refuses or is blocked, does it say why and what the user can do about it?',
      { tooltip: 'Because an unexplained “I can’t help with that” is a dead end.',
        fix: 'Explain refusals and offer a path forward.' }),
    q('D36', 'EF', 'blocked-action clarity', 'Are blocked or failed actions shown clearly rather than failing silently?',
      { tooltip: 'Because silent failure is the worst failure.',
        fix: 'Surface blocked and failed actions clearly, never silently.' }),

    // Section 7: Make artifacts
    q('D37', 'MA', 'live artifacts', 'Does the agent produce live artifacts (dashboards, apps, tools) that keep working after the turn ends?',
      { ceiling: true,
        tooltip: 'Because a living artifact is worth more than a frozen screenshot.',
        fix: 'Produce live artifacts that keep working after the turn ends.' }),
    q('D38', 'MA', 'static artifacts', 'Does the agent produce static artifacts (reports, slides, documents) users can keep?',
      { tooltip: 'Because sometimes a durable document is exactly the deliverable.',
        fix: 'Produce durable documents and reports users can keep.' }),
    q('D39', 'MA', 'iterative updates', 'Can a user change one part of an artifact without regenerating the whole thing?',
      { ceiling: true,
        tooltip: 'Because full regeneration loses edits and wastes time.',
        fix: 'Let users change one part without regenerating the whole artifact.' }),
    q('D40', 'MA', 'version awareness', 'Does the product track versions of an artifact so users can see or revert changes?',
      { ceiling: true,
        tooltip: 'Because agentic edits need history.',
        fix: 'Track artifact versions so users can see and revert changes.' }),
    q('D41', 'MA', 'portability', 'Can artifacts be exported, linked, or embedded elsewhere?',
      { tooltip: 'Because value trapped in the app is value lost.',
        fix: 'Make artifacts exportable, linkable, and embeddable.' }),
    q('D42', 'MA', 'persistence', 'Do artifacts persist somewhere the user can return to, separate from the chat transcript?',
      { tooltip: 'Because scrollback is not storage.',
        fix: 'Store artifacts somewhere users can return to, outside the transcript.' }),

    // Section 8: Build a home
    q('D43', 'BH', 'navigation', 'Can users navigate across tasks, threads, artifacts, or workspaces?',
      { tooltip: 'Because a single endless thread is not a home.',
        fix: 'Add navigation across tasks, threads, artifacts, and workspaces.' }),
    q('D44', 'BH', 'output browser', 'Is there a browser or library for generated outputs, not just scrollback?',
      { tooltip: 'Because users need to find past work by object, not by scrolling.',
        fix: 'Give users a library of generated outputs, not just scrollback.' }),
    q('D45', 'BH', 'threads/context panels', 'Are threads and context available as persistent interface, not just history?',
      { tooltip: 'Because context should be a surface, not a memory test.',
        fix: 'Make threads and context persistent interface, not just history.' }),
    q('D46', 'BH', 'continuity', 'Does context and memory carry across sessions so users continue where they left off?',
      { ceiling: true,
        tooltip: 'Because restarting cold every session is exhausting.',
        fix: 'Carry memory across sessions so users continue where they left off.' }),
    q('D47', 'BH', 'brand/domain fit', 'Does the interface fit your brand and domain rather than looking like a generic chat wrapper?',
      { tooltip: 'Because a home should feel like yours.',
        fix: 'Make the interface fit your brand, not a generic chat wrapper.' }),
    q('D48', 'BH', 'feedback/steering', 'Are feedback and steering (thumbs, corrections, preferences) surfaced as interface the user can act on?',
      { tooltip: 'Because steering the agent should be part of the UI, not a support ticket.',
        fix: 'Surface feedback and steering as controls users can act on.' })
  ];

  var levels = [
    { max: 34,  n: 1, name: 'Chatbot',   line: 'A prompt box and a stream of text. The model may be capable, but the interface does little to help.' },
    { max: 54,  n: 2, name: 'Assistant', line: 'Responses are structured and may include a widget, but the experience remains chat-first and the agent works out of view.' },
    { max: 74,  n: 3, name: 'Copilot',   line: 'Generative UI, visible progress, and meaningful controls enter core workflows. The interface begins working alongside the user.' },
    { max: 89,  n: 4, name: 'Intelligent Workspace', line: 'The product becomes a place, not a thread: persistent artifacts, navigation, memory, and layouts that adapt to the work.' },
    { max: 100, n: 5, name: 'Fully Agentic', line: 'The interface assembles itself around the task while remaining accessible, recoverable, and portable like hand-built software.' }
  ];

  return { primitives: primitives, quick: quick, deep: deep, levels: levels };
})();