Web Directions Year round learning for product, design and engineering professionals

The past week’s reading (read my breakdown of nearly 2 dozen articles here)—from across Phoronix to Stripe, from Answer.AI to the fringe blogs that are like canaries in the industry coal mine—points toward a the ongoing reorientation of the entire software development lifecycle. It’s not that AI makes code faster to write. It’s that AI, finally, makes verification tractable at scale.

For decades, we’ve accepted a hard constraint in software engineering: more eyes and more approval layers slow things down. apenwarr captures this: each layer of approval multiplies process drag by an order of magnitude. It’s a law written in organizational DNA. Code review, security review, architecture review—each adds latency. Each is necessary. Each is expensive.

What if that weren’t the case anymore?

Google’s Sashiko system flagged 53% of bugs in the Linux kernel that human reviewers missed entirely. This isn’t about replacing reviewers, but shifting what humans do. The verification layer, once a manual bottleneck, becomes parallel infrastructure. The expensive layer—human attention—is freed to do what humans do well: exercise judgment, make architectural decisions, and risk assessment on edge cases machines may miss. At least for now.

Peter Lavigne’s insight is equally astute: the question isn’t “must I review AI code?” but “how do I verify it’s correct?” Those are different problems. Review is expensive and serial. Verification can be automated, parallel, exhaustive. Formal methods, compiler constraints, test suites, unlike humans, scale. They get faster as machines improve. Human code review? It stays linear.

This shift ripples outward. Annie Vella’s research found that as engineers use AI, they don’t offload writing time into design time. They compress across all tasks. Less writing, less designing, less testing—less of everything. Because the entire development lifecycle is being squeezed. Not (just) by AI replacing parts of the process, but by AI-assisted systems touching all of it. The bottleneck isn’t where it was.

The Tier Collapse

What most industry commentary misses is that this rebalancing isn’t universal. It’s not even democratic.

Utopai’s argument that “software will stop being a thing” is seductive and partially true—but not in the way the thesis suggests. The future isn’t three tiers (elite companies with senior engineers reviewing AI output; large enterprises with platforms and fractional expertise; small shops with “software plumbers” building local tools).

What’s actually happening is that the definition of “software” is splintering. At the top, yes, there’s institutional software written by humans, reviewed by humans, subject to constraints that formal verification will increasingly handle (but all for how much longer). Alongside it—not below it, not within it, is an explosion of ephemeral, personalized, automated systems built by agents, for agents and humans in combination.

Craig Mod’s reflection captures this better than any economics paper. The software being built isn’t appearing on PyPI or GitHub’s trending pages. It’s on Claude Code projects, local instances, private Replit servers, internal tools. Answer.AI looked for a PyPI surge and found nothing. Because this emerging software is in the spaces between institutions, in the glue that holds together personal and organizational workflows. It is emergent.

Agents as Citizens

The infrastructure for this splintering is arriving fast. Stripe’s Machine Payments Protocol exists because an increasing percentage of your website’s visitors won’t be people. WebMCP and Simon Willison’s agentic engineering framework are both standardizing how agents interact with human-built systems. Andrew Ng’s Context Hubis explicit about the goal: agents need to remember what they learn, share knowledge, build institutional memory the way human teams do.

This is infrastructure, it assumes agents are permanent participants in computational systems, not edge cases.

The Honest Layoff Conversation We’re Not Having

Meanwhile, Resume.org’s survey suggests companies are doing something remarkable: they’re, let’s say “gilding the lilly” about why they’re laying people off. Or rather, they’re finding it more palatable to frame workforce reductions as “AI-driven” than to acknowledge the real reason: financial constraints, margin pressure, the ordinary churn of capitalism. The market would punish that. It rewards “efficiencies”.

Only 9% of companies say AI has fully replaced roles. Only 45% say it’s even partiallyslowed hiring. Yet nearly 60% are restructuring and claiming AI did it.

This isn’t a deflection about AI’s impact. It’s one about causation. AI is convenient cover for decisions made on fundamentals that would’ve happened anyway. Though ironically those fundamentals are driven by the emergence of AI. It’s just that the AI is often undermining the business model of these companies.

What Stays the Same (For Now)

Folks when predicting the future often look for what will change. Jeff Bezos argues for building strategies around what stays the same.

Greg Olsen’s essay on Grace Hopper’s Revenge and Andrew Murphy’s constraint-theory perspective both point at something harder to move than code output: the actual bottlenecks in software production. Code speed was never the constraint. Coordination costs, verification overhead, the difficulty of getting from intent to running system—those are the real constraints. AI touches them all, but not equally. Not instantly. Not evenly across organizations.

Geoff Huntley’s work on software porting suggests something optimistic: once you extract the specification of a system from its implementation, you can move it across languages trivially. AI is getting very good at that extraction. The implication: we’ll see more polyglot systems, more language-agnostic architecture, more emphasis on specification as the artifact of value. The code becomes subordinate to the design.

The Week’s Thread

What ties these threads together? A quiet acceptance that the decade-long story about “AI will write code” was the wrong story. Instead we are seeing that AI will distribute work differently across the software lifecycle, will make previously expensive activities cheap and parallel, will redefine what “software” means when agents become ordinary computational citizens, and will sharpen the distinction between the constraints we can relax (verification, code writing, port speed) and the ones that remain hard (intention, architecture, knowing what to build).

Anything else is novelty. This week’s articles are the serious engineering talking to itself.