Following what's lit up when you don't have a plan

The first time I noticed the pattern, I was building a system in a game.

I needed a function. So I built one. While building it, I could see it needed another function to work properly. I built that too. That one suggested a third. By the time I stopped, what I had wasn't three functions. It was a primitive with two things it depended on and two things that would eventually depend on it.

I didn't design any of that. I just followed what needed to exist next.

That was a long time ago. The domains have changed. The pattern hasn't.

When I try to describe what I actually do, the clearest version I've found is this: I write primitives. All I do is write primitives all the time. Every day I'm designing a new primitive or thinking about how a tool can help a layer within a product full of primitives. It's not a method I chose. It's how my brain works. It feels logical in the way that things feel logical when they're just how you see.

The games turned into audio tools. The audio tools turned into a product platform. The platform needed infrastructure. The infrastructure needed governance. Each step looked like a domain change from the outside. From the inside, each step was the same pattern running in a new context.

I only understood this clearly when I didn't have a plan.

After the game audio work ended, I spent some time without an obvious domain. The appetite for the field I'd been in had gone quiet. I knew how to build but didn't have a clear thing to build toward. That's an uncomfortable place to be when you've always had a field to orient around.

What I found was that I couldn't not build. The instinct didn't care that the domain had gone. It just kept finding things that needed to exist next. A tool for something I was doing by hand. A primitive that two other things needed. A system that wanted to exist because the friction kept appearing in the same place.

This is different from having a roadmap. A roadmap tells you what to build next because someone decided it in advance. Following what's lit up means you build the thing that the current thing needs, then you build what that thing needs. The structure emerges from the work instead of preceding it.

As a solo founder, that process compounds in a way it doesn't inside a larger organisation. There's no planning cycle that overrides what the work is asking for. You just follow the signal. The bootstrapped SaaS I'm building now, the products under Norskape, didn't come from a market map. They came from building one thing, noticing what it needed, and building that.

Now I work with agentic AI, building with Claude, operating in a context of multi-agent systems and harness engineering. The agent harness, the governance layer, the workflows that run autonomously across the OS I've built. These are primitives in exactly the same sense the game functions were. The domain is different. The pattern is identical.

Following what's lit up isn't a strategy. It doesn't produce a five-year plan. What it produces is a body of work that makes sense in retrospect, where each thing was built because the previous thing needed it, where the architecture is real because it emerged from real friction.

The things that emerged without planning have turned out to be more coherent than the things I tried to plan. Because they were built from signal, not from a theory about what the signal would eventually be.

I still don't have a plan in the traditional sense. I have a method. The method is: notice what's lit up. Build there. See what it needs. Build that.

It has never once failed to produce the next thing.