First step. Not AI, but security

When I came back, I wasn't thinking about AI, projects, or money at all.

The first thing that became obvious was that the world around me had gotten harsher. Almost immediately I started hearing the same thing over and over: don't go online without a VPN; VPN traffic gets throttled; there were cases where ordinary online activity led to people getting visits from the authorities.

I wasn't living alone. And the idea of putting people close to me at risk didn't sit well with me from the start.

So the first real question wasn't "what do I do next," but how to be online safely at all.

I understood the basics. What a server is. How the internet works. That a VPS costs pennies.

But I also understood something else: any ready-made VPN means somebody else's server, somebody else's rules, and potentially somebody else's logs.

Put simply, you pay for a service that can see everything passing through it. That didn't work for me.

The logic pointed to a simple but unpleasant conclusion: if you're going to do this, run your own server. And then hide the traffic so even your provider can't tell what's going through it.

On paper that sounded like overkill. Especially given that: I'm over 45; I hadn't touched Linux in decades; not a single command was in my head.

But there was no alternative.

At that point I got lucky. Someone I'd met back in the jungles told me a short phrase: "Check out Claude Code. It runs straight from the terminal."

Not "go learn Linux." Not "take a course." Not "figure out how everything works."

Just — work where the work actually happens.

I bought a server for about six dollars. Installed Linux. Opened the terminal.

And it became clear pretty quickly: you don't need to know the commands. You can phrase them in plain human language.

Not "type this in," but: connect to the server; install a VPN; set up encryption; make it work.

And it worked.

I didn't understand exactly what was happening inside. But I saw the result: the VPN came up, connected, and did its job.

That was the simplest version. No masking. No extra complications.

And right at that moment I was told again: "Even the very fact of VPN traffic can be a problem."

The next question was direct: how do you hide the VPN itself?

The answer turned out to be step-by-step and calm. No magic.

How to make the traffic look like ordinary HTTPS. How to set up the server so from the outside it looks like a regular website. How to minimize traces.

The investment at this stage was minimal: about six dollars for the server; fifteen dollars for Claude Code, which ran straight from the terminal and essentially replaced my knowledge of commands.

But something else mattered more.

At that moment it became clear that this approach works for more than just VPN. If you can assemble a complex thing in the terminal step by step like this, then by the same method you can take apart other tasks too — infrastructure, automation, services.

This wasn't really about security. This was the first experience that made it clear how I could actually work now.

What the work looks like when you don't need to know the commands

After the VPN story, I was asked the same thing a few times. Okay, you say "human language." Then what? You open the terminal — and what, you literally write "make me a VPN"?

Almost. But if you write it like that, you'll get garbage.

The most important thing I figured out pretty fast: the tool doesn't think. It does. If you don't understand what you actually want, it will execute something. Just not what you need.

"Make a VPN" is a junk request. Because it's unclear what counts as the result at the end.

But if you write: connect to the server, install WireGuard, create one client, show me the QR code — now there's something to work with.

The difference isn't length. The difference is that afterward you can verify: did it work or not.

Here's how it looks for me in practice.

I open the terminal. I write the task, not commands. In ordinary words. It replies: here's what I'm going to do and these are the steps. I look. I say — go ahead. It does it and shows the result.

If it doesn't work — I don't go googling. I just write back: it's not connecting, here's the error, here's what I see. And I get the next step.

This isn't magic. It's just a system that knows the commands better than I do but has no idea what I need until I spell it out.

My part of the work is the unpleasant one: understanding exactly what I want to get, and being able to verify it actually works.

I made a bunch of mistakes at the start.

Wrote too vaguely. Like "set up the server." But what does "set up" mean? For what? What should the end state be?

Believed it when it said "done." And then it turned out done — but not working. Now I only trust verification: did it connect or not, does it do what it was meant to do.

Also — I tried to understand every command. That's a trap. If you start digging into every line, you'll drown and get nothing done. It's enough to understand the logic: what we're doing, why, and how to verify it.

In essence, the whole method is very simple. You phrase the task. You look at the plan. You execute. You verify. If something breaks — describe the symptom and move on.

The tool I use is Claude Code. It runs straight in the terminal and costs fifteen dollars a month.

This isn't an ad or a recommendation. I honestly don't care what it's called.

What matters is this: you manage the task, the system manages the commands.

The next case is coming up. There it'll be clear that this works for more than just VPN.