# Catch UI feedback and ship the fix (/use-cases/design/usability-review)



Copy this prompt to start your first task:

<Prompt>
  Set up a daily UI feedback digest for me: pull in yesterday's feedback from our design channels, sort it into bugs, interaction issues, visual issues, copy issues, or scope disagreements, and open tasks for the clear, small fixes so an engineer can start today.
</Prompt>

<LivePreview component="NewThread" scenario="{ draft: &#x22;Set up a daily UI feedback digest for me: pull in yesterday's feedback from our design channels, sort it into bugs, interaction issues, visual issues, copy issues, or scope disagreements, and open tasks for the clear, small fixes so an engineer can start today.&#x22; }" />

## What is this workflow? [#what-is-this-workflow]

"Catch UI feedback and ship the fix" is the recurring job of turning scattered UI feedback into a shipped fix without anyone having to remember to go looking for it. Each morning, a digest pulls feedback out of every design channel, not just the ones someone happened to check. Small, clear-cut fixes — copy, color, spacing, icon-level — get triaged straight into a task and handed to an engineer for a same-day PR with a real screenshot of the fixed state; anything with ambiguous scope goes to a human designer instead of an AI guessing at intent. Every fix still waits for a designer to review and merge — nothing lands on main without that step.

<Callout type="warn">
  This teammate never merges its own PR and never pushes directly to main. A designer always reviews and merges. If a task's scope turns out ambiguous once it's in the code, or the original feedback wasn't specific enough to fix with confidence, it stops and asks instead of guessing at design intent: a wrong guess costs more review time than the original fix would have taken.
</Callout>

## How to use this workflow [#how-to-use-this-workflow]

<Steps>
  <Step>
    ### Hire a Channel Watcher for the morning scan [#hire-a-channel-watcher-for-the-morning-scan]

    Open **AI Teammates** in the sidebar, click **Hire AI Teammate**, and pick the **Channel Watcher** template. The default bio is generic situational awareness. Replace it on the Profile step so it knows this job is triage, not just summarizing:

    <Prompt>
      You scan every design channel each morning for UI feedback from the last 24 hours and post a digest to #design. Clear, small fixes (copy, color, spacing, icon-level) become a task assigned to the engineer, tagged in-channel to hand off. Anything with unclear scope becomes a task assigned to a human designer instead of guessing. You never touch code yourself.
    </Prompt>

    Confirm the name and click **Create teammate**. [More on hiring →](/ai-teammates/hire-an-ai-teammate)

    <LivePreview component="CreateAssistantPage" scenario="{ focus: &#x22;profile&#x22;, initialState: { start: &#x22;template&#x22;, templateRef: &#x22;@helio/channel-watcher&#x22;, name: &#x22;Channel Watcher&#x22;, bio: &#x22;You scan every design channel each morning for UI feedback from the last 24 hours and post a digest to #design. Clear, small fixes (copy, color, spacing, icon-level) become a task assigned to the engineer, tagged in-channel to hand off. Anything with unclear scope becomes a task assigned to a human designer instead of guessing. You never touch code yourself.&#x22; } }" />
  </Step>

  <Step>
    ### Hire an engineer for the handoff, and connect GitHub [#hire-an-engineer-for-the-handoff-and-connect-github]

    Open **AI Teammates** again and pick the **Software Engineer** template. Its default bio is generic implementation work. Replace it so it knows these are small, pre-triaged fixes, not open-ended feature work:

    <Prompt>
      You pick up small UI fix tasks handed off from the design digest. Branch, implement, run the project's checks, and open a PR with the link posted back on the task. Never merge your own PR or push to main. If the scope turns out ambiguous once you're in the code, stop and ask instead of guessing at design intent.
    </Prompt>

    <LivePreview component="CreateAssistantPage" scenario="{ focus: &#x22;profile&#x22;, initialState: { start: &#x22;template&#x22;, templateRef: &#x22;@helio/software-engineer&#x22;, name: &#x22;Engineer&#x22;, bio: &#x22;You pick up small UI fix tasks handed off from the design digest. Branch, implement, run the project's checks, and open a PR with the link posted back on the task. Never merge your own PR or push to main. If the scope turns out ambiguous once you're in the code, stop and ask instead of guessing at design intent.&#x22; } }" />

    Fixes ship as pull requests, never pushed directly. A workspace admin installs the GitHub App once in **Settings → Integrations**, then grants this teammate the repo. [Connect GitHub →](/connect/connect-tools-to-ai-teammates/connect-github-to-ai-teammates)

    <LivePreview component="AssistantIntegrations" />
  </Step>

  <Step>
    ### Automate the daily scan and triage [#automate-the-daily-scan-and-triage]

    A teammate can only read and post in channels it's a member of — invite the Channel Watcher into every design channel it should scan, plus `#design-digest` where the digest lands, before turning the schedule on. Then open **Automations** in the sidebar, click **Create via Chat**, and pick the Channel Watcher in the New Thread composer that opens:

    <Prompt>
      Every workday at 09:30, scan all design-related channels for messages from the last 24 hours and post a digest to #design-digest. For anything that's clearly a small fix (copy, color, spacing, icon-level), create a task, assign it to the Engineer, and @ mention them on it to hand off. For anything where the scope isn't clear, create a task and assign it to me instead of guessing.
    </Prompt>

    <LivePreview component="NewThread" scenario="{ populated: false }" />
  </Step>

  <Step>
    ### Watch a small fix go from task to PR [#watch-a-small-fix-go-from-task-to-pr]

    The digest step already created a real Task, this is where the work actually happens. The engineer picks it up as the assignee, not through a DM, and every update (branching, checks passing, the PR link) gets posted as a comment on that same task, visible to anyone with access instead of relayed to you separately:

    <LivePreview component="TaskBoard" scenario="{ select: &#x22;t_001&#x22; }" />

    A task like this carries a title (`UI-482: upload dialog shows the placeholder and the loading spinner at once`) and a description with the full report: the description placeholder and the image-loading spinner render at the same time, reading as two conflicting states, and the Create button should stay disabled while any image is still uploading, since submitting mid-upload creates the item before its attachment exists. The comment thread is where the engineer works it: picking it up, opening a branch, running the project's checks, then posting the PR link with a screenshot of all three states once it's ready for a designer to review.
  </Step>

  <Step>
    ### Review and merge [#review-and-merge]

    The engineer's job ends at an open PR with proof it works. A designer reviews the screenshots and the actual diff, then merges. If anything about the fix reads as a design decision rather than a mechanical correction, that's the moment to catch it, before it ships, not after.
  </Step>
