Speaker Notes

Mitchell Hashimoto’s new way of writing code

Mitchell Hashimoto shares lessons from building HashiCorp and Ghostty, optimizing developer productivity under strict constraints, and adapting engineering workflows for the era of AI coding agents and background automation.

The Pragmatic Engineer · 1:58:24 · YouTube ↗

Podcast episode · host + guest  Intermediate · engineering history and architecture stories

Highlights

10 clips · 15 min of 118 min
    • A strict mentor removed his mouse to force immediate mastery of command-line tools.
    • Harsh environmental constraints can dramatically accelerate technical skill acquisition.
    • Early immersion in terminal multiplexers and keyboard shortcuts builds lasting infrastructure intuition.
    • Financial constraints forced reliance on free tools like VirtualBox rather than paid cloud instances.
    • Working within tight limitations naturally guides engineers toward cleaner architectural designs.
    • Understanding foundational constraints is core to crafting robust software.
    • Early cloud-agnostic tools faced heavy skepticism when AWS was the sole dominant player.
    • Economic gravity dictates that massive markets will inevitably attract multiple major competitors.
    • Foundational conviction in market expansion justified building cross-cloud infrastructure layers.
    • Companies may want your software, but departments will fight over whose budget owns the purchase.
    • Bundling multi-product tools complicates sales because different teams own different parts of the stack.
    • Unclear budget ownership can stall sales entirely, leading to commercial failure.
    • Pre-planning and categorizing GitHub issues on the ground is essential for productive offline coding.
    • Breaking work into 15-minute chunks avoids the difficulty of entering multi-hour flow states on planes.
    • Executing bug fixes locally without internet allows bulk-pushing dozens of closed issues upon landing.
    • Acquisitions by massive companies can turn founders into cogs working on unrelated legacy projects.
    • Using a regret-minimization framework helps founders set high financial thresholds for life-altering buyouts.
    • Narrowly failed corporate board votes can alter company history and preserve independent products like Terraform.
    • Use regret minimization to determine a life-changing acquisition price.
    • Arman and Mitchell independently arrived at $100M as their minimum acceptable threshold.
    • Asking for a high valuation can successfully push hesitant corporate buyers to board-level decisions.
    • Ghostty splits execution across UI, IO, and renderer threads, unlike most standard terminals.
    • The renderer samples terminal state on a VSYNC clock to ensure smooth visual updates.
    • Low-level font rendering and grid state management must be handled manually without relying on OS shortcuts.
    • AI-generated PR spam forced a shift from default-allow to policy-driven default-deny.
    • New community-driven models require explicit vouching before opening a pull request.
    • Bad behavior permanently blocks the contributor, their voucher, and the entire invite tree.
    • Low-effort, AI-generated pull requests have overwhelmed open-source maintainers with noise.
    • Ghostty replaced open PR access with a community vouching system inspired by the Lobsters platform.
    • Vouchers put their own reputation and entire trust tree on the line for anyone they endorse.
    • Traditional Git and mainline clones break down under massive repository scales and parallel agent churn.
    • Deep merge queues and heavy branching create severe workflow bottlenecks.
    • Version control needs a paradigm shift akin to Gmail's handling of massive data to retain discarded context.
    • Delegate slow, non-thinking research and ecosystem mapping tasks to background agents.
    • Turn off desktop notifications to ensure you control when the agent interrupts you.
    • Use agents to expand your productivity boundaries without sacrificing deep focus.

Questions this video answers

14 · every answer cites the moment it was said
01 How did you start learning to code as a kid without money? 2 sources · 2:52

Mitchell started programming early as a teenager motivated by video games, teaching himself using online code and printouts of the PHP manual. Without money for professional books, he learned through freely available online resources and trial and error.

02 How did you land your first programming job in college? 2 sources · 5:50

He landed his first job after blogging during his freshman year of college, which caught the attention of a Ruby on Rails consultancy looking for developers. Despite not knowing Ruby or Rails yet, he met with them in person and took the job, learning various technologies on the fly.

03 Why did you create Vagrant while working at the consultancy? 2 sources · 12:56

Vagrant was created to solve the problem of wasting billable hours setting up inconsistent development environments for short-term clients. By using free virtualization tools, he could quickly spin up reproducible local environments to help teams without wasting half a day on setup.

04 Why did HashiCorp bet on a multicloud strategy so early? 2 sources · 17:50

HashiCorp bet on a multicloud future despite AWS being the dominant player because they believed any economically massive market would naturally attract competitors. Their conviction was that other tech giants like Microsoft and Google would inevitably enter the cloud space, making cloud-agnostic tools necessary.

05 Why did your first commercial product, Atlas, fail as a business model? 3 sources · 35:57

Atlas failed because it forced users to run all products at once, making it impossible for single-product users to buy in. Additionally, it triggered internal budget fights across different company departments over who should pay for it.

06 How did you maintain your coding productivity while traveling constantly on airplanes? 3 sources · 47:12

