We now have Kerr’s Law (Interview)

Summary of We now have Kerr’s Law (Interview)

by Changelog Media

2h 27m•November 4, 2026
Listen to Episode

Overview of We now have Kerr’s Law (Interview)

In this Changelog Media interview, Adam Stachowiak talks with Dave Kerr — creator of Hacker Laws and author of Effective Shell — about how AI agents are changing software engineering, and what still matters most: clarity, simplicity, security, and shared understanding. The conversation centers on a newly coined “Kerr’s Law,” the role of Linux/shell fundamentals in the AI era, using Kubernetes and YAML to govern agentic workloads, and the tension between rapid AI-assisted output and the human need to truly understand what was built.

Kerr’s Law

Dave’s on-the-spot law is the episode’s core insight:

The limiting factor to building and scaling software is how well a team keeps its mental models synchronized with reality.

Why it matters

  • A single engineer can move fast and keep intent aligned with output.
  • Teams, however, need deliberate checkpoints to stay aligned on architecture, behavior, and risk.
  • In the AI era, code may be produced faster than humans can reason about it, making alignment even more important.

AI-Assisted Engineering: Speed vs. Understanding

Dave and Adam spend much of the episode discussing how agents change the shape of engineering work.

Main themes

  • AI can one-shot complex tasks, but that often creates systems with weak primitives or hard-to-extend designs.
  • The real challenge is no longer syntax or line-by-line code generation — it’s system-level reasoning.
  • Engineers increasingly need to review:
    • architecture
    • idioms and conventions
    • authorization boundaries
    • blast radius
    • operational behavior
    • maintainability over time

Practical stance

  • Use agents to accelerate work, but don’t skip:
    • spec review
    • code review
    • system review
    • security review
  • Sometimes the right move is to slow down on purpose so the team’s mental model stays current.

Linux, Shell, and the Unix Philosophy Still Matter

A recurring idea is that modern AI tools are still built on old, simple primitives.

Why Dave values these fundamentals

  • Tools like bash, grep, ls, pipes, and simple CLI patterns remain powerful because they are:
    • deterministic
    • composable
    • inspectable
    • easy for agents to chain together
  • He sees AI coding agents as a modern celebration of the Unix philosophy:
    • small tools
    • clear interfaces
    • pipelines that compose into complex workflows

Related takeaway

  • Understanding Linux, containers, and shell workflows gives engineers more leverage in an AI-driven world.
  • Knowing the machine that builds the machine is becoming as important as knowing the app itself.

Governance, Kubernetes, and Agent Infrastructure

Dave describes work his team is doing around running agents like managed services.

What they’re building

  • Open-source tooling that lets teams run agents in Kubernetes
  • YAML-based agent definitions
  • Governance, auditability, and permissions around agent execution
  • Deterministic steps where needed, with agentic steps layered around them

Why Kubernetes fits

  • Resource management
  • Observability
  • Secrets handling
  • Audit trails
  • Deployment patterns familiar to SRE and platform teams

Key idea

Agents should be treated more like microservices with judgment:

  • constrained
  • observable
  • governable
  • restartable
  • deployable across environments

Open Source, Security, and the CVE Reality

Dave is optimistic about open source, but noticeably more conflicted than in the past.

What changed

  • AI makes it easier to copy ideas, patterns, and even architectural choices without directly copying code.
  • Open source is now entangled with:
    • growth hacking
    • supply-chain risk
    • fast-moving dependencies
    • licensing uncertainty
    • security exposure

A concrete pain point

  • His team reportedly spends around 25% of engineering time on CVEs, especially in the npm ecosystem.

The broader concern

  • Frontier model providers may eventually become a layer that influences architectural decisions.
  • Dave raises the possibility that companies could pay models to favor certain products or tools during “build vs. buy” recommendations.

Evidence, Not Just Code

A major practical idea in the interview is that agents should produce proof, not just output.

Dave’s preferred artifacts

  • terminal recordings
  • screenshots
  • before/after evidence
  • logs from real runs
  • shell session videos
  • interactive demos

Why this matters

  • A test passing is hygiene; it’s not enough by itself.
  • He wants evidence that:
    • the workflow works
    • the UI behaves correctly
    • the terminal interaction is credible
    • the system matches the intended outcome

Related tool

  • Dave discusses ShellWrite, a tool for recording shell sessions and generating terminal-style output artifacts for pull requests and documentation.

Mental Health, Flow, and AI’s Emotional Amplification

One of the most candid parts of the episode is Dave’s discussion of bipolar disorder and how AI can amplify cognitive and emotional volatility.

Main points

  • AI can intensify:
    • grandiosity
    • hyperfocus
    • rapid context switching
    • “slot machine” behavior
    • overconfidence in half-baked ideas
  • For people already prone to extremes, agents can make it harder to regulate pace and attention.

His coping strategies

  • No creative work after 6 p.m.
  • Deliberate shutdown rituals
  • Awareness of warning signs
  • Time to process and integrate ideas
  • Spending time with other humans, not just the machine

Broader takeaway

  • The tech is powerful, but engineers need boundaries, empathy, and self-awareness to use it safely and sustainably.

Open Source Side Projects and the Loss of Craft

Dave expresses a sense of grief that many handcrafted projects can now be reproduced quickly by models.

His tension

  • Side projects used to signal:
    • curiosity
    • craft
    • patience
    • playful learning
  • Now a lot of that can be compressed into a short agent session.

Still, there’s value in the craft

  • The point is not to reject AI.
  • It’s to preserve the human experience of building, learning, and exploring.

What Dave Thinks Experienced Engineers Bring

Dave argues that experience still matters a lot in the AI era.

Why experienced people have an edge

  • They know when something is a solved problem.
  • They can smell risky architecture quickly.
  • They understand tradeoffs, operations, and long-term maintenance.
  • They can act as the “adult in the room” for teams moving fast.

But the young still matter

  • Newer engineers may grow up native to agentic workflows.
  • The future likely belongs to people who combine:
    • curiosity
    • judgment
    • systems thinking
    • practical experience

Practical Recommendations from the Conversation

For teams

  • Keep specs and reviews in the loop.
  • Use agents to accelerate work, not replace judgment.
  • Review the architecture, not just the syntax.
  • Produce evidence artifacts for every meaningful change.

For individual engineers

  • Learn Linux, shell, Docker, and Kubernetes basics.
  • Build systems that are deterministic where it matters.
  • Keep your mental model fresh and don’t let tools outrun understanding.
  • Put boundaries around AI usage to protect focus and well-being.

For open source maintainers

  • Expect more scrutiny, more copying, and more security pressure.
  • Be explicit about governance and auditability.
  • Don’t assume open source is unchanged just because the license is.

Closing Thought

The episode’s biggest idea is that AI doesn’t eliminate the need for understanding — it raises the premium on it. Dave Kerr’s “law” reframes engineering as a coordination problem: the team that can keep its understanding aligned with reality will move fastest, safest, and most sustainably in the agentic era.