For a long time, the most honest description of my job was this: I made things that looked real but weren’t.

Interfaces that responded to a tap. Prototypes with spring physics and page transitions and little micro-interactions I’d obsess over for hours. Flows you could actually click through and, for a second, believe. But underneath, there was nothing. No data. No logic that survived a refresh. A beautiful shell, and I was the guy building the shell.

Framer was where I lived. If you didn’t use it, the shortest way to explain it is Figma with hosting. You designed the thing, and then you could actually put it on the internet at a real URL, which felt like magic the first time it happened. I loved that tool. I loved it in a way that’s probably not healthy for a piece of software. I learned every corner of it, then went looking for the corners it didn’t officially have.

That was the part I got addicted to: pushing Framer past what it wanted to do. Code components. Overrides. Dropping into little bits of JSX to make something behave the way the design in my head demanded. Somewhere in there I started writing more code than I realized. I just didn’t call it that yet, because it lived inside a canvas and I still thought of myself as a designer who occasionally typed some logic to get an animation right.

Then I’d hit the ceiling.

Every single time. I’d want a real backend. I’d want state that persisted for an actual user, not a fake demo one. I’d want to ship a thing that wasn’t a “site,” that could do something, remember something, connect to something. And Framer would very politely tell me no. Not with an error, just with the quiet absence of the feature I needed. The dream would end at the edge of the sandbox, and I’d go back to designing another beautiful shell.

I made peace with that ceiling for years. You tell yourself the wall is just where your job ends and someone else’s begins. Design up to here, hand it off, let the “real” developers take it the rest of the way. That’s the story every designer gets told, and I believed it.

The moment the wall disappeared

I don’t want to be dramatic about this, so I’ll just say it plainly: Claude Code broke the entire idea of development for me.

The first time I used it, the thing I’d been fighting Framer about for years stopped being a fight. I wanted a small tool. I described it. It got built. Not perfectly, not in one shot, but built. Real files, real code, something I could run and change and break and fix. And the ceiling I’d spent years bumping my head on just wasn’t there anymore.

That’s a strange feeling to sit with. For most of my career, the limit on what I could make wasn’t my taste or my ideas. It was my inability to translate them into something that runs. That gap was the wall. And suddenly the wall was a conversation.

So I started building. Small apps first. Then a few Chrome extensions, which taught me more than I expected because you can’t fake your way through a manifest.json and content scripts with vibes alone. Then actual websites, the kind with logic behind them and not just pages. Every one of these was something old-me would have designed, exported, and handed off. Now I was designing it and shipping it. The same brain, minus the handoff.

Learning the boring parts, which turned out to be the good parts

Here’s the thing nobody tells you about crossing this line: the code getting written for you is the easy part. The rest of it is a whole craft you now have to actually learn.

Git, for one. I came in thinking version control was bureaucracy. It is not bureaucracy. The first time I understood what a branch really was, and then the first time I created a merge conflict and had to sit there and untangle it, something clicked about how software actually gets made by more than one person. Commits started to feel less like chores and more like a diary of decisions. I got weirdly into it.

Best practices, too. Why you structure a project the way you do. When to break something into its own file. What “readable” even means when the reader is future-you at 1am. None of this is glamorous and all of it is the difference between a toy and a thing you can maintain.

I want to give real credit here, because I didn’t figure any of this out alone. The developers at Incredible took me in when, on paper, I had no business being in their conversations. They answered questions that were probably painfully basic. They let me be bad at it in front of them, which is the only way anyone gets good at anything. If you’ve ever been the least technical person in a technical room and had that room be patient with you instead of protective of its knowledge, you know what a gift that is. That’s most of why I stuck with it.

Being early paid off in a way I didn’t expect

The other piece of this is where I work. Incredible is a small, voice-first AI company, and we made a bet early that we were going to actually live inside these tools instead of watching them from a distance.

So we were early. Genuinely early, not “we tried it once for a blog post” early. We were on Claude Cowork before most people I know had heard of it. We were wiring up MCPs and figuring out what they were good for while the docs were still catching up to reality. We had Claude Code in the workflow early enough that we were forming our own opinions about it rather than borrowing everyone else’s.

That head start did something subtle but real. When you’re early to a tool, you don’t inherit anyone’s assumptions about how to use it. You have to build your own sense of what works and what doesn’t, where it’s magic and where it quietly falls on its face. And now, months of that later, a lot of AI-native work just feels natural to me. I’m not intimidated by a new model or a new integration. I have a gut for it. I can tell pretty fast whether something’s going to hold up or whether we’re about to spend two days chasing a dead end. That instinct isn’t talent. It’s just reps, earned by being willing to be early and occasionally wrong.

Where this leaves me

I’m not going to slap a new title on this. I still design. I care about typography and motion and the feeling of an interface exactly as much as I ever did. That hasn’t moved an inch.

What moved is the ceiling. The gap between the thing in my head and the thing that actually exists got small enough to step over. I don’t design up to a wall and hand it off anymore. I keep going. Sometimes the thing I ship is worse code than a real engineer would write, and I know that, and I’m fine with it, because it exists and it works and last year it would have been a static mockup with a note that said “imagine this is interactive.”

The honest version of the last few years is that Anthropic’s tools did most of the heavy lifting on making that possible for me. I don’t say that as a fan, I say it as someone whose actual daily work changed shape because of them. Claude Code didn’t teach me to code so much as it removed the reason I always had for not learning. Everything after that was on me, but it never would have started without that first wall coming down.

And the wild part is that this is the worst these models will ever be. They only get better from here. I have no idea what the ceiling looks like now, or if there even is one anymore. For the first time in my career, that question is fun instead of frustrating.

I spent years designing things I couldn’t build. I’m not doing that anymore. Turns out the wall was never really the point. It was just waiting for the right thing to come along and take it down.