Intro -> Next Level

Nearly two years ago, my team had an idea. “Let’s build an on-device agent that is actually useful. You know, one that can do stuff on the machine for the user, so they can get back to their work more quickly.” Agentic tools were barely getting started, but we figured they would help us do things a little faster. One week later, we’d created our proof-of-concept.

It was rough. It barely held together. But it ran — and back then the tools were pretty rough too, but a week for something that should have been six weeks was the kind of velocity that turned heads. Was the product amazing? No, but it was impressive for how fast it got done, and I could see something else: software development was about to level up… again.

This is not the first time software engineering has leveled up. One could argue that the first level was writing the machine’s instructions by hand. Punch cards. Assembly. (Remember coding NES games in 6502 assembly?) You weren’t expressing an idea so much as driving the hardware, one instruction at a time, trying to hold the whole game in your head while you did it.

Then the compiler arrived. FORTRAN proved the idea in 1957; by the time C spread with Unix through the 1970s, a generation had stopped hand-writing assembly. We handed the typing to the compiler and moved up a level — to logic. Variables, branches, how data moves through a program to get work done. We’ve lived at that level, compiled and interpreted, for most of the time I’ve been building software.

Agentic coding is the next level. When the agent can understand the concept and express it in code, you can stop thinking about the flow of the code — you get to think about the flow of the idea, the capability you’re actually trying to bring to life. Software development gains an extra degree of creativity (not that it wasn’t before, but more so).

We’ve stopped writing the flow of the code. The new job is the flow of the idea.

That shift did something I didn’t expect: it made me more creative. When I can take an idea and see it on screen in minutes — I can iterate at the speed I think at (well… I could if I could get responses fast enough — there’s still some work to do there). I find out what feels right long before I’d normally have finished arguing with myself about it. I can experiment with paths that are probably sub-optimal, but which have learning lessons in them, because they become cheap to try. My list of things to look into ‘some day’ went from a few tens of ideas to a few hundred in a matter of weeks. So many possibilities!

Becoming truly useful.

I remember when smartphones became truly useful. For me — that was when you could sync your calendar over the internet, all the time — that was the moment the calendar in my pocket became a necessity. A thing I depended on. Ever since I saw what agentic coding could do nearly two years ago, I’ve been watching for its version of that moment: not “impressive in a demo,” but useful to me, on my own work, every day.

It looks like that moment is here.

The tools are still immature, and still mostly pointed at large companies (agentic harnesses, anyone?). But the tide is shifting toward people like you and me. A creator can hand off a lot of their daily email, the scheduling, the office busywork. An open-source maintainer can let an agent triage PRs and resolve the conflicts, and do nothing more than review the fix. A hobbyist can watch an idea come alive in minutes instead of dying on a list. I’m not predicting that — I’m watching it happen in my life and the lives of others around me.

So I’m starting this blog to write it down. What it’s like to build stuff now, how it’s changing, and what I’m learning from it. There will be experiments that worked and the others that didn’t. There will be patterns that emerge as I use the tools. There will be lessons I only learned by getting them wrong first. It won’t always be about agents, or even about code — but for a good while it will be, because that’s what I’m curious about right now.

Mostly, I want to catalog what it actually feels like to work one level up — while the level is still new enough to remember the climb.