Oxide RFDs

If you follow Oxide (perhaps just by reading their Blog[1] and RFDs[2]), I think you'd find a more rigorous engineering and business culture than most case studies you're referring to from the 90s/00s. Of course it's not impossible that Oxide is getting themselves in trouble, but there is more evidence supporting a successful case, in my opinion. [1]: https://oxide.computer/blog [2]: https://rfd.shared.oxide.computer/

All the best! I personally came to know Oxide for their cool RFD culture. It's worth a read: https://rfd.shared.oxide.computer/ Start from RFD 1 ;)

The podcasts are more like 1% -- most of what we have done is via the written word; see our RFDs[0] or our docs[1]. (And at the risk of being too on brand, it is worth listening to our recent podcast episode on RFDs themselves.[2]) [0] https://rfd.shared.oxide.computer/ [1] https://docs.oxide.computer/ [2] https://oxide-and-friends.transistor.fm/episodes/rfds-the-backbone-of-…

Yes, and it cites the Oxide RFD that introduced this specific wording to me too: https://rfd.shared.oxide.computer/rfd/0576#_llms_as_writers > LLM-generated prose undermines a social contract of sorts: absent LLMs, it is presumed that of the reader and the writer, it is the writer that has undertaken the greater intellectual exertion. (That is, it is more work to write than to read!) For the reader, this is important: should they struggle with an idea, they can reasonably assume that the writer themselves understands it — and it is the least a reader can do to labor to make sense of it.

AI usage is great. The problem is the asymmetry in effort between generating text automatically, and then further amplifying this via posting it, while then expecting human eyeballs to spend the time reading it. It is antisocial. If you're generating AI text you shouldn't expect humans that you aren't paying to bother reading it, purely out of politeness. Brian Cantrill has a great piece on this: https://rfd.shared.oxide.computer/rfd/0576

> Every solution requires someone to manually write something. Nobody does. Hot take: hire people that value writing. Create a culture around that. Oxide is a great example of a company culture that values writing, as shown by their rigorous and prolific RFDs: https://rfd.shared.oxide.computer/rfd/0001 See also: https://oxide-and-friends.transistor.fm/episodes/rfds-the-backbone-of-… Many of these RFDs have hit HN by themselves.

I really like Oxide's take on AI for prose: https://rfd.shared.oxide.computer/rfd/0576 and how it breaks the "social contract" where usually it takes more effort to write than to read, and so you have a sense that it's worth it to read. So I get the frustration that "ai;dr" captures. On the other hand, I've also seen human writing incorrectly labeled AI. I wrote (using AI!) https://seeitwritten.com as a bit of an experiment on that front. It basically is a little keylogger that records your composition of the comment, so someone can replay it and see that it was written by a human (or a very sophisticated agent!). I've found it to be a little unsettling, though, having your rewrites and false starts available for all to see, so I'm not sure if I like it.

It’s not a traditional blog, but Oxide’s RFDs cover exactly what you asked — implementation details and trade-offs: https://rfd.shared.oxide.computer/

I've always been a fan of repos that I come across with ARCHITECTURE.md files in them, but that's a pretty loose framework and some just describe the what and not the why. Otherwise, I wish I worked at a place like Oxide that does RFDs. https://rfd.shared.oxide.computer Just a single place with artifacts of a formal process for writing shit down. In your example, writing down "The greens are oversaturated by X% because we will lose a lot of it in the transfer process to film" goes a long way in at least making people aware of the decision and why it was made, at least then the "hey actually the boosted greens look kinda nice" can prompt a "yeah but we only did that because of the medium we were shipping on, it's wrong"

