AI Coding

I’ve now produced a few apps using AI coding assistants. A deep-time world timeline (https://github.com/garyo/deep-time-timeline, check it out at https://deep-timeline.org/), an AI-assisted personal knowledge management app written for my own use (https://github.com/garyo/gco-llm-pkm), a WebGPU image-shader-evolver experiment, a web-based packing list app (https://github.com/garyo/packzen, at https://packzen.org), and a software construction tool called pcons. Claude Code has already improved several fold since I started doing this kind of development six months ago, which itself is noteworthy. I’ve heard that Anthropic is now writing much of Claude Code’s new functionality with claude itself. This really does seem like a tipping point to me.

I’m an end-of-career senior software developer and architect; I’ve been a CTO and individual contributor, I’ve managed developers, product lifecycles, and written big projects in all kinds of languages and toolsets. These thoughts are from my perspective; I imagine others will have very different feelings and ideas sparked by the AI revolution we’re living through. But to me, it feels like one of the most significant changes I’ve lived through, if not the most. This comes with a slew of benefits, but even more caveats and concerns. More on that below.

Speed: Idea to Working App

For me, AI coding assistants like Claude Code have drastically reduced the activation energy of starting a new project. I’ve kept a backlog of “wouldn’t this be cool” ideas for decades; most of them are just too much work for a very uncertain business model, not knowing if they’d even work or not. Or I see some piece of software out in the world and think “I know I could do that better; I could make something that works just the way I want” — but is it worth spinning up a whole project for a few weeks or even months of work, just to make something a tiny bit more customized to my taste?

The answer, with Claude Code, is emphatically yes. I can write a spec, have Claude code up an initial version in an afternoon, and spend a few more days adding features, trying different approaches, even starting again, and in a long weekend or a week or two have something really quite decent. I’m pretty happy with packzen at this point.

Finding meaning

I don’t think I was ever a mythical “10x” engineer, but I’ve always been pretty good at it, and I’ve been proud of the work I’ve done, both the user-facing results and the code quality itself. So what does it mean for me to turn over a large chunk of that process to an algorithm?

A lot of people, myself included, are very concerned about how anyone will learn programming if we leave all the grunt work to machines. I personally am happy to direct and collaborate, more like a conductor than an orchestra musician, but without musicians, a conductor is nothing. Where will those people come from in the future? Will new developers learn high-level skills (project management, UX design, the tradeoffs between time and space, performance and maintainability, and the importance of good API design, knowing just how much flexibility to design in, where to draw the lines in testing, and so on)? I learned those skills through a lifetime of programming in all kinds of languages, from the lowest to the highest levels, creating systems large and small, and thinking deeply about what worked and what didn’t. Can those skills be taught by prompting an LLM? It may be that they can, but right now I’m skeptical. It’s all too easy to create “slop” that satisfies no one.

I note that this isn’t just an issue with software developers. Marketing, legal, HR, governance, medical, and customer support roles are all at risk of being replaced by AI (in some cases they’ll likely do it better than humans, and in some cases not — and probably nobody in power will care). If we don’t have a way for people to learn their jobs by doing, then where will future experts come from?

But for me personally, at this point in my life, I’m less interested in learning the details of the Clerk auth API or how to set up state management in Astro, or even puzzling through a C++ metaprogramming task, than I am in getting my product idea turned into something I can see and play with and show others. I want to make helpful and interesting things. Frameworks will churn, as they do; languages will evolve, dependencies will go stale, and things will have to be adjusted. For me, that’s no longer the fun part. I’m glad to turn that over to an always-cheerful always-helpful assistant.

Collaboration, not assistance

Coding with an AI tool like Claude (I use Opus 4.5 today) is starting to feel much more like working with another person than it did even a few months ago. It asks questions, it suggests ideas. I often start with a vague outline of my vision, with a few important signposts, and say “suggest three ways to approach this, with analyses for each one, and let’s discuss.” Things get deep really fast, and between us we can flesh out a detailed design that to me feels right. And if it turns out it has blind alleys, there’s no ego involvement — Claude is happy to backtrack and take a different approach. And it’s really good at refactoring.

Is a coding agent the new compiler?

I rarely look at the generated assembly or bytecode from a compiler — only when I’m truly interested in bare-metal performance. Most of the time, I trust the tool to generate reasonable assembly code. I wonder if, in a few years, this is how we’ll treat coding assistants? We’ll tell them what to do, review the high level results, and trust that the code they wrote accurately represents our intent. I’ve seen articles on the net saying it’s not the same, because writing code and compiling it is deterministic; there’s only one correct executable program that represents a certain source file. But for at least a decade or two, since the advent of branch prediction and speculative execution hardware, that’s no longer even close to true. Modern compilers have incredible optimization engines that create tighter machine code than a human ever could, and we’ve long ago turned over those fine-grained decisions to them. They loop-unroll, auto-parallelize, and reorder code while maintaining correctness. It’s absolutely true that a text-based description of a program for an LLM is a lot looser than C++ source, but I think this will eventually be seen as a difference of degree, not kind.

But is it thinking?

Here’s a quick anecdote; I’ll try to avoid anthropomorphizing, but it gets pretty hard. I prompted Claude Code to add a significant feature to my personal knowledge manager app. It produced a two-page detailed plan with a good UX, careful, secure back end API and good tests. I prompted it to go ahead with the implementation. It wrote a few hundred lines of code and then wrote “Ah, now I understand the problem better. I can see that my approach won’t work well, and it duplicates code from another part of the app. Let me think about a better approach.” It then goes off, writes 250 lines of very nice code, and produces an improved plan. I approve that and it then proceeds to write the whole feature, which works first time.

So what am I to make of this “now I understand” and “let me think”? Does it understand anything at all? Isn’t it just a “stochastic parrot” as some people claim? If a person made those statements, I would have no trouble believing that they do understand the problem better after digging into it. There’s no denying that Claude explored an approach for a while, “decided” that it was going down a blind alley, and was able to pop out and create a better solution. I really don’t see any reason not to believe that it does understand the code, its own approach, and the overall goal. Some people may say it’s not real understanding or real thought unless the system producing the results is “alive” or made of the right organic substrate or has the right quantum synaptic structure, so perhaps I’m just an operationalist in this case, but I think it’s rapidly becoming a distinction without a difference.

I plan to write another essay digging into the philosophical implications of this, but for now I’ll just side with those who think this is a real form of understanding and thought, and probably true agency. Consciousness is another matter entirely though. As a side note from a child of a philosopher, it amazes me that we as a culture are now engaged in practical philosophy — the oldest existential questions are suddenly made manifest and testable, and they affect our daily lives.

What does this mean for the future of development?

Bigger Picture