The Ideas Were Always There

I have a notebook. Physical, spiral-bound, nothing fancy. I've kept versions of it for most of my career. It's where ideas go that don't have a home yet.

A swipe interaction that teaches a complex concept through progressive layers. A data visualization that lets you feel the weight of a number instead of just reading it. An onboarding flow that adapts its pace to the user's confidence. An interface that treats negative space as a functional element, not just aesthetic padding.

Good ideas. Some of them great, honestly. All of them shelved. Not because they were impractical in theory, but because I could calculate the implementation cost in my sleep. I knew what the component architecture looked like. I knew how many responsive breakpoints needed custom handling. I knew the state management would be a headache. The ideas weren't impossible — they were expensive. And in a world of sprints and handoffs, expensive ideas die quietly in backlog grooming sessions, labeled "nice to have" by someone who's never had a nice idea.

So they lived in the notebook. And every year, the notebook got thicker.

The Invisible Editor

Here's what nobody tells you about creative constraint — especially when you understand both design and development. It doesn't just limit what you build. It limits what you allow yourself to imagine. And it does it so gradually that you don't notice it's happening.

After enough years of running the cost-benefit calculation in your head before you even sketch an idea, your brain starts doing the editing automatically. You skip entire categories of solutions because you can see the implementation complexity too clearly. You default to patterns you know are efficient to build. You optimize for shippability instead of excellence.

Knowing code makes this worse, not better. A designer who doesn't code might propose the ambitious idea and let someone else figure out the build. A designer who codes knows exactly why it's hard, and self-edits before the idea fully forms. You kill the concept at the speed of thought. It's very efficient self-sabotage.

I didn't realize how much I'd been self-censoring until the constraint disappeared.

Two Hours and Three Years

The first time I built something from the notebook, it was almost accidental. I was between client tasks, had maybe two hours, and remembered a concept I'd sketched years ago — an interactive component that explained a complex process through layered reveals. You'd start with the simplest version, and each interaction would add a layer of detail. Not a tutorial. Not a tooltip. A spatial unfolding of information.

I knew exactly what this required. A container with multiple positioned layers, opacity and transform transitions orchestrated through state, scroll-triggered or click-triggered progression, and responsive behavior that couldn't just stack vertically on mobile — it needed a fundamentally different interaction pattern at small viewports.

In the old world, that's a week. Easy.

I described the concept and the technical approach to Claude Code. Twenty minutes later, I had a working prototype. Not a mockup. A thing I could click through and feel.

It wasn't perfect. The timing needed work — the easing curves were generic and the stagger between layers was too uniform. One of the transitions felt abrupt where it should have been fluid. I could see in the CSS that the transition-timing-function was linear where it needed a custom cubic-bezier. I corrected it, refined the stagger values, adjusted the transform origins so the reveals felt like they were emerging from a natural anchor point.

Two hours. An idea I'd been carrying for three years. Built, refined, and functional.

I sat there for a minute. Then I opened the notebook.

The Uncorking

What followed was something I can only describe as a creative uncorking. I started pulling ideas off the shelf — some recent, some years old — and building them. Not all of them worked. Some concepts that seemed brilliant in the notebook turned out to be mediocre in practice. (One idea I'd been precious about for two years lasted approximately four minutes in a browser before I deleted it. Humbling. Necessary.) That's fine. That's design. The point is I could find out in an afternoon instead of never finding out at all.

A few things happened that I didn't expect.

First, the old ideas evolved. An interaction pattern I'd sketched in 2019 combined with something I'd learned about CSS container queries in 2023, and the result was better than either idea alone. Ideas that had been frozen in amber started cross-pollinating because I was actually working with them instead of just storing them. The technical landscape had changed since I'd originally conceived them, and building them now meant building them better.

Second, the volume of new ideas increased. Dramatically. When your brain stops filtering for feasibility — when the cost calculation no longer kills ideas in the cradle — it generates more freely. I started waking up with concepts. Seeing interfaces in everyday experiences. Noticing interaction opportunities in physical spaces and translating them to digital. The creative faucet, which I hadn't realized was barely dripping, opened up.

Third — and this one caught me off guard — the quality of all my work improved. Not because the tool made it better, but because I was exercising creative muscles that had atrophied under the weight of practical estimation. When you spend your personal time exploring ambitious, experimental ideas, you bring that expansiveness back to everything — the full-time product role, the solo practice client, the internal tools you build for your own business. I started proposing solutions I wouldn't have proposed six months earlier. Not reckless ones. Better ones. Ideas with more range, more nuance, more consideration for how the experience actually feels.

What This Actually Looks Like

I want to be specific about what this looks like in practice, because "creative freedom" is easy to romanticize and hard to make tangible.

Last month I built three things that wouldn't have existed in my old workflow:

For a solo practice client — an interactive wine region explorer with 3D terrain visualization that lets you understand how elevation, aspect, and microclimate affect what grows where. Mapbox GL with custom tile layers, terrain exaggeration, dynamic camera positions, and responsive controls. In the old world, this is a multi-week development project requiring a mapping specialist. I built it in a day — not because the code was trivial, but because I could direct the implementation with precision. I knew what Mapbox's API expected. I knew how the CSS needed to handle the map container at different viewports. I could work at both levels simultaneously.

For my own business — a proposal document system that generates branded, polished PDFs with dynamic content. Not a template, but a layout engine that makes intelligent decisions about page composition. Typography, spacing, visual hierarchy, all systematized. Previously, this would have been a custom development project with its own timeline and budget. Done in an afternoon. (The PDF rendering pipeline alone would have been a two-day rabbit hole in the old world. I know because I've been in that rabbit hole. It's dark down there.)

For a full-time product role — a data visualization layer within an AI platform dashboard that responds to the user's interaction history, surfacing the metrics they care about and dimming the ones they don't. The interaction design, the responsive behavior, the transition choreography between states — all of that would have been a multi-day design exercise in Sketch, followed by a week of implementation and back-and-forth with the engineering team. I iterated through the entire thing in a single session and handed off working code for the engineers to integrate.

None of these are revolutionary in concept. Designers think about this stuff all the time. The revolution is that I built all three. In a month. Across my solo practice and full-time product work. While context-switching between a winery client and an enterprise AI platform.

There's a metaphor I keep coming back to. For most of my career, I've been a chef who designs incredible recipes and knows exactly how to cook them — but only has time to cook one at a time, slowly, while the rest sit in a recipe box. I knew the techniques. I understood the chemistry. I just couldn't execute at the speed of my imagination.

Now I can. Every dish, start to finish. And the recipe box is finally getting lighter.

The notebook still exists. I still write in it. But the ideas don't stay there long anymore. They move from concept to reality in hours instead of never. And that changes the relationship you have with your own creativity.

You stop being a designer who has ideas. You become a designer who builds them.

This is Part 4 of a series on the shift from traditional design workflow to code-first with AI. Next up: the craft question — does AI-assisted code actually meet a professional quality bar?