I have thought for years Rust needs to bifurcate. Asyc/await really desperately needs a garbage collector. (See this talk from Rustconf 2025: https://youtu.be/zrv5Cy1R7r4?si=lfTGLdJOGw81bvpu and this blog:https://rfd.shared.oxide.computer/rfd/400) Rust that uses standard techniques for asynchronous code, or is synchronous, does not. Async/await sucks all the oxygen from asynchronous Rust Async/await Rust is a different language, probably more popular, and worth pursuing (for somebody, not me) it already has a runtime and the dreadful hacks like (pin)[https://doc.rust-lang.org/std/pin/index.html] that are due to the lack of a garbage collector What a good idea

It's definitely a bit contrived, but to me it's also emblematic of the issues with async Rust. The note on mpsc::Sender::send losing the message on drop [1] was actually added by me [2], after I wrote the Oxide RFD on cancellations [3] that this talk is a distilled form of. So even the great folks on the Tokio project hadn't documented this particular landmine. [1] https://docs.rs/tokio/latest/tokio/sync/mpsc/struct.Sender.html#method… [2] https://github.com/tokio-rs/tokio/pull/5947 [3] https://rfd.shared.oxide.computer/rfd/0400

Also, if you haven’t read the linked Oxide RFD#3 [1], I recommend doing so. It has shaped much of our hiring process. > But how does one assess candidates for such positions? This is an age-old question without a formulaic answer: designing, building, selling, and supporting computing systems is itself too varied to admit a single archetype. > In terms of evaluation mechanism: using in-person interviewing alone can be highly unreliable and can select predominantly for surface aspects of a candidate’s personality. While we advocate (and indeed, insist upon) interviews, they should come relatively late in the process; as much assessment as possible should be done by allowing the candidate to show themselves as they truly work: on their own, via their creations. [1] https://rfd.shared.oxide.computer/rfd/3

It's not worth pointing out the technical flaws in the post[1]. It is obvious the author does not have a strong grasp of the tools he is criticising. A better example of this style of post is Oxide's evaluation[2] for control plane storage that actually goes over their specific needs and context. [1] Ok, just one, Rick Houlihan is currently at MongoDB. [2] https://rfd.shared.oxide.computer/rfd/53

The closest I have seen are the Oxide computer company RFD documents, many of which are public. Example: https://rfd.shared.oxide.computer/rfd/0177 Main index: https://rfd.shared.oxide.computer

Ah. In that case, that is not a mode (which is why I misunderstood), that is the default way Remix works and it's more or less what every user of Remix is doing. Some people might implement API endpoints in Remix itself, but for the most part people are calling out to APIs in loaders. Here's a Remix site that works that way: https://rfd.shared.oxide.computer/ We have an API written in Rust that serves the RFD contents and powers search. For logged-in internal users, we are also talking to GitHub APIs in loaders to pull in PR comments.

Ah thanks! Yeah I should have mentioned this in my comment, thank you for adding the context. By the way, you can browse public RFDs here: https://rfd.shared.oxide.computer/ I didn't include any links to any RFDs in my comments today because I have only been referencing non-public ones.

I continue to resonate with the Oxide take when I hear this kind of sentiment expressed about AI prose "... LLM-generated prose undermines a social contract of sorts: absent LLMs, it is presumed that of the reader and the writer, it is the writer that has undertaken the greater intellectual exertion. (That is, it is more work to write than to read!) For the reader, this is important: should they struggle with an idea, they can reasonably assume that the writer themselves understands it — and it is the least a reader can do to labor to make sense of it. If, however, prose is LLM-generated, this social contract becomes ripped up: a reader cannot assume that the writer understands their ideas because they might not so much have read the product of the LLM that they tasked to write it. If one is lucky, these are LLM hallucinations: obviously wrong and quickly discarded. If one is unlucky, however, it will be a kind of LLM-induced cognitive dissonance: a puzzle in which pieces don’t fit because there is in fact no puzzle at all. This can leave a reader frustrated: why should they spend more time reading prose than the writer spent writing it?" https://rfd.shared.oxide.computer/rfd/0576#_llms_as_writers

I think the Oxide computer LLM guidelines are wise on this front: > Finally, LLM-generated prose undermines a social contract of sorts: absent LLMs, it is presumed that of the reader and the writer, it is the writer that has undertaken the greater intellectual exertion. (That is, it is more work to write than to read!) For the reader, this is important: should they struggle with an idea, they can reasonably assume that the writer themselves understands it — and it is the least a reader can do to labor to make sense of it. https://rfd.shared.oxide.computer/rfd/0576#_llms_as_writers The heavy use of LLMs in writing makes people rightfully distrustful that they should put the time in to try to read what's written there. Using LLMs for coding is different in many ways from writing, because the proof is more there in the pudding - you can run it, you can test it, etc. But the writing _is_ the writing, and the only way to know it's correct is to put in the work. That doesn't mean you didn't put in the work! But I think it's why people are distrustful and have a bit of an allergic reaction to LLM-generated writing.

"Using LLMs at Oxide" [0], as seen on the HN frontpage yesterday, had a bit to say about LLMs as writers > LLM-generated prose undermines a social contract of sorts: absent LLMs, it is presumed that of the reader and the writer, it is the writer that has undertaken the greater intellectual exertion. (That is, it is more work to write than to read!) For the reader, this is important: should they struggle with an idea, they can reasonably assume that the writer themselves understands it — and it is the least a reader can do to labor to make sense of it. > If, however, prose is LLM-generated, this social contract becomes ripped up: a reader cannot assume that the writer understands their ideas because they might not so much have read the product of the LLM that they tasked to write it. If one is lucky, these are LLM hallucinations: obviously wrong and quickly discarded. If one is unlucky, however, it will be a kind of LLM-induced cognitive dissonance: a puzzle in which pieces don’t fit because there is in fact no puzzle at all. This can leave a reader frustrated: why should they spend more time reading prose than the writer spent writing it? [0] https://rfd.shared.oxide.computer/rfd/0576

> Took them 3 months before a "we're not interested" email was sent. No reasons, either. Yeh this is really really tough. They have an excellent RFD that explains the hiring process and it contains a section on this here: https://rfd.shared.oxide.computer/rfd/0003#_rejection_of_non_interview… I ported their Hubris kernel to RISC-V and ARMv6 before applying for a role to work on it, so thought I had reasonably strong materials, but got rejected. I fully understand and empathise with their reasons for not providing feedback, but it does mean you're left not knowing whether you were a hair's breadth away from getting in but were behind a better candidate and it would be worth trying again in the future, or rejected for other reasons that no improvement in materials will make up for. As a fully signed-up member of imposter syndrome club I'll obviously lean towards the latter ;)

Take a look at [RFD 363](https://rfd.shared.oxide.computer/rfd/0363) which describes our test setup in manufacturing for an individual compute sled. Note that a minibar is a low-volume relatively expensive fixture that does not require UL, CSA, CE Mark, or other certification for use in manufacturing and would not be suitable for general release.

Agree. There's stuff missing, and there are problems which likely are "multiple Phd theses" level to solve cohesively. Either in Rust or a successor language when the problem space has been explored. For me the most annoying part are the footguns async Rust introduces, which Rust generally is blessedly empty of compared to e.g. Go or other languages. Like for example, cancellation safety, dealing with "long running" futures, cleanly terminating a program, deadlocks at a distance [1] and others I'm forgetting now. [1]: https://rfd.shared.oxide.computer/rfd/0609

A few years ago I worked for a tech company that had many senior ex-Googlers engineers, with 30+ years of experience in SWE, and they were able to imbue into our team a culture of engineers writing and reading Design docs. There was even a design doc for design docs. This CAN help, but one of the problems that happened as the company grew in size and age, was that there was a plethora of design docs, and no real summary. So we supplemented the documents with recurring presentations to new engineers, who could get a glimpse of the design decisions, without being overwhelmed with design doc reading. Oxide (Bryan Cantrill's computer company) does something similar with their RFDs (Requests for Discussion), but publicly. Their "design doc for design docs" is RFD 1, and you can read it here: https://rfd.shared.oxide.computer/rfd/0001

It's not just about performance: having an in-process MVCC engine would simplify the implementation of many single-machine concurrent applications. Currently you usually have to combine SQLite with some kind of concurrency primitives; this is extremely painful because most OS-level concurrency primitives are really easy to misuse (e.g. it's trivial to accidentally add deadlocks, and very hard to spot and remove these ahead of time: example hard to spot concurrency bugs https://fly.io/blog/corrosion/, https://rfd.shared.oxide.computer/rfd/400)

Oxide uses Helios, their own illumos-based distro: https://github.com/oxidecomputer/helios They’ve written up their reasoning in this RFD: https://rfd.shared.oxide.computer/rfd/0026#_comparison_illumos_and_lin…

I see, you wish to limit the domain. Do safety issues in the async runtime count ? Or is even "async Rust" out of your criteria ? What about this one ? "Futurelock in Tokyo" ? https://rfd.shared.oxide.computer/rfd/0609

Been trying to decide whether adopting a traditional RFC process or Oxide's RFD (https://rfd.shared.oxide.computer/rfd/0001) would better suit my team. We're using ADRs at the moment but we've ended up mixing a discussion like process into it and review process and using ADRs more like RFCs/RFDs

Maybe I remember the Grok ones more clearly but it felt like “I asked Grok” was more prevalent than the others. I feel like the HN guidelines could take inspiration from how Oxide uses LLMs. (https://rfd.shared.oxide.computer/rfd/0576). Specifically the part where using LLMs to write comments violates the implicit social contract that the writer should put more care and effort and time into it than the reader. The reader reads it because they assume this is something a person has put more time into than they need to. LLMs break that social contract. Of course, if it’s banned maybe people just stop admitting it.

It stands for ‘Request for Discussion’: https://rfd.shared.oxide.computer/rfd/0001

futurelock [0] was special specifically because of this aspect where even a future which seemingly acquires and releases a lock in a single poll triggers a deadlock. what you describe is just a standard async deadlock. much easier to spot when debugging. and one can reason about those deadlocks in pretty much the same way one would reason about deadlocks between threads. [0]: as named and described in https://rfd.shared.oxide.computer/rfd/0609