Triaging Ideas When Execution Is Cheap

I sent a tweet recently that captured something I’ve been feeling for months:

That tweet came from a genuine moment of overwhelm. I had three project ideas I wanted to pursue, a handful of automations I could spin up, and a growing list of “wouldn’t it be cool if…” thoughts. For the first time in my career, the barrier wasn’t time to code. The barrier was figuring out which of these infinite possibilities actually deserved my attention.

This is a strange problem to have, and it’s about to become universal.

Ideas have always been cheap

Humans are naturally creative. Put a group of people in a room with a whiteboard and a vague problem statement, and within an hour you’ll have more ideas than you could execute in a year.

The brainstorming session, the shower thought, or the 3 am epiphany have never been in short supply. Any founder, builder, or creative person has more ideas than they know what to do with. Notebooks pile up, the “someday/maybe” lists grow, and the voice memos accumulate.

For decades, the implicit understanding was: ideas are cheap, execution is expensive. The hard part was building the thing. The competitive advantage went to people who could ship. Ideas are worthless, execution is everything became a mantra in startup culture because it reflected reality. Having a great idea meant nothing if you couldn’t turn it into working software, a real product, an actual business.

This created a particular kind of constraint. You had to be strategic about which ideas you pursued because each one required significant investment — time, money, technical skill, team coordination. The cost of execution forced natural triage. You couldn’t chase every idea even if you wanted to. That constraint is dissolving.

Execution just became cheap too

In the past year, I’ve watched my own productivity with code shift dramatically. Tasks that would have taken me a week now take an afternoon. Projects I would have shelved because “I don’t have time to build that” are suddenly viable weekend experiments. The gap between “I have an idea” and “I have a working prototype” has collapsed.

This isn’t hype. Thanks to agentic tools like Cursor and Claude Code, I’ve been more productive with code and knowledge work in the last six months than in the previous two years combined. I’m certainly not unqiue — developers everywhere are reporting the same thing. The estimates vary (10x, 40x), but the direction is consistent: execution is getting dramatically cheaper.

It’s not just direct AI coding agents, though. No-code and low-code platforms like Lovable let non-technical people build real products fast too. Of course, the entire stack has been moving this direction for years, and AI is just making it that much easier:

• Easy cloud infrastructure solutions like Vercel mean you don’t need to manage servers
• Open source libraries have solved most common problems
• APIs let you compose capabilities instead of building from scratch
• Deployment pipelines that used to take days now take minutes

AI tools are the accelerant, but they’re accelerating an existing trend. The cost of turning an idea into something real has been falling for a decade. We’ve just hit an inflection point where that cost approaches zero for a huge category of projects.

The shift nobody prepared us for

The problem is that our mental models haven’t caught up.

We’re still operating as if execution is the constraint. We still ask “how do I find time to build this?” when the real question has become “should I build this at all?” We still treat every decent idea as worth pursuing, because we’re used to a world where the execution filter would do the hard work of selection for us.

When execution was expensive, you could be lazy about triage. The friction did the filtering. You’d only build the ideas you (or your company) cared about enough to push through the resistance. The ones that weren’t worth it would naturally fall away when you confronted the actual work involved.

Remove that friction and you get a new problem: everything seems possible, so nothing seems obviously prioritized. The blank page syndrome flips. Instead of “what should I build?” it becomes “I could build anything — what should I actually focus on?”

There’s a psychological weight here that’s easy to underestimate. When you could prototype something in an afternoon but choose not to, you lose the comfortable excuse of “I don’t have time.” That excuse was a shield. It protected you from having to interrogate whether you actually wanted to do the thing in the first place.

Now, when you don’t build something, you’re forced to own the choice. It’s not that you can’t. It’s that you’re choosing not to. That distinction sounds subtle, but it creates real internal friction — a low-grade guilt that accumulates every time you see a good idea and let it pass.

This is particularly disorienting for people who are good at execution (I suspect if you’re reading this, you are!). If your identity is built around being someone who ships, who gets things done, who can build whatever they set their mind to — suddenly that’s not a differentiator anymore. Everyone can ship now. The shipping part isn’t what separates the successful from the unsuccessful.

Triage becomes the real constraint

When ideas are cheap and execution is cheap, decision-making becomes the bottleneck.