I pre-planned by downloading GitHub issues on the ground and breaking them down into small 15-minute bug fixes. Since inflight Wi-Fi was absent or patchy, I committed code locally and pushed large batches of fixes upon landing.

07 What happened with the early near-acquisition offer from VMware? 3 sources · 51:58

Two years into the company, VMware approached us with an informal acquisition path that eventually reached a verbal offer. We raised our asking price using a regret minimization framework, but the deal ultimately fell through when a final board vote failed.

08 How did you decide what counteroffer to make during the VMware acquisition talks? 2 sources · 57:20

Arman introduced the regret minimization framework, prompting the founders to independently determine the absolute minimum payout that would satisfy them even if the acquiring company scrapped their product. They independently arrived at a target of $100 million, which was vastly higher than the initial $20 million verbal offer. When they presented this number, VMware took it to an unplanned board meeting where it ultimately failed to pass.

09 What was your experience working with the major cloud providers at HashiCorp? 3 sources · 1:00:11

AWS was characterized as annoyingly arrogant and reluctant to help with integrations despite massive investments, whereas Microsoft was professional, collaborative, and focused on mutual success. Google Cloud possessed incredible technology and architectural thinking, but their business side was completely disengaged from partnership metrics. These distinct operational dynamics shaped significant engineering and business friction during HashiCorp's growth.

10 How is Ghostty's multi-threaded architecture structured? 2 sources · 1:12:28

Ghostty separates core responsibilities across distinct threads to maximize performance and smoothness. It uses a central UI thread for drawing windows, an IO thread to process shell bytes, and a renderer thread that samples terminal state to submit work to the GPU. This decoupled design allows the application to maintain high framerates and separate rendering logic from terminal state management.

11 How do you handle low-quality AI pull requests in open source? 2 sources · 1:26:12

Open source maintainers are shifting from default-allow pull requests to explicit community vouching systems to combat AI-generated code spam. If a vouched user behaves badly, they and their entire vouching tree are permanently blocked from the repository. This restores the natural back pressure and trust required for sustainable software maintenance.

12 Why is Git struggling with agentic AI workloads? 2 sources · 1:32:02

Git performs poorly with extremely large monorepos because users must clone the entire repository, and mainline Git lacks native fixes for this scale. Furthermore, the massive churn generated by AI agents overwhelms traditional merge queues and branch management workflows. As a result, version control systems face breaking scale limits and may need fundamental rearchitecting.

13 How must testing evolve for AI-driven development? 2 sources · 1:38:16

Testing must expand into harness engineering, where developers build auxiliary tooling and validation checks to prevent agents from breaking things while pursuing goals. Because AI models are goal-oriented and often overlook broader side effects, traditional test coverage and CI/CD pipelines are insufficient. Developers must create automated guardrails that actively course-correct agent behavior.

14 How do you effectively incorporate coding agents into daily workflows? 1 source · 1:46:46

Developers should keep an autonomous agent running constantly on slow, non-thinking tasks like library research or exploring edge cases while stepping away. By turning off desktop notifications, the developer dictates when to interrupt the agent rather than being distracted by it. This approach allows you to delegate routine work and choose what to think about without sacrificing deep focus.

Section-by-section summary

25 parts

Self-taught through online code and manuals

Mitchell began coding early by studying online resources and the PHP manual during daily walks to school. He built early gaming websites and even took freelance gigs to understand how internet transactions and image uploads worked.

Landing a rails consultancy job early

A blog post led to his first professional role at a Ruby on Rails consultancy during college. Building diverse MVPs exposed him to varied scale challenges and different technologies quickly without prior enterprise experience.

Immersion in Linux and keyboard workflows

A privacy-focused mentor forced him off graphical tools by physically taking away his mouse. This harsh constraint rapidly forced him to master the terminal, tmux, and SSH, sparking his lifelong interest in infrastructure.

Notebook of unsolved infrastructure problems

After struggling with a distributed systems university project, he documented missing architectural pieces in a physical notebook. Sharing these notes during an exit review prompted his future co-founder Arman to propose starting a company.

Vagrant born from consultancy time constraints

Vagrant was created to eliminate the hours wasted setting up inconsistent development environments for short-term clients. Leveraging free tools like VirtualBox due to budget constraints taught him the power of designing around strict technical limitations.

Betting on a multicloud future early

Early AWS was raw and often unreliable, yet it represented a fundamental paradigm shift away from physical server rooms. Their conviction that the cloud market would naturally fragment led them to build cloud-agnostic tooling despite widespread skepticism.

Choosing venture capital to move fast

Surrounded by cloud-first startups in San Francisco validating his architectural ideas, he decided to start a company. To outpace the rapidly growing cloud market and build multiple foundational tools simultaneously, they chose venture capital over bootstrapping.

Building the foundational HashiCorp product stack

HashiCorp systematically built out core infrastructure tools like Packer for image building, Console for service discovery, Terraform for infrastructure as code, and Vault for secrets management. Each product targeted a specific operational pain point arising from the shift to dynamic cloud environments.

