Mitchell Hashimoto's New Way of Writing Code

How Mitchell Hashimoto Keeps an Agent Running at All Times

Mitchell Hashimoto — co-founder of HashiCorp, creator of Terraform, and currently building Ghostty — joins Gergely Orosz on The Pragmatic Engineer to share a deeply considered methodology for AI-assisted development. This isn’t hype or hot takes. It’s a practitioner with 20 years of experience describing how he’s fundamentally restructured his daily workflow around AI agents.

The core discipline: “I endeavor to always have an agent doing something at all times. I want an agent if I’m coding, I want an agent planning. If they’re coding, I want to be reviewing. There should always be an agent doing something.”

Before every transition — leaving the house, driving somewhere, stopping for the day — Mitchell spends 30 minutes asking: “What’s a slow thing my agent could do next?” He gives agents research tasks, library evaluations, and edge-case analysis that don’t need real-time attention. Critically, he turns off all agent notifications: “I choose when I interrupt the agent. It doesn’t get to interrupt me.”

On what AI actually gives you: “It’s really allowed me to choose what I want to actually think about. I always felt limited — I’m going to have to spend the next two hours doing this boilerplate. But now I don’t have to learn about it.” This isn’t about producing more code. It’s about redirecting cognitive energy to the work that matters.

Harness Engineering: The Compounding Quality Strategy

Mitchell’s most original contribution to the AI coding discourse is harness engineering — his term for building tooling that agents can call to prevent repeat mistakes.

The pattern: When an agent makes a mistake, instead of just correcting it, build a test harness, validation script, or linting rule that the agent can invoke to self-check. Add the rule to your CLAUDE.md or agents.md file. The agent never makes that specific mistake again.

This compounds over time. Each session improves the harness. Each harness improvement makes subsequent agent sessions more reliable. Mitchell calls this one of his key goals for 2026 and considers it the critical infrastructure investment for teams using AI agents.

The expanded test requirement: AI is “goal-oriented” — it will break things outside its current task scope to achieve its immediate goal. This means test coverage needs to be far more expansive than what was sufficient for human-only development. Every AI mistake should result in a harness improvement, not just a fix.

Context-Dependent Quality: From Zero Review to Every Line

Mitchell applies completely different quality standards depending on the project:

• Ghostty (open-source terminal, long-lived): Reviews every line of AI-generated code. Performance to 9 microseconds per frame matters.
• Throwaway projects (family wedding website): Zero code review. “Did it render right in three browsers? Ship it. It’s only online for 2 months.”

This pragmatism extends to competitive agent runs. For hard tasks where confidence is low, he runs two agents in parallel — Claude Code vs. Codex — and picks the better result. He describes himself as “the mayor” managing at most two agents at a time.

Why Git May Not Survive the Agentic Era

The most provocative prediction: “This is the first time in like 12 to 15 years that anyone is even asking that question — will Git be around? — without laughing.”

Mitchell argues that Git and GitHub forges “do not work with agentic infrastructure today.” When agent churn is 10-100x human churn, merge queues become impossible, disk space explodes, and human reviewers can’t keep pace. He advises a stealth company working specifically on this problem.

His vision for version control’s future: keep far more branches, failed experiments, and history — never delete. This is the “Gmail moment for version control.” But it requires fundamentally better tooling to find relevant context in massive repositories.

AI-Generated Open Source Contributions Are Destroying Signal

Ghostty receives 2-3 low-quality AI-generated PRs daily. Mitchell now closes them without reading if they lack an associated issue number. “AI makes it trivial to create plausible looking but incorrect and low-quality contributions. Open source has always been a system of trust. Before we had default trust. Now it’s default deny.”

He wishes agentic tools would “put a pause on opening PRs” — the friction they cause for maintainers outweighs the convenience for contributors. He even identifies Claude’s tell: opening a draft PR with no body, editing the body, then reopening it — a pattern no human follows.

6 Principles from Mitchell Hashimoto’s AI Workflow

• Always have an agent running — Use transitions (driving, breaks, end of day) to queue slow agent tasks. Agents should never be idle during working hours
• Separate planning from execution — A dedicated planning step before agent coding dramatically improves output quality
• Build harnesses, not just fixes — Every agent mistake should produce tooling that prevents recurrence, not just a correction
• Choose what you think about — AI’s value isn’t more code per hour but redirecting cognition to architecture, design, and user needs
• Context-dependent review rigor — Production code gets every-line review; throwaway prototypes get zero review. Match effort to stakes
• Invest in the learning curve — “It’s as if someone tried Git for an hour and decided it wasn’t productive. It takes sustained effort to become proficient”

What This Means for Engineering Organizations

Mitchell frames AI’s value not as raw productivity gains but as expanded capacity to experiment. Proof of concepts that took a week can now be done in a day. But he’s notably cautious: “I hesitate to say more productive. There’s an expectation they could do more. You should be able to build a full demo, design, everything — you don’t need a team to do that anymore.”

For organizations, the implications are concrete: require AI tool competency in hiring, treat agent configuration files (CLAUDE.md) as first-class infrastructure, invest in harness engineering, and accept that CI/CD pipelines need fundamental rethinking to handle the expanded testing that AI-generated code demands. Everything in engineering infrastructure — editors, forges, CI/CD, testing, observability, sandboxing — is on the table for change at once. As Mitchell puts it: “This is the first time in my 20-year professional career that so much is on the table for change at one time.”