The world outside, the code inside

Lately I've been feeling pretty low. Partly because of the state of the economy, partly because it's starting to hit my wallet too. My savings are slowly disappearing, old clients are slipping away, and finding new ones isn't exactly a walk in the park.

And as if that weren't enough, the final blow came. I found my cat dead.

I don't even know what happened to him. Maybe a car, maybe some lowlife. Around here there are even stories about groups of teenagers going around hurting cats. I don't know if they're true, or if they have anything to do with what happened to mine. But the fact that I even have to ask myself that makes me feel sick.

I look at what's going on in the world and it feels as though we're entering a darker and darker period. Wars, conflicts, economic uncertainty, people seeming to bring out the worst in themselves. Maybe it's just me seeing everything through darker glasses lately. Could be.

And with all this sadness weighing on me, I still have to work. I've got a project for a startup that needs to be finished on a very tight deadline, deadlines to meet, problems to solve.

The strange thing is that work has almost become the only place where I can stop thinking about everything else. I open my editor, focus on one task, then the next. A bug, a function, a performance issue. Finally, something I can actually do something about. Something I can, in theory at least, fix.

And to be fair, things aren't going badly either.

The research I've been working on is finally starting to produce some interesting results. What began as a simple proof of concept is turning into something that actually works. There's still a lot to test and prove, but seeing some of those ideas take shape is incredibly satisfying.

The game I'm building is coming together too. It's starting to look like what I imagined in my head, with its universe, planets, resources and interactions. I catch myself trying it out and thinking: damn, this is actually happening.

And all of that is thanks in part to AI, which by now is doing, I'd say, a good 70% of the work.

Why 70% and not 100%?

Good question. And maybe that's exactly what I've learned over the last few months.

AI has become unbelievably good at writing code. You can ask it to implement a function, a module, a fairly complex system, and often you get something back in no time. But when you get into system design, performance, architectural decisions that seem irrelevant today but make all the difference when you need to scale tomorrow, that's where I still run into problems.

Not always, of course. But often enough that I've changed the way I work with it.

The funny thing is that I often already have the whole system in my head. I know where I want to take it, which components I'll need, how they should communicate. And at first I thought: perfect, I'll explain everything and let it build the whole thing.

Seems like the most logical approach, right?

Well, no. Or at least, it often doesn't work for me.

If I explain the whole idea, I end up with loads of code, sometimes even neatly structured code, but then the corrections begin. A bad architectural choice, a dependency I didn't want, one part that works perfectly on its own but becomes a problem when you connect it to the others. And you end up debugging, rewriting parts and losing the very time you thought you were saving.

So I started doing something much simpler. I don't explain everything. I give it the work piece by piece.

With the game, for example, I first built the universe engine. Then the user session system. Then resources, planets, their logic. Each piece with its own responsibilities, trying to keep it as independent as possible. Only afterwards did I start connecting everything.

And bit by bit, the result came together. Without having to constantly tear down half the architecture because something wasn't thought through at the beginning.

Someone might say: hang on, that's just how you should develop software even without AI.

Exactly!

That's the whole point.

I've realized that working with AI agents is becoming more and more like working with a team. And I don't just mean because you can hand tasks to different agents. I mean the actual way you have to think about and organize the work.

You need to understand what to delegate, when to delegate it, which dependencies exist, what needs to be ready before something else can start. You need to know how to distinguish important decisions from implementation details.

In other words, the skills of a team lead come into play, or at least someone who knows how to coordinate software development.

And I think people who already have those skills have a huge head start when it comes to getting the most out of AI agents.

But careful, because that doesn't mean organizing a team is enough to make everything work. Even humans misunderstand each other, communicate poorly, assign vague responsibilities. How many projects have failed not because the developers weren't good, but because the work was organized like crap?

The same thing happens with agents. Maybe in different ways, but the problem is very similar.

And that's also why I'm not a big fan of this obsession with massive Markdown files, endless documentation and gigantic instruction sets that are supposed to tell an AI how to behave in every possible situation.

I'm not saying documentation is useless, obviously. Far from it.

But what works much better for me is knowing how to break the work into the right steps, in the right order of priority, rather than trying to cram the entire knowledge of a project into a file and hoping an agent will understand it all.

I don't have some enormous document laying out every single thing my agents are supposed to build in the coming months. Most of the project is in my head.

When the time comes, I know which piece to tackle, which constraints to give, and what to check. Sure, I make mistakes too. But this way I feel like I waste far less time than when I try to plan and generate everything at once.

Maybe that's exactly the skill that will become more and more important. Not knowing how to write every single line of code, but knowing what to build, how to split it up and, most importantly, recognizing when something isn't right.

And that brings me back to a phrase people keep repeating: AI is a multiplier.

If you're crap at something, you risk multiplying that too. If you know what you're doing, it can massively multiply your abilities.

Sounds obvious, but I think about it a lot.

And I'm not saying this because I'm some brilliant guy who always knows what to do. Quite the opposite. I'm crap at plenty of things too. I've made bad bets on projects, wasted time, made stupid decisions and I keep making them. Just look at how many things I've built without managing to turn them into a business that lets me live comfortably.

At least I try to admit it.

Because if I can't admit that the problem might be my decision, my lack of skill or simply something I haven't understood, then no AI model is really going to help me. If anything, it'll help me build the wrong thing much faster.

And this is where our dear old ego enters the picture.

I get the feeling that a lot of people expect AI to somehow validate their abilities. If the result doesn't work, it's the model's fault. If it works, that's because they had a brilliant idea.

But maybe the model did exactly what we asked. Maybe it was our idea that was wrong.

That's hard to admit, especially when you've invested time, money and perhaps years of your life into something. I know that feeling well.

And yet I think the ability to question ourselves will matter even more in a world where we can produce software, content and entire products at a speed that would have seemed impossible just a few years ago.

Because now we can make mistakes much faster.

And maybe learn much faster too. But to learn, we first have to accept that we were wrong.

Anyway, I started out talking about the sadness I'm carrying around and somehow ended up talking about software architecture, AI agents and ego. As usual, everything gets tangled up in my head.

Outside, there are still problems I can't fix with an editor and a terminal. And they weigh on me. A lot.

In here, at least, I can still build something. Watch an idea take shape, an experiment finally work, a game begin to take on a life of its own.

I know it doesn't fix the rest.

But right now, it helps me keep going.

And as for AI, I still think the biggest problem isn't necessarily its intelligence.

It's our ego. The thing that stops us seeing when we're the ones getting it wrong, even as we hold in our hands the most powerful tool we've ever had for getting things done.