Summary: I once assigned design exploration, critique, and implementation to three Claude interfaces, using sketches, specifications, and rendered screens to exchange information. That was the division of labor I chose, not a permanent capability map for the products. The workflow was useful because every handoff contained something that could be examined and left room to correct or stop the work.
When designing a new layout, I often move between several working windows. I first inspect a visual proposal, then discuss the requirements and trade-offs, modify the code, and finally return to the actual page to check the result.
Measured only by the number of operations, this is not the shortest path. For me, however, separating these questions makes the result easier to assess than asking one round to be beautiful, reasonable, usable, and already live all at once.
What I want to share is this arrangement of work, not proof that a particular tool will always be unable to do something.
Three Roles Were My Way of Dividing the Work
For that project, I treated Claude Design as an explorer that proposed visual sketches. I used the web version of Claude as a critic to discuss requirements and design trade-offs. Claude Code handled implementation within the project.
| Role I assigned | Main delivery in that round | What still had to be confirmed before handoff |
|---|---|---|
| Explorer | A sketch or mock | Which page, states, and placeholder data it represented |
| Critic | Requirements and specification notes | What had been decided, what remained disputed, and what the acceptance criteria were |
| Builder | Code changes and check results | The changed version, test scope, actual rendering, and publication status |
Role assignments do not define permanent product capability boundaries.
This does not mean that a web interface cannot write code or that Code cannot assist with visual design. Features change with versions, tools, and permissions, and users can choose another distribution of work. Three interfaces also do not establish that three models have been shown to be independent from one another.
I divided the roles so that the question each round needed to answer would remain clear.
Three Handoff Artifacts Turn Intent into Something Checkable
In this workflow, I mainly used three kinds of handoff artifacts: mock HTML to express a visual proposal, specification Markdown to record requirements and limits, and screenshots to preserve a particular version and screen state.
Handoff files should state their version, purpose, and unresolved questions.
If a sketch uses placeholder data, the next role should know that. If the specification contains an unresolved trade-off, the next round should not treat it as approved. A screenshot should be connected to the relevant version, viewport, and state so that its evidentiary scope is clear.
In my notes on synchronizing design data, I discussed bringing brand data into a workflow. Synchronizing some design data does not mean every sketch, specification, and screen will travel back and forth automatically or completely. The feedback path still has to be arranged and checked by a person.
Clear handoffs can reduce misunderstanding, but they cannot guarantee error-free collaboration.
What I Added Was Feedback, Not a Choice Between Pipelines and Loops
Even after a sketch is approved, implementation may reveal content lengths, interaction states, or screen sizes that were not considered earlier. I want the workflow to send those discoveries back rather than remove the opportunity for correction merely because one stage was marked complete.
A pipeline can include tests, returns, and rework. A loop can repeatedly return to the same mistake. The label alone does not determine quality.
A feedback path does not mean every round will make the right correction.
A more practical arrangement is to state what was discovered, what should change, and why the change is worthwhile before deciding whether to continue, revert, or stop. After a correction, the result still needs to be checked to see whether it addressed the original problem and whether it created new effects.
An Actual Screen Is Evidence, but Its Scope Is Limited
I bring screenshots of the actual page back into the discussion because they are more concrete than a description of what the design “should” look like. But a single image preserves only one screen at one moment; it does not establish that every function passed.
A screenshot can preserve one state, but it cannot replace complete functional acceptance.
A form may look reasonable on screen while submission, error messages, and data handling still require separate checks. The absence of overflow on desktop does not establish that mobile layouts, keyboard interaction, or other browsers are appropriate. The relevant checks depend on the scope of the change and the situations in which it will be used.
Likewise, a local rendering, a successful build, and the content served from the production domain are separate confirmations. Whether an article or page is live ultimately depends on the version readers actually receive.
The Human Retains Direction and Final Authorization
This arrangement continues the approach I described in multi-model collaboration: let roles contribute different perspectives, then bring the question back to information that can be checked.
AI can propose approaches, compare trade-offs, and point out issues I did not anticipate. I do not need to pretend that a tool cannot participate in discussions about value. In my own projects, however, I choose to retain human authority over the purpose, scope, and final execution.
Proposing options, deciding what to adopt, and actually executing a change are different responsibilities.
For me, the most important position at the center of the loop is not the role that endlessly demands another iteration. It is the role that can answer: What did this change solve? How far does the evidence extend? Is the result now sufficient?


💬 Comments
Loading...