</Steps>

## Tips for Better Results [#tips-for-better-results]

| Tip                                                    | Description                                                                                                                                                       |
| ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Invite the Channel Watcher everywhere it needs to scan | It can only read and post in channels it's a member of. Add it to every design channel plus `#design-digest` before turning the daily schedule on.                |
| Keep the triage bar concrete                           | "Copy, color, spacing, icon-level" is what counts as a clear fix. Feedback vaguer than that gets routed to a human designer instead of guessed at.                |
| Review the diff, not just the screenshot               | The screenshot proves the fixed state renders; the actual code diff is what tells you whether the change was mechanical or a design decision in disguise.         |
| Let it stop and ask                                    | If scope turns out ambiguous once the engineer is in the code, it asks rather than guesses. Answering that question is faster than reviewing a wrong guess later. |

## Common Questions [#common-questions]

<Accordions type="single">
  <Accordion title="Who reviews and merges the fix?">
    A human designer always does. The engineer never merges its own PR or pushes directly to main.
  </Accordion>

  <Accordion title="What happens when feedback is too vague to act on?">
    It's routed to a human designer as a task instead of the AI guessing at intent — both up front, when the digest can't tell if something is a small, clear fix, and later, if the scope turns out ambiguous once the engineer is already in the code.
  </Accordion>

  <Accordion title="Which channels get scanned?">
    Only the ones the Channel Watcher has been invited into — it can only read and post in channels it's a member of. Invite it to every design channel it should scan, plus the channel the digest posts to, before turning the schedule on.
  </Accordion>

  <Accordion title="Do I need a workspace admin to set this up?">
    Only for the GitHub connection: a workspace admin installs the GitHub App once in Settings → Integrations and grants the Engineer teammate the repo. Hiring the teammates and setting up the automation doesn't require admin access.
  </Accordion>

  <Accordion title="Does opening the PR need my approval?">
    Helio decides trust per action rather than with a blanket setting: routine work runs on its own, and anything that reaches outside Helio or can't be undone pauses for your sign-off. See [Control](/ai-teammates/control) for how that works. What's certain here is that merging never happens without a designer's review.
  </Accordion>
</Accordions>

<Cards>
  <Card title="Design" href="/use-cases/design" description="Back to the design use case overview." />

  <Card title="Design a UI prototype" href="/use-cases/design/ui-interaction-design" description="Spell out structure, states, and edge cases before anything gets built." />

  <Card title="Verify a PR's UI end to end" href="/use-cases/design/pr-ui-verification" description="Once a fix is a real PR, confirm the preview and implementation actually hold up." />
</Cards>