What I Think About AI

I think AI is great. I also think it's a very real and highly useful innovation. Not hype. Not a bubble. Not doom. Just mostly good old-fashioned human ingenuity moving the world forward.

But "AI" is a wildly overloaded term right now, so let me be specific about what I mean. After all, "AI" can mean about 200 different things right now. New AI-adjacent innovations are spawning daily that need new terms just to talk about them accurately.

AI, at its core, is various methods for doing data analysis and synthesis. Neural networks, backpropagation, reinforcement learning, embeddings, attention, weights. After these methods proved useful for analyzing data and generating data with incredibly accurate and useful results, many, many more services and methods have continued to be built on top of these core building-block AI methods.

AI is now such a ubiquitous tool used in so many contexts of computers that it is no different than a CPU calculating things for you. Said another way, we should stop attaching AI to everything, because it has lost all meaning. We do not call new apps "CPU-calculated software", now do we? However, the category of AI is still moving so fast and doing so much, that we don't have the right words to turn everything into a unique category yet, so "AI" branding remains.

An important NEW AI layer

There's a newer layer that applied all that analysis capability into something new: synthesis and generation. With LLMs being perhaps the most transformative.

• Image analysis → image generation (Midjourney, DALL·E, Stable Diffusion)
• Music analysis → music generation (Suno, Udio)
• Video analysis → video generation (Sora, Runway)

And then embeddings and attention: key ingredients in the very powerful ability of AI to approximately understand meaning and intent. That's what makes semantic search, RAG, and context-aware tools actually work. It's also how content and recommendation algorithms work now. Google Search, TikTok's feed, Spotify's Discover Weekly.

When you combine all of this and point it at software development specifically, something unusual happens. The ability of models to reason about code is now good enough that it.. reasons reliably not just about what code does, what code means, but when to execute code too. And when you can simultaneously generate code, reason about code, and then run that code in an automated loop, you get agents.

And it turns out.. a lot of things can be controlled by code. A lot. And agents are proving to be very useful and lucrative.

That's the AI I'm talking about. And this stuff really works. And it's awesome.

When I Realized AI Is Gamechanging

There are a few specific moments where I went from "this is interesting" to "this actually changes everything."

The first time I used ChatGPT. I was having fun within the first hour. Not impressed-by-a-demo fun — actually productive fun. I was learning things, building things, using it as a tool. I knew that day it wasn't hype.

The first time I used Cursor. This was the moment I realized AI agents weren't a joke. Not a chatbot answering questions — AI applying actual understanding to actual actions in the world, reading my code, editing files, running commands. It was doing real work. That distinction matters: going from AI that advises to AI that acts is a bigger jump than it sounds.

The first time I used bolt.new. I typed a prompt and got a working app. Not a component, not a snippet — an entire app. In the browser. No setup. That's a different category of thing. Creating software used to require knowing how to create software. That constraint just quietly disappeared.

It Started with ChatGPT

What made AI click for me as a real innovation was learning with ChatGPT. I could ask it a question, get an answer, and then go deeper. And deeper. Branch into a related concept. Come back. Ask it to explain something more and more simply until it clicked. Most of my programming education (and education in general!) has happened in conversations with AI since then.

I still use it this way constantly. Just today before writing this I had a legitimate learning breakthrough about Zod and tRPC - two important TypeScript tools that are genuinely complex at first glance - I kept seeing those terms float around and never had a clear mental model of why they mattered. One fishing session with Claude later and it actually clicked. Not because it dumped documentation on me, but because it found the right angle, the right analogy, and I could keep pulling on the thread until I got there.

Then the Vibe Coding Tools Showed Up

Cursor immediately blew my mind the first time I used it. AI can do WHAT with all my code? ITS STILL GOING? MEIN GOTT!

And then came the AI app builders. The game had changed once again - entire apps, in one prompt, in the browser, no setup. Development just got weird. Anyone can make an app now. The barrier that used to keep software to software people is basically gone.

And then the thing that made it personally interesting: all these tools run on React and Tailwind. The stack this whole new ecosystem converged on. The stack I'd been working toward for years. So when everyone was discovering vibe coding and marveling at the outputs, I was realizing: wait, AI and all these new AI apps are ridiculously well-versed in the exact tools I already use? Well that's very convenient and also very useful for figuring out how these things actually work.

AI Is Overpowered at Programming Specifically

There's something I understood pretty early that I think a lot of people may underestimate: AI is unfairly good at programming compared to other knowledge-intensive fields.

The reason is that programming is the one domain where work product, documentation, and culture all live on the internet - the actual code, the reasoning behind it, the decisions that shaped it. All of that got trained into these models. So when you ask an AI about a library, an architecture pattern, a debugging strategy - it's drawing on real-world practice, not just documentation.

Compare that to law or accounting. The rules are codified, sure, and AI has seen those. But the actual work that lawyers and accountants do every day? Strictly proprietary. No open-source tax returns. No public workpapers. AI has to reason from principles without the corpus of practice to back it up.

