When AI enters design tools, the most common misunderstanding is that designers can finally "draw with one sentence."
That is attractive. Fewer manual steps, fewer menu clicks, and less repeated operation are real improvements.
But if an AI design tool only moves designers from manually operating software to verbally operating software, it is not enough. The designer has only moved from being a mouse-and-shortcut operator to being a prompt-and-chat operator.
The more valuable direction is not to make designers faster drafting operators. It is to help designers spend more of their energy on ideas, judgment, constraints, and tradeoffs.
Drafting Is Not Low-Value, But It Is Not All of Design
To be clear: drafting is not low-value work.
Drawings, models, sketches, and renders are design language. Without expression, design judgment cannot be communicated or checked.
The problem is that real design work often spends too much time on repeated execution rather than judgment:
- placing the same type of component in the right position
- adjusting dimensions and clearances according to rules
- filling in walls, openings, and furniture from existing boundaries
- moving back and forth between several versions
- turning verbal feedback into model changes
- repeatedly checking whether drawings, models, and screenshots still match
These tasks require patience and precision, but they do not all need to be executed line by line by the designer.
The irreplaceable part of design is deciding what is worth doing, why it should be done that way, which constraints cannot be broken, where compromise is acceptable, and whether the final expression still matches the intent.
AI design tools should serve that judgment instead of producing more output that the designer has to inspect and repair.
"One-Sentence Design" Can Hide the Real Problem
If a tool's main promise is "type one sentence and generate a space," it can hide complexity very quickly.
A generated bathroom, living room, or exhibition booth may look plausible. That does not mean the design workflow is working.
The designer still needs to know:
- whether the dimensions are credible
- where the walls and openings came from
- whether components have semantics and dimensions
- whether clearances have been checked
- whether visual feedback can return to the model
- whether the AI can still understand the current state next time
If those questions have no answer, AI has only compressed execution into a result. It makes the first generation faster, but it does not make ongoing design more stable.
That is why AI design tools should not optimize only for prompt-to-image or prompt-to-scene. They need to organize design work as a continuing workflow.
What a Better Workflow Looks Like
In my view of SketchUp Agent Harness, an AI tool for designers should at least support this chain:
design intent
-> project directory
-> structured working model
-> design rules
-> components and source evidence
-> SketchUp execution
-> visual review
-> structured repair
The key point is that the designer is not dealing with a black-box output. The designer is maintaining a project.
A designer can express a goal in natural language:
"Create a 2 m by 1.8 m bathroom with a toilet, vanity, door, mirror, basic lighting, and a clearance check."
But the agent should not only turn that sentence into a picture. It should turn the request into project state: space dimensions, components, rules, assumptions, clearance checks, an execution plan, and a repairable model.
Next time, the designer should not need to start over. They should continue from an existing project state.
Designers Should Control Judgment, Not Every Execution Detail
AI can take on more low-level execution, but it should not take away design judgment.
A better division of labor is:
- AI organizes project state
- AI executes repeated modeling actions
- AI turns source evidence into a first working model
- AI checks structural problems
- AI turns visual feedback into repairable actions
- designers decide direction, constraints, tradeoffs, and acceptance criteria
This does not make designers less involved. It moves their involvement to the level where it matters more.
If designers still have to confirm every line, every object, and every small position, AI has only added a new interface.
If a designer can say "this opening should not be sealed," "this wall is too thick," or "this area is not a room, it is an exterior void," and the agent can write that feedback back into the structured model, then AI is starting to support real design work.
Runtime Skills Should Serve Design Tasks
This is why I treat runtime skills as an important part of design tools.
A designer-facing skill should not be a maintainer's development note. It should not expose internal product implementation details.
It should serve real design tasks, such as:
- space planning
- floor plan import
- component search
- design rules
- semantic placement
- visual feedback
- structured repair
The role of these skills is not to give the AI a few prompting tricks. Their role is to help the agent know how to act in a specific design context, how to respect project state, and how to avoid turning a local project decision into a global product rule.
Runtime skills are part of the design workflow, not marketing packaging.
Local Project Memory Must Not Pollute Product Rules
AI design tools also face a practical problem: every design project has local facts.
The orientation of one floor plan, a client's preference, a scale correction for one import, or a room naming convention may belong only to the current project.
If the agent writes those local facts into product defaults, the product will quickly become unstable.
A better approach is layered:
- product runtime skills hold general design task capability
- project or session memory serves only the current project
- maintainer development skills serve product development and release work
- only generalized and validated patterns move into central knowledge or product rules
This layering is not engineering neatness for its own sake. It protects the designer's work boundary and the privacy of client materials.
AI Should Reduce Noise, Not Create More Drafts
A weak AI design tool generates endless options and leaves selection, repair, explanation, and finishing work to the designer.
A better AI design tool should reduce noise.
It should help designers reach a state they can judge, not produce a pile of results that cannot continue.
For designers, the valuable outcome is not "AI gave me many images." The valuable outcome is:
- I can understand why the current proposal looks this way
- I can point out a problem
- AI can turn the problem into a structured change
- I can keep versions
- I can keep moving instead of restarting
That is workflow-level efficiency.
Conclusion
I do not think AI makes designers less important.
If the tool is designed well, AI can release designers from a large amount of low-level execution and help them focus on intent, judgment, constraints, review, and tradeoffs.
But the tool itself has to respect design workflow.
It cannot only pursue "type one sentence and generate a result." It has to maintain project state, preserve source evidence, execute into professional software, accept visual feedback, and write that feedback back into structured truth.
Designers should not become drafting operators in the AI era.
Designers should become directors of the design workflow.
Originally published on my personal site:
https://marlinbian-site.pages.dev/writing/designers-should-think-not-draft/
More links: GitHub · YouTube · LinkedIn · Bluesky · Mastodon · Discord
Top comments (0)