"AI-native" for the rest of us
We’re just weeks away from the singularity, yet many of us still need to review code before it gets merged. In organizations that don’t yet auto-stamp a subset of pull requests or have engineers individually ship to prod, navigating AI adoption can look like:
- Enthusiastic engineers creating a ton of pull requests that their peers then need hours to make sense of.
- Uncertainty around whether AI is a net benefit to productivity. Does it lead to increased revenue or impact? Or does it just generate more work for people to review?
- Blowing through token budgets without a clear sense of what you accomplished.
- Occasional moments of delight where you think, “Wow, that’s really cool.”
Fortunately, even when humans are still a bottleneck, you can use AI to improve both the throughput and quality of work. You just need to change how you work to make room for it.
Going parabolic
One of our big deliverables for the PSI Toolkit this quarter is a brand new Postgres database backend. The toolkit, a piece of open source software New_ Public co-develops with several national public broadcasters, was originally built as a prototype on top of Firebase Realtime Database. That version became an overly abstract, loosely typed denormalization nightmare and locked everyone into Google Cloud. Our port to a typed oRPC API over the summer started us on the road to salvation, and adding Postgres support will free us from sin.
It’s not a particularly complex application, but it’s not a simple CRUD app either. Our draft database design document forecasted 60 tables with 475 columns. Thanks to AI and some planning work up front, progress currently looks like this:

“AI-native”
My favorite definition of “AI-native” is “only possible because of AI.” For example, we track our Postgres project in a highly detailed spreadsheet covering everything from the status of each procedure to the test coverage of each procedure’s router file. A year ago, it would’ve taken me days to curate such a spreadsheet. AI made it possible in a few minutes.
![]()
AI-native SDLC
Inspired by Eliyahu Goldratt’s The Goal, I started an AI-Native Software Delivery document a few months ago as a mental framework for navigating AI adoption. One key idea from the book: when a bottleneck ceases to be a bottleneck, you have to go find the new bottleneck and manage to that. An equally important second idea: if the old bottleneck becomes highly efficient, it can even cause more problems than you had before.
When you simply throw AI at writing a bunch of code, the bottleneck moves from writing code to reviewing it. Agents open pull requests faster than people can review them, and they pile up in a queue. However, if you put more effort into the step before writing code, definition, you can better manage the review bottleneck.

Twice as fast
Loosely compared to late 2025 velocity, the Postgres project is going twice as fast:

Even with “require at least one approving human review for merge” as a constraint, our throughput increasingly comes from AI. AI writes the code, AI writes the tests, and AI describes the changes.

AI is really helpful, but velocity comes from clarity in definition and clarity in verification.
Contracts as a foundation, prototypes and decision records to create alignment
Before the oRPC project over the summer, much of the application’s business logic was ambiguous: defined in code but not clearly specified or even contradictory at times. We put a ton of effort into reconciling all of it into an explicit, typed contract. This contract then provided a definition for how the application should behave. It turned “move to Postgres” into 151 procedures we could incrementally port and test.
Contract in place, the discussion then turned to how we should architect the Postgres implementation. Because AI makes it cheap to write code, two engineers each built a working version of their proposed approach:
- One put an interface in front of each part of the data model, so that we could move to Postgres domain by domain.
- The other implemented the oRPC contract directly against Postgres, so that we could black box the entire implementation and avoid the work of defining a common abstraction. They built it three times, once each with the Kysely, Prisma, and Drizzle database libraries.

After debating the working versions, we ended up choosing the first approach and canonized it in a series of four architecture decision records (ADRs). Before AI, a team of our size would’ve argued over a design document. AI made it possible to better explore the problem space, visualize each option, and feel more confident in our final decision.
Good, but not perfect
Before starting the Postgres port, we set up an API replay test suite that drives a sequence of oRPC calls and records every answer as a snapshot. This let us capture the expected behavior using Firebase and then use the snapshots to evaluate Postgres’ behavior. If Postgres answers differently, it shows up as a test failure.
Both the planning and the tests helped, but hindsight shows we could’ve gone further. More than half of reviewers’ change requests were something we could have decided up front or caught with a test. Because of AI, each of these can now also be fodder for improving the system.

Feed the loop
Yesterday, I sat in on a call while the group discussed whether a second deliverable was achievable this quarter. I listened patiently while they debated how to determine whether items were P1, P2, etc. After a while, I chimed in with: “This work is actually pretty well-scoped. I think we could crank through it with AI.”
This morning, I applied the lessons from the Postgres port: spend even more time on upfront definition, and make it even easier for computers and humans to review the work.
First, I asked AI to put all of the issues in a spreadsheet. Then, in a second tab, AI and I iterated on a standard prompt to use with every issue. Finally, in a third tab, AI and I worked on a PR description template to make it easier for humans to verify the work.
Within an hour, I had the work planned out and five pull requests ready for review. They’ll be the grist for refining the prompts. I’ll feed any review comments or feedback into the prompt and template, and then send AI to crank through a larger batch.
Code is cheap, as long as you know the direction you’re headed. For the rest of us, “AI-native” means using AI to do the work, but also using AI to better understand the entire system.