QUICK ANSWER

Record your screen with Clipy and talk through the UI changes you want, pointing to each part as you go. Give Claude Code the recording link and ask it to make the changes. A single walkthrough lets you explain how the interface should look and behave without writing a separate prompt for every detail.

Make the UI changes I describe in this Clipy walkthrough: [link].

When should you put several UI requests in one recording?

Batch requests when they share a surface and a review context. Three changes to an account-settings flow belong together because the viewer needs to understand the same page, account state, and purpose. Reviewing the whole flow also exposes interactions between requests.

Keep unrelated tasks separate. A landing-page heading, a billing permission bug, and a background upload failure may all occur in the same product, but they have different evidence and verification needs. Putting them in one recording saves little if the agent must untangle three investigations afterward.

A useful batch has a clear scope sentence: “These are the changes I want to the settings experience on desktop and mobile.” If you cannot summarize the batch without listing unrelated projects, split it.

Separate urgency as well. An urgent production defect should not wait for a set of visual preferences to be resolved. Record the defect’s reproduction on its own and let the remaining walkthrough describe lower-priority improvements.

The number of requests matters less than their clarity. Three ambiguous instructions can be harder than six explicit ones. A good stopping point is when you are moving to a different audience, workflow, or product decision. You can link two recordings in the same task while preserving their separate scope.

What can a recording explain that a list misses?

A written list can say “move the action above the fold.” A walkthrough can show the current viewport, the competing actions, the surrounding information, and when the action becomes visible. Your narration supplies the intended change while the screen anchors the reference.

That is especially useful for words such as “this,” “here,” “after,” and “the other one.” Those references are easy for a person watching the recording to follow, but they can become ambiguous in a transcript. Deliberate pointing, visible labels, and a pause on the target improve the evidence available to the agent.

A recording also preserves state transitions. “Keep this open after saving” is not a request to make the panel permanently visible. Showing the panel before Save, during Save, and afterward makes the distinction easier to explain.

Check the handoff: if a frame shows several buttons, name the one you mean.

Clipy’s skill documentation describes the available transcript, key moments, images, and recording-context document. Claude can use that material to structure your requests. Pointer evidence depends on capture, and it should not be treated as a guaranteed DOM or source-code mapping.

How should you prepare a UI feedback walkthrough?

Open the build you want changed and identify it in your handoff. A production page, a preview deployment, and a local branch can look similar while differing in important details. Include the environment or relevant version so Claude does not investigate a state that its checkout cannot produce.

Write a short private outline before recording. For the illustrative settings example, the outline is:

  1. Give the Save action the intended visual prominence.
  2. Keep the settings panel open after a successful save.
  3. Resolve the mobile menu’s overlap with the settings content.

The outline is not a complete implementation plan. It keeps your recording from wandering. You can still explain the rationale naturally while looking at the page.

Have any authoritative design reference available. If you need a precise spacing or color change, use a known token or measured requirement. Do not invent pixel values from a glance. “Use the primary action style already used on the profile page” may be more accurate than guessing a color code.

Prepare the states the feedback needs: desktop, narrow viewport, open panel, unsaved change, saved result. You do not need to tour every state of the application. Show the states that define the request or constrain a likely implementation.

Finally, use test content where possible. A recording shared for UI review should not expose unrelated customer records just because the affected component also appears on a sensitive page.

How do you narrate each change without writing a long prompt?

Use one short pattern for every request: number, target, current behavior, desired behavior, and boundary. This makes natural speech easier to separate later.

For example:

“Change one is the Save button at the bottom of this panel. It is hard to distinguish from Cancel. Use our existing primary action treatment for Save. Keep the labels and click behavior unchanged.”

That request gives Claude a target and an established source of style. It does not ask the agent to invent a new visual system. The boundary also prevents a cosmetic change from drifting into form behavior.

For the next request, say the transition explicitly:

“Change two is what happens after saving. I want this panel to stay open after a successful save so I can continue editing. The close control should still close it. I have not decided what should happen after navigation away.”

You have now supplied a behavior, a preserved action, and an unresolved case. The agent can investigate the existing navigation behavior without quietly treating your silence as approval to change it.

Pause between requests. Show the relevant state before moving on. If you change your mind mid-recording, say which instruction supersedes the earlier one: “Ignore my first suggestion about moving Save; keep its location and change only its visual prominence.” That correction should appear in the extracted task list.

How should you distinguish bugs, preferences, and open decisions?

A walkthrough often contains all three. Treating them as identical creates avoidable mistakes.

A bug is a mismatch with an established requirement. A preference is a requested change whose value comes from the person’s judgment. An open decision is something the person has not settled. The same visible state could fit any category depending on the product context.

For our example, Save’s visual prominence is a design request. The panel closing might be a bug if the agreed specification says it should stay open, or a behavior change if the current implementation matches the old specification. The mobile overlap is observable, but the preferred replacement layout may still need a decision.

