When people talk about AI design tools, the default question is often: can AI draw for me? Can it make renderings? Can it turn one sentence into a model?

Those questions matter, but they are not the whole workflow a designer needs over time.

Designers do not only need a faster drawing button. They need a workbench that can hold design judgment across a project: where the intent lives, where source material lives, who maintains the rules, how the model state changes, how visual feedback returns to the design, and why each revision happened.

That is why I prefer to think in terms of an AI workbench for designers, not a chatbot, image generator, or automatic drafting plugin.

A workbench is different from a chat tool

Chat tools are good at answering questions. You can ask for color ideas, style references, spatial suggestions, circulation advice, or material options. They can provide inspiration and help organize language.

But a real design project does not stop at one answer.

A project changes over time. A client revises the brief. Site conditions shift. The budget tightens. A designer rejects yesterday’s decision. The model becomes inconsistent. A screenshot reveals a new problem.

If AI is only a chat interface, it struggles to answer questions like these:

  • What design rules are currently active?
  • Which dimensions came from source material, and which ones are inferred?
  • Which space did the last client comment actually change?
  • Should this rendering issue change the model, material, lighting, or just presentation?
  • What changed between the current version and the previous one?

The value of a workbench is that it does not treat conversation as the only container. It turns conversation into project state that can be saved, checked, and repaired.

The designer remains the judge

The most dangerous misunderstanding is that AI turns designers into people who merely give commands to a machine.

The better division of labor is the opposite.

AI can help with lower-level execution: organizing material, creating a first working model, trying variations, checking rules, preparing screenshots, recording versions, and translating feedback into concrete actions.

But the designer still owns the important judgment:

  • what the goal is;
  • which constraints cannot be broken;
  • what counts as a good proposal, not just a busy image;
  • which feedback should be accepted and which feedback is temporary noise;
  • which rules should be updated and which ones are only local exceptions.

A good AI design workbench should not turn the designer into a prompt operator. It should reduce repetitive drafting, searching, organizing, and repair work so the designer can focus on intent, tradeoffs, and acceptance.

A workbench needs at least six layers

From the outside, an AI design workbench may look like a natural-language request: “Make this living room better for reading.”

Behind that request, at least six layers should be active.

The first layer is design intent. The AI needs to understand the problem you are trying to solve, not only the words you typed.

The second layer is project material. Floor plans, references, components, materials, constraints, client feedback, and site information need provenance.

The third layer is a structured model. A design cannot live only in screenshots and chat history. Spaces, dimensions, components, rules, assumptions, and versions need an editable fact layer.

The fourth layer is design rules. Personal preferences, project requirements, session instructions, and product defaults may all exist at the same time. Their priority has to be explicit.

The fifth layer is professional software execution. AI should not only give advice. It should be able to execute structured design state into tools such as SketchUp.

The sixth layer is visual review and repair. Screenshots, renderings, and top views can reveal problems, but they should not become the final source of truth. Accepted feedback should return to the structured model, rules, or source evidence.

When these layers work together, a design project is no longer a loose pile of chat suggestions and images.

SketchUp Agent Harness is one example

The core idea behind SketchUp Agent Harness is that natural-language control of SketchUp is only the entry point. The more important question is how to turn a design project into a durable workflow.

In that direction, Codex or Claude is not the entire product. They are entry points into the workbench. The important pieces are the project workspace, structured design model, runtime skills, SketchUp bridge, component information, import evidence, snapshot records, and repair loop.

This does not mean the product is already mature enough for every design scenario. Many parts still need iteration: better floor-plan import, more reliable component libraries, richer design rules, and a stronger visual feedback loop.

But the direction is clear: an AI design tool should not only chase “type one sentence and get a result.” It should help designers maintain a design project that remains editable, traceable, and repairable over time.

What this series covers

This series is not a low-level protocol guide, and it is not a developer architecture document. It is about how designers can collaborate with AI.

The next pieces will discuss:

  • why a designer’s core value is judgment and tradeoff, not faster drafting;
  • why chat advice should become a durable design project;
  • how visual feedback can move from “this looks wrong” into a structured change;
  • which rule should win when personal preferences, project constraints, and current instructions conflict.

My position is simple: AI should not take over the designer’s judgment. It should become the designer’s workbench, organizing intent, material, rules, model state, feedback, and repair so real projects can move forward more reliably.