Lull is a browser-based ambient instrument. You open it, press play, and it slowly fills a room with evolving sound. Every bounce triggers a sound. The visuals and audio are the same system — change one, you change the other. Leave it on AUTO and it quietly shifts itself, like weather.
It's live at lull.entifydesign.com.
The app is about 4.5MB across a handful of files. Not the tidiest architecture, but it works, it ships, and it sounds good. Sometimes that's what matters.

Keeping the whole picture in mind.
Lull has a lot of moving parts that all connect to each other. The audio processing, the physics, the visual states, the controls — they're deeply intertwined. When I described a new behaviour I wanted, Claude Code understood how it fit into everything that already existed. It didn't just write code in isolation; it worked within the system.
For anyone who's briefed a developer and had them build something that technically works but breaks three other things — this is the difference. Context retention is the real superpower.
‍
Getting things right quickly.
Adding a new control. Connecting it to the physics. Adjusting a visual behaviour. Changing how the auto mode drifts. These came back clean, on the first try, fast. The iteration speed for well-defined tasks is genuinely unlike anything I'd experienced before.
‍
Remembering constraints so I didn't have to.
There's an undocumented rendering limit on how long a script block can get — I discovered it the hard way. After that, I kept a reference document tracking every constraint. But Claude Code was already flagging it unprompted: "This section is near the limit. New code should go elsewhere." It held the guardrails even when I forgot they were there.

How much I became the director, not the maker.
I expected to spend most of my time figuring out how to build things. What actually happened was that I spent most of my time figuring out what to build — what the right interaction should feel like, how features should relate to each other, what the experience would be like at 2am with headphones on.
Claude Code handled execution. My job became vision, taste, and judgment. That's a meaningful shift.
‍
How faithfully it follows a design system.
The dial component in Lull is specified in detail: exact size, fill colour, a white dot indicator, an arc that appears only while dragging, a label that flips to the current value mid-drag and back on release — all laid out in Figma. Claude Code implemented every state, every edge case, consistently across every instance in the app. For designers: if you can describe what you want with precision, it builds it that way. Your design rigour directly determines the quality of what you get back.
‍
The moments where it went confidently in the wrong direction.
This did happen. Occasionally a solution would be structurally off — patching something that needed rebuilding, or resolving a symptom without addressing the cause. Claude Code doesn't flag its own blind spots. Catching those moments is on you. It rewards people who know what good looks like and can recognise when something isn't quite there yet.
‍
How much a good brief changes everything.
I ended up writing a detailed reference document — every constant, every known limit, every key behaviour. Not because Claude Code forgets mid-session, but because a clear brief means every session starts sharp. Think of it like onboarding a very talented collaborator: the more context you give them, the better the work.

‍

Define the structure before building anything.
The architecture of Lull emerged through iteration. It works — but some of those decisions were expensive to undo. Starting with a clear structural brief, even a rough one, would have saved time and avoided a few painful refactors.
‍
State constraints explicitly from the start.
Claude Code respects boundaries when you give them. It doesn't always infer them. "Don't change this section" or "use the existing function, don't create a new one" — say it directly. Assumptions get you into trouble.
‍
Keep features and cleanup separate.
My slowest sessions were the ones where I was trying to add something new and tidy up related things at the same time. They pull in different directions. Do one, then the other.

Building Lull with Claude Code was unlike any project I've worked on before. A solo project — custom physics, a full audio engine, a polished design system, auto mode, recording, live deployment — shipped in a few weeks. Without Claude Code, I'm not sure I'd still be waiting to get started.
The tool is real. So is the skill you need to use it well. But that skill looks a lot more like product thinking and design judgment than engineering. If you know what you're building and can describe it with clarity, you can build things that used to require a team.

If you're curious about the app, it's at lull.entifydesign.com. Worth opening on good speakers with the volume up.
‍
Lull is still evolving — and if you use it, there's a feedback button in the bottom right corner of the app. I read every response. The direction Lull takes next is genuinely shaped by how people experience it, so if something resonates (or doesn't), I'd love to hear it.

Follow along on Instagram at @entify.design — that's where I share updates as the project develops.