Last week I released Protocollie. Built in 4 days with languages I don’t know, without even directly touching the code. People keep asking “how?” but I’m not entirely sure it’ll work the same way twice.

We’re all making this up as we go.

There's this moment in every new technology where everyone pretends they know what they're doing. We're past that moment. Or maybe we haven't reached it yet. Either way, we're in this delicious middle ground where nobody can pretend expertise because the whole thing keeps changing under our feet.

I've been thinking about expertise lately. How long does it take to become an expert? Malcolm Gladwell said 10,000 hours, but he was talking about violins and chess. Skills where the rules don't update every two weeks. Where your muscle memory doesn't become obsolete overnight.

If the most experienced AI pair programmer in the world has been doing this for at most two years then we're all beginners. Forever beginners, probably, the way things are accelerating.

I keep calling it a "system" but that implies I planned it. What really happened was more like accumulation. Like how a desk collects papers until suddenly you have a "filing system."

It started with one document because I kept forgetting what I told Claude about the architecture. Then two documents because I got tired of solving the same problems. Then three because I noticed I was repeating the workflow. Then four because the stories needed somewhere to live.

Four documents. Not because four is optimal. Just because that's when I stopped adding more.

Sometimes I wonder if I'm just LARPing as a programmer now. Like those people who play elaborate games of house. "Let's pretend this document is architecture! Let's pretend this process is official! Let's pretend we know what we're doing!"

But the software is real. It compiles. It runs. People use it. So maybe the pretending is the point? Maybe all methodology is just mutually agreed-upon fiction that happens to produce results?

The Architecture Overview - Started as a README. "Here's what this thing probably does, I think."

The Technical Considerations - My accumulated frustrations turned into documentation. Every time Claude had trouble, we added more details.

The Workflow Process - I noticed I kept doing the same dance. So I had Claude write down the steps. Now I follow my own instructions like they're sacred text. They're not. They're just what happened to work this time.

The Story Breakdown - Everything in 15-30 minute chunks. Why? Because that's roughly how long before Claude starts forgetting what we discussed ten minutes ago. Like a goldfish with a PhD.

That first Sunday building Protocollie, I discovered a new way of working. I'd wander into my office, check what Claude had built, test it real quick. If it worked, great! Commit and push. "Now build the server connection UI," I'd say, and wander back out.

Made breakfast. Claude coded.

Played with my son. Claude coded.

Watched some TV. Claude coded.

Every hour or so, I'd pop back in. Five minutes of testing. One minute of feedback. "Actually, can you make it remember the last server?" Back to my Sunday.

It was like having a very dedicated junior developer. Except this junior could type 10,000 words per minute and never got distracted by Twitter.

The whole day, I maybe spent 90 minutes actually "working." The kind of focused work where you're making decisions, testing things, saying "no, not like that." The rest was just... living my life while software materialized in the background.

There's this strange time dilation that happens. You prompt. You go live your life. You come back to ten thousand lines of code. You spend 5 minutes reading. One sentence of feedback. Another ten thousand lines appear while you're making lunch.

The ratio is all wrong. Input to output. Effort to result. Time to progress. It breaks every mental model I have about how work should feel.

Sometimes I feel guilty. Like I'm cheating. Like someone from Hacker News is going to comment "excuse me, you can't build software that fast, and definitely not while making pancakes, please return to your regularly scheduled struggling."

I told someone recently that we're in the "throwing spaghetti at walls" phase of AI development. They corrected me: "You mean ‘and seeing what sticks’?"

No. I mean throwing spaghetti at walls. The sticking is irrelevant. The throwing is everything.

Every weird process, every failed experiment, every "this shouldn't work but it does" moment, they're all data points in an experiment we're running collectively without a hypothesis.

My four-document system? Spaghetti that happened to land in a pattern I could recognize. Tomorrow it might slide off the wall. That's fine. I'll throw more spaghetti.

I've been coding for long enough to remember when we carved HTML tables by hand. When CSS was a suggestion, not a lifestyle. When JavaScript was for mouseover effects and nothing else.

Each era, we abstracted away the previous era's work. Assembly to C. C to Java. Java to Ruby. All the way up to "I describe what I want and it appears."

But this isn't just another abstraction layer. It's something else. Something weirder.

When I built Protocollie, I wasn't programming. I wasn't not-programming either. I don’t know what to call it. We don’t have the word for it yet.

The skill isn't syntax anymore. It's not algorithms. It's not even system design, really. It's something like "coherent desire" or "precise imagination" or "structured wishing."

Looking back at my documents, I realize they're not about the code at all. They're about memory and forgetting. About what matters enough to preserve and what can be regenerated.

The Architecture Overview isn't really architecture. It's "what would I want to know if I had amnesia?"

The Technical Considerations aren't really instructions. They're "what would frustrate me if we had to repeat it?"

The Workflow Process isn't really process. It's "what patterns emerged that I don't want to lose?"

The Story Breakdown isn't really planning. It's "how do I make progress when everything resets?"

Maybe that's all any documentation is. Messages to future confused versions of ourselves.

We're all junior developers again. But not junior in the traditional sense, where senior is waiting after enough years pass. We're junior in a permanent sense, where the technology evolves faster than expertise can accumulate.

It's like being a professional surfer on an ocean that keeps changing its physics. Just when you think you understand waves, they start moving sideways. Or backwards. Or turning into birds.

This is either terrifying or liberating, depending on your relationship with control.

I have no idea what I'll build next week. What process I'll use. What documents I'll create or abandon. Whether any of this will still make sense.

That uncertainty used to bother me.

We're in a moment where every developer is simultaneously an expert (at their own weird process) and a complete beginner (at whatever comes next). Where four days of work can produce what used to take months. Where the main skill is explaining what you want to something that types faster than you can think.

My four-document system isn't a recommendation. It's just one data point in the collective experiment we're all running. A fossil from last week's development process. Already outdated. Already nostalgic.

But that's what makes this moment electric. We're all building sandcastles at low tide, knowing the water's coming back. The sandcastles are software. The tide is progress. And we're having the time of our lives.

Tomorrow someone will discover a three-document system. Or a five-document system. Or no documents at all, just good intentions.

And it'll probably work.

The four documents I used? They're on GitHub now. Not as gospel. Not as a template. More like... archaeological artifacts. "Here's what one person did, once, on a particular week in 2025."

Look at them if you want. Get inspired. Get confused. Then ignore them completely and make your own. They're not instructions—they're just evidence that something worked, once, for someone.

Like finding someone else's hiking trail markers. Useful to know someone passed this way. Dangerous to assume their path is your path.