Ask Claude to retain those distinctions:

Category What to record What Claude should avoid
Observed defect Reproduction and expected requirement Assuming a technical cause from appearance
Requested design change Target and intended visual outcome Broadening the request into a redesign
Open decision Options and what is unresolved Choosing a product direction silently

This is particularly useful when speaking casually. “Maybe put that in the header” should not become a firm instruction to relocate the control. If you want the agent to propose options, say that. If you already chose an option, state it plainly.

The recording can preserve uncertainty as faithfully as certainty. A useful brief tells the implementer what is still undecided.

How do you hand the walkthrough to Claude Code?

Start with the recording link and the task. If the agent needs the Clipy skill or account access, ask it to handle setup and guide you through anything it needs. You can keep explaining what you want in ordinary language.

Read this Clipy UI walkthrough and list the changes I asked for. Keep my final corrections and priorities in mind. Implement the agreed changes, then attach Clipy proof to the GitHub PR: [recording link].

What should the extracted request table contain?

A table is useful because it forces separate outcomes. Here is an illustrative extraction from the account-settings walkthrough:

ID Request Evidence Preserve Acceptance check
R1 Give Save the existing primary action treatment Example 00:12, panel actions visible Labels and action handlers Save matches the established primary style in the recorded state
R2 Keep the panel open after successful Save Example 00:38, save sequence Explicit close action Save completes and panel remains open; close still works
R3 Resolve mobile menu overlap with settings content Example 01:05, narrow viewport Access to existing menu destinations Agreed narrow-layout behavior works without covering required content

These times are examples, not references to a real recording. A real table should use only timestamps and assets that exist. If the exact action is not captured, the evidence cell should say that instead of pretending a nearby frame establishes it.

R3 also needs a question: should the menu push content, overlay it temporarily, or close after a destination is selected? The visible overlap does not answer that product decision. Until the desired interaction is agreed, the acceptance check remains incomplete.

Keep IDs stable through the task. They are simple conversation labels, not a new project-management system. “R2 works, but R1 still lacks the intended emphasis” is much easier to act on than “The second part is good, but the thing at the bottom is still off.”

How do you write acceptance checks for visual feedback?

An acceptance check should describe an observable result under named conditions. It should not prescribe implementation unless the implementation itself is a requirement.

For R1, “the button looks better” is weak. “Save uses the existing primary button variant and Cancel retains its current secondary treatment in the open settings panel” gives the reviewer something concrete to compare. If the project does not have such a variant, that is a discovery question rather than permission to invent one.

For R2, show the entire action: open panel, change a field, save successfully, and inspect whether the panel remains open. Then exercise the close control. A still image of an open panel does not establish its post-save behavior.

For R3, agree on the desired narrow-screen interaction before testing it. Specify the relevant viewport or actual device conditions. Do not convert a desktop browser resized to a narrow width into a claim of testing on an actual phone.

Separate positive and preserved behavior. A change can satisfy the new request while breaking the previous close action or keyboard path. Ask for relevant regression checks based on what changed, not an indiscriminate test of every feature in the product.

Avoid making every visual preference mathematically exact. Some reviews require human judgment. In those cases, name the design reference and who decides whether the result matches it, while still testing any objective behavior involved.

How do you handle dependencies and conflicting instructions?

Requests may share implementation even when they have separate acceptance checks. R1 and R2 may involve the same panel component. R3 may touch a shared navigation component used elsewhere. Claude should discover those relationships from the code instead of assuming that every table row maps to one file.

Ask for a short implementation order after the requirements are clear. A visual change may be safe independently, while a behavior change requires understanding state transitions first. If R3 remains undecided, R1 and R2 can often proceed without pretending the whole batch is blocked.

Conflicting narration needs special handling. Suppose you say “make the action sticky” early in the recording and later say “keep everything where it is.” Those statements may conflict. An agent should cite the conflict and ask which applies, unless you explicitly marked the later statement as a correction.

Written follow-up can clarify the recording. State which request it changes: “For R1, use the existing primary style and do not make the action sticky.” That preserves the rest of the batch and avoids requiring another complete walkthrough.

Keep source-of-truth decisions visible in the conversation or task description. A recording is useful evidence, but a later explicit clarification should not be lost because an older transcript remains attached to the task.

How do you keep a feedback batch from becoming a redesign?

Name the boundary at the start. “Change the three things in this walkthrough; preserve the rest of the page’s structure” tells Claude what kind of task it is performing.

Prefer existing design patterns. Ask it to inspect the established component and token system before adding a new style. This helps the requested button emphasis feel like part of the application rather than a separate design exercise.

Distinguish adjacent observations from authorized work. You may notice another problem while narrating. Say whether it belongs in the current batch or should be recorded for later. Otherwise, an agent may turn every complaint into an implementation requirement.

