How I AI: A Designer's Guide to Cursor with Elizabeth Lin – From Y2K Aesthetics to Interactive Pianos

Cursor is surprisingly good at generating visual chaos, interactive prototypes, and weirdly charming UI ideas. The harder part is knowing what to keep. Elizabeth Lin uses Cursor less like an automatic designer and more like a fast-moving creative partner that can generate layouts, animations, sound interactions, and stylistic variations she would never mock up manually.

Elizabeth is an independent design educator who has created programs for Khan Academy and Lambda School. Through Design Is a Party, she teaches designers how to prototype with Cursor without turning the work into a traditional engineering exercise. In this episode of How I AI, she treats code generation as a medium for exploration: rapid visual experiments, interactive behavior, and design iteration that would normally take much longer in tools like Figma.

Elizabeth explores Brutalist and Y2K homepage directions, builds a playable piano, and iterates on a generated dashboard until it resembles a real product rather than generic AI UI. Cursor generates aggressively while she edits, critiques, restores checkpoints, and narrows the work toward something intentional.

Using Cursor as a visual exploration partner

Elizabeth starts with conversation instead of generation. Before asking Cursor to redesign anything, she asks it what styles and visual movements it already understands well. That gives her vocabulary she can reuse later in prompts, especially for aesthetics she might not normally describe in precise visual terms.

Ask Cursor what aesthetics it understands

She begins with an intentionally bland homepage and opens Cursor chat without any styling attached. Instead of jumping directly to a redesign prompt, she asks Cursor which visual aesthetics and movements it can implement and how it describes them. The response includes references like cyberpunk, vaporwave, Brutalism, and Y2K alongside details about typography, motion, texture, color palettes, and effects.

Her first prompt is deliberately broad:

List design aesthetics and movements you can implement, and describe the visual characteristics of each one.

The point was not whether Cursor produced a perfect design-history summary. The design-aesthetic brainstorming workflow turns its vocabulary into prompt material for deliberate visual experiments.

Mix references and see what the model invents

After reviewing the style list, I choose a combination that should clash in interesting ways: Brutalist and Y2K. Elizabeth asks Cursor to redesign the homepage using both references at once and waits to see what emerges.

Redesign the homepage using Brutalist and Y2K visual references.

The generated homepage leaned heavily into early-web nostalgia. Cursor added a blinking command-line cursor, animated typing effects, glossy hover treatments, glowing UI elements, and exaggerated transitions. Elizabeth clearly enjoys the unpredictability of this stage. Some decisions are awkward, some are excessive, but several are directions she would not have explored on her own. Instead of evaluating the output as a finished design, she evaluates it as creative raw material. The glow effect is over-the-top, but maybe worth refining. The typing animation is technically impressive even if it needs restraint. The value comes from reacting to the output and steering from there.

Restore checkpoints before the rabbit hole gets too deep

One of Elizabeth's strongest practical habits is restoring checkpoints constantly. Before rerunning a prompt or trying a new direction, she reverts to a known state. She warns that once a project drifts too far into bad iterations, it becomes harder to recover. Restore checkpoints and Git commits keep experimentation reversible.

Redesign the homepage using Brutalist and Y2K visual references.

When she reran the exact same Brutalist-and-Y2K prompt from a clean checkpoint, Cursor generated something completely different: a more restrained layout with cleaner typography and fewer dramatic effects. Comparing both versions side by side helped surface specific preferences. I missed the glow from the first version. Elizabeth preferred parts of the cleaner hierarchy from the second. The exercise became less about finding a perfect output and more about identifying which individual ideas deserved another round of refinement.

Building interactive prototypes that static mockups cannot show

The most convincing part of the episode is Elizabeth's playable piano prototype. Instead of generating another static landing page, she uses Cursor to build something interactive with sound, animation, and browser behavior. It demonstrates why designers are increasingly interested in code-native prototyping tools.

Automate repetitive setup with Cursor Rules

Elizabeth keeps all of her prototypes inside a reusable playground project. A simple Cursor Rule tells the agent that whenever she asks for a new prototype, it should duplicate a template folder and register the new project on the homepage automatically. The rule itself is short, but it removes a surprising amount of repetitive setup work.

If I ask you to create a new prototype, copy this folder and then add it to my homepage.

That lightweight automation lets her focus on interaction design instead of scaffolding. She still reviews the generated file structure, imports, dependencies, and changed paths afterward, but the repetitive boilerplate disappears. It is a practical example of using AI tooling to reduce friction instead of surrendering control.

Generate a working instrument from one prompt

