IDE 495 · Prototyping for Experience  ·  MicroArtistry 2026

AI amplifies the quality of
your thinking.

A field guide to productive AI workflows and ethical practice for designers, artists, and engineers who build things.

Part 01  ·  The Mental Model

What AI is — and isn't — in a design context.

Before you touch a tool, build the right mental model. AI in design is not magic, not a shortcut, and not a replacement for your judgment. It is a translation engine: it translates your intent into form. The quality of what comes out is directly determined by the quality of what you put in.

01

Specificity produces resonance.

AI is a translation engine, not a creativity engine. It translates your intent into form. Vague intent produces vague output — usable, pleasant, and forgettable. A specific emotional argument, a precise context, a clear constraint: these produce output that means something because you gave it something to mean.

"Hopeful" is not a prompt. "The kind of hope that has already made peace with uncertainty" is a prompt.
02

Context is everything — and you build it.

AI knows nothing about your project until you tell it. It doesn't know your design argument, your user, your tone, your constraints, or your influences. Every time you start a session or a new prompt chain, you are starting from zero unless you actively feed in context. Your job is to build that context — and keep feeding it in.

Write a Design Intent Document. Paste it at the start of every session. This one practice changes everything.
03

The last mile of judgment is always yours.

AI can generate a hundred options in the time it used to take you to sketch one. None of them are good or bad until you say so. Choosing what aligns with your design argument — and being able to say why — is where your authorship lives. Accept nothing you can't explain. Discard freely. The curation is the design work.

If you can't say why you kept something, you haven't made a design decision yet.
Capability Map

What AI is strong at — and where it misleads.

Strong at
  • Generating many variations quickly
  • Translating intent into code syntax
  • Producing plausible first drafts
  • Suggesting alternatives you hadn't considered
  • Explaining what existing code or systems do
  • Diagnosing errors from symptom descriptions
  • Maintaining style and structure across iterations