Ask for a scoped diff explanation. The final report should connect each group of changes to R1, R2, or R3. If a large unrelated file changes, the agent should explain why that work was necessary. A recording does not exempt the implementation from ordinary code review.

The same boundary applies to copy. “Make the action more prominent” does not imply permission to change its label, promise, or destination. If wording is part of the request, include the intended words or ask for a separate proposal.

A clear batch feels small even when it crosses a few components: you know what changed, why it changed, and which visible result to inspect.

What evidence should you ask for after implementation?

Verify this change in the running app. Record the verification with Clipy and attach the Clipy proof link to this GitHub PR: [PR link]. Show the problem before the fix and the result after it.

The agent handles recording and sharing. Open the proof link in the PR to see what it actually checked. Ask it to include the important screens and a reload when the change should persist.

A recording shows the run that was captured, not every possible case. If the agent cannot record in its current environment or cannot update the PR, it should say so. A walkthrough assembled from screenshots should be labeled as such, not presented as continuous screen capture.

What should you do when only part of the batch is correct?

Respond using the request IDs. Accept the parts that meet their checks and explain the remaining discrepancy for the others. This preserves progress and avoids reopening everything with a vague “not quite.”

For example:

“R2 passes: the panel stays open after Save and the close control still works. R1 needs another pass because Save and Cancel still have equal emphasis. R3 is waiting on my decision about whether the menu should overlay or push the page.”

This is an illustrative review response, not a test outcome. Its useful feature is that each statement has a scope. Claude knows which work is complete, which is incorrect, and which has never been decided.

If you need another recording, start at the remaining issue. Reference the existing request rather than narrating the whole original batch again. A short correction is often enough when the shared context is already sound.

When your preference changes, label it a new requirement. “I now want Save in the header” is different from “You failed to preserve the agreed location.” Keeping that distinction avoids blaming the implementation for a moving target and makes the next task clearer.

A batch is complete when every request is accepted, deliberately deferred, or explicitly removed. A visually polished page with an unmentioned missing request is still an incomplete handoff.

How does this differ from asking Claude to inspect the live UI?

Live inspection lets an agent explore the current application. A recorded walkthrough preserves a person’s specific requests and the state in which they made them. Both can be useful in the same task.

Anthropic documents screenshot input and live computer use in supported Claude Code environments. The point of a feedback recording is therefore not that Claude cannot see an interface. It is that your explanation, sequence, and priorities should remain available after you finish reviewing. Image workflows, computer use.

Ask Claude to use the recording to understand the request and its live tools to investigate and verify, when those tools and permissions are available. If live access is unavailable, it should report that limitation rather than claiming it clicked through the result.

A saved recording is also useful when the reviewer and implementer are not working at the same time. The reviewer does not need to remain in a shared session while the agent edits the code. The handoff still needs an accessible repository and a clear development environment.

For broader options across coding agents, see the existing recording-context guide. Keep the mechanism secondary to the outcome: a set of changes that a reviewer can understand and verify.

What do people ask about recorded UI feedback?

How many UI changes can I include in one walkthrough?

There is no useful universal count. Group requests that share the same surface and review context, and give each a separate outcome. Split the recording when you move to unrelated workflows or unresolved product decisions. A concise list of request IDs matters more than maximizing the number of changes per video.

Should I tell Claude which source files to edit?

Only if you know the relevant files and have a reason to constrain the implementation. Otherwise, identify the visible element, route, and intended behavior, then let Claude inspect the repository. Pointer position and appearance alone do not establish the owning source component.

Can I say “make this look better” while pointing?

You can use it to open a design discussion, but it is not a complete acceptance criterion. Explain what bothers you and name a reference or desired relationship, such as clearer primary-action emphasis. If you want options rather than a predetermined change, ask Claude to propose them before editing.

What if I contradict myself in the recording?

State the final instruction explicitly or clarify it in writing afterward. Ask Claude to retain the correction in its request table. If the recording contains incompatible requests without a clear correction, the agent should identify that conflict instead of silently choosing one.

Does the recording automatically become an editable implementation brief?

This workflow asks Claude to create a reviewable request table in your conversation from the available context. You can correct that table there.

Can I use the same walkthrough with another coding agent?

Clipy’s skill documentation includes other supported agents, including Cursor and Codex. The request structure transfers: identify targets, separate requirements from suggestions, and check each result. Setup and available tools differ, so use the relevant agent’s documented integration instead of assuming Claude-specific steps apply everywhere.

For your next review, open Clipy for Claude Code, record the actual interface, and number the changes as you speak. Give the agent a clear batch and give yourself a clear review list.

Which sources support this walkthrough method?

Source notes, checked September 10, 2026:

The request IDs, table, prompts, and acceptance checks are instructional templates. No customer outcome, conversion improvement, automatic task-extraction accuracy, or verified implementation result is claimed.