Starting from a fresh chat, Elizabeth asks Cursor to create a digital piano prototype in an old Mac OS-inspired visual style. She intentionally starts a new conversation because lingering context from earlier chats can influence the result unpredictably.

Create a digital piano prototype in an old Mac OS-inspired visual style.

Cursor generates a clickable piano with retro styling, playable keys, waveform controls, and sound. The interactive piano workflow shows how Elizabeth gets from one prompt to a testable interaction while reserving browser, input, accessibility, and latency review for humans.

Interrogate the prototype instead of accepting it blindly

Elizabeth does not stop once the piano works. She asks Cursor follow-up questions about how the sound generation works, which audio libraries it used, and what kinds of waveform controls are available. That conversational layer matters because it exposes additional creative possibilities. A designer who understands the available sound options can start experimenting with entirely different moods, instruments, or interaction feedback systems without needing to hand-code the implementation.

Turning an ugly AI dashboard into something usable

Elizabeth's dashboard redesign demo is the clearest example of AI-assisted art direction rather than AI autopilot. She starts with a generic personal-finance dashboard full of heavy shadows, inconsistent spacing, noisy colors, and awkward typography. Instead of replacing it entirely, she critiques it iteratively like a design lead reviewing junior work.

Give targeted critique instead of one giant prompt

Her first correction focuses on concrete visual problems. She asks Cursor to remove the drop shadows, simplify the components, and reference modern financial-product interfaces. Elizabeth prefers short conversational prompts because long requirement lists often cause the model to ignore later instructions.

Remove the drop shadows, simplify the components, and use a restrained visual system informed by modern financial-product interfaces.

Her feedback combines three different kinds of direction:

1. Remove a specific treatment she dislikes, especially the heavy drop shadows.
2. Define the intended visual character through simpler components and clearer hierarchy.
3. Reference products and design systems that communicate the right level of polish without copying them directly.

The next version immediately looked calmer. Cursor replaced the shadows with borders, simplified the layout, and introduced more structure. Elizabeth still spotted problems though, including awkward typography and background treatments that did not fully extend across the page. Instead of dumping every critique into one message, she fixed the most distracting issue first and continued iterating from there.

Use design principles as shorthand

For the next iteration, Elizabeth references Edward Tufte's information-design principles and asks Cursor to simplify the dashboard's colors. The reference acts as compressed design language. Instead of explaining chart hierarchy, restraint, and information density manually, she invokes a recognizable design philosophy that the model broadly understands.

Simplify the page’s colors and apply principles associated with Edward Tufte’s information design.

The interface became quieter and more structured, but Elizabeth still judged whether the charts communicated clearly. The design-principles iteration workflow shows how targeted critique and named principles guide successive revisions without turning taste into autopilot.

Prompt for taste, then review aggressively

In the final round, Elizabeth experiments with a more aspirational instruction. Instead of specifying grids or spacing rules directly, she asks Cursor to improve the layout to a standard an experienced Apple product designer would approve of.

Improve the layout to the standard you would expect from an experienced Apple product designer.

The phrasing worked surprisingly well. Cursor reorganized the layout into a cleaner grid and distributed information more evenly across the page. Elizabeth treats this kind of role-based prompting as a heuristic rather than magic. The model is not applying an official Apple review process or guaranteed design expertise. It is pattern-matching against a broad set of associations about clarity, spacing, and product polish. Human judgment still decides whether the result is coherent, original, accessible, and appropriate.

Design judgment remains the review system

Throughout the episode, the most useful pattern is not the prompts themselves. It is Elizabeth's willingness to critique aggressively, restart often, and treat generated output as disposable until something genuinely interesting appears. Cursor generates options quickly, but taste still comes from selecting references, identifying weak decisions, and knowing when a flashy effect is adding delight versus clutter.

She also demonstrates a bookshelf prototype powered by a Notion database, showing how Cursor becomes more valuable once prototypes use real structured content instead of placeholder lorem ipsum. Connecting prototypes to actual datasets exposes edge cases, browsing behavior, and information density much earlier in the design process. At the same time, she stresses using approved or synthetic datasets rather than exposing personal records or sensitive information.

The workflows in this episode work best for designers who already know how to critique interfaces but want faster ways to explore interaction, motion, sound, and visual direction. Cursor is especially strong when the goal is experimentation: testing aesthetics, generating interactive behaviors, or rapidly iterating on rough concepts. It is much weaker as an unsupervised product designer. The parts worth copying are Elizabeth's process habits: save checkpoints constantly, iterate on one problem at a time, collect prompts that worked well, and feed the model broader creative references than standard app design galleries. Human judgment still determines whether the result is coherent, accessible, on-brand, and worth shipping.