Navigating early growth without revenue

HashiCorp spent its first four years prioritizing open-source adoption and product vision over immediate monetization. Investors supported this trajectory through sequential funding rounds as open-source downloads and GitHub traction surged.

Overcoming the first commercial failure

An initial bundled product called Atlas failed because corporate buyers fought over which department's budget should pay for it. Following a sobering board meeting, the founders abandoned this approach and pivoted to a focused, per-product open-core model.

Maintaining productivity through structured airplane coding

During years of relentless travel, Mitchell maintained high output by breaking GitHub issues down into isolated 15-minute tasks on the ground. On flights without internet, he executed these micro-tasks locally and pushed large batches upon landing.

Navigating the intense IPO preparation process

Preparing to go public required running the company like a public entity months in advance, including mock earnings calls and strict regulatory secrecy. The internal blackout was so absolute that even family members were kept completely in the dark.

Surviving a near-acquisition by VMware

Two years into the company, VMware made an acquisition approach that nearly succeeded after negotiations reached $100 million. When the VMware board ultimately voted down the deal, it accidentally preserved the path for Terraform and independent growth.

Varying relationships with major cloud providers

Hashimoto reflects on HashiCorp's difficult partnerships, describing AWS as arrogant and unhelpful, Microsoft Azure as professional and business-focused, and Google Cloud as technologically brilliant but oblivious to business co-selling.

AI tools paradoxically increasing terminal usage

Contrary to expectations, the rise of AI coding assistants and CLI tools has actually increased the frequency and importance of terminal usage. This surge led to the creation of libghostty to provide a robust, zero-dependency terminal embedding library.

Choosing Zig and a multi-threaded architecture

Ghostty was built using Zig to explore low-level systems programming and desktop software. It uses a novel multi-threaded architecture separating UI, IO, and renderer threads to handle complex text layout and fonts efficiently.

Extreme performance optimization for smooth rendering

Hashimoto details how Ghostty maintains a grid state and optimizes its renderer to submit work to the GPU in just nine microseconds. While imperceptible to end users, this level of craftsmanship ensures lightning-fast output during heavy logging.

Managing multiple AI agents as a developer

In daily development, Hashimoto keeps AI agents constantly active for coding, planning, and research. He acts as the mayor of his workflow, running up to two agents concurrently and rigorously reviewing critical code changes.

Overhauling open source governance against AI PR spam

The massive influx of low-effort, AI-generated pull requests forced Ghostty to abandon traditional open-source contribution models. They transitioned first to banning unvouched AI PRs and later adopting a vouching network to protect maintainer sanity.

Open source repos adopt community vouching systems

To combat AI-generated noise, projects are replacing default-allow PR policies with strict community vouching networks. If a contributor behaves badly, the system permanently bans them along with their voucher and the entire tree of people they invited.

Forking is the true core privilege of open source

Maintainers carry the multi-year burden of code long after hitting merge, meaning they are never obligated to accept outside contributions. Contributors frustrated by rejections should exercise the fundamental open source right to fork and maintain their own software.

Git and version control face breaking scale limits

Traditional version control systems like Git struggle with performance and deep merge queues when subjected to heavy agentic code churn. Version control needs a fundamental redesign to handle massive parallel branches and retain valuable discarded experimental context.

Testing and harness engineering must evolve for AI

Because agents are goal-oriented and will break unconstrained code paths to achieve objectives, testing must become far more expansive. Developers are shifting focus from writing direct products to building robust harness engineering tools that keep agents safely constrained.

The best engineers context switch the least

Top-performing developers often have quiet backgrounds and spend uninterrupted hours deep in flow rather than chasing social media. Minimizing context switches preserves deep technical thinking and problem-solving capacity.

Startups demand decade-long commitment and hubris

Aspiring founders must prepare for a ten-year journey that requires a strong ego and unwavering belief in their advantage. Meanwhile, engineers today face higher expectations to build complete demos and handle vague tasks independently using modern AI leverage.

0:00 / 1:58:24
k play/pause · f fullscreen · m mute
n next · p previous clip · t highlights/full
< > slower/faster · / search what was said
  • Vagrant8× · first 12:46

    A tool created to spin up reproducible development environments using virtual machines.

  • Terraform13× · first 0:11

    An infrastructure-as-code tool used to provision and manage cloud resources declaratively.

  • Vault12× · first 24:46

    A secrets management and encryption tool built to secure production environments.

  • Regret minimization framework1× · first 57:28

    A decision-making tool used to evaluate major risks and career moves by projecting into the future to minimize regret.

  • Zig1× · first 1:08:48

    A systems programming language used to build Ghostty as a modern alternative to C.

  • Vouching system4× · first 1:26:14

    A trust-based mechanism where community members must be vouched for by an existing member to submit pull requests.

  • Harness engineering1× · first 1:38:07

    Building auxiliary tooling and expanded tests that AI agents can call to prevent bad code and course-correct.