Weak at — or misleading in
  • Knowing what's good — that's your job
  • Understanding your design argument without context
  • Producing original ideas (it recombines what it's seen)
  • Catching its own confident errors
  • Representing all bodies, cultures, and aesthetics equally
  • Knowing when to stop generating
  • Telling you what it doesn't know
Part 02  ·  Productive Workflows

Design with AI, not through it.

These workflows are organized around what you're trying to build — not around specific tools. The tools change; the design practice doesn't. In every workflow, the principle is the same: you bring the intent, AI brings the execution speed. The judgment is yours.

Before any workflow: build your context.

AI doesn't know your project. You have to tell it — and you have to tell it every session, because AI has no memory between conversations. The single highest-leverage practice in this entire guide is writing a short Design Intent Document and pasting it at the start of every AI conversation. It takes five minutes. It saves you from spending the whole session wrestling AI back toward your argument.

Design Intent Document — Template
Project:What you're making and for whom.
Design argument:What you want a user to feel, think, or understand.
Tone:Hopeful / Cautionary / Ambiguous — and what that means for this project.
Constraints:Budget, materials, platform, time, skill level.
Influences:References, precedents, works you're in conversation with.
What I need right now:The specific task for this session.
</>

Vibe Coding

Web / App / Interactive behavior
Direct AI to write code by describing what you want it to do and feel — not by describing the code structure you think you need. Stay at the level of design intent. The syntax is AI's problem; the experience is yours.
Describe the interaction the way a user would experience it. "When someone hovers over this element, I want them to feel a slight hesitation — like the interface is making a decision." That's a prompt. "Add a CSS transition" is a task, not a design brief.
Prompt structure
I'm building [type of experience]. When [user action], I want the user to feel [emotional quality]. The response should feel [characteristic — immediate/delayed/weighted/playful]. Here is the current code: [paste]. Revise so that [design goal].
Pitfall: Accepting code you can't explain. If you can't describe what the code does in plain language, you don't own it yet. Ask AI to explain every block before you move on.
Explore →

Microcontroller Programming

Arduino / ESP32 / Sensors / Actuators
Use AI to write firmware for physical computing — sensor reads, output control, timing loops, state machines, communication protocols. The approach is the same as vibe coding: describe the physical behavior you want before you ask for code.
Describe the physical event chain before asking for code. "When the distance sensor reads under 30cm, I want the LED to pulse twice — fast — then hold at low brightness." That's a spec. That's what produces usable firmware.
Prompt structure
I'm using [Arduino Uno / ESP32 / etc.]. My setup: [sensor type on pin X], [output type on pin Y]. Behavior: when [condition], [output] should [response]. The feeling should be [quality]. Write Arduino code and include comments explaining each section.
Pitfall: AI makes confident errors in pin assignments, timing values, and library calls that only surface on hardware. Always test generated code on the actual board before assuming it's correct.
Explore →

Hardware Troubleshooting

Wiring / Power / Sensors / Serial debug
When physical systems fail, AI is a strong diagnostic partner — if you give it enough to work with. The more specific your symptom description, the more targeted the diagnosis. "It doesn't work" gets you a checklist. A precise symptom gets you a root cause.
Describe the symptom, not your theory about the cause. Your theory may be wrong; the symptom is a fact. Tell AI what you expected to happen, exactly what happened instead, and what your serial output shows.
Prompt structure
Component: [name, model if known]. Connected to: [pin / bus / power rail]. Expected behavior: [X]. Actual behavior: [Y]. What I've already tried: [Z]. Serial output: [paste]. Code: [paste relevant section]. What could cause this?
Pitfall: Skipping the serial output step. Most hardware bugs are visible in serial output — if you're not checking it, you're troubleshooting blind and so is AI.
Explore →

User Interface Development

HTML / CSS / JS / Data visualization
Build web-based UIs — control interfaces, data dashboards, interactive experiences, presentation layers — through AI-generated HTML/CSS/JS. Design the emotional register of the interface before you describe the components. What should a user feel when the page loads?
Aesthetic intent first, component list second. If you open with "I need a nav bar and three cards," you'll get the most generic version of that layout. If you open with the emotional experience you're designing for, AI will make different choices.
Prompt structure
Build a [type of interface] for [purpose]. The visual feel should be [aesthetic qualities — dark/minimal/warm/etc.]. The user should feel [emotional quality] when they first see it. Color palette: []. Typography feel: []. Key interactions: [list]. Output a single self-contained HTML file.
Pitfall: Not pushing back on the default aesthetic. AI's default UI style is clean, bright, and generic. Name the aesthetic you want in the first prompt — or you'll spend your time undoing instead of building.
Explore →

Image Generation

Visual ideation / Concept / Assets
Use AI image tools for rapid visual ideation, concept communication, mood board building, and placeholder assets. Image generation rewards emotional specificity above almost everything else — the more precisely you name the feeling, the more the image delivers it.
Specificity is craft. "Hopeful" produces stock imagery. "The kind of hope that has already made peace with uncertainty" produces something that could only mean one thing. The difference between those two prompts is the difference between a placeholder and a design argument.
Prompt structure
[Scene: who/what, setting, time] — [Emotion target: specific, grounded in a situation] — [Technique: lighting, medium feel, color temperature, framing] — [What it should do for a viewer: which Norman level]
Pitfall: Using the first generated image. The first output reveals what's possible; the second or third — after critique and revision — is where the design work actually happens. Treat generation as a conversation, not a delivery.
Explore →

Documentation & Design Writing

Process docs / Rationale / Reflection
Use AI to help you articulate, structure, and refine your design rationale — not to generate it. Your job is to have the thoughts; AI's job is to help you get them from your head into clear language. The design argument must come from you first.
Never ask AI to write your rationale from scratch. Give it your rough thinking — even bullet points and fragments — and ask it to help you find what you're actually trying to say. The difference: one produces your voice, the other produces generic design-speak.
Prompt structure
Here are my rough notes on [design decision]: [paste fragments]. Help me articulate the design argument I'm making. Keep my voice — don't smooth it into generic language. What I'm trying to say is approximately: [your attempt]. Make it clearer without making it someone else's.
Pitfall: Accepting polished-sounding output that doesn't actually represent your thinking. Read it aloud. If it doesn't sound like you defending your work, revise it until it does.
Explore →
Part 03  ·  Ethical Commitments

Being an honest and responsible AI designer.

These aren't rules imposed from outside — they're the practices of a designer who takes their work seriously. Transparency is a posture of confidence, not confession. Knowing where your authorship lives is a professional skill, not an admission. Each of these commitments makes you a better designer, not just a more ethical one.

01  ·  Authorship

Know where your creative contribution lives.

Your authorship is in the choices you made: what context you built, what emotional argument you brought, what you kept and what you discarded, and why. You can't claim authorship of work you accepted without evaluation. You can absolutely claim authorship of a rigorous, AI-assisted design process — if you can account for the decisions.

"I used AI to generate [X]. The design intent driving that generation — and every choice about what to keep — was mine."
02  ·  Transparency & Disclosure

Say what you used AI for — and what you didn't.

Transparency about AI use is a professional norm that's still being established. Be part of establishing it well. Name specifically what AI contributed to your work and what you contributed. The strongest version of this isn't "I used AI" — it's a precise account of the division of labor that reveals the quality of your design thinking.

"AI generated the initial firmware. I specified the sensor thresholds, the timing logic, and the behavior feel — and revised the output three times before the interaction felt right."
03  ·  Copyright & Style

Understand what "in the style of" actually means.

When you prompt "in the style of [artist]," AI reproduces patterns extracted from that artist's work — work that was in the training data, often without the artist's consent. That artist's style, developed over a career, is being imitated at scale. Use style prompts with full awareness of what you're doing, and consider whether the original artist would want their visual language used this way.

Use style references as inspiration points you can articulate, not copy-paste commands. Know whose work you're drawing on — and be able to say why.
04  ·  Bias & Representation

AI reflects its training data — which reflects historical inequity.

AI image and text models overrepresent certain bodies, aesthetics, cultures, and worldviews because that's what the training data contained. If you don't actively push back on defaults, you're inheriting and reproducing those biases in your work. Notice who appears in your generated images. Notice whose design aesthetic reads as "neutral." It isn't.

Actively specify representation in your prompts. If you're designing for a particular community, make that specificity visible in what you generate — don't let the model's defaults make that decision for you.
05  ·  Energy & Environment

AI has a real environmental cost that's easy to ignore.

Generating images, running large language models, and training AI systems consume significant amounts of energy and water for cooling — far more than most users realize. This cost is invisible in the interface, which makes it easy to use AI habitually rather than intentionally. Use AI deliberately: iterate with purpose, not volume.

Generate fewer, more considered iterations. Twenty images with clear intent will teach you more and cost the environment less than two hundred generated because generation is easy.
06  ·  Data & Privacy

What you put in may not stay private.

Prompts, images, and text you enter into AI tools may be stored and used to improve future models, depending on the platform and your account settings. Treat AI conversations as semi-public spaces. Don't paste proprietary work, personal data, research data about human subjects, or anything that would be harmful if made public.

Check the data retention settings of every tool you use. Know the difference between what the interface implies and what the terms of service actually say.