NOTES · NOV 9, 2026 · BY TECH BENDERS
A method from NASA for building with AI
When AI writes the code, the expensive mistakes move to design. What we inherited from NASA systems engineering, and where the human stays in the loop.
When AI can write most of the code, it is tempting to think process matters less. If a model can produce a working feature in minutes, why spend time on requirements, design reviews or verification plans?
We think the opposite is true. When writing code gets cheap, the expensive mistakes move somewhere else: building the wrong thing, building it in a way that does not fit, or building it without knowing what it will cost to run. Those are exactly the problems systems engineering was designed to prevent. Our method comes from the NASA Systems Engineering Handbook, calibrated by project type. Ours is the layer on top: building with AI.
This post explains what we took from that framework, why it still matters, and where the human sits in every loop.
Why a space agency's handbook
The NASA Systems Engineering Handbook (NASA/SP-2016-6105 Rev 2) is a public guide. It accompanies NPR 7123.1, the agency's systems engineering requirements, and describes systems engineering as a methodical, multidisciplinary approach to designing, building, operating and retiring a system.
It is not a software manual, and we do not pretend it is. What it offers is a way of thinking about any complex system that has to work in a real environment, for real people, under real constraints. That is what most software projects are, whether they are built by hand or with AI.
Two clarifications matter. First, this is a public framework that anyone can read and apply; Tech Benders is not certified or accredited by NASA. Second, the handbook itself expects to be adapted. It has a whole section on tailoring, which says the formality, depth of documentation and timing should vary with the type, size and complexity of the project. Using a scaled version is not a shortcut around the framework. It is what the framework asks for.
Three ideas we kept
The handbook is long. Three of its ideas carry most of the weight for us.
Verification is not validation
The handbook draws a sharp line between these two words, and the line is worth memorizing. In its words, "verification of a product shows proof of compliance with requirements," while "validation of a product shows that the product accomplishes the intended purpose in the intended environment."
Put simply: verification asks whether you built the thing right. Validation asks whether you built the right thing. A feature can pass every test and still fail the people who use it, because the requirement itself was wrong.
AI makes this distinction more important, not less. A model is very good at satisfying the instruction it was given. It has no way of knowing whether that instruction reflects what the business actually needs. Validation is a human job.
Cost is decided early
The handbook includes a figure on the life-cycle cost impact of early decisions. Its point, stated on NASA's page for that section, is that the life-cycle costs of a program "tend to get 'locked in' early in design and development." The figure, which NASA attributes to the Defense Acquisition University, illustrates that design may account for a small share of the money spent while committing most of the life-cycle cost.
For software built with AI, the lesson translates directly. The data model, the boundaries between systems, how users and teams are isolated, which model handles which task and how much context it receives: those decisions are made in design, and they determine what the system costs to run for years. A fast build does not change that. It just means you reach the consequences sooner.
Sequence and continuous disciplines are different things
The handbook's systems engineering engine lists seventeen common technical processes, grouped into system design, product realization and technical management. The numbering suggests seventeen steps in a row, but they are not. Design and realization are a sequence: they go from what people expect to a delivered product. Technical management (planning, requirements and interface management, risk, configuration, decisions) runs continuously alongside the whole project.
That distinction keeps a method light. A client does not go through "configuration management" as a phase. It happens all the time, without them having to see it.
Our five phases
We compressed the sequence into five phases. Each one has a clear question and a clear owner.
Discovery. What you actually need, in your words, before we look at what you asked for. They are not always the same thing. This is where validation starts: we write down the expectation the system has to meet in its real environment.
Design. Requirements, decomposition and the architecture that holds them. This is where the cost of the project is decided, not during the build. AI can help here (drafting options, summarizing an existing codebase, listing edge cases), but the decisions are made and signed by people.
Build. Implementation and continuous integration. This is where AI contributes the most, and where speed is real. You see working software early and often, not at the end.
Monitoring. Two questions, not one. Does it meet the spec (verification), and does it solve what you expected once it runs in your real environment (validation)? We keep them separate on purpose, because a green test suite only answers the first.
Transition. Deployed, documented and yours. If it cannot run in production, it is not done.
The bridge: code that was generated, not written
Here is the part we find most interesting. NASA's software engineering requirements, NPR 7150.2, already have a section on the automatic generation of software source code. In the NASA Software Engineering Handbook, the requirement asks the project to define its approach to auto-generated code, including the verification and validation of the generation tools, the allowable scope for using generated code, the verification and validation of the generated code itself, configuration management of the tool's inputs and outputs, and policies for making manual changes to generated code.
That requirement was written for code generators, long before large language models. But it describes, almost word for word, what responsible use of AI coding tools looks like: decide where AI is allowed to write code, review what it writes like any other artifact, keep track of what went in and what came out, and have a rule for when a person edits generated code by hand.
The framework we inherited already had a box for what we do with AI. That box asks for exactly what is most often skipped.
Human in the loop, concretely
"Human in the loop" can become a slogan. In our method it has specific meanings:
A person owns every requirement. AI can propose requirements; it cannot accept them.
A person reviews every change before it ships. Code written by AI is traced and verified like any other artifact.
A person validates in the real environment. Passing tests is necessary, not sufficient.
A person decides the cost envelope. We plan the use of AI so its cost stays under control over time, and someone is accountable for that number.
The point is not to slow AI down. It is to put judgment exactly where AI cannot supply it.
Where to start
If your engineering team already uses AI to write code and wants a workflow it can trust, the path Claude Code for engineering teams goes from the first session to agents in CI/CD, with testing and code review along the way. The workshop Claude Code for your team takes one change from the first prompt to a reviewed pull request, with a human approving what ships. For the design side, see Software architecture and system design.
And if you want this method applied to your own system, see how we work.