Blog · From the team

Speed With Safety: Quality-Controlled AI-Native Delivery for Enterprise Systems

By Abhinav Saha, Forward-Deployed Engineer · November 3, 2026

Enterprise technology leaders have heard two competing claims this year. One says AI can modernize core systems in months. The other says AI-written code cannot be trusted near the systems that run the business.

Both are partly right. Speed and safety are not a trade-off that has to be accepted. But achieving both on long-running systems requires a different first step than most modernization plans assume.

Our CTO, Navin Budhiraja, recently described how we run an AI-native SDLC, in which every control runs on every change and named people sign off at key points. This post extends that view to existing systems. It draws on recent industry research, the leading delivery frameworks and my own experiments on publicly available codebases, and it addresses one question: what changes when the starting point is code that has been in production for years, or even decades?

Adoption is near-universal. Results are not.

Published estimates of AI's productivity impact vary widely, and the variation itself is the most instructive finding.

StudyWhat it found
GitHubDevelopers finished a coding task about 55% faster with an AI assistant
McKinseySome coding tasks done up to twice as fast
METR (2025)Experienced developers on codebases they knew well were slower with AI, mostly from reviewing and correcting its output
Faros AI (10,000+ developers)About 21% more tasks and 98% more pull requests merged, yet organizational delivery stayed flat
DORA (2025, ~5,000 professionals)About 90% adoption; AI amplifies an organization's existing strengths and dysfunctions alike

The Faros data is the most telling. Developers completed more work and merged nearly twice as many pull requests, yet the organization delivered no faster. The additional output accumulated where AI does not help: review queues, approval meetings and release boards.

DORA's research explains the spread. AI acts as an amplifier: in a mature engineering environment it accelerates delivery, and in a fragile one it accelerates the fragility.

The gain came from the environment, not the model

One benchmark result illustrates the point. On a widely used test of real-world bug fixing, AI systems resolved about 2% of problems in late 2023. By April 2026, the best systems resolved about 78%.

Over the same period, models answering in a single pass plateaued near 20%. The gain came from the system built around the model: an agent that reads the files, runs the tests, observes failures and iterates.

The implication for technology leaders is direct. A lower-cost model in a well-engineered environment can outperform a frontier model in a poor one. The environment, not the model, is the primary investment.

The bottleneck has also moved. Writing code was once the expensive middle of delivery. Agents have compressed it sharply, but they have not compressed deciding what to build or verifying what was built. These are organizational constraints rather than technical ones, and they now set the pace.

Two rows of delivery stages, titled: Build shrank. Deciding and checking now set the pace. Before: writing code was the expensive middle, with Build the widest, shaded stage among Requirements, Design, Build, Test, Deploy and Operate. After: deciding what to build and checking it set the pace, with Requirements, Design and Test shaded and Build narrow. Shaded means where most of the time goes; widths are illustrative, not measured.
the delivery bottleneck, before and after agents

The real barrier is verifiability, not age

I expected earlier-generation languages and complex architecture to be the main obstacles for an AI agent in the codebases I experimented on. They weren't.

The main obstacle was the absence of any way for the agent to confirm that a change was correct. Several patterns recurred:

  • Test commands that report success without executing a single test. A pipeline built on them would report green indefinitely.
  • Significant portions of code excluded from the build, making it impossible to tell what is still in use.
  • Builds that succeed only on one specific machine, with dependencies pointing to locations that no longer exist.
  • Multi-year modernization efforts that moved substantial code to modern platforms while adding few or no tests. In some cases, test coverage declined.

The last pattern is the most significant. These efforts delivered real value, separating business logic and removing platform dependencies, yet the systems emerged no more verifiable than before.

Modernization doesn't produce verifiability as a byproduct. It has to be an explicit goal.

The most useful measure of how hard a system will be to modernize is therefore not its age, but whether an agent can verify its work against it. By that measure, some relatively recent code is just as challenging, and it is worth assessing the whole application portfolio on that basis.

Verification comes before acceleration

Organizations typically adopt AI in stages. An engineer first works with a single agent and reviews all of its output. Next, several agents work in parallel on separate tasks. Over time, as automated checks prove reliable, agents take on recurring, well-defined work, with people supervising the process rather than every line.

Each stage beyond the first depends on an automated way to check the work: tests, a reliable build and an end-to-end run against a real environment. Without it, every change requires human review, and a codebase remains at a single supervised agent regardless of the tooling available.

Three rising steps, titled: Every step past the first stands on an automated check. One agent, supervised: a person reads every change. A few agents in parallel: checks catch mistakes first. Earned autonomy: people supervise the loop. The second and third steps rest on an automated check of tests, a reliable build and an end-to-end run. Without a check, a codebase stays at the first step.
AI adoption steps and the check they rest on

This is where Navin's post and this one connect. Our delivery model applies layered defenses and a set of named, centrally owned rules to every change. Those controls need something to run against, and many long-running systems do not yet provide it.

For these systems, the verification loop is not a stage in the process. It is the precondition for the process. Building it is the first deliverable, not preparation for the real work.

Migration also changes the nature of intent. In new development, intent is authored: a team decides what the software should do and checks that it does so. In migration, intent must be recovered from the code, and the question is more demanding. Does the new system behave exactly as the original did, including behaviors nobody intended but downstream processes now depend on?

Two flows, titled: In migration, intent is recovered, then proven by a check. New development: intent is authored, then intent, spec, plan, change, review. Migration: intent is recovered from the code, then existing code, recovered intent, spec, plan, change, and a before-and-after check, which asks whether it behaves exactly as it did before.
new development vs. migration · where intent comes from

