Just By Asking
You try things that don’t deserve to exist yet. And some of them turn out to deserve it.
Here’s what used to happen when you wanted software.
You’d have an idea. Then you’d think: can I build this? Do I know how? You’d Google around. Read documentation. Copy paste from Stack Overflow. Maybe it worked. Maybe it didn’t. Maybe you gave up.
Or you’d pay someone. Wait weeks. Get something that wasn’t quite right. Pay more to fix it.
The question was always: can this be done? And the answer depended on what you knew or who you could afford.
Here’s what happens now
You have an idea. You ask for it. You get it.
Not perfectly. Not always. But you get something. And then you ask for it to be different. And it changes. You go back and forth. You say “no, more like this” and “what if instead” and “can you make it do this other thing too?”
The question isn’t “can this be done?” anymore.
The question is: can I ask for it?
This sounds like a small shift. It’s not.
When you had to know how to build something, the bottleneck was knowledge. You were limited by what you’d learned, what you’d memorized, what you’d done before.
When you can just ask, the bottleneck is... imagination? Clarity? Knowing what you want?
The people who are still say AI (In October 2025) isn’t useful for coding are measuring the old thing. They’re asking: does it write perfect code? Does it understand my complex legacy system? Can it architect something in one shot without hallucinating?
These are good questions for the old world. Where code is seemingly the product.
But code was never the product. The product is the thing that works. The button that submits. The page that loads. The data that updates.
Here’s what people aren’t getting
They think AI coding tools are a faster way to write code.
That’s like thinking a calculator is a faster way to do long division.
Technically true. But it is fundamentally missing the point.
The calculator made it so you could ask mathematical questions you’d never have sat down to solve by hand.
It changed what was worth trying.
I watch people dismiss AI coding day after day because the code isn’t clean enough. Because it imports the wrong library. Because you have to fact-check it.
And I think: you’re still thinking in the old paradigm.
The paradigm where code is precious. Where every line is hand-crafted. Where mistakes are expensive.
But what if you can throw it away and ask again? What if “working” matters more than “elegant”?
What if the question isn’t “will AI write better code than me?” but “what could I build if building was just talking?”
Here’s a thing that happened to me just yesterday.
I wanted a tool. A specific tool for a specific problem to parse some gnarly json and reformat it into cleaned up markdown. Small thing. Would’ve taken me three or four hours to build, maybe more. I wasn’t even sure I wanted it bad enough to spend those hours.
I asked Codex CLI. Took three minutes. Got something. Wasn’t quite right. Told it what was wrong. It fixed it. Three more tries. Had my tool.
Total time: fifteen minutes.
Did I “build” it? Not in the traditional sense. Did I get what I wanted? Yes.
And here’s the thing: I wouldn’t have built it the old way. It wasn’t worth those hours. The cost was too high. The idea would’ve just... stayed an idea.
How many ideas are like that? How many things could exist, should exist, would be useful but aren’t worth the cost of traditional building?
The real shift is the cost of trying.
When trying costs hours or days or weeks, you only try the important things. The safe things. The things you’re sure will work.
When trying costs minutes, you try... everything. The weird ideas. The “wouldn’t it be cool if” ideas. The ideas that might not even work.
You try things that don’t deserve to exist yet. And some of them turn out to deserve it.
People say: “but it hallucinates.”
Yes. It does. It makes mistakes. It invents libraries that don’t exist. It’s more than confidently wrong sometimes.
But here’s what I want to ask: how often were you wrong when you were learning to code? How many times did you write something that didn’t work? How many Stack Overflow answers did you copy without really understanding?
The difference is: you could be wrong in private. You’d debug. You’d figure it out. The wrongness was part of the process.
With AI, the wrongness is... collaborative? You catch it. You correct it. You say “no, that’s not right” and try again.
It’s still wrongness. But it’s faster wrongness. It’s cheaper wrongness.
And the cost of being wrong is what determines how much you experiment.
Things wait outside us, hover at the door. They keep to themselves. Ask them who they are and they don’t know, they can give no account of themselves. What accounts for them? The mind does — IX. 14
Here’s what I think people should sit with
What would you make if making only required asking?
Not “what would you make if you had infinite time to code?” Because that’s still about you. Your skill. Your knowledge.
What would you make if the barrier was just: can you describe it? Can you imagine it clearly enough to ask for it?
That’s a different question. That’s a question about creativity, not capability.
The old world of software was about gatekeeping. Not maliciously. Just structurally.
You had to learn the languages. The frameworks. The patterns. You had to put in the hours. You had to become the kind of person who could build.
And that was fine. That made sense. There was no other way.
But now there’s another way.
Now you can just... ask.
And the people who spent years becoming builders feel that as a loss and as a devaluation. As their expertise becoming less special.
And it is less special. I’m sorry. That’s true.
But it’s not worthless. The experts will build better things faster. They’ll ask better questions. They’ll know what to ask for. They’ll catch the mistakes.
But the new thing. The actually new thing isn’t that experts get faster.
It’s that non-experts get to build at all.
I think about a particular close friend sometimes. They have ideas. Ideas for tools they wishes existed. Little utilities for work. Nothing complicated. But they can’t build them. Never could.
Six months ago, that was that. Ideas with nowhere to go.
Now? They can ask. And get something. It’s not perfect. But it’s something. And something is infinitely more than nothing.
But still, people arguing about whether the code is good enough.
The question isn’t and shouldn’t be: will this replace developers?
The question is: what becomes possible when the cost of possible drops to zero?
What gets built when building is just talking?
What exists that couldn’t exist before?
Not because it was impossible. Because it wasn’t worth the effort. Wasn’t worth learning the syntax. Wasn’t worth debugging for hours.
How many of those things are there?
How many ideas died because they weren’t worth building?
How many get to live now?
Just by asking.