Your AI setup is premature optimization

I didn’t build my first custom skill for months. Agent skills have been around for a while — I knew about them, understood the concept, had zero reason not to use them. But I didn’t. Because I didn’t need one yet.

Then I noticed something. I kept opening fresh chats and dictating the exact same prompt over and over again. Not a similar prompt — the same one. Word for word. At some point it just got exhausting. So I spent five minutes turning it into a skill. It works great.

That’s the whole story. No framework. No architecture decision. Just friction that got annoying enough to fix.

The rule you already know

Every developer has these two principles drilled into them:

Avoid premature optimization. Avoid hasty abstractions.

We teach them to juniors. We fight about them in code review. We cite them in architecture discussions like scripture.

And then we sit down to set up our AI coding workflow and throw all of it out the window.

Eight hours building a multi-agent setup with sub-agents, dozens of tools, a fleet of MCP servers, and a curated collection of the most popular community skills. Before writing a single line of actual project code. Before knowing which of those tools you’ll actually reach for.

That’s not preparation. That’s procrastination wearing a productivity costume.

Built from friction, not from tutorials

The best AI setup isn’t the most sophisticated one. It’s the one that grew out of a real problem you actually had — not from a YouTube tutorial, not from a Reddit thread about someone else’s workflow.

Every useful piece of my current setup exists because something bothered me enough to fix it. Not because I planned for it upfront. Not because someone on the internet said it was essential.

The skill I built? Five minutes. Born from real, repeated pain. The multi-agent orchestration system I didn’t build? Would have taken a full day and solved nothing I actually needed solved.

Start with nothing

Here’s the counterintuitive move: try working with a clean chat. No elaborate configuration. No stack of plugins. Just you, a prompt, and the task in front of you.

Do your actual work. Pay attention to where it hurts. When the same friction shows up for the third time — then build the abstraction. Not before.

Circling around your setup under the guise of preparation is still standing still. The code doesn’t care how polished your tooling is. It cares whether you shipped.

The next time you’re about to spend an afternoon configuring your AI workflow, ask yourself: am I solving a problem I have, or a problem I might have?