Pursuing Frontiers

My first program spit percentages onto a black screen. It had no buttons, no colors, no cute animation to hide that inside there were four fairly questionable calculations. It was a Copa América results predictor. I fed it match data and it gave me back probabilities of win, draw, or loss.

A calculator with big ambitions written in Python.

I was fascinated.

I don’t remember if it got things right, but the truth is I barely cared. I had gotten the computer to do something I had imagined. And I had done it without knowing how to code.

Until that moment, software was something other people made.

I started using ChatGPT at the end of 2023. I asked it things every day, posed logic problems, read about those language models that supposedly predicted the next word. I struggled to reconcile that explanation with what I had in front of me. Predicting the next word seemed like a pretty modest activity for something that could discuss with me how to solve a problem.

Then a friend — one of those restless types always into something — told me:

“I’m using it to code.”

He wasn’t a programmer either. I worked with solar installations and renewable energy consulting. I could talk about panels, projects, investments. If you handed me a Python file, my first question was what you open it with.

But that line stuck with me. If he could, I wanted to try.

I started from the bottom. Way down. “Where do I put this?” “How do I run it?” “Why is everything red?” ChatGPT wrote code and then had to explain what to do with the gift. There was something very funny about that relationship: I could ask it for a program before I knew how to start one.

That’s how the predictor showed up.

It took the last ten official results of the teams and their opponents. It weighted streaks, recent matches, blowout wins. I decided one thing should weigh more than another and the model helped me turn that hunch into a calculation. Then I ran the code and looked at the results in the terminal.

There they were. My percentages. With a number of decimals that surely gave them more authority than they deserved.

And right away I wanted to change something.

What if we give more weight to the latest matches? What if we consider who they beat? Because putting four goals past a weak opponent shouldn’t count the same as beating the champion. What if we add this? And that?

I was hooked. I could go from one idea to another without hitting, every time, the wall of not knowing how to write it in a programming language. Later I gave it an HTML interface. Now my invention had a face. Pretty basic, but a face nonetheless.

I struggle to explain how big that discovery was without sounding over the top. It was a small program, yes. But I wasn’t looking at the size of the program. I was thinking about everything else I could try.

Of course I quickly ran into things I didn’t understand.

Concepts stacked up faster than the quality of the foundations. I could get something to work and not be entirely clear on why. When it came to connecting parts, configuring programs, or moving information from one place to another, the party lost a lot of its rhythm.

ChatGPT handled the logic well if I served it the problem cut into pieces. But I carried the whole project. I copied code, pasted it, ran it, brought the error back to the chat. Sometimes the model went blind: it couldn’t see what was happening in another application and started giving me instructions so I would act as hands, eyes, and errand boy.

We had an artificial intelligence and a messaging service. The messaging service was me.

I set out to study. AI fundamentals in University of Helsinki courses, essential Python features. I needed to understand a little better the mess I was getting into. And I also wanted to stop asking some things.

Meanwhile, the models improved faster than I learned. Just as I got comfortable with one way of working, another possibility appeared. It was a little frustrating and pretty addictive. What I studied helped, but that feeling of “okay, now I understand the map” never arrived.

I no longer expect it. I accept that I don’t think that point is coming.

At some point I started doing these things for work. Automations, internal tools, web apps. I was no longer playing with who won a match; there were real processes that could be improved and people who would use what I built.

Less entertaining limits than a code error also showed up. Ideas that needed investment. Prototypes that were just a piece of a much larger project. Hours someone had to put in. Money someone had to spend.

AI didn’t solve that part for me.

But building fast had enormous utility: I could get an idea out of my head and put it through something more demanding than my own enthusiasm. Use it. Show it. Discover that a feature was awkward, that a piece was missing, or that something so brilliant in the abstract didn’t matter much to anyone.

The opposite could also happen.

A prototype lets you say “look, it’s possible.” Then comes the conversation about whether it works well, whether it holds up, whether it’s secure, whether anyone will want to use it on a Tuesday morning, once the novelty has worn off.

Those are different conversations. I’m interested in getting to the second one quickly.

Then Cursor showed up and saved me an obscene number of trips between windows.

The AI was inside the project. It could browse files, touch several parts, follow relationships I used to have to explain by hand. You felt the change in your body: less copy-paste, fewer interruptions, more time thinking about what I wanted to do.

I could throw myself fully into developing.

The models kept improving and I started asking for things I wouldn’t even have tried a few months earlier. That’s one of the hardest parts of all this to measure. It isn’t only how much faster you do the same thing. It’s what occurs to you to ask once you’ve confirmed that the previous thing already comes out.

Your ambition gets spoiled.

The soccer predictor had stopped impressing me a while back. Now I wanted apps, complete automations, systems that talked to each other. And every time something worked, the same thought appeared — pretty dangerous for any agenda:

Well, while we’re at it…

Now I’m writing during a break in a three-day livestream. The SpaceXAI team is showing Grok Bot with a brief that seems designed for people like me: build a company end to end with agents.

A company. An application isn’t even enough for us anymore.

I’ve been trying it and this site came out of that. I explained what I wanted to a lead agent, a Chief, who handed work out to other agents. Design, code, repository, deploy on Vercel. Things that used to mean opening programs, connecting services, and following instructions started happening inside the same flow.

A few years ago I didn’t know where to paste the code. Now I have a Chief. My corporate career has been very strange.

What interests me about this stage is that that problem of the blind AI, waiting for me on the other side of an application, is starting to get solved. It can act on more parts of the process. It needs fewer trips from its errand boy.

And I, of course, am already thinking what else to give it.

That’s where it’s worth downshifting. Because handing over the results of ten matches is one thing, and giving access to personal accounts, repositories, and services is another. Convenience invites you to open doors. Later you have to remember which ones you opened.

I’m excited to delegate. I’m also uneasy about how much I might end up depending on systems whose workings I don’t fully control. Both things happen to me at once. I don’t have an elegant conclusion that settles them.

When I started, my lack of knowledge decided fairly quickly how far I could go. I had an idea, moved a little, and hit a wall.

Today I still hit walls, but a lot farther out.

That’s why I find it hard not to get excited when I think about agents working for hours, carrying out processes I wouldn’t even have thought to try alone. Not because I believe everything will turn out well. Because now I can try it.

And that’s where a new discomfort shows up.

For a long time, “I don’t know how to code” was enough of an explanation to leave an idea in the drawer. It wasn’t an invented excuse: it was a real limit. But that limit keeps leaving me more and more room, and at the same time fewer places to hide.

Now I have to decide what I want to do with all this. What problem I know well enough. What my time is worth. What I’m willing to finish when the fun part of watching things appear on a screen is over.

I never asked too much of the predictor. It was enough that it returned some percentages and let me play at changing them.

With what’s coming I’ll have to be a bit more demanding — and I have increasingly powerful tools to try.