"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:

Hand-drawn chart of oRPC procedures served on Postgres on main, as weekly bars with a line through their tops, on a scale from 0 to 100% of the 151 procedures in the API: by Nov 19, 141 of 151 (93%), with a flat week marked “OOO: Team retreat” starting Oct 19, and a steep climb in the last two weeks

“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.

Hand-drawn excerpt of the tracking spreadsheet with four of its 151 procedure rows. profiles.get and settings.update are served on Postgres, calling the Member, Profile, User and Settings repositories, with 8 and 16 API test files. comments.setReaction is in progress in an open pull request, with 4 test files and 84% router file branch coverage. moderation.createModerationTaskNote is not served yet, with 1 test file and 0% branch coverage. Six more columns are not shown.

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.

Hand-drawn illustration titled “Where the work waits”, in three rows across Define, Write code, Review and Shipped. Before AI, a person writes the code slowly, a tall backlog waits in front of them, and 2 changes ship. With agents, a robot writes code fast, but a stack of big pull requests waits for a puzzled reviewer who sends work back for rework, and still 2 ship. AI-native, a person and AI define the work with a contract, ADRs and prototypes, AI writes the code and tests, CI checks each pull request first, a few small pull requests wait for a reviewer who checks them against the contract, and 4 ship.

Twice as fast

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

Hand-drawn timeline in weeks titled “Twice as fast”: the Postgres port’s 122 merged pull requests so far took 7 weeks this fall, Sep 29 to Nov 19. At the same three engineers’ late 2025 pace, when they merged less than half as many pull requests a day, the same work is estimated at 18 weeks, 11 more weeks.

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.

Line chart of 2026: New_ Public PRs with an AI co-author rose from 42% to 95%, PRs with descriptions over 300 words from 12% in March to 80% in September and 77% in November so far, product pages visited by end-to-end tests from 24% to 63%, and test lines as a share of all lines from 14.5% to 34.5%, while the share of merged PRs a later fix changed within 30 days stayed between 9.5% and 15.5%

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:

  1. One put an interface in front of each part of the data model, so that we could move to Postgres domain by domain.
  2. 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.

Hand-drawn timeline in weeks: with AI, the Kysely, Prisma, and Drizzle versions of the second approach were all built in 2 days, Aug 18 to 19. At the team’s 2025 pace of about 2,400 lines a week per engineer, the same three builds of 4,100 to 5,400 lines each would have taken about 6 weeks.

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.

Hand-drawn chart titled “What reviewers asked for”: 182 change requests in 130 review comments on 44 Postgres port pull requests in the 30 days to Nov 19, shown as one bar split by type. A bracket over the blue part, more than half the bar, reads “59%: definition or a test could have caught it”, covering definition we could have settled first 49 (27%), wrong or missing behavior 33 (18%), and tests too weak 25 (14%). The grey rest is code structure 42 (23%), performance 15 (8%), style and wording 15 (8%), and other 3 (2%).

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.