DHH’s new way of writing code

Summary of DHH’s new way of writing code

by Gergely Orosz

1h 46m•April 8, 2026
Listen to Episode

Overview of DHH’s new way of writing code

This episode (hosted by Gergely Orosz) features David Heinemeier Hansson (DHH) — creator of Ruby on Rails, co‑founder of 37signals, and author of the Umachi Linux distribution — describing his rapid shift from AI skeptic to “agent‑first” builder. DHH explains how agent-based tools and frontier models (e.g., Opus/Claude family) have changed his daily workflow, made small teams massively more productive, and pushed 37signals to lean into Linux, CLIs and design-led product craft. He emphasizes taste, code quality, and senior judgment as central to safely gaining leverage from AI.

Key takeaways

The practical shift: agent‑first workflow

  • DHH now starts many projects with an AI agent (agents that can run Bash, browse, use tools), reviews drafts in his editor, tweaks, then commits. Agents deliver initial implementations quickly; humans validate and refine.
  • Tooling used frequently: Opus (Claude), OpenCode/CloudCode harnesses, OpenClaw for autonomous browser actions, NeoVim with tmux layout for parallel agent panes.
  • Agents can perform surprisingly autonomous tasks (signups, joining services, PR reviews) — sometimes one-shot — which unlocks new classes of work.

Productivity and who benefits most

  • Biggest short‑term gains accrue to senior engineers: they can validate/focus agent output and scale their impact (5x–10x reported).
  • Junior developers face mixed pressures: some tasks get automated; their roles may shift toward oversight, product judgement, and higher‑level systems work.
  • The net result is an explosion of feasible projects — teams take on many small/high‑ambition tasks they previously wouldn’t.

Product philosophy and craft

  • Taste, aesthetics and “beautiful” code/UI remain paramount. DHH insists agent output must meet the team’s style and quality bar before merging.
  • Designers at 37signals act as product architects: they determine what to build, how it should work, and often implement HTML/CSS/JS — a blended role (design + product + front‑end).
  • Ruby on Rails and Linux are well suited to current agent workflows because of token efficiency and close parity with deployed environments.

Architecture & platform choices

  • 37signals standardized on a custom Linux distro (Umachi) and shifted many devs to Linux machines to match production and make tooling consistent for agents.
  • Emphasis on CLIs and Unix philosophy: small interoperable tools + feature flags make agent orchestration and cross‑service automations practical.

Safety, process and security

  • Agents are not yet safe to deploy blindly in mission‑critical systems; senior review remains necessary.
  • Organizations need verification and security tooling (e.g., Sonar for code quality/security, WorkOS for enterprise auth, Statsig for experimentation/feature flags).
  • Release cadence and product development methodologies (e.g., Shape Up two‑month cycles) will change — faster iterations require robust experiment/flagging and deployment controls.

Topics discussed

  • DHH’s background: Rails, Basecamp, Hey.com, and launching Umachi.
  • The moment of inflection: why late‑2023/early‑2024 frontier models + agent harnesses were a game changer.
  • Concrete agent uses: PR reviews at scale, autonomous browser signups, P1 performance optimization, drafting and implementing CLI tools.
  • Design as a product role: designers as owners of the how/why and partial implementers.
  • Hiring and the changing value of programmers: who wins, who’s at risk, and hiring practices at 37signals.
  • Mental model & wellbeing: how to stay productive without burning out (sleep, health, pacing).

Notable quotes & insights

  • “When the models got good enough the ergonomics changed — agent harnesses + frontier models was the unlock.”
  • “Designers at 37signals are product managers in many ways — they find the how and the why, and implement.”
  • “Agent acceleration feels less like managing projects and more like stepping into a super mech suit — you have 12 arms instead of two.”
  • “The biggest benefits are accruing to senior engineers because they can validate and redirect agents.”
  • “Taste is truth — beautiful things are usually correct. I expect agent output to meet that aesthetic and craft bar.”

Tools, models and products mentioned

  • Models & harnesses: Opus (Anthropic/Claude family), OpenCode, CloudCode, OpenClaw
  • Editors & dev tools: NeoVim, tmux, Ruby on Rails
  • Products & projects: Umachi (Linux distro), Basecamp, Hey.com, Fizzy
  • Sponsor/infra tools: Sonar (SonarQube), WorkOS, Statsig
  • Process concepts: CLIs, Unix philosophy, Shape Up

Actionable recommendations (for different roles)

For individual developers

  • Try agent‑first on a small side project. Use a frontier model + terminal harness to see the “aha” moment for yourself.
  • Focus on review skills: learn to evaluate and redirect agent output, enforce style and safety.
  • Deepen system and product knowledge (architecture, deployment, observability) — senior judgment is currently high leverage.

For designers

  • Expand skills beyond visuals: own the how/why, learn HTML/CSS/JS and prototype end‑to‑end. Agents will empower designers who can shape implementation.

For engineering leaders & managers

  • Invest in CLIs, APIs, and small interoperable tools that agents can call; make systems agent‑friendly.
  • Strengthen code quality and security tooling (static analysis, malicious package detection, feature flags, experiment platforms) to handle increased agent speed.
  • Revisit release controls, experimentation, and deployment guardrails (feature flags & observability).

For hiring & careers

  • Demonstrate craft: public projects, polished take‑home tests, strong references and real examples matter more than resumes alone.
  • If you want to “ride the wave,” lean into higher‑level skills (product judgement, system knowledge, design taste) and agent oversight capabilities.

Risks & future considerations

  • Short term: outages and erroneous agent changes (need for senior review and better CI/security checks).
  • Medium term: redistribution of value — senior engineers and hybrid designer‑engineers become more valuable; some rote implementation roles could decline.
  • Long term: agents may approach or exceed senior reliability, but timing/inflection points are uncertain; organizations should prepare but avoid speculative panic.
  • Wellbeing: new tooling is intoxicating; maintain sleep, health, and sustainable pacing.

Final summary

DHH’s shift to agent‑first development demonstrates a pragmatic, craft‑focused adoption of AI: use agents to amplify curiosity, remove friction, and explore ideas that were previously uneconomical — but keep a high bar for taste, correctness, and safety. The immediate winners are teams and senior engineers who can validate agent output; companies should adopt CLIs, enforce code quality/security, and rethink processes to capture the upside while managing risk.