A few days ago I published a lighthearted post about building a coding mascot generator with Google AI Studio. The app itself — MascotCraft Studio, complete with a mascot named Octo-Byte — wasn't the point of the post. It was a fun side project. But the comments turned into something I've been thinking about ever since.

The Comment That Stuck With Me

Someone left a comment that's been rattling around in my head:

"We're moving from an era where implementation was the bottleneck to one where judgment becomes the bottleneck. When anyone can generate code, interfaces, and integrations in minutes, the differentiator becomes identifying worthwhile problems, defining clear requirements, and recognizing whether the result is actually good."

I read that, nodded, moved on with my day — and then kept coming back to it.

What "Implementation Was the Bottleneck" Used to Mean

Think about what it took to build something like MascotCraft Studio even three or four years ago. You'd need:

• Someone who knows frontend (to build the UI)
• Someone who knows how to call an image generation API
• Someone who knows how to call a language model API
• Someone who knows how to wire those together into a coherent app
• Someone who knows how to deploy it

That's a team. Or at minimum, a single person wearing a lot of different hats, each requiring real expertise.

I described what I wanted in a paragraph. The implementation step — all of the above — happened in minutes.

So... What's Left?

If the hard part used to be "can we build this," and that part is now fast, what's the hard part now?

Based on that comment thread, it's things like:

• Identifying worthwhile problems. Anyone can generate an app. Generating an app that solves a problem someone actually has is different.
• Defining clear requirements. My prompt for Octo-Byte was reasonably specific, but Gemini still made a bunch of decisions I didn't ask for — color palettes, visual styles, a gallery feature with local storage. Some of those were great. One of them (the gallery using localStorage) was pointed out by another commenter as something that wouldn't actually hold up if this were a real product — saved mascots vanish if you switch browsers or clear your cache.
• Recognizing whether the result is good. This is the one I think about most. I looked at Octo-Byte's bio and thought "this is charming and well-written." But charming and well-written isn't the same as correct or appropriate for the use case. Evaluating output quality is its own skill, separate from being able to produce output at all.

The Part That's a Little Uncomfortable

Here's the thing I keep circling back to: judgment isn't something you can prompt your way into.

You can ask an AI to "review this code for bugs" or "tell me if this design is good," and it'll give you an opinion. But knowing whether that opinion is trustworthy — knowing enough to push back, to say "actually, for my use case, that tradeoff doesn't make sense" — that still requires you to understand the problem space yourself.

In other words: the easier it gets to generate things, the more it seems to matter that you actually understand what you're generating and why. It's less "know how to build everything yourself" and more "be able to tell good implementation from bad, quickly, across a much wider range of things than you could personally build by hand."

What This Means in Practice

I don't have this fully figured out, but it's shifted how I think about a few things:

• When I look at a piece of code or a generated feature now, I try to also think about "what would a wrong but plausible-looking version of this look like?" — because that's the version judgment needs to catch.
• When AI tools generate something for me (like Gemini did with MascotCraft Studio), I try to actually read through what was added rather than just checking "does it work." The localStorage gallery point only came up because someone else looked closely enough to notice it.
• I'm less worried about "will AI make skills obsolete" and more curious about "which skills are becoming more valuable because of this shift" — and judgment, evaluation, and knowing what questions to ask seem to be high on that list.

An Open Question

I don't have a tidy conclusion here, because I don't think there is one yet — this feels like something the whole industry is figuring out in real time. But I'm curious: if "judgment becomes the bottleneck," how do you actually practice and sharpen that judgment deliberately, rather than just hoping it accumulates as a side effect of experience?

If you've got thoughts on this, I'd genuinely like to hear them. 🌸