Why AI Requires a New Approach to Defense Software Engineering
Executive Summary
The cost of changing software has changed, the way the Department of War (DoW) specifies software has not changed enough with it. Many programs still inherit acquisition logic developed for physical systems: define requirements extensively, approve them, build the system, then validate whether it meets the need.
That approach was rational when software construction and change were expensive. Modern software engineering, and increasingly generative AI, has reduced the effort required to build, revise, and compare many forms of software. Studies of AI-assisted development have shown both substantial acceleration on bounded tasks and slower performance in mature, context-heavy codebases, underscoring that the effect is highly dependent on task and environment.[1] [2]
The implication is not the end of requirements engineering, but a change in where requirements should be discovered. Mission outcomes, architecture, cybersecurity, interoperability, and other high-consequence decisions still require early rigor. Reversible product decisions should increasingly be tested through working software rather than predicted exhaustively through documents.
This direction is consistent with the DoW’s January 2026 Artificial Intelligence Strategy, which calls on the DoW to “weaponize learning speed,” measure deployment velocity and operational cycle time, place capabilities in operators’ hands, gather feedback rapidly, and iterate based on mission impact. [3]
The DoW should apply that principle more broadly to software engineering:
Define the mission and boundaries first, build the Smallest Useful Experiment (SUE), learn from users, and progressively mature capabilities.
1. The Cost of Change Has Changed
Traditional software engineering placed significant value on discovering errors during requirements and design because errors discovered later could become dramatically more expensive to correct. That principle, often associated with Dr. Barry Boehm’s work on software economics [4], helped reinforce requirements-heavy development models.
The principle still matters. A late change affecting weapons safety, an aircraft interface, cryptographic architecture, an enterprise data model, or a cross-domain solution can remain extremely expensive. In modern software systems, the cost of change varies substantially by the type and consequence of the change. Historical evidence suggests that software has never had a single universal cost-of-change profile: large systems often exhibit steep downstream cost escalation, while smaller, localized, and lower-consequence changes can behave much more like a flatter curve.
Figure 1. The Cost of Change Has Bifurcated

Boehm-derived studies report defect-correction costs rising from about 1× in requirements to 40–1,000× in operations. Later work found post-delivery escalation of roughly 100:1 for large systems versus about 5:1 for small, noncritical systems. Intermediate values on the flatter curve are illustrative. [5] [6] [7]
For many application-level decisions, cloud computing, modular architectures, automated testing, DevSecOps, and AI-assisted engineering can reduce the effort required to experiment with and revise bounded functionality. AI can rapidly generate functional alternatives, modify interfaces, create tests, refactor bounded components, generate documentation, and translate examples into executable behavior.
The appropriate level of upfront specification is partly an economic choice. When construction is expensive, organizations have an incentive to predict more before building. When an alternative can be produced and evaluated rapidly, experimentation can become less expensive, and often more informative, than prolonged specification.
The relevant question therefore changes from:
| What complete set of detailed requirements can we define before development? |
to:
| What is the fastest governed experiment that can resolve the next important operational uncertainty? |
The Department’s current AI strategy points in precisely this direction. Its Pace-Setting Projects emphasize aggressive timelines, measurable outcomes, and rapid iteration in which failure contributes to learning and improvement.
AI does not simply flatten the cost-of-change curve. It expands the domain of reversible decisions. Functional alternatives that once required substantial engineering effort can increasingly be generated, evaluated, discarded, and regenerated before they harden into production dependencies. The consequence is a shift in the economically optimal point of specification:
some decisions that once had to be predicted before development, can now be resolved more effectively through development.
2. From Requirements to Evidence
Requirements are not disappearing. They should become more intentionally layered. The relevant tradeoff is therefore no longer only the cost of changing a requirement too late, it is also the cost of specifying an uncertain requirement too early.
An intent-first program should establish:
- Mission outcome: What operational deficiency, delay, risk, or opportunity must be addressed?
- Users and operational context: Who will use, operate, support, and maintain the capability?
- Measures of effectiveness: What observable outcomes demonstrate mission value?
- Constraints and guardrails: What security, statutory, safety, classification, interoperability, accessibility, records, and data requirements must be respected?
- Architectural boundaries: What enterprise services, interfaces, hosting environments, standards, and data structures constrain the solution?
- Testable behaviors: What specific behaviors can be expressed through acceptance criteria and automated tests?
- Product hypotheses: What workflows, features, and design assumptions remain uncertain and should be tested?
Figure 2. From Requirements to Evidence

