Rishi Baldawa

AI coding agents make architecture-shaped changes faster than teams can notice.

Stop playing tennis with bad AI PRs.

The biggest risk in AI adoption isn’t moving too slowly.

AI tools are flooding PR queues and the instinct everywhere is to call review the bottleneck.

An agent reviewed a Go PR and confidently said ‘skip.’

When AI is let loose on porting a large complicated rule-matching library from Go to Rust; you find some contractors across hundreds of sessions, and a few hard lessons.

Every high-stakes industry independently invented the same communication protocol.

Simon Willison ships most of his code from his phone via agents.

Porting Tim Bray’s quamina from Go, most things translated cleanly.

A production-ready Rust port of quamina that’s 1.7x faster than Go and 2.1x faster than Java. 369 tests, formal verification with Kani, and memory safety validation with Miri.

From YAML eating Norway to NASA losing $327 million, specification gaps cause failures at every scale.

Using AI coding assistants feels productive until you’re spending more time reviewing generated code than you saved writing it.

Comprehensive UIs meant to give operators full visibility often create the cognitive load that degrades their decision-making.

SQLite maintains 590 times more test code than production code.

Scheduling everything forces confrontation with finite capacity.

AI tools shift the bottleneck from code generation to verification.

When leadership says ‘do more with less,’ they usually mean find higher-leverage work.

When Frank Drake’s colleagues couldn’t decode his own message to aliens, it revealed a universal problem that compression requires a shared decompression algorithm.

When agents handle implementation, experienced engineers shift from typing code to architectural guidance.

Moving fast doesn’t mean finishing projects quickly.

The explosion of AI-generated pull requests is less of a capacity problem and more a specification problem.

Ten posts diagnosed why review bottlenecks under AI.

AI review tools show 73.8% acceptance rates but add 2h 28m to PR closure time.

Stacked PRs promise to unblock authors and parallelize reviews.

Batching is more than a productivity hack.

AI changes what breaks, not just how much breaks.

While continuous integration does catch bugs, and it’s more impactful by fundamentally changing who is responsible for what aspects of code quality.

Fast code review response seems to conflict with thorough review.

Part of your attention stays on the previous task.

Code review effectiveness falls off a cliff instead of gradually.

A 1961 queuing theorem predicts the bottleneck we’re seeing: AI doubles code arrival rate while review capacity stays fixed.

Assigning PRs to a team feels collaborative, but it triggers diffusion of responsibility.

The same discipline ops teams learned about gradual automation applies to AI agent integration.

GitHub’s spec-driven development pattern treats specifications as executable source code that AI compiles into implementation.

Multiple signals suggest a development paradigm shift: code deletion as progress, throwaway work as strategy, tools as artifacts.

AI-driven optimization needs reliable verifiers, which means testing becomes the most important thing.

The efficiency-thoroughness trade-off explains why ‘carefully review AI output’ is useless advice.

Shopify’s production agent system hit the same problem we’ve seen with config files and god objects-monolithic prompts become unmaintainable.

Teams iterate on prompts by changing everything and hoping it’s better.

Just like we learned to compress search queries from sentences to operators, AI tool usage shows the same fluency curve.

Developers who break tasks into sub-tasks and work iteratively with agents succeed at 83% vs 38% for one-shot prompts.

AI doesn’t fix broken processes-it amplifies them.

How the IETF’s approach to technical consensus could transform how engineering teams make decisions, especially in async environments where traditional voting falls apart.

Current AI agent discussion focuses on replacing humans, but the real value is treating agents like microservices - small, focused, with clear boundaries.

Progressive rollouts feel safer, but fine-grained rollouts can actually make incidents harder to detect and diagnose, turning safety practices into safety theater.

The obsession with AI productivity gains obscures what actually makes engineering effective.

AI coding tools respond to the quality of your input.

How Quamina manages pattern lifecycles: lock-free concurrent additions and lazy deletion with periodic rebuilds.

Runtime execution of Quamina’s dual-automaton architecture, processing events field-by-field to collect matches

How Quamina compiles JSON patterns into a two-level finite automaton that shares structure across thousands of patterns