I understand why this feels unsettling. When you've spent years getting good at something, watching a machine do it is a lot to process. But the feeling I keep coming back to is liberation. So many improvements I would have put off now start with a prompt. Being able to build so much of what I can imagine is breathtaking.

More shipped, same guardrails

At Filestage, we've gone from around 200 to 300 merged PRs a month without an increase in bug reports. That's roughly 50% more, with a $20 monthly AI subscription per developer. Everyone chooses their own tool: some use Codex, some Claude Code, some Cursor. PR counts only tell part of the story. We're also tackling bigger changes across the product in less time and with more confidence.

The agents keep improving, and our investment in CI guardrails is paying off: linting, type checking, duplication checks, 100% test coverage, and end-to-end tests. The feedback is there every time an agent makes a change.

Seeing that makes me wonder: could we be going even faster? Models have become good enough that I now consider it irresponsible to merge without an AI code review. Could passing our checks and getting an AI review's approval eventually be enough to merge a PR? I haven't settled that question, but it no longer sounds far-fetched.

The extra throughput has already exposed bottlenecks in our CI. We hit Cloudflare's free tunnel limits because our end-to-end test instances need to receive webhooks from third parties. CI started breaking for our engineers. We also had to give our shared development database more resources to handle the connections.

Using our infrastructure as code setup and open source FRP tunnels, I quickly vibe coded a solution to the problem. The tools creating the extra load also helped remove the bottleneck.

Abstractions still matter

I agreed with a lot of DHH's Rails World keynote about the end of writing code by hand. But his prediction that agents will move from Rust and C++ to assembly and eventually microcode goes too far for me.

I see the attraction of getting an agent to write a faster implementation in a language I wouldn't choose to write myself. But high-level representations are useful to the agent too. Given how today's LLMs generate code, I see several reasons to keep them:

• More output means more details to get right. Generating assembly means predicting registers, offsets, and calling-convention details that a compiler would otherwise handle.
• Compact code preserves context. users.filter(u => u.active) expresses an operation in a few tokens that can take many assembly instructions. Understanding a repository that already fills 200,000 tokens is hard enough before expanding it into lower-level instructions.
• Abstractions help reasoning. Types, functions, modules, ownership, and data structures expose intent and constraints. Lowering everything to assembly makes much of that information harder to recover.

We also already have tools such as Clang to turn source code into native machine code. Why spend probabilistic inference reproducing routine translation that a deterministic compiler already handles efficiently? Targeted assembly optimization may be worthwhile, but I wouldn't make it the default representation for a whole system.

My bet remains: LLM → high-level representation → deterministic compiler → machine code. The representation may change. I expect useful abstractions to become even more valuable as agents take on larger systems.

What comes after text files?

I've always been frustrated with how we build software. Bret Victor's The Future of Programming captured that feeling beautifully: look at the possibilities explored decades ago, then look at what we settled for.

Years matching parentheses and quotes. Debating tabs and spaces. Searching hundreds of files to reconstruct how something works. Formatters and linters helped, but I still had to hold the system in my head while staring at little pieces of it.

If agents can handle the code, could we finally work directly with the logic, interfaces, and data models we want? Could UML and entity relationship diagrams become useful everyday interfaces to a living system, kept in sync as we change it?

I want to see a use case and zoom into its logic, all the way down to the code when I need to. See how data moves through it. Bring production context into that view: which paths people actually use, where requests get stuck, which branches never run.

I don't know what that environment will look like. But for the first time in years, it feels within reach.

After 18 years of typing code, I thought I knew what programming felt like. I'm excited to find out what it feels like next.