Recovered intent is not a specification. It is a set of hypotheses with confidence levels and open questions, and it requires review by domain experts. The before-and-after check turns those hypotheses into evidence. This matters most in real-time and device-facing systems, where failures are often silent: output continues, plausibly, with something missing.

"Migration" is five different jobs

"Migration" can describe five quite different undertakings. The role of AI differs in each, as does the evidence that the work succeeded.

PatternWhat changesAI's main roleProof of successRisk
EncapsulateNew interface onlyInterface discoveryOriginal system is the referenceLowest
RehostEnvironment onlyMinimalSame build runsLow
ReplatformRuntime onlyMechanical changesExisting testsLow–medium
Re-architectStructureDiscovery, verificationMatches at new boundariesHigh
RewriteAll but business rulesIntent recoveryMatches end to endHighest

Application portfolios rarely fit a single pattern. Triage, assigning each application its pattern before work begins, converts an application count into a set of economic profiles. That is the basis of a credible plan.

A further finding: the most significant blockers are often not architectural. In the codebases I examined, what prevented operation on modern infrastructure was mundane. Builds could not be reproduced, applications emitted no health signals for an orchestrator to monitor, and release packages were assembled from files that could not be traced to source.

None of these is resolved by decomposing a system into microservices. In one case, the system was already distributed, with clean plugin boundaries and its own high-speed transport between instances; what it lacked was packaging and operational tooling. When a microservices rewrite is proposed as the path to modernization, it is worth asking whether the real constraints are build reproducibility, observability and supply chain. That work rarely appears in a plan framed as "break it into services."

The economics: what compounds, and how to know early

Headline comparisons, such as a large team over years versus a small team over months, are persuasive but do not decompose. If a program overruns, they cannot show which component moved. Three principles make the economics manageable:

  • Environments drive the timeline, not application count. Investment in access, tooling and checks pays off across every application in the same environment, and must be repeated in a new one. Ten applications in one environment can cost less than three spread across three.
  • The second application should cost substantially less than the first. This happens only if reusable assets, such as discovery methods, migration playbooks and check patterns, are captured deliberately during the first. Nothing compounds by accident.
  • Cost per migrated application should be measured at a held check pass rate. That is, cost per application while before-and-after checks continue to pass at the same rate. Cost alone can be lowered by reducing verification, and in migration those failures are rarely visible.

Discovery cost is a reliable early indicator. By the fourth or fifth application, it should be materially lower than for the first; if not, reuse is not working, and that becomes visible months before the budget shows it. Rework is the second indicator: if it rises while cost falls, quality is being traded away.

Proving a human was in the loop

"Human in the loop" is a common commitment. Auditors and regulators increasingly ask for proof.

Navin described the human sign-offs in our process, where named individuals accept what gets built, approve the design and clear security. The specific gates vary with the work; the principle does not. Accountability remains with people, because after an incident, "the system routed it" is not an acceptable answer.

The more subtle requirement is making those gates provable. Consider two statements:

  • "We have a policy that a human reviews every change." That's a claim about behavior.
  • "The system cannot produce a merge without a recorded approval." That's a control.

A person's diligence cannot be audited. A system that refuses to proceed without an approval record, and logs every blocked attempt, can be. In a migration, where an error may surface months later in a system that runs a plant, a payment network or a supply chain, that evidence is what allows speed without added risk.

How we do this at Hang Ten

Our Hobie Platform applies one assurance standard to everything we deliver. Much of our work is new development, where it lets customers ship quickly without relaxing any control. The same platform and controls apply when we modernize systems that have served the business for decades. Those engagements add one prerequisite: a way for the system to check its own work.

A typical modernization engagement proceeds in five steps:

  1. Triage the portfolio, sorting each application into its migration pattern and economic profile.
  2. Recover intent from the code, with the customer's domain experts confirming what the system really does.
  3. Build the before-and-after checks, so every change can be verified automatically.
  4. Migrate in phases, under the same controls and human sign-offs as new development.
  5. Capture what we learn as reusable assets, so each application costs less than the one before.

For leaders weighing whether AI can accelerate modernization without adding risk, three questions are a useful starting point:

  • Which systems in the portfolio can check their own work today, and which cannot?
  • How many distinct environments, rather than applications, does the portfolio span?
  • When an auditor asks who approved a change, can the system answer on its own?

If these questions resonate, we would welcome a conversation. Speed and safety are not a trade-off. They need to be built in the right order.

Sources

  • Budhiraja, N. An AI-native SDLC that raises the assurance bar while shortening the cycle. Hang Ten, Aug 2026
  • Claxton, L. The AI-Native SDLC Playbook. Anthropic, Aug 2026
  • Cherny, B. Steps of AI Adoption. Jul 2026
  • Medisetty, U.K. Running a Software Factory Efficiently at Uber Scale. Uber Engineering, Aug 2026
  • Kordick, J. The Realities of Application Modernization with Agentic AI. Microsoft, Jan 2026
  • Agentic AI in the SDLC. arXiv:2604.26275
  • Peng et al. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv:2302.06590
  • McKinsey & Company. Unleashing developer productivity with generative AI. 2023
  • METR. 2025 developer productivity study, and Changing our Developer Productivity Experiment Design, Feb 2026
  • DORA. 2025 State of AI-assisted Software Development
  • Faros AI. The AI Productivity Paradox

— Abhinav