The introduction of LLMs has shaken up software development, and thus our work. In this RFD, we outline how we adapt our operations to make use of LLMs in a way that benefits both our clients and ourselves. We discuss LLM use and non-use at Defined Once, as well as LLM workflows that we deploy in practice.
First things first
At the time of writing, there is a rapidly evolving discussion around how LLMs are used in the context of software engineering. Accompanied by a strong shift towards an expectation to use LLMs all throughout society, we've found that this topic requires attention and active discussion from our side. It is our goal to provide practical handles and bring nuance into a conversation that is quickly gaining polarization.
While LLMs may provide utility across a variety of domains, this document's sole focus is on how LLMs are used for the purpose of software engineering at Defined Once. The scope explicitly doesn't cover how LLMs are used in other aspects that may be relevant for running a business or an organization. While this document is intended for the general public, it dives into concepts and technical jargon unique to software engineering. As with all RFDs, this document is an invitation to open discussion and is welcome to be challenged and critiqued.
Obviously, merely having an LLM policy does not categorically shield us from LLM misuses; however, being transparent about our process holds us accountable. Before unpacking our use of LLMs, we recognize that the current state of the art (frontier models) exclusively runs on a computer outside of our control, which poses an inherent tension towards data privacy and operational sovereignty. For ourselves, as well as for our clients, we regularly re-evaluate the threat model in order to confidently say what risks are acceptable. Per client, we codify how LLMs may or may not be used in our engagement letter.
This document builds on top of Oxide's LLM Policy 1, which enumerates the various use cases and anti-patterns of LLMs, a recommended read. The decidedly important point that we find necessary to repeat here is the objection towards using LLMs for writing (or any form of storytelling, for that matter, such as presenting). When an author lets the LLM do the writing, they shift the burden of understanding onto the reader to piece it together (given there is something to be understood in the first place). Not only is this distasteful and disrespectful towards the reader, but it puts immense strain on social trust and the value of storytelling. We would like to preserve this very trust with you, the reader. This RFD, like all of our published writing, has been fully written by us, mortal humans.
Ownership and Responsibility
At Defined Once, we take complete ownership and responsibility over our work; this is a firm non-negotiable.
Software has always been a means to an end. It is used to automate and accelerate processes to improve productivity, or to be a solution to previously unsolvable business problems. The value of software is what it can enable you to do. 2
Though, the code itself was never the point. It is no more than a collection of decisions, based on some requirements, put into a format that machines can conveniently verify and execute. The process of coding concerned continuously bumping into a problem and then considering which of the available options would best fit into the bigger picture. The constant decision-making could make coding feel like a slow endeavor from time to time, and a frustrating one too; days or even weeks of careful consideration and deliberation could go by, all believed to benefit the business needs in the long term but not adding any direct value on their own. The conscious line-by-line decision-making did, however, grant you two things more or less for free: ownership and responsibility.
Those who stand skeptical towards LLMs may argue that embracing them is at odds with retaining exactly this ownership and responsibility, since code that has been written by LLMs requires understanding the available options and the resulting decisions after they were made. Almost certainly, this will harm your comprehension of the problem and the decision; you simply were not there when it was made. Besides, the problem has already been solved, so it requires more discipline to put yourself through understanding the possible options, knowing that you most likely won't gain the joy or pride of finding a good solution yourself. Because you are more detached from a system's internals, it becomes easier to lose ownership and control over it.
By those who are embracing LLMs, this critique is countered with the idea that, when using LLMs to write code, you are still making (and owning) decisions, but they just became more relevant by moving closer to the domain that actually matters: the business requirements that justified writing software in the first place. There is a finite number of problems we can solve in our lifetime, so if LLMs can shield us from having to decide variable names, function splitting and data modeling, enabling us to think in terms of customer demands, features and business value instead, isn't that great? Yes, it is indeed more difficult to understand coding decisions after they have been made, but what is the point of owning these decisions in the first place if LLMs can, at any point, explain them or replace the associated code just as easily?
We happen to be a software consultancy. Our business model is centered around understanding business requirements and selling software as a solution. Software is our product and service, so ownership and responsibility are what clients pay us for. Yet, that is not to say that reviewing every line of code by hand or manually deciding each function name remains worthwhile. We constantly re-evaluate the methods we put in place that provide us the trust and confidence over the LLM's output. Funnily enough, this is not so different from onboarding a new human team member: there too, we must establish trust through time and experience, set guardrails and check in, and put in effort to understand their contributions. In the end, we take full responsibility for the work that they ship in the name of Defined Once. Clients trust us to make the right calls about our development process and hold us accountable when our software does not (safely) meet the requirements. This will not change, and this will still be where our value is.
To explain how we retain ownership and how we remain responsible, we differentiate our usage of LLMs between two modes: research and code generation. We find it useful to distinguish between these two modes because they serve entirely different goals: research is about improving the quality of our work, while code generation is about producing a higher quantity. The following describes our responsibilities in each mode and provides an operational description of day-to-day workflows.
LLMs for Research
The first way in which we use LLMs is for the purpose of elevating the quality of our work by either getting a more thorough understanding or by broadening our knowledge about concepts outside of our core expertise. This aligns with scaling up "T-shaped" skills. The following use cases give an idea for how such research is done in practice.
Going Deeper
One can easily get a deeper understanding for how something works under the hood by conversing with an LLM. However, we must not take any LLM-generated claim for granted and always demand primary sources or reproducibility steps to substantiate the claims. The responsibility remains with us for following any linked sources and reading up on them independently. Importantly, the goal with LLM-assisted deep research is not to offload critical thinking, analysis or reading comprehension.
On the other hand, it is more important than ever to be able to motivate why one does not need to go deeper. LLMs are built to maximize engagement and will always be pleased to answer something. 3 Reading synthetically generated text ("AI speak") can quickly wear down one's attention, so we must set confident boundaries around what does not require deep understanding and is thus not worth our time.
Search
LLMs have proven to be incredibly capable in performing semantic searches over large swaths of text, for example when looking for something specific in the codebase that can't be described with a single keyword or when having a complex semantic query inside documentation. We treat such searches as starting points and have found LLM search to be incredibly useful to test our decisions, for example by finding contradictions when assumptions change inside of large knowledge bases. LLMs are also very capable at reporting where documentation or code has drifted, uncovering design questions that previously might have gone unnoticed.
Adversarial Analysis
In this use case, the LLM plays an adversarial role and is pointed against our design documents, code or pull request messages. Our design process consists of writing extensive documentation, typically in the form of an mdBook 4, which is convenient because LLMs are very capable at reading through structured markdown files. The LLM is then tasked with finding security weaknesses, inconsistencies or unforeseen failure modes. Importantly, we also imagine scenarios with an altered threat model to better anticipate future changes in the requirements. This process usually does not take much time, since generated claims are quick to verify.
At pull request time, we find it useful to describe the incoming changes ourselves still: first of all, since it is good practice to keep explaining changes to each other, putting active effort into filtering out noise from relevant project updates, and secondly, since LLMs can challenge our idea of what the changes entail. Both help us to retain ownership and responsibility.
We've found having LLMs write our pull request or commit messages not to be particularly useful, as these messages are often so specific and detailed that we consider them a mere replication of the git diffs, but in a worse syntax.
LLMs for Code Generation
The second mode is using LLMs for the purpose of increasing the throughput of our work while maintaining quality. The reason why we chose to go faster in the first place is that (when done well) it can unlock new timelines for projects that were previously not possible. As a company whose core service is helping teams adopt Rust, lowering the cost of rewriting code can play a role in the willingness to adopt Rust in the first place. The core focus of this mode is harnessing the speed-ups of code generation while retaining code quality and ownership.
We will use the term "agent" to describe an LLM that is given tools and a degree of autonomy for the purpose of making contributions to code directly. One of the core principles here is simply about setting clear and well-understood boundaries about what the agent is doing. By owning the boundaries, we continue to own the generated output of the agent and thus keep our hands on the steering wheel. It can be thought of as an "AI-sandwich" 5, where we clearly define the boundaries in terms of inputs and outputs, which leaves the agent with a well-defined and verifiable task in the middle.
Preparation
Before we interact with an agent, there are a number of setup preparations and best practices for the purpose of constraining the agent.
Firstly, we believe that deterministic and empathetic tooling plays a huge role in producing high-quality software. Programming languages with good error messages, code checkers, formatters and static analysis tools are in their own right an excellent way of improving software, but in the context of LLMs they are an absolute must. We heavily automate these tools along with security advisory checks that report on known vulnerabilities from our dependency tree.
Additionally, we make heavy use of organized knowledge bases that not only contain code documentation but also the greater (social) context of the project, explaining the stakeholders, their motivations and any relevant project constraints or timelines. Crucially, this allows readers to understand the more subtle background motivation behind technical decisions. The knowledge base also contains an extensive manual in terms of tool use, coding guidelines and more high-level best practices that are specific to the project. The agent is given an entry path into the knowledge base that puts a subset of crucial documents into the start of every context window. This subset typically includes the background context and coding guidelines, but depending on the task, the agent may dig deeper into the documentation. Obviously, this does not guarantee that the agent will follow the guidelines, but it does result in spending less time fixing deviations from the guidelines.
An agent is able to perform tasks thanks to its harness, which is just a piece of software monitoring the output of the LLM and performing actions based on that output. Popular harnesses today leave a lot to be desired in terms of security and sandboxing. Unfortunately, most harnesses provide the agent the ability to run shell commands, which gives the LLM unfettered access to the host computer. At the time of writing, deterministic guardrails are still an open problem despite recent developments 6. This is arguably the most important part of the LLM workflow that we would like improved and are keeping tabs on. Currently, we sandbox the agent inside a container or VM and provide access to only the repository we want it to work on.
Specs and Decision Logs
We found it to be very effective to align the agent with the task by iterating on specification documents first. They specify the what and the how by laying out a clear step-by-step implementation plan. The spec also repeats the boundaries as well as any important constraints that are relevant for this task, such as any new dependencies or whether new state can be introduced. In addition to specifications, we prepare the input/output interfaces that the agent will use by writing types, traits and function signatures, as we would for our human colleagues. The step-by-step plan is also incredibly useful because it allows us to interject between steps to perform course corrections or manual validations. Writing interfaces and specifications by hand is a manual process, and we recognize that this approach sits in contrast to more autonomous ways of using agents. This approach requires our attention and consent throughout the whole implementation process, and that is precisely how we retain ownership and control over our work.
For any question not answered in our specs and knowledge base, the LLM is instructed to generate a decision log. Here, an LLM must record the open question, the context and possibly a recommendation, but it is always a human that decides the answer, and whether answering the question is relevant in the first place. Each decision log carries a date, and the collection of decision logs is fed back in as context for later LLMs.
Testing and Review
Coming back to the AI-sandwich analogy from earlier: LLM-generated code sits in between the human-verified input and output. Testing is an important way of implementing and documenting that verification, which is why we hold writing tests to the same standard of quality as writing code. If testing is not held to the same standard, the sandwich analogy breaks and ownership over the codebase is lost.
As explained earlier, we reject LLM-generated pull requests: if you can't hand-write a descriptive summary of what your pull request contains, then you have lost ownership over it. During the review process, we generally shift to using LLMs in research mode because, after all, review is about improving quality.
Taste
LLMs and AI are often praised as the ultimate productivity improvement tools, allowing us to perform knowledge work, solve math problems and build systems with little effort and at marginal cost. Some go as far as to claim that eventually, LLMs will cause the act of thinking to become a hobby instead of a desired skill, and that coding will suffer the same fate as chess: turning into something that's still fun to do, but that a computer will always be better at.
We are not ignorant of this prophecy and, like many professional software engineers, have had to acknowledge that LLMs have indeed become good at coding and a useful tool for building systems. It would be naive, and unproductive moreover, to discard LLMs out of emotion or nostalgia. It is why we try to embrace LLMs with nuance, trying not to fall for doom scenarios created through careful marketing, but also not rejecting something that is clearly useful out of selfishness or vanity.
Only time will tell how our role in building systems will change. However, even if LLMs were perfect and solutions were provided instantly and effortlessly, we believe that taste and self-control remain the principles that will continue to provide value. By deciding what to build and, perhaps more importantly, what not to build, we bring calmness and focus in a world of ill-considered mediocrity.
References
-
RFD 576 - Using LLMs at Oxide https://rfd.shared.oxide.computer/rfd/0576
-
This is a less eloquent rephrasing of Cory Doctorow's famous quote: "Code is a liability. Code’s capabilities are assets. The goal of a tech shop is to have code whose capabilities generate more revenue than the costs associated with keeping that code running" https://doctorow.medium.com/https-pluralistic-net-2026-01-06-1000x-liability-graceful-failure-modes-d69f384af9e4
-
Bryan Cantrill (Oxide) described LLMs as the eternally pleasing management consultants that will try to create a dependency on them together with you https://www.youtube.com/watch?v=5D7QPOIZ7gY
-
mdBook is a nice way of reading through a collection of markdown files, maintained by the Rust project https://rust-lang.github.io/mdBook/.
-
The term was introduced to us in conversation by Thijs Bongertman from Honest-AI
-
Kravchenko et al. APPA: Recoverable Information-Flow Control for Real-World LLM Agents 2607.24625 https://arxiv.org/abs/2607.24625