Code Is a Medium

Last month I sat in a room with a dozen designers. Nobody would call themselves a developer. We opened VS Code, opened Claude Code, and I said: "Build something. Anything. You have an hour."

One person built a Pokédex. Another built a personal finance tracker. Someone else made a working quiz app for their kid. These weren't mockups. These weren't prototypes that approximate the experience. These were real, running, interactive applications — and the people who built them had never written a line of code in their lives.

I've been thinking about that room ever since, because what happened in it wasn't a parlor trick. It was a medium shift.

For most of software's history, code has been a trade skill. You learned the syntax, internalized the patterns, spent years building fluency — and then you could make things. Everyone else described what they wanted and hoped the translation held. That's not a knock on engineers. It's a description of a constraint. Code was hard to work in, so working in it required dedication, and dedication created specialization, and specialization created a divide between the people who understood problems and the people who could shape solutions.

We built entire industries around managing that divide. Product management. Business analysis. Requirements documentation. Design handoffs. Sprint planning. All of it, fundamentally, is translation infrastructure — the machinery we invented to move intent from one side to the other.

What's changing isn't that everyone learned to code. It's that the medium itself changed.

When I describe what I want to build in natural language and an AI agent produces working code, I'm not "coding" in any traditional sense. I'm working in code the way a filmmaker works in footage — shaping the material directly, seeing it back, adjusting. The feedback loop went from days to seconds. The translation layer disappeared.

This is what it looks like when a medium becomes accessible. Not dumbed down — opened up.

The distinction matters. Accessible media don't produce worse work. They produce different work, because different people can finally touch the material. When cameras became portable, we didn't get worse photography. We got street photography, war photography, photojournalism — entire genres that couldn't exist when the medium required a studio and a fifteen-minute exposure. When desktop publishing arrived, professional typesetters didn't disappear. But the relationship between writing and typography changed permanently. The people shaping the words could now shape how the words looked.

Here's what a typical session looks like for me now. I open VS Code. I open a terminal with Claude Code. I describe what I'm trying to build — not in technical specifications, but in the language of the problem I'm solving. The agent produces code. I run it. I see what works and what doesn't. I adjust. I iterate.

The critical thing isn't that the AI writes the code. It's that I'm in the material. I'm not describing a prototype to someone who will build it. I'm not creating a mockup that approximates the experience. I'm shaping the actual thing — the real, running, interactive thing — and I can feel when it's right the same way I can feel when a layout is right or a sentence lands.

And here's what surprised me: the skills that matter most in this mode aren't technical. They're editorial. Knowing what to build. Knowing when something feels right and when it feels off. Knowing how to describe a problem clearly enough that the solution emerges cleanly. Knowing when to push for more and when to ship what you have.

These are design skills. Product skills. Craft skills. They're the skills that were always supposed to matter most, but couldn't — because the bottleneck was implementation, and implementation required a different fluency entirely.

Now the bottleneck is judgment. The hardest part isn't making the thing. It's knowing what the thing should be.

Engineers have always known this, by the way. The best engineers were never just translating specs — they were making design decisions constantly, filling in the gaps that no specification could fully cover. What's changed is that now the people who own the intent can participate in those decisions directly, in real time, in the actual material. Not instead of engineers. Alongside them. Each bringing distinct fluency to the same surface.

I think back to that room of designers. The absorption was total — because they were finally touching the thing, not describing it. That's the shift. Not that code got easier. That code became a medium anyone with taste and intent can work in.

The designers who learn to work in it won't replace engineers. The operators who start building their own tools won't eliminate the need for architecture. But the line between who has ideas and who implements them is going to blur until it's unrecognizable. And the things we build on the other side of that blur are going to be better. Not because the tools got faster. Because more kinds of intelligence are finally touching the material.

Code isn't just a trade skill anymore. It's a medium. And the most interesting work is going to come from the people who just got access to it.