I was painfully aware of this contrast because I'm a former accountant. In accounting, the only way to learn how things are actually done is to ask someone who's done them. That knowledge doesn't exist on the internet. It lives in firms, behind NDAs, passed quietly from senior to junior. The part I loved most about switching to software was that I could learn as much as I wanted, on my own, for free. You can just go and do professional-level software learning and professional-level software work entirely in the open and literally no one can stop you. It's all there. That was true before AI. AI just made it absurdly more true.

But there's an even more fundamental reason coding models are overpowered: code is inherently testable. When a model generates code, you can run it. It either compiles or it doesn't. The tests pass or they fail. The function returns the right value or the wrong one. That feedback loop is automatic, verifiable, and scales to billions of training examples. No human evaluator needed.

Compare that to generating a legal brief or a medical diagnosis. How do you automatically verify that at scale? You can't. You need expensive human review, and even then experts disagree. Code is one of the only knowledge domains where the output carries its own verification mechanism built in. That's why reinforcement learning works so absurdly well for coding - the reward signal is free and unambiguous.

Agents Are Nutty

One of the most underrated things about AI is how it significantly chips away at the brittleness problem in software. Where we used to rely on regex, manual edge case handling, and fragile ETL pipelines, agents just handles the messy parts. They're incredible translators that deal with arbitrary requirements without needing every case accounted for in advance.

The same logic applies to agent skills and workflows. Instead of building and maintaining a whole script or system for every automation need, you can describe the intent in plain English and get 90%+ of the value immediately, with none of the debugging overhead. And then there's the best-of-both-worlds scenario: build a real system where precision matters, and hook agents up to it as the interface layer. You get deterministic reliability underneath and natural language flexibility on top. Telling the agent what to do is real and the threshold for what's worth automating just dropped by an order of magnitude.

Desktop Agents Are Gonna Be Ubiquitous In Office Work

At some point I stopped writing in my notes app almost entirely.

The reason is context. When I'm writing about a component I built, my coding agent can read the actual component, the related files, the git history. It knows the project. In Notion I'd be manually copying context over, hoping I got the right pieces, switching tabs constantly.

And multi-file operations. I can generate a post, add metadata, update navigation, cross-link related content - all in one conversation. The agent creates the files. I approve them. Done.

When agents handle the synthesis work, you can go from idea to published in minutes. That changes what feels worth doing. Documenting a debugging session, writing up a feature as I build it - stuff that used to feel like overhead now has low enough activation energy that it just happens.

And this functionality is actively being rolled out to all office work, not just for programming.

Now I Think About AI as a Fundamental Building Block in Software

In just the last few years, revolutionary new services and APIs have been shipped that make building software much easier, faster, and better. I reach for these new services constantly, and I can make much more powerful software thanks to them. All I'm doing is composing higher-level AI building blocks and I can make new and interesting tools. But since AI has touched multiple parts of the software I made, I'm tempted to call it "AI-powered!", when really, that's now a catchall that's.. not helpful!

Code Is Now Free (but Code Knowledge Isn't)

The clearest thing I've taken from all of this: code is free now. If you can describe what you want with enough precision, the code gets written. The constraint has moved.

What matters now is everything above writing the code. Critical thinking. System design. Architecture. Knowing what to build and why, and having strong enough taste to recognize when the output is wrong. Those skills matter more than ever, not less. Because now the bottleneck is making good, useful apps and solving all the hard problems.

I want to push back on one thing: code knowledge still matters. Maybe as much as before. The nature of it has shifted - when AI writes the code, you stop caring about syntax and start caring about blocks of logic. You're reading at a higher level of abstraction. But reading at that level well, understanding what each chunk actually does, knowing when something is subtly wrong - that requires being genuinely good at your language. Mastery is still highly rewarded, even if the pace of AI development makes it tempting to skip.

What I actually believe: mastery and productivity are both necessary, and you have to balance them deliberately. The good news is that velocity makes mastery easier to build, not harder. When AI accelerates what you can learn, build, debug, and experiment with, you're encountering more code, more edge cases, more patterns. You learn faster because you're moving faster. The ceiling goes up.

The golden rule: delegate, don't abdicate.

Programming Is More Fun Now

One more thing nobody talks about enough: programming is way more fun now. Syntax friction is a joy killer. The gap between having an idea and having a thing that works used to be filled with the tedious parts - boilerplate, looking up the docs, googling 5 terms and reading articles about them, googling syntax. That gap is nearly gone. You type what you want and you get it.

But making what I really want - production-grade apps that solve real problems, that scale, that handle edge cases, that are actually good - still quite difficult. The hard parts are still hard. But features? Demos? Prototypes? Those are free now and the fun-to-friction ratio has never been better.

What I Haven't Figured Out

A lot of it, honestly.

There are developers using AI to do all kinds of crazy things every day. I don't think we are done discovering use cases for AI. I also think there is a massive backlog in software development today where old apps not built with AI in mind are behind on the times. I think there are a lot of opportunities to make genuinely better software than before, but it still takes that same attention to detail and time and effort that old software required.

That's where I am. Check back in six months, it'll probably look different.