The further a requirement moves toward mission constraints, architecture, interoperability, safety, or irreversible consequences, the stronger the case for early definition. Detailed workflows, interfaces, and other reversible product decisions are generally more amenable to iterative discovery.
This distinction enables programs to remain rigorous without prematurely freezing functionality. It is also consistent with the Department’s Software Acquisition Pathway, which is designed around iterative development, frequent delivery, active user engagement, and continuous refinement. [8]
Working software then becomes more than the product of requirements engineering. It becomes one of its most powerful inputs.
A prototype lets operational users perform realistic tasks, expose incorrect assumptions, compare alternatives, identify missing information, reveal integration problems, and distinguish mission needs from preferences. AI can lower the cost of producing and revising the artifact through which that learning occurs.
That does not mean a prototype is production software. A capability created in several days may provide valuable evidence about usability or workflow while remaining far from satisfying production requirements for cybersecurity, resilience, interoperability, authorization, accessibility, data management, and sustainment.
The objective is rapid learning, not premature fielding.
Intent-first development therefore does not reduce requirements rigor, it concentrates rigor on mission intent, constraints, architecture, acceptance evidence, and high-consequence decisions while allowing reversible product choices to remain adaptable.
3. An Intent – First Development Model
An intent-first lifecycle can be considerably simpler than traditional requirements-heavy development. Intent-first development is not a replacement for Agile, DevSecOps, human-centered design, or the Software Acquisition Pathway. It is a requirements and governance pattern for applying those practices in an AI-assisted environment.
Establish intent and boundaries
Operational sponsors, users, product leaders, engineers, cybersecurity personnel, data owners, and acquisition professionals define the mission problem, desired outcomes, measures of effectiveness, constraints, major interfaces, and unacceptable outcomes.
Identify the highest-value uncertainty
Instead of attempting to specify every feature, the team asks what it most needs to learn. Examples may include whether a workflow actually reduces processing time, whether users understand a proposed interface, whether authoritative data is sufficient, or whether a capability can operate within existing identity and security services.
Build the smallest governed experiment
Teams use approved development environments and AI-assisted engineering tools to rapidly produce a prototype or bounded functional increment. Human engineers remain accountable for architecture, code review, security, testing, licensing, and technical decisions.
Put it in front of users
Representative users evaluate the capability using realistic mission scenarios. The team measures task completion, time, errors, usability, operational effect, integration dependencies, and other relevant outcomes.
Feedback should create evidence, not merely another collection of opinions.
Engineer progressively for production
Once value and feasibility have been demonstrated, the team applies progressively stronger production controls: secure architecture, interface engineering, automated testing, cybersecurity assessment, observability, resilience, configuration management, authorization evidence, data management, and operational support.
The cycle then repeats.
4. Where The Cost Curve Remains Steep
AI does not eliminate the consequences of poor engineering. In some cases, rapid generation may make disciplined architecture even more important because teams can create technical debt and architectural drift faster than before.
The DoW should therefore distinguish between reversible functional decisions and high-consequence structural decisions.
- Low-consequence application features, interfaces, reports, workflow variations, dashboards, notifications, and similar functionality can often rely heavily on rapid experimentation.
- Moderate-consequence operational capabilities should use controlled pilots with progressively stronger testing, cybersecurity, data, and operational controls.
- Safety, security, or mission-critical functions should retain the formal requirements, architecture, verification, validation, certification, and accountable technical authority appropriate to their consequences.
This is where the traditional cost-of-change principle remains strongest. AI may make rewriting software inexpensive while doing little to reduce the cost of changing a certified interface, migrating authoritative data, coordinating dependent systems, reaccrediting a capability, or correcting a flawed safety assumption.
For engineering and acquisition purposes, it is increasingly useful to think of the curve as bifurcating by consequence and reversibility.
For many functional decisions, the curve is becoming flatter. For architectural, integration, security, safety, and other high-consequence decisions, it can remain steep.
Software engineering practices should reflect that difference.
5. Recommended Actions
The DoW can implement this model largely within authorities and pathways that already exist.
1. Make intent-based requirements the default for software
Software requirements should concentrate on mission outcomes, users, constraints, measures of effectiveness, major interfaces, and architectural boundaries. Detailed functionality should remain adaptable unless there is a compelling reason to fix it early.
2. Make governed prototypes part of requirements discovery
Programs should use prototypes and operational pilots deliberately to test uncertain workflows and assumptions. Program reviews should examine working software and evidence from operational users alongside documentation.
3. Measure learning velocity and mission impact
Programs should supplement traditional cost and schedule reporting with cycle time, deployment velocity, adoption, operational feedback, and measurable mission outcomes.
4. Apply progressive assurance
Controls should increase with maturity and consequence. Concept prototypes, operational pilots, and production capabilities should not be treated as though they present identical risks.
The DoW already has rapid acquisition authorities and pathways, and an expanding ecosystem intended to connect commercial technology with operational requirements. However, a persistent gap remains between organizations exploring innovative technologies and the program offices responsible for inserting and scaling them. [9]
Broader acquisition constraints also remain relevant. Research examining six defense programs found that PPBE can slow capability development and reduce fiscal flexibility, while also cautioning that its effects on technology transition are sometimes overstated. [10]
The point is therefore not to invent another acquisition framework. It is to use existing software authorities differently.
Conclusion
Generative AI has not eliminated requirements engineering, architecture, cybersecurity, testing, or accountable acquisition.
It has changed the economics surrounding them.
When working software can be produced and revised rapidly, detailed functional assumptions no longer need to be resolved exclusively through documents before users encounter a solution. For many software decisions, building a controlled experiment and observing what happens may now be faster, cheaper, and more reliable than attempting to predict the answer in advance.
At the same time, architectural, security, safety, interoperability, and other consequential decisions continue to carry substantial downstream costs and require deliberate engineering rigor.
The appropriate response is therefore neither traditional requirements-first development nor unconstrained AI coding.
It is intent-first software engineering:
Define the mission.
Establish the boundaries.
Identify the uncertainty.
Build the smallest, useful experiment.
Put it in operators’ hands.
Measure what happens.
Then engineer progressively toward production.
Learn More
If you found this white paper helpful and would like more information, please contact KGSinfo@koniag-gs.com. In your email, be sure to reference the white paper and include any specific follow-up requests or details you’d like us to provide.
[1] Sida Peng, Eirini Kalliamvakou, Peter Cihon, and Mert Demirer, “The Impact of AI on Developer Productivity: Evidence from GitHub Copilot,” 2023
[2] Joel Becker, Nate Rush, Beth Barnes, and David Rein, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity,” METR, 2025
[3] Department of War, Artificial Intelligence Strategy for the Department of War, January 2026.
[4][5] Barry W. Boehm, Software Engineering Economics. Englewood Cliffs, NJ: Prentice-Hall, 1981.
[6] NASA, Error Cost Escalation Through the Project Life Cycle, NASA/20100036670, 2010.
[7] Barry Boehm and Richard Turner, Balancing Agility and Discipline: A Guide for the Perplexed. Boston: Addison-Wesley, 2003.
[8] Department of Defense, DoD Instruction 5000.87, Operation of the Software Acquisition Pathway, current edition.
[9] MITRE, AiDA, “DoD Innovation Ecosystem.”
[10] Olivia Letts, Edward Hyatt, and Jerry McGinn, PPBE, Technology Transition, and “The Valley of Death”, Acquisition Research Program, Naval Postgraduate School, May 2024.
