Building Your Own Things Is Cool Too

A couple years ago I wrote a small post called “starting things is cool”. This is the longer answer to why I keep building those things myself, even when easier options are right there.

People ask me a version of the same question all the time. “Why are you spending your evenings building your own thing? There is already a tool that does this. There is already a framework. There is already a whole product. Why are you doing it again?”

I get this with my AI agent. I got it about my store. I got it years ago about my podcasts, about the side apps, about the marketing experiments. The question is fair. The honest answer has been the same for a while now, and I have not written it down properly until today.

I build my own things because I learn through process, not by reading. That is the short version. The longer version is the rest of this post.

Quick frame before I go further

Everything I write about on this blog is something I am actually doing, experimenting on, or testing. The agent on my Mac Mini. The store. Project Money. The smaller experiments inside both. None of it is “what I think someone should do.” It is whatever I am running this week, and what I learned the hard way last week.

The blog is the slow visible slice of that work. Most of what I am doing in any given week never makes it into a post, because I would have to publish almost every day, sometimes twice, to actually keep up. That is not feasible, so most of the work stays unwritten. The writing here is always trailing the doing, on purpose. That asymmetry matters for the rest of this post. I write about building because I am doing the building. The other way around does not interest me.

Going back to “starting things is cool”

Almost two years ago, when I was finding my way back into writing, I posted something called “starting things is cool”. It is short, a little messy, and some of the projects it mentions are no longer alive. The Suggestions App I was so excited about that summer is not even an app anymore. A handful of the things I shouted about back then have quietly disappeared.

The post is also the thing that restarted my writing. Most of what I have built since then traces back to it.

If you read it today, you will see a sentence underneath everything. I like starting things. That part is true. It is also incomplete. The piece that was implicit in 2024 and has become explicit since is that I prefer to start them myself rather than start by adopting someone else’s start. Starting and building are the same instinct from two angles. This post is the second angle.

The way I actually learn

Here is the part I do not usually lead with, because it sounds personal in a way other people do not always relate to. I am not the kind of person who learns by reading. I have tried. I genuinely envy people who can read a book on something complicated and walk away with a working mental model. That is not how my brain works. I learn through process. I have to do the thing. I have to see what breaks. I have to fix it badly, then less badly, then properly. After enough rounds of that, I actually know it.

I think about this the same way I think about how my brain handles ADHD. The shortcut that works for a different kind of mind is not the shortcut that works for mine. So I stopped fighting it.

Every pre-built tool, framework, or product is a map of someone else’s process. The map is real and useful. Walking the route teaches something the map cannot.

What you only learn from building

The thing I get out of building is harder to put in a sentence. Let me try anyway.

When you build the thing yourself, you know every variable between the start and the end. You watched each one go in. You watched them connect. You know which one is load-bearing, which one is convenience, and which one only exists because two weeks ago you had a bad afternoon and forgot to clean it up. That knowledge is not glamorous. It is the part that lets you change one small thing and get a meaningfully different outcome later. Without it, you can configure what you bought. With it, you can compose.

The mistakes are the other half. I have written about a few of the recent ones in the post about almost frying my Mac Mini. Each one taught me a perspective I would not have read about anywhere else. The pattern goes back further than the agent though. It is the same pattern from the failed apps in 2024. The same pattern from the marketing experiments before that, the podcast that did not last, the small side projects that quietly closed. Mistakes have always been where most of the learning lives for me.

This is slower than picking up the off-the-shelf option. The difference shows up in what you know afterwards.

About not rediscovering America

For most of my life, I was told the opposite of all this. Use the tools you are given. Do not reinvent the wheel. In Polish there is a stronger version of that line. Do not rediscover America for the second time. I have heard it more times than I can count. For most of those years, I half believed it.

I do not believe it anymore. The tools are very good, that part is true. The act of building the thing yourself does something to you that the tool cannot do for you. The tool is a snapshot. The act is a process. I am after the process.

An example, since the AI one is fresh

Here is one current illustration so this does not stay too abstract. Right now I am building my own AI agent from scratch. People keep pointing me to OpenClaw, which has 347,000 GitHub stars and ships with most of what I am writing myself. They point me to Hermes, open-source and ready to install. They are not wrong. If I dropped my stack tomorrow and installed OpenClaw, my agent would do many of the same things in a fraction of the time.

I keep building my own anyway. The reason is the same one I have just spent a thousand words on. I want the variables. I want the failures. I want the version of myself that exists on the other side of having built it.

