Insights

Building for the AI-native development life cycle: What actually works in agentic coding

How UST’s AI, working with Anthropic as a Global Premier Partner, is helping enterprises move from coding assistants to governed agentic delivery.
By Adnan Masood, PhD | Chief AI Architect, UST

The software development life cycle is being rewritten before our eyes. Humans now formulate intent, define architecture, and govern specifications while orchestrated AI agents handle the repeatable mechanics of building software. We call this the AI-Native Development Life Cycle, or AIDLC.

Gartner projects that 60 percent of organizations will adopt smaller software engineering teams at scale by 2029, up from 15 percent in 2026, with those teams typically running four to five members. The delivery evidence is arriving faster than the projection. PwC has published results from a legacy insurance modernization in which 5.5 engineers delivered what previously required 12, cutting calendar delivery time in half and reducing mean time to resolution by 77 percent on infrastructure transformation work. At Amazon, six engineers rebuilt the Bedrock inference engine in 76 days, a project originally scoped for 30 developers over 12 to 18 months, with normalized commit velocity per developer rising roughly twentyfold. And a single-case study conducted at Itaú Unibanco documented one staff engineer, supported by four specialized agents, delivering a four-person squad’s scope inside a regulated brownfield bank.

The most important finding is the one nobody puts in the headline. In the Itaú case, the gating factor was the engineer’s deep institutional knowledge and the quality of the upstream specifications; the underlying model's capability was secondary. That shapes everything we do at UST’s Alpha AI Practice, and it underpins how we build agentic delivery on Anthropic’s Claude platform for clients across financial services, healthcare, and insurance.

Here is what has worked in production, and what we would tell any engineering leader planning the transition.

DIVIDER

Start with evals, or do not start

The single biggest predictor of agentic delivery success is whether an evaluation harness exists before the first feature ships. An eval harness is an automated suite that scores agent output against your definition of correct, on every run, at merge time. Without one, you are trusting vibes at enterprise scale, and vibes accumulate technical debt at machine speed.

Our practice standard, productized as UST-Eval, treats evals the way traditional teams treated unit tests: mandatory, versioned, and owned. Every agentic workstream gets a golden set of representative tasks, expected outcomes, and failure cases drawn from the client’s actual codebase and domain. Claude Code sessions run against that harness continuously, and no generated code merges until it clears the bar.

Published evidence points in the same direction. In a banking microservices case study, embedding non-negotiable security constraints into the specification layer reduced security defects by 73 percent relative to unconstrained AI generation, while preserving developer velocity. Worth stating plainly: that figure comes from a single case study rather than a replicated trial, and the broader literature reviewing it says so explicitly. We treat it as directional and hold our own engagements to client-specific baselines measured before and after.

DIVIDER

Rubrics turn judgment into infrastructure

Evals answer whether the output is correct. Rubrics answer whether it is good. The distinction matters because senior engineering judgment is the scarcest resource in the AIDLC, and rubrics are how you externalize it.

We build rubrics as explicit scoring dimensions: architectural conformance, security posture, test coverage, readability, and adherence to domain invariants. Each dimension carries a defined bar and concrete examples of passing and failing work. Then we do something that surprises most clients: we use Claude itself as a rubric grader, with a frontier model scoring the delivery agents' output against the rubric before a human ever looks at the pull request. Human reviewers see only work that has already cleared the machine grade, along with the grader’s reasoning. Review time drops, and reviewer attention concentrates on the decisions that genuinely need it.

DIVIDER

Assessment before compression

Leaders consistently want to know how small their teams can get. The honest answer is that team size is an output of readiness, and readiness is assessable. Before compressing any team, we run a structured assessment against five preconditions: self-service environments, golden-path CI/CD, an evaluation harness that scores agent output against contracts, MCP servers that expose internal systems as governed context, and repository-level agent instructions treated as versioned, reviewed artifacts.

An organization missing two of those five will watch the tiny team experiment fail, and it will blame the model rather than the missing platform. The Itaú study makes the point precisely: when specifications were vague or omitted legacy integration contracts, the agents generated code that violated systemic behavioral contracts. The manual rework negated the efficiency gains . Assess first. Compress second.

DIVIDER

Short-risk sprints beat big-bang transformation

