Mitchell Hashimoto

The sense I always got from the outside (I don't know him personally), is that Mitchell is just a really good engineer that wants to build great products. Nothing more. He's honest about what he's passionate about. Hence why he went from running the company to stepping back to being an IC. I've got a lot of respect for that. Below is his personal website, for those who haven't read his posts. https://mitchellh.com

Not sure if ghostty is the best example https://mitchellh.com/writing/ghostty-memory-leak-fix

When really solid programmers who started skeptical (and even have a ban policy if PR submitters don’t disclose they used AI) now show how their workflows have been improved by AI agents, it may be worth trying to understand what they are doing and you are not. https://mitchellh.com/writing/my-ai-adoption-journey My experience mirrors that of Mitchell. It absolutely is at the level now where AI can free up time to do the really interesting stuff.

On the Ghostty recommendation, read this first - https://mitchellh.com/writing/ghostty-memory-leak-fix > A few months ago, users started reporting that Ghostty was consuming absurd amounts of memory, with one user reporting 37 GB after 10 days of uptime. > ... > The leak was present since at least Ghostty 1.0, but it is only recently that popular CLI applications (particularly Claude Code) started producing the correct conditions to trigger it at scale. The limited conditions that triggered the leak are what made it particularly tricky to diagnose. > The fix is merged and is available in tip/nightly releases, and will be part of the tagged 1.3 release in March.

I haven't personally implemented one but I'll quote someone who has spent a lot more time on it: > Many of these implementations are ad-hoc, one-off solutions. They aren't using any shared library or codebase.2 Terminal emulation is a classic problem that appears simple on the surface but is riddled with unexpected complexities and edge cases.3 As a result, most of these implementations are incomplete, buggy, and slow.4 [1] (I mean, it's possible html/css deserves to be called horrible also but they produce an undeniably superior result) [1] https://mitchellh.com/writing/libghostty-is-coming

Got to this after perusing Mitchell Hashimoto's writings (https://mitchellh.com/writing) following the recent libghostty-vt discussion (https://news.ycombinator.com/item?id=45347117). Interestingly enough while looking for HN commentary there was none,so I thought others may also find it interesting :)

Little offtop: would someone remember mitchellh's setup for working with AI tools? I remember someone posted in an AI-hate-love threads here and it's not in the his blog[1] 1: https://mitchellh.com/writing

I'd recommend folks to check-out https://ghostty.org if you haven't. It is fast, feature-rich and native! The main author of Ghostty also wrote about how different terminals handle emojis https://mitchellh.com/writing/grapheme-clusters-in-terminals (2023)

Discussed here when it was first published - https://news.ycombinator.com/item?id=36161397 (27 comments) - but worth revisiting now that the project it described, Ghostty, has reached 1.0: https://mitchellh.com/writing/ghostty-1-0-reflection

Mitchell has a 5 min lightning talk discussing performance of ghostty which is worth a quick watch https://www.youtube.com/watch?v=cPaGkEesw20&t=3015s It's one of those things that you don't realize how poor the performance is until you experience something better. Mentioned from his blog: https://mitchellh.com/writing/ghostty-is-coming

The author has a dev log I’d recommend if you’re curious about what makes it different + general goodies on Zig/terminal emulators. https://mitchellh.com/ghostty

Have any details on how you've implemented Nix? For my personal projects I use nix without docker and the results are great. However I was always fearful that nix alone wouldn't quite scale as well as nix + docker for complicated environments. I've used the FROM SCRATCH strat with nix: https://mitchellh.com/writing/nix-with-dockerfiles Is that how you implemented it?

The state of the art here is to detect mode 2027, and enable it when supported. This lets you know the terminal will handle graphemes properly. I maintain two TUI libraries which use this technique and emoji support has been (nearly) great. (One of which uses your uniseg library!) https://mitchellh.com/writing/grapheme-clusters-in-terminals

One of the most interesting examples is Mitchell Hashimoto of HashiCorp fame (13B publicly traded company). His career path was: HashiCorp CoFounder -> CEO -> CTO -> Engineer -> finally left HashiCorp in December 2023. Now he enjoys private life while creating a super-cool Ghostty terminal in Zig [0], currently in private beta. [0] https://mitchellh.com/

> I (selfishly) hope whatever is next is still hacker adjacent, bc your work has been a big inspiration to a lot of us. Best of luck to you! You should check out the terminal he's been working on codenamed Ghostty [0]. [0]: https://mitchellh.com/ghostty

This certainly looks interesting. I've been using Kitty for a while and it works great and supports so many features. It would be nice to see how it compares to Foot in terms of speed. I'm also curios about Ghostty, the in-progress (but currently private) terminal from Mitchell Hashimoto. https://mitchellh.com/ghostty

