Opinion

Postgres 19 Delayed: Why AI Coding Slows Releases

Postgres 19 was delayed amid a rise in reported defects. The underlying issue may be that AI-assisted development increases code volume faster than teams can review, test, fix, and maintain it.

Font size

Postgres 19 has been delayed. Author Brent H. Haas argues that the increase in reported defects is related to AI-assisted programming, which has expanded the volume of code being produced. This article examines how costs shift across AI-assisted generation, review, testing, fixing, and maintenance, while noting that the conclusion still requires empirical validation.

What AI Has Made Longer

The claim that “AI writes bad code” is too simplistic.

The first thing AI-assisted programming changes is output. Once requirements are broken down, an Agent can quickly produce boilerplate, adapter layers, test scaffolding, and repetitive changes. Commit counts rise, diffs grow, and feature branches remain active longer.

What takes longer is the queue of work that follows a change.

A feature that previously took half a day to implement had relatively predictable review and testing times. Today, the same requirement may yield a runnable version in two hours, followed by a backlog of questions:

  • Which additional edge cases need coverage?
  • Which additional compatibility risks need investigation?
  • How much generated code needs manual verification?
  • Who will fix failing tests?
  • Who will maintain subsequent versions?

AI has not eliminated engineering work. It has shifted some of that work from implementation to verification. If verification capacity does not increase at the same pace, the queue builds up.

The central argument is not that AI only produces poor code. Rather, AI-assisted programming raises code output while also increasing the amount of work required for review, testing, and maintenance. This is a throughput amplification effect, not a simple decline in quality.

Postgres Has a Different Bottleneck

Database software and ordinary applications do not face the same constraints.

Applications can use staged rollouts and, when necessary, roll back to the previous version. Postgres must account for upgrade paths, existing extensions, driver compatibility, replication behavior, concurrency semantics, and long-term support across multiple major versions.

A seemingly local change can affect:

  • The execution results of existing SQL;
  • Transaction isolation and locking behavior;
  • VACUUM, replication, and backup workflows;
  • Internal interfaces used by third-party extensions;
  • The migration cost experienced by users during upgrades.

As a result, the release criteria for Postgres 19 cannot depend only on the percentage of features completed. Teams must also determine whether the release candidate leaves behind enough high-severity, difficult-to-detect defects.

The key factor is not how much code was written, but the radius of the change. AI is effective at rapidly expanding the scope of modifications, but every expansion of that scope also expands the risk.

The Postgres delay illustrates a shift in the project's bottleneck: away from implementing features and toward fixing defects and maintaining quality.

More Bugs Do Not Necessarily Mean Worse Code

It is easy to interpret “more bugs were found” as “the quality of the generated code suddenly deteriorated.”

Those are not the same thing.

Suppose a release contains 100 defects. Before AI, a team might test only the most common usage paths and receive 30 reports. After AI expands the amount of code and the scope of changes, test coverage also expands, and the team receives 80 reports.

Eighty is not necessarily worse than 30.

If the additional 50 reports come from deeper concurrency, migration, or failure-path testing, the increase may indicate that defects are being exposed earlier. The more relevant questions are:

  • How many high-severity issues remain in the release candidate?
  • How long does it take to fix a defect once it is found?
  • Do the fixes introduce regressions?
  • Does the team have enough capacity to clear the backlog?

AI programming therefore cannot be evaluated by counting bugs alone, nor by looking only at commit counts, generated lines of code, or feature completion rates.

A more useful metric is effective delivery speed:

Effective delivery speed = Number of features that pass acceptance and can be safely released / Cycle time

If AI shortens feature implementation from three days to one, but review takes two days, testing takes three, and fixing takes four, it has improved code generation speed rather than delivery speed.

Review Becomes the New Bottleneck

AI-generated code affects review in ways that go beyond higher line counts.

Manual review works well for verifying that code does what it is expected to do. When reviewers face a large volume of structurally similar generated code with uncertain details, they quickly lose patience. Reviews can deteriorate into:

  1. Checking whether the diff looks like correct code;
  2. Running the tests once;
  3. Inspecting a few obvious security concerns;
  4. Trusting the Agent's explanation.

The problem is that code that “looks right” and code that actually behaves correctly are not the same.

CI systems also come under pressure. Generated code usually brings more tests, configuration, and branching combinations. As test suites grow longer, developers begin skipping full test runs, local feedback slows, and CI queues accumulate.

Some of the most hidden costs appear during maintenance. It is easy for AI to generate 500 lines at once, but six months later, a team modifying nearby logic still has to understand those 500 lines. Lower generation costs do not eliminate the cost of comprehension.

A more reliable engineering workflow assigns AI to bounded tasks that are easy to verify:

  • Generate call code against an existing API;
  • Add tests for failure paths;
  • Run static checks and fix explicit errors;
  • Automatically compare results before and after a migration;
  • Split high-risk changes into small commits that can be rolled back independently.

This is preferable to having an Agent modify the core execution path, compatibility layers, and test expectations simultaneously, followed by a manual review of one enormous diff.

The Debate Over 318 Points on HN

The original title was:

Postgres 19 is late and it’s AI’s fault

The Hacker News discussion received 318 points and 212 comments. The disagreement centers on whether the additional code produced with AI creates more defects or amplifies bottlenecks that already existed in the development process.

Supporters of the original argument generally followed this logic:

  • AI produces more code;
  • More code requires more review, testing, and maintenance;
  • Project-management capacity remains unchanged, so higher output creates a backlog;
  • Local speed gains mean little for high-risk software such as databases.

Those who reject the claim that “AI is entirely to blame” also have valid reasons:

  • The Postgres delay may result from a combination of scheduling, division of work among contributors, and testing windows;
  • The increase in bugs may reflect stronger testing rather than worse code;
  • AI may only amplify existing process problems and cannot replace root-cause analysis;
  • Without comparative commit, review, and defect data, any causal claim remains speculative.

Another group of commenters noted that AI code does not degrade uniformly. It works well for boilerplate, documentation, test coverage, and mechanical migrations. Human design remains essential for concurrency, protocol details, and security boundaries.

For that reason, “Postgres 19 was delayed because of AI” is better treated as a hypothesis that needs testing than as a proven causal conclusion.

Source material:

Engineering Implications

This matters for more than one delayed database release. It exposes a common measurement error in AI-assisted development: teams treat generation speed as productivity, commit volume as progress, and passing unit tests as readiness to ship. Once the bottleneck moves to review, concurrency validation, and defect repair, those metrics can encourage teams to expand the area of unverified changes.

The scarce capability is increasingly not code generation, but the ability to verify code. Executable specifications, differential testing, migration replays, static analysis, and review time allocated according to risk are all closer to delivery efficiency than counting generated lines. What makes the Postgres 19 situation different is that AI amplified not a standalone utility, but a core system defined by high compatibility requirements, concurrency, and costly migrations. No matter how quickly individual pieces are generated, the overall cycle can lengthen if verification costs grow faster than diffs.

How much AI contributed to the delay remains uncertain. The 318 points and 212 comments show that the discussion was active, not that causation has been established. Drawing a conclusion would require, at minimum, comparisons of commit volume across releases, the proportion of AI-assisted work, defect-fix cycle times, and CI data. Until then, this is a management hypothesis worth testing.

Source: http://rhaas.blogspot.com/2026/10/postgres-19-is-late-and-its-ais-fault.html