We structure every agentic engagement around short-risk sprints: one- to two-week cycles with a single falsifiable hypothesis, a defined eval gate, and a pre-agreed kill criterion. A first sprint might test whether Claude Code can generate migration code for one bounded domain at a first-review acceptance rate the client sets in advance. If it clears the gate, we expand scope. If it misses, we fix the specification layer, since that is where the failure almost always lives, and rerun.

This keeps blast radius small, produces evidence executives can act on, and builds the specification muscle the whole model depends on. It also mirrors what PwC calls the foundation sprint, in which the AI-enabled stack is wired into code repositories, project backlogs, design files, and documentation before delivery begins. That sprint is the least glamorous investment in the engagement and the most predictive of success.

DIVIDER

Process discipline: BMAD and sub-agents

Two process patterns have earned permanent places in our playbook.

The first is the BMAD method, which structures agentic delivery through explicit planning personas before execution begins. An analyst agent produces the brief, a product-manager agent produces the requirements, an architect agent produces the technical design, and only then do developer agents generate code against those artifacts. The sequence enforces specification-driven development structurally. Skipping straight to code generation is how organizations vibe-code their way into unmanageable systems, and the contract-first alternative is now well described in the research literature.

The second is sub-agent orchestration. Claude Code supports spawning specialized sub-agents with scoped context and scoped permissions: a test-writing sub-agent that sees only the contract and the interfaces, a security-review sub-agent that runs after every diff, a documentation sub-agent that maintains the domain README. Scoping context to the bounded domain reduces hallucination and architectural drift, and it maps directly to the reverse Conway maneuver: align teams and their agents to value streams with clean context boundaries, and both move faster.

DIVIDER

The tools: Claude Code, Codex, Cursor, Windsurf, and Copilot

We run all of these in client environments, and the most useful thing we can tell a leader is that the tool question is the wrong first question. The durable asset is the agentic engineering process: the specifications, evals, rubrics, repository-level agent instructions, and MCP-governed context that any capable agent executes against. Build that layer well, and it travels across every tool below. Skip it, and no tool saves you. The Amazon result is instructive here, since the team spent its first weeks redesigning workflows around agents before the delivery clock started.

That said, each platform has a distinct shape, and mature teams deploy them deliberately rather than defaulting to one. Claude Code is our workhorse for deep, repository-aware work in regulated domains: a well-maintained CLAUDE.md encoding architectural rules, hooks enforcing policy at tool-call time, and sub-agents dividing labor within a bounded context. Codex-style asynchronous agents shine on breadth, fanning out across a backlog of well-specified, self-contained tasks and returning reviewed pull requests. Cursor and Windsurf earn their place in the interactive loop, where an engineer is actively shaping code and wants tight editor-native iteration, multi-file awareness, and fast context retrieval. GitHub Copilot remains the pragmatic on-ramp for large developer populations already living in the GitHub ecosystem, and its agent mode is closing the gap on autonomous task execution.

The pattern that works is fit-for-purpose assignment governed by one specification layer: depth agents on architecturally sensitive paths, async agents on high-volume routine work, editor-native tools in the human-in-the-loop inner cycle, and the same contracts, evals, and merge gates applied to output from all of them. Route architectural reasoning to frontier models and boilerplate to smaller ones and instrument every session so the token cost of each merged pull request is a known quantity. Undifferentiated model routing and undifferentiated tool assignment are the two largest sources of waste we see in agentic delivery today. Declaring a single winner misses the point. The winner is the organization whose process makes every tool interchangeable.

DIVIDER

The leadership agenda

Gartner also issues a warning that belongs in every operating plan: organizations relying on AI to eliminate junior software engineering roles risk hollowing out their own talent pipeline by 2028, since slowing junior hiring inhibits knowledge transfer and eventually forces companies to compete for scarce senior talent. Three-quarters of software engineering leaders in the same research expect headcount to stay flat or grow. Tiny teams are a restructuring, not a downsizing program.

The agenda between now and 2029: mandate specification-driven development on production paths, invest disproportionately in platform engineering and evals, protect the junior pipeline by retraining entry-level roles around context engineering and output validation, and treat token consumption as a governed FinOps discipline.

At UST, our partnership with Anthropic gives us a front-row seat to what frontier agentic capability looks like when it meets enterprise reality. The organizations winning this transition share one trait: they treat governance as the accelerant, and they build the harness before they hire the horsepower.