Learning to See: What Art Can Teach a Frontend Engineer

For a long time, I thought building a good interface was mostly about getting things right.

The layout should be aligned. The spacing should be consistent. The colors should work together. The components should be reusable. The code should be clean.

And, of course, all of these things matter.

But the more I explore the creative side of building digital products, the more I realize that there's something else worth learning.

The ability to see.

Not just to look at an interface, but to understand why it feels the way it does.

Looking is easy. Seeing takes practice.

Imagine two interfaces built with the same components, similar colors, and almost identical layouts.

One feels balanced, calm, and effortless. The other feels crowded, awkward, or somehow unfinished.

Both might follow the same spacing system. Both might use consistent typography. Both might be technically sound.

Yet something feels different.

Perhaps it's the relationship between the elements. Perhaps the visual weight is distributed differently. Perhaps one gives your eyes room to rest while the other demands attention from everywhere at once.

These differences aren't always obvious when you're focused on individual components.

You begin to notice them when you step back and look at the whole.

And I think this is where an artistic eye starts to matter.

What drawing teaches us about interfaces

When you draw something, you gradually learn that observing an object is different from simply recognizing it.

You might know what a face looks like, but drawing one requires you to pay attention to proportions, shadows, negative space, and the relationships between individual features.

You stop drawing what you think you see and start looking more carefully at what's actually there.

I find this idea interesting when applied to interface design.

It's easy to look at a website and see a collection of familiar elements: headings, buttons, cards, images, and navigation bars.

But what happens when you look beyond those individual elements?

You begin noticing how the whitespace shapes the composition, how typography establishes hierarchy, how contrast directs attention, and how the smallest changes in proportion can influence the entire experience.

The interface becomes more than a collection of components. It becomes a composition.

Perhaps developing an artistic eye isn't about making everything look beautiful. Perhaps it begins with learning to notice things you previously overlooked.

Code teaches precision. Design asks for judgment.

As engineers, we're trained to think about structure, logic, consistency, and correctness.

We ask whether something works, whether it scales, whether it's maintainable, and whether it solves the problem.

These are important questions. But visual experiences introduce another layer.

Does this feel right?

Is the hierarchy clear without being obvious? Does the animation communicate something, or is it simply moving because it can? Does the interface invite exploration, or does everything compete for attention?

These questions don't always have a single correct answer.

That's what makes them interesting.

You can follow a design system perfectly and still produce an interface that feels visually unbalanced. You can implement every detail from a Figma file and still miss the intention behind the design.

Because understanding a design is different from reproducing it.

When you understand why an element has prominence, why a section needs space, or why an interaction happens at a particular moment, you can make better decisions when the original design doesn't provide every answer.

You move beyond implementation and begin participating in the design process itself.

Sometimes, less is a better decision

It's easy to become fascinated by details.

A carefully crafted hover effect. A beautiful gradient. A clever transition. A perfectly aligned icon.

I enjoy exploring these things, too.

But a collection of beautiful details doesn't automatically create a beautiful experience.

Sometimes, adding another animation makes the page feel busier. Another color weakens the visual hierarchy. Another decorative element distracts from the message.

And sometimes, removing something makes the entire composition work better.

This is one of the most interesting aspects of visual design: the solution isn't always to add more.

You might spend time experimenting with different treatments, only to discover that the simplest version communicates the idea most effectively.

That simplicity isn't necessarily the result of doing less work. It can come from understanding what deserves attention and what doesn't.

Good visual judgment isn't just knowing what to add. It's recognizing what doesn't need to be there.

Learning to see is a practice

I don't think developing an artistic eye is reserved for people who studied art or design formally.

It's something we can develop through observation and experimentation.

Look at a website you admire. Instead of immediately asking how it was built, ask why it works.

Where does your attention go first?

What makes the composition feel balanced?

How does the typography influence the mood?

Why does one section feel spacious while another feels dense?

What happens when an element moves? Does the movement guide your attention or distract you?

Then experiment.

Change the spacing. Adjust the proportions. Remove an element. Try a different type scale. Slow down an animation. Compare the results.

Don't just recreate what you see. Try to understand the decisions behind it.

The same curiosity can be applied to drawing, photography, architecture, films, or almost anything visual. Each offers another opportunity to observe how composition, light, contrast, rhythm, and space influence the way we experience something.

Over time, these observations can become part of how you approach your work.

You begin seeing more possibilities, asking better questions, and making decisions with greater intention.

Somewhere between art and engineering

I'm increasingly interested in the space between designing an experience and engineering it.

It's a space where visual judgment meets technical decisions, where interaction becomes part of the design, and where code can be more than a way to reproduce a static layout.

It can become a medium for exploration.

An idea can be tested through motion. A visual concept can become interactive. A small experiment can reveal something that wasn't obvious in a Figma file.

Technology gives us the ability to build these experiences. Design helps us decide what those experiences should communicate. Art can teach us to pay closer attention to the details that shape how they're perceived.

I don't think the goal is to make everything more elaborate or visually impressive.

Sometimes, the most meaningful result is an experience that feels simple because someone paid attention to all the things that could have made it complicated.

That's the kind of thinking I want to develop as an engineer: not just the ability to build something that works, but the judgment to understand how it looks, feels, and communicates.

I'm still learning.

And maybe the next step isn't always learning another framework, animation library, or design tool.

Maybe it's learning to see a little better before deciding what to build.