Since my blog post is linked, I wanted to clarify something. While this appears to be the broad message, I don't think the author intended to imply this about my post specifically, but I still feel the need that I point out the following in my prompt eng blog post (linked by the OP)[1]: > To start, you must have a problem you're trying to build a solution for. The problem can be used to assess whether prompting is the best solution or if alternative approaches exist that may be better suited as a solution. Engineering starts with not using a method for the method's sake, but driven by the belief that it is the right method. [1]: https://mitchellh.com/writing/prompt-engineering-vs-blind-prompting

> I don't work directly on most of those projects anymore. I was CEO for ~4 years, CTO for ~5 years, and then transitioned to being an individual contributor. I think it's his job now to get distracted. :) Though I see no reason from this post to think Hermes is one of Mitchell's projects. https://mitchellh.com/

One of the best pieces of writing I've come across that I still come back to about grokking complex codebases was written by Mitchell Hashimoto. https://mitchellh.com/writing/contributing-to-complex-projects

I have personally emailed Mitchell Hashimoto (this guy: http://mitchellh.com/ ) to thank him for his awesome software. He wrote me back, and was very gracious. This is what it means to be human. Well done!

I think before even being able to entertain the thought of slowing the fuck down, we need to seriously consider divorcing productivity. Or at least asking a break, so you can go for a walk in the park, meet some friends and reflect on how you are approaching development. The gold standard of AI adoption for me would be what's encoded in this post https://mitchellh.com/writing/my-ai-adoption-journey. I've had tremendous success with roughly following the ideas there. > The point is: let the agent do the boring stuff, the stuff that won't teach you anything new, or try out different things you'd otherwise not have time for. Then you evaluate what it came up with, take the ideas that are actually reasonable and correct, and finalize the implementation. That's partially true. I've also had instances where I could have very well done a simple change by myself, but by running it through an agent first I became aware of complexities I wasn't considering and I gained documentation updates for free. Oh and the best part, if in three months I'm asked to compile a list of things I did, I can just look at my session history, cross with my development history on my repositories and paint a very good picture of what I've achieved. I can even rebuild the decision process with designing the solution. It's always a win to run things through an agent.

I think framing it as a site for people that are positive about AI is probably the wrong way to go, but around it kf you don't want just a bunch of AI psychosis posts and nothing else. I think it would be better if, instead of being defined in terms of being "positive" about AI (in the sense of saying that everything to do with AI is all great and rosy and awesome, and thinking every new AI thing is the next big thing, and praising every vibe-coded piece of slop), the focus was explicitly on having mature, software engineering-focused discussions of how to actually understand, make, and use AI and AI tools/harnesses, where it's taken as common ground that these are tools, not magical genies that will usher in the rapture of the nerds or make software development obsolete, nor uniquely evil technologies that only fascists could ever use or like or that are completely useless, or tools that only talentless hacks who don't care about the craft, good use. So basically to avoid shallow dismissals and endless culture of war arguments. I would love to have a place that discusses the pros and cons of different ways of approaching specification, natural language programming, DSLs, property-based testing, behavior-driven development, lightweight formal methods like model checking, or even more heavyweight formal methods like doing proofs, etc, as means of using the extra time and lowered cognitive load allowed by AI coding agents to actually increase the reliability and improve the…

>For example Zig is probably the most impressive new language, and it’s got a ton of awesome stuff but the chance that I’m going to adopt it over a language with often comparable performance that is ALSO much safer? Rounds to zero. 1) Rust, in practice, is "safer" than Zig but doesn't seem to be "much safer". See: https://mitchellh.com/writing/ghostty-gtk-rewrite > Our Zig codebase had one leak and one undefined memory access. That was really surprising to me (in a good way). Our Zig codebase is large, complex, and uses tons of memory tricks for performance that could easily lead to unsafe behaviors. I thought we'd have a lot more issues, honestly. Also, the one leak found was during calling a 3rd party C API (so Zig couldn't detect it). So this is a huge success. Take that as you will. And what Ghostty does probably requires a decent chunk of "unsafe" that would likely hide a bug anyway. To me, the tradeoff of a demonstrably small number of bugs in a system software language in return for the demonstrably faster developer velocity (Zig compiles WAY faster than Rust, Zig wraps C/C++ libraries way easier than Rust, Zig cross compiles way more easily, etc.) is a decent tradeoff for my use cases. For me, programming is about corralling motivation more than anything else. Rust saps my motivation is ways that Zig does not. I love what the Oxide folks are doing. Having someone pwn your big server because of a memory bug? Yeah, I'd reach for Rust in their use cases. Or,…

Some commentary about the radar... try: Boox Go 10.3 tablet Agree. Avoid reMarkable™. Hostile to the community and better options are out there or on the way including Boox, Onyx and the new Daylight Computer. https://daylightcomputer.com/product https://www.zdnet.com/article/best-note-taking-tablet/ --- adopt: Blank Spaces app No need to pay money on ios. Clear off all the icons and when you need something swipe down in the middle of the screen and open search or swipe over to the alphabetical listing. Windows Phone was way ahead of its time on this one. --- assess: TypeScript – What does it buy me over JS? This one is a little bit flame bait... at the cost of a build step you get a much more reasonable development experience for JS targets with reliable types. The problem is smart people want to flex their brain a lot more than their restraint (where are my grug brains at?) and type astronauting makes the experience much worse. As with all things there is a balance however TS should be "Adopt". --- hold: Zig – This looks like a dead-end for me I keep looking at Zig and playing with it but I am so productive with Go and Python for things that need to be fast enough Zig doesn't have much that I need. However Mitchell Hashimoto is using it to great success for his new MacOS terminal emulator which makes me think I just haven't tried using it in the appropriate domain... maybe a raytracer is in my…

It seems I've committed the cardinal sin of failing to specify my units. So to clarify, it's $25k per year. But my mistake that aside, I appreciate your reply. I saw in another comment thread that you added that you have a blog post in the pipeline on building the new billing system. So I'm really looking forward to reading that. I've enjoyed reading other billing/payments content. And I'm sure your post will also be insightful and highly detailed. I think it's so so fascinating that this feature is consistently solved at the contract/legal and customer support "layer" of the stack. That's really unpleasant to me, because it is a lot harder for me to wrap my head around the specifics of how different edge cases will play out. Like as a programmer, I've built up all these skills on reaching technical documentation, understanding systems, their limits, and complex interactions. But instead of using that muscle memory, I have to try to talk with a human and deal with the seemingly intentional vagueness of the legal system. It feels to me a lot like the story from Mitchell Hashimoto about dealing with the bank for his startup, where he was dodging calls from his account executive and generally behaving in a way that the bank is not used to from enterprise clients. [0] I'm ready to admit my behavior is anti-social and irrational here. But, it is what comes natural to me. This is meandering now. But, I just want to sneak in a bit more info on my use cases, since you also…

Kitty is fine, but there is a big issue with tmux and the dev seems to think it is about tiling and not about using remote machines.[0] Sure, I tile because it is there and I don't have control of the terminal I'll use on the other end, but the main draw is I gotta work on machines I'm connecting to with ssh. I think there's a lot of us still needing tools like this (and mosh) but little support. Looks like people were trying to help the dev but there was communication breakdown. I'm all for making sure things are done right and not just accepting hacky solutions, but there has to end up being a solution. I'd honestly just love to have a minimal terminal like foot[1], but that's wayland only and wayland support is still very mixed. And who knows when ghostty will come out[2]. But I also need linux + mac support and I think a lot of people do (and no wayland to mac port?). Too many terminals are far too bloated. And boy... do I not need this bullshit[3] [0] https://github.com/kovidgoyal/kitty/issues/391 [1] https://codeberg.org/dnkl/foot [2] https://mitchellh.com/ghostty [3] https://github.com/warpdotdev/Warp/issues/900

I had the same experience and kept wondering if I was missing something important. I'm not a fan of Python, so I was anxious about not using the thing everybody recommended, but for my project I ultimately went with what I know well (C#). I've happily had zero issues. LangChain docs and tutorials were useful for understanding the popular practices for approaching AI-driven development, but the biggest challenge by far has been getting a baseline prompt and measuring performance of alternative implementations against that in a sensible way that doesn't break the bank. Mitchell Hashimotos's Prompt Engineering article [1] was way more helpful in this regard than anything I saw in LangChain. To that end I've also been working on a tool to save me money by caching requests and responses, blocking unexpectedly expensive requests, keeping a granular history of requests for prompt cost analysis, etc. Maybe I should open source it and get some VC bux too? [1] https://mitchellh.com/writing/prompt-engineering-vs-blind-prompting

Mitchell Hashimoto had a blog post a few months ago talking about him moving off of GitHub: https://mitchellh.com/writing/ghostty-leaving-github This is a man who's spent a significant portion of every day for the last 15 years on GitHub.

Mainly this https://mrshu.github.io/github-statuses/ But also product decisions that don't seem to be aligned with the preferences of users... see https://mitchellh.com/writing/ghostty-leaving-github

I think Mitchell outlined his vision for libghostty pretty well here: https://mitchellh.com/writing/libghostty-is-coming Alacritty is already pretty performant (relative to a lot of the other terminal emulators), but my read is Ghostty has been going hard over performance/standards/protocols (like Kitty).