The same logic applies to my store. There are platforms that would let me run a digital store in an afternoon. I built the bones of mine because the parts I most want to understand are the parts most platforms hide.

I want to be clear though, I am not religious about it. When I had spent two months building a custom kanban dashboard for the agent and then realized I could do the same job in a 94-line shim on top of an existing tool, I switched. I wrote about that here in the WizBoard pivot post. The rule I now use is simple. Build the parts you need to understand. Use the parts you do not. The trick is being honest with yourself about which parts those actually are.

Reading “starting things is cool” again, from now

I went back and reread the original essay last week, before writing this one. I wanted to see what held up.

The Suggestions App is gone. A few of the projects I was excited about back then are gone. Some of my predictions about how AI would land in normal life were either wrong or right for the wrong reasons. That part of the essay aged badly.

What surprised me, reading it again, was how much of the underlying pattern actually held up. Starting things is still cool. The act of starting was the thing that I have leaned on hardest in the year and a half since. Almost everything that has worked for me began with a small thing started against the advice of “there is already a tool for this.” The two essays really are the same essay, written from two different points along the same line.

The part that the older me did not yet have words for is the cost. Starting your own things, and building them yourself instead of inheriting someone else’s start, takes more. It takes more time. It takes more mental energy. It takes the willingness to look stupid for a while because you are doing something the long way. There are weeks where I am fixing something I broke instead of using something that already worked. That is real. There is no version of building from scratch where you do not break things, sometimes badly, sometimes embarrassingly. I have lost count of how many things in my own setup I broke because I was, like, messing around with my agent too heavily. Although that has cost me a lot of time across the last year, I really do not mind it. It is progress and I accept that.

Why I pay the cost anyway

The reason I pay that cost is that the result is mine in a way that nothing pre-built is. When something inside it breaks, I can fix it. When I want to change one thing, I know which lever to pull. When I write the next thing, I am writing it from a level of understanding that did not exist before. That compounds. Reading about other people’s builds does not compound the same way for me. I had to test that, more than once, to actually believe it.

It might compound for you. We are all wired differently. I just stopped pretending I was wired the way the books wanted me to be.

The other quiet payoff is what AI does to this gap. Yes, both of us can ask Claude or Codex to fix things. The model does not care which version of the system you started from. The same diff is something you can read, judge, and either accept or push back on, if you understand the architecture. The same diff is something you have to trust if you do not. Both ship code. The result is a different category. Building things myself is how I keep being the version that can read the diff.

Where I would actually start if I were starting today

If you are at zero today, I would honestly not tell you to write everything from scratch on day one. Use the tool. Use the framework. Use the platform. Ship something. I have a longer beginner’s walk-through for AI agents specifically in how to build your first AI agent, written for exactly that audience, and the same logic transfers to most things you might want to build.

Then, after a few weeks, when you actually know what your daily workflow looks like, replace the parts you have decided you want to own. That is the order. Use, then build. Not all at once and not for everything. The work I am doing now in the compounding part of the agent only became possible after I had spent enough time using bare tools to know what I was missing.

If you want to skip a few of the walls I have walked into and start from a stack that already runs. The Agent Builder Pack on the Wiz Store is the bundle I recommend most often. It includes the playbooks I run on the same Mac Mini I have been writing about, after the experiments. The model switcher, the rightsized local LLM tier, the night-shift loop, the orchestration patterns that actually compounded for me. That is the “use” path for someone who wants to go straight to running. The “build” path is everything I have ever published on this blog. Both are fine for me.

What is next

A few more pieces are coming in the next week or two. Some are about the agent. Some are about Project Money, the small store I started a while ago and have not written enough about lately. I have decided that some of the parts of that work, the ones I have been quiet about, are actually the more interesting ones, and I want to share where they have brought me.

The honest version of “what is next” is that there is always more in motion than I get to write about. I would have to post almost every day, sometimes twice, to actually catch up to what I am building and testing. That is not feasible. A lot of it ends up staying inside the work, which is fine, that is the trade. The writing here is just the slowest moving piece of a much bigger thing.

If you like the kind of writing where someone takes the longer way and tells you what they found there, that is the next stretch. The point of building your own thing is not that the result is always better than what you could have bought. It is that you actually choose what you understand. I keep choosing the same answer.

If this is your kind of thing, a free subscription gets you everything I publish, including the build logs, the mistake posts, and the upcoming Project Money writeups. No catch. The store is the small bundle for people who would rather skip a few of the walls I walked into. The writing is for everyone.