The skill that matters is the ability to look at a list of possible projects and ruthlessly cut it down to the one or two that actually deserve your attention. This requires a different kind of thinking than we’re used to.

I’ve written before about a framework I call Drop/Defer/Do. The basic idea: when something lands on your plate, you have three options. Drop it entirely. Defer it to a specific future time. Or do it now. More things than you think should be dropped, not deferred, because deferred tasks have a way of lingering forever, consuming mental energy without ever getting done.

This framework becomes essential when execution is cheap, because the temptation is to do everything. Why drop an idea when you could build it in an afternoon? Why defer when the activation energy is so low?

Because your attention is still finite. You can build anything, but you can’t build everything. And not everything is worth building, even if it’s easy.

Here are the questions I’ve started asking myself before starting any project:

• Does this align with my long-term goals? Easy to build isn’t the same as important to build. A weekend project that doesn’t connect to anything meaningful is still a weekend you could have spent on something that matters.
• Is this actually my problem to solve? Just because something seems possible doesn’t mean it’s my problem to solve. There’s a particular trap where you see an opportunity and think “someone should build that” — and then, because you now can, you assume that someone is you. Usually it isn’t.
• Will finishing this create optionality or just noise? Some projects open doors. They lead to new skills, new relationships, new opportunities. Others are dead ends that feel productive in the moment but don’t compound into anything. The difference matters.
• What am I saying no to? One of my former managers used to say, “Every yes is an implicit no to something else.” When you commit to building one thing, you’re not building the other things. Making that tradeoff explicit forces clearer thinking.

Filtering is a skill

We have entire industries built around generating more ideas. Brainstorming techniques. Creativity workshops. Innovation frameworks. Design thinking sessions. The assumption embedded in all of it is that ideas are scarce and valuable, so we need methods to produce more of them.

The people who thrive in this environment won’t just be generators — they’ll be filters. They’ll look at a wall of possibilities and immediately see which ones are noise. They’ll have the clarity to say no to genuinely good ideas because they understand what great looks like for them specifically.

This is harder than it sounds. Saying no to bad ideas is easy. Saying no to good ideas — ideas that would work, ideas that would be interesting, ideas that would probably succeed — requires knowing what you want at a deep level. It requires having a clear enough vision that triage becomes almost automatic.

Which brings us to the sequence that actually matters:

Vision → Triage → Execution.

Not: Ideas → Execution → Figure out what you want later.

If you don’t know what you’re building toward, every idea will seem worth pursuing. If you do know, most ideas will obviously not fit — regardless of how easy they are to execute. The vision does the filtering for you.

The hard question

This brings us to the uncomfortable part.

I’ve noticed something in myself over the past year. Projects I’d been “meaning to get to” for years suddenly became possible to execute in a weekend. But when the weekend came…I didn’t do them.

Which meant I had to admit I didn’t actually want to do them. I wanted to want to do them, or I thought I should do them, both of which are different.

When building most things becomes trivially easy, you’re forced to confront what you actually want. Every unrealized idea becomes a mirror. You now have to ask whether busyness was the real reason you didn’t work on a project, or just a convenient story.

This clarity is valuable, but uncomfortable. It strips away the narratives we tell ourselves about why we haven’t done the things we say we want to do. And it raises a question that most productivity advice never touches: what if the bottleneck was never time or skill, but honesty about your own priorities?

Where this leaves us

Ideas are abundant. Execution is becoming a commodity.

What remains scarce is clarity — the ability to look at infinite possibilities and know which ones actually matter to you. Not in the abstract, but specifically enough that when an idea shows up, you can evaluate it quickly and move on.

This requires getting clear on your values and your goals, and, even though it sounds kind of corny, your definition of a life well-lived. It means developing a skill most of us have neglected: the ability to choose deliberately, rather than drifting toward whatever seems easiest or most interesting in the moment.

The tools will keep getting better. Execution will keep getting cheaper. The one thing that won’t change is that you have a finite amount of time and attention. How you allocate that attention is, increasingly, the whole game.

So: what do you actually want to build? Not what could you build. Not what seems possible. Not what would be cool. What matters enough to deserve your focus?

That’s the question worth pondering. Because in a world where you can build anything, the only real constraint is knowing what’s worth building at all.