The Economics, Estimation, and Team Topology of Software Engineering in the AI Era

Across global technology organizations, AI coding assistants and autonomous agents have reached near-universal adoption: 75% to 95% of software engineers now use AI tools at least weekly, and roughly 70% run two to four distinct AI coding tools side by side. Yet empirical telemetry across tens of thousands of developers exposes a sharp disconnect between task-level code generation speed and organizational delivery velocity.

As the marginal cost of producing syntax approaches zero, the binding constraint in software production has migrated from manual implementation to specification discipline, architectural verification, security governance, and human review capacity. In earlier articles on Spec-Driven Development, Context Engineering, Harness Engineering, and Why Harness Engineering Matters, I explored those verification controls at the repository and runtime levels.

In this post, we zoom out to examine how that constraint shift is reshaping the broader software industry—breaking physical-size COCOMO models and traditional story-point estimation, elevating functional sizing, rewriting commercial IT pricing models, altering the Total Cost of Ownership (TCO) of production systems, testing the limits of hyper-lean “AI-native” pods, bifurcating engineering careers, and establishing a new set of operational practices.

flowchart TD
    accTitle: How AI coding tools relocate the primary constraint in the software lifecycle
    accDescr: AI coding agents compress manual boilerplate and syntax generation by 30 to 50 percent, inflating physical line counts and pull request volume. Without specification gates and deterministic harnesses, the surplus code breaks KLOC and story-point estimates while accumulating in human review queues, security remediation, and production rework.
    subgraph PreAI ["Classic Bottleneck: Manual Implementation"]
        SpecOld["Upfront Spec, KLOC / COCOMO<br/>and Story Pointing"] --> CodeOld["Manual Coding and Boilerplate<br/>(60%–70% of sprint effort)"]
        CodeOld --> ReviewOld["Bounded PR Review and QA"]
    end

    subgraph UncheckedAI ["Unchecked AI Adoption: Downstream Congestion"]
        FastGen["Agentic Code Synthesis<br/>(30%–50% faster routine coding)"] --> Bloat["PR Size +154% and Duplication 8x"]
        Bloat --> Queue["Review Duration +91%<br/>and 44% Security Flaw Rate"]
        Queue --> Rework["Flat Company DORA Velocity<br/>and Rising Production Rework"]
    end

    subgraph DisciplinedAI ["AI-Era Engineering Discipline"]
        SpecGate["Executable Specifications<br/>and Small-Batch Decomposition"] --> Harness["Model-Routed Agents Inside<br/>Deterministic Quality Harnesses"]
        Harness --> HumanVerify["Focused Architectural Review<br/>and Continuous Flow Telemetry"]
    end

    PreAI --> UncheckedAI
    UncheckedAI --> DisciplinedAI

---

1. Reconstructing software estimation: from typing effort to verification capacity

Why physical-size COCOMO models fracture under AI

Long before agile teams debated Fibonacci cards, enterprise and defense cost engineering rested on Barry Boehm’s Constructive Cost Model (COCOMO). Published in 1981 (Software Engineering Economics) from regressions over 63 waterfall projects at TRW ranging from 2,000 to 100,000 lines of code, Basic and Intermediate COCOMO treated physical program size—Kilo Lines of Code (KLOC)—as the primary predictor of person-month effort (PM), with mode-specific coefficients for Organic, Semidetached, and Embedded projects. Intermediate COCOMO then scaled that estimate by a 15-driver Effort Adjustment Factor (EAF):

PM = a_i(KLOC)^b_i · EAF

When Boehm and colleagues at the University of Southern California (USC) rebuilt the framework in 2000 as COCOMO II—calibrated across 161 projects—they added an Early Design model accepting Function Points alongside the Post-Architecture equation:

PM = A · (Size)^E · ∏ EM_i

Here, A = 2.94, the scaling exponent E = 0.91 + 0.01 · ∑ SF_j spans 0.91 to 1.226 across five organizational Scale Factors (PREC, FLEX, RESL, TEAM, PMAT), and ∏ EM_i is the product of 17 Effort Multipliers.

A 2026 conceptual framework in Frontiers in Artificial Intelligence, Toward LLM-aware software effort estimation, argues that COCOMO II’s inadequacy under LLM-assisted development is structural rather than parametric: no amount of statistical recalibration closes the gap once code-size proxies such as SLOC lose their link to human effort. In KLOC-driven COCOMO practice, that structural mismatch surfaces in three places:

1. The KLOC fallacy: COCOMO’s core premise is that physical code volume correlates positively with human authoring effort and delivered system capability. When coding agents synthesize thousands of lines of boilerplate, adapters, and unit tests in seconds—and favor verbose copy-pasting over refactoring—KLOC stops measuring human effort and starts measuring technical debt.
2. Corrupted backfiring and maintenance equations: Feeding AI-inflated KLOC into COCOMO II—or into QSM gearing (“backfiring”) tables to convert source lines into Function Points—mistakes redundant verbosity for massive functional scope. At the same time, COCOMO II’s Annual Change Traffic (ACT) maintenance equations miss the downstream “propagation tax” of locating and patching duplicated blocks scattered across unfamiliar files.
3. Unmodeled outer-loop cognitive work: Legacy TOOL and MODP (modern programming practices) multipliers assume human-written code inside static lifecycle allocations; they do not capture context curation, prompt-generate-verify loops, architectural governance, or non-labor LLM token consumption.

Why traditional story points fracture under AI

Agile teams that abandoned COCOMO decades ago for relative sizing hit the exact same wall. For more than two decades, sprint planning relied heavily on story points—a relative measure of effort popularized by Mike Cohn and estimated through rituals like Planning Poker. Story points compressed three variables into a single Fibonacci number: volume of implementation work, technical complexity, and requirement uncertainty. That abstraction worked reasonably well while human typing and manual implementation dominated sprint timelines.

AI-native development environments such as Cursor, GitHub Copilot, and Claude Code break that baseline math in three ways:

1. Hyper-inflation on routine scaffolding: Across standard tasks, AI coding tools cut manual coding effort by 30% to 50%, compressing CRUD endpoints, UI scaffolding, and boilerplate—historically 60% to 70% of enterprise codebases—into minutes. Teams that keep legacy Fibonacci baselines while adopting agentic tools see velocity inflate on routine tickets without any matching change in delivered value.
2. Uneven compression across the backlog: Story point forecasting depends on relative consistency across ticket types. While UI scaffolding and schema mapping shrink dramatically, McKinsey’s 2023 developer productivity study found that time savings shrank to less than 10% on tasks developers rated as highly complex. A historical “5-point” CRUD ticket might drop to an hour, while a “5-point” distributed state bug still takes days.
3. Cognitive inversion from writing to verifying: Classic estimation asked how hard a feature was to write. AI-era estimation asks how long it takes to specify intent, curate context, audit non-deterministic diffs, validate system boundaries, and catch subtle regressions. Because code generators routinely emit diffs that compile cleanly while violating domain invariants—a pattern I documented firsthand in the five AI hotel implementations study—verification effort frequently exceeds authoring effort.

Four emerging estimation and forecasting practices

In response, cost engineers and software delivery teams are replacing physical line counts and subjective effort points with four complementary practices:

• Parametric recalibration, automated Function Points, and agentic overlays: Organizations in defense, aerospace, and regulated enterprise portfolios have not replaced auditable parametric math with raw LLM guesses—especially since empirical benchmarks (From COCOMO to GPT) show off-the-shelf zero-shot LLMs still underperforming classical ML and calibrated regressors on project effort accuracy. Instead, parametric estimation is adapting across three layers:
  • A proposed AI Assistance Usage driver for COCOMO and COSYSMO: In Systems Acquisition Cost Modeling Initiative for AI Assistance (2024 Acquisition Research Symposium), Ray Madachy, Ryan Bell, and Ryan Longshore propose a five-level AI Assistance Usage cost driver (Very Low to Very High) built on the COCOMO framework and aligned with ISO/IEC/IEEE 15288 lifecycle processes, alongside COSYSMO_AI. The driver is not calibrated yet: an online Delphi survey, supported by the USC Boehm Center for Systems and Software Engineering, is collecting expert multiplier estimates and paired AI-assisted vs. unassisted effort data to derive its effort multipliers. As with any COCOMO driver, Nominal (1.0) is the default for a typical project.
  • Function Point Analysis (FPA) as an invariant size measure: Unlike KLOC, IFPUG Function Points (ISO/IEC 20926) and COSMIC (ISO/IEC 19761) size what user-recognizable capabilities software delivers—inputs, outputs, inquiries, logical files, and data movements—independently of how syntax is produced. A 300-FP system remains 300 FP whether coded manually or orchestrated via agents, so FP stays a stable denominator and AI’s true impact shows up in the numerators of hours/FP, $/FP, and defects/FP. Automated NLP and LLM tools—such as ScopeMaster and research frameworks like CosMet—extract functional sizes directly from user stories, reducing manual counting effort while flagging ambiguous requirements upfront.
  • Agentic front-ends over deterministic engines: Commercial suites pair AI ingestion with Monte Carlo risk engines: Galorath layers SEERai over SEER-SEM to extract traceable sizing inputs and Work Breakdown Structures from unstructured RFPs; QSM’s SLIM suite models Schedule–Budget–Staff–Quality constraints against QSM’s historical database of completed projects; and Unison Cost Engineering’s ICEAA guidance for AI-enabled systems adds explicit non-coding cost pools for data acquisition and cleansing, iterative GPU tuning cycles, and post-deployment drift and adversarial monitoring.
• Lean flow telemetry and “split until small”: High-performing product teams are retiring story points—or collapsing upfront sizing into quick T-shirt buckets (XS, S, M, L, or Too Big to Estimate)—and enforcing strict small-batch decomposition. Forecasting relies on historical flow metrics: Cycle Time (averaging 4.2 days across the industry and under 1 day for elite teams), Flow Time (total elapsed time from start to production), Flow Load (active work in progress), and Flow Efficiency (active touch time divided by total elapsed time). Flow efficiency immediately exposes where AI gains stall: active coding shrinks while wait queues in code review and integration testing expand. Alongside this, Google’s DORA program expanded its classic four keys to five by adding Deployment Rework Rate—the share of unplanned deployments triggered to remediate production incidents—as an early warning indicator when AI generation outpaces verification rigor.
• Specification-driven and verification-weighted sizing: Where upfront sprint capacity planning or PERT range estimation is still required, teams weight work by specification ambiguity and verification surface area rather than expected lines of code—compressing the inner-loop build band modestly while widening code-review, integration, and security bands. A 2026 multivocal literature review of 67 sources reinforces that specification discipline—not raw model capability—is the primary constraint on AI-assisted software dependability. Tickets explicitly budget time for context curation, deterministic acceptance harnesses, and cross-service integration checks.
• LLM comparative judgments and Diff Delta™: In enterprise settings that retain story points for portfolio governance or client reporting, teams are moving away from Planning Poker toward pairwise comparative judgment grounded in Thurstone’s law and Bradley–Terry preference models. Instead of guessing absolute Fibonacci numbers (or training brittle project-specific estimators like early GPT2SP models that fail on cold-start repos), engineers or few-shot LLMs compare pairs of backlog items to judge which requires more effort, lowering bias and cold-start data requirements. Retrospectively, engineering intelligence platforms such as GitClear replace raw commit and line counts with Diff Delta™, weighting durable, non-churned code changes that correlate far better with genuine engineering effort than raw lines added.

The proposed AI Assistance Usage scale rates how deeply AI is woven into a project’s workflow. The effort multipliers for each level are still being collected, so the scale is not yet a calibrated adjustment:

Proposed AI Assistance Usage Rating	Rating Definition (Madachy, Bell & Longshore, 2024)
Very Low	Minimal to no AI assistance; development relies primarily on traditional methods and tools; AI tools may be present but are rarely consulted
Low	Occasional AI consultation, typically for clarification or basic information retrieval; AI is not deeply integrated into the workflow
Nominal (default)	Regular AI use for code help, design insights, or testing assistance; a recognized part of the toolkit but not central
High	Frequent, strategic AI use; AI plays a central role in multiple phases, from design to code review
Very High	AI deeply ingrained in most phases and crucial to decision-making, problem-solving, and task automation; the process is designed around AI

Estimation Paradigm	Core Unit of Measure	Primary Constraint Captured	Strengths in AI Workflows	Key Limitations
Legacy COCOMO / KLOC Backfiring	Physical KLOC or KLOC-to-FP gearing ratios	Historical manual coding labor per physical line	Auditable closed-form equations for waterfall hardware/defense programs	KLOC inflates via AI duplication; misses outer-loop review and token costs
Functional Sizing (FPA) & AI-Adjusted Parametrics	ISO IFPUG / COSMIC Function Points + proposed AI Assistance Usage driver	Invariant user functionality vs. maturity-adjusted hours/FP	Technology-agnostic size measure; automated counting tools reduce manual sizing effort	Requires clean requirements prose; AI driver multipliers still awaiting Delphi / project-data calibration
Classic Story Points (Planning Poker)	Relative Fibonacci points (1, 2, 3, 5, 8...)	Manual coding volume, complexity, and uncertainty	Surfaces hidden assumptions during cross-functional discussion	Baselines fracture under uneven AI speedups; misses review and verification queues; not comparable across teams or vendors
Lean Flow & Issue Count (“No Estimates”)	Cycle Time, Flow Efficiency, Throughput, Rework Rate	Wait queues, PR review latency, and WIP congestion	Cuts ceremony overhead; pinpoints downstream review bottlenecks	Requires disciplined decomposition into uniformly small tickets and stakeholder trust
LLM Comparative Judgment	Pairwise preference ranking mapped to points	Semantic scope and relative architectural complexity	Works on cold-start projects via few-shot inference; reduces anchoring bias	Sensitive to vague ticket prose; can inherit historical sizing distortions
Verification & Diff Delta™ Telemetry	Durable code change and test/eval coverage weight	Specification rigor, verification scope, and non-churned output	Filters out AI code bloat and short-term churn	Primarily a retrospective diagnostic metric rather than a pre-sprint forecast

---

2. Commercial realignment: pricing software in the post-hourly era

The “Efficiency Tax” on Time-and-Materials billing

For software agencies, consultancies, and global system integrators, AI-assisted delivery has triggered an immediate commercial squeeze. Historically, IT services relied on either Time and Materials (T&M)—billing clients per developer hour or daily rate card—or Fixed-Price contracts tied to a static upfront scope.

When AI tools compress routine coding and test scripting by 30% to 50%, hourly T&M billing imposes an “Efficiency Tax”: vendors that invest in agentic toolchains and deliver faster bill fewer hours, cannibalizing their own top-line revenue while the client captures 100% of the productivity surplus. Traditional fixed-price contracts invert that capture, letting the vendor retain margin expansion—unless procurement teams force steep upfront discounts or iterative AI product discovery triggers constant change-request gridlock.

Enterprise buyer pushback and IT services deflation

Enterprise procurement teams have moved aggressively to capture those expected labor savings upfront:

• Widespread contract renegotiation: HFS Research’s 2026 Enterprise Pulse study found that 77% of enterprises plan to renegotiate pricing with IT service providers, 48% plan to shift work to another provider, and only 17% expect to renew with limited change.
• 25%–30% discount demands and structural deflation: Persistent Systems CEO Sandeep Kalra told Reuters that clients are asking for the same work at prices 25% to 30% lower. HCLTech CEO C. Vijayakumar expects AI to cause 2% to 3% annual deflation at an industry level, and warned that the roughly 40% of industry services most exposed to AI could shrink at a 3% to 5% compound annual rate for several years.
• The bookings-to-revenue squeeze in global IT: In Q2 FY27 (October 2026), Infosys reported that AI-specific revenue jumped 29% quarter-over-quarter to 10.5% of total revenue ($5.145 billion quarterly revenue and $5.2 billion in large-deal total contract value), yet trimmed full-year constant-currency revenue growth guidance from 1.5%–3% down to 1%–2%, citing macroeconomic weakness in North America and a weak large European manufacturing client. Peers Wipro (guiding -1.5% to +0.5% sequential growth) and HCLTech show the same dynamic: legacy maintenance and development contracts deflate faster than new agentic transformation bookings convert into recognized revenue, while enterprises pull routine development back into internal teams and Global Capability Centers (GCCs).

flowchart TD
    accTitle: Evolution of commercial software pricing models under AI labor compression
    accDescr: AI reduces routine coding hours by 30 to 50 percent, causing revenue cannibalization under Time and Materials billing and 25 to 30 percent buyer discount demands. Vendors respond by shifting to Fixed-Price milestones and Function Point rate cards, Gain-Share contracts, and KPI-indexed Value Level Agreements.
    Driver["AI Compresses Routine Coding Hours by 30%–50%"] --> TM["Time and Materials (T&M) Crisis:<br/>Vendor suffers 'Efficiency Tax'<br/>77% of enterprise buyers renegotiate"]
    TM --> FP["1. Fixed-Price Milestones<br/>(&gt;65% of Accenture bookings)<br/>and Function Point Rate Cards;<br/>requires strict internal token caps"]
    TM --> GS["2. Zero-Upfront &amp; Gain-Share<br/>(HCLTech / E.ON: no Year-1 payment;<br/>Cognizant / Daimler Truck split)"]
    TM --> VLA["3. Outcome-Driven VLAs<br/>(Unit-of-value pricing governed by<br/>a joint value realization office)"]

Real-world post-hourly pricing architectures

To escape the Efficiency Tax without sacrificing operating margins, consultancies and engineering agencies are decoupling revenue from headcount across three commercial models:

1. Fixed-price bookings and standardized Function Point rate cards: In Accenture’s fiscal 2026 fourth quarter, fixed-price work, including outcome-based engagements, made up more than 65% of new bookings. In enterprise and public-sector Application Development and Maintenance (ADM) outsourcing, some buyers anchor fixed-price rate cards in Function Points counted under the ISO-standardized IFPUG or COSMIC methods ($/FP) rather than team-relative story points or AI-inflated KLOC—a vendor-neutral output unit for benchmarking supplier cost and defect density that makes AI efficiency gains visible in the price per FP. Fixed fees also move inference costs onto the vendor, which is why vendors meter internal LLM token budgets on these engagements: in October 2026, Accenture capped central funding for employees’ Claude usage at $29 per month, charging anything above that to the project.
2. Zero-upfront and shared-savings (gain-share) deals: Vendors increasingly absorb initial transition risk in exchange for a share of downstream savings. According to people familiar with the agreement cited by Reuters, HCLTech will not be paid for the first year of a multiyear cloud management deal with European energy group E.ON, with payments from the second year tied to efficiency gains and business outcomes. Reuters also reported that Cognizant’s workplace services deal with Daimler Truck calls for AI-related savings to be shared between the companies.
3. Outcome-driven Value Level Agreements (VLAs): Some managed-service providers, such as Version 1, replace hourly rate cards and static SLAs with VLAs, often governed jointly through a value realization office. Contracts price a concrete unit of value (cost per processed transaction, active user, or resolved ticket) and tie fees to audited telemetry such as unit cost-to-serve, lead time for change, availability and MTTR, escaped defects, and cloud spend per transaction.

Commercial Model	Core Billing Unit	Who Captures AI Efficiency	Risk Allocation	Primary 2026 Fit
Time & Materials (T&M)	Billable developer hour / day	100% Client (vendor absorbs the Efficiency Tax)	Client bears delivery and rework risk	Exploratory R&D, staff augmentation, and ambiguous advisory
Fixed-Price / $/FP Rate Card	Deliverable milestone or counted Function Point	Vendor (minus 25%–30% bid discounts or recalibrated $/FP)	Vendor bears estimation, token burn, and overrun risk	Bounded migrations, ADM outsourcing, and standard CRUD builds; fixed-price work exceeds 65% of Accenture bookings
Gain-Share / Shared Savings	Percentage of verified cost reduction	Split contractually (e.g., Cognizant/Daimler Truck)	Vendor fronts Year-1 capital risk; shared upside	Large-scale cloud modernization and legacy application consolidation
Outcome-Driven / VLA	Unit-of-value card and KPI telemetry	Co-captured via shared-risk performance bands	Jointly governed by a value realization office	Continuous AI-native product engineering and platform modernization

---

3. Software cost dynamics: is building software actually cheaper now?

The unit-cost vs. total-cost paradox

One of the most important findings in modern engineering economics is that while the marginal cost of generating initial code has dropped by 30% to 50%, the end-to-end Total Cost of Ownership (TCO) of building and operating production software remains roughly flat—or higher—than before AI.

Conflating syntax generation with systems engineering ignores two classic economic principles: Amdahl’s Law (a pipeline’s overall speedup is bounded by its slowest unaccelerated stage) and Baumol’s Cost Disease (as automated stages become cheap, human-intensive verification, security review, and integration consume an ever-larger share of total budget). Early narrow benchmarks—such as timing developers writing an isolated HTTP server from scratch—measured typing speed in a vacuum. Production studies tell a very different story:

• The METR Randomized Controlled Trial (-19% actual speed vs. +20% perceived speed): Evaluating 16 experienced open-source maintainers across 246 real tasks in mature repositories exceeding 1 million lines of code, METR found that developers allowed to use AI tools (primarily Cursor Pro with Claude 3.5 and 3.7 Sonnet) took 19% longer than when working without AI. Before starting, those developers predicted a 24% speedup; even after finishing slower, they believed AI had made them 20% faster—a 39-percentage-point perception gap. Removing the friction of typing feels productive even while total clock time leaks into prompting, reading, and debugging “almost right” suggestions (a frustration echoed by 66% of developers in Stack Overflow’s survey). METR has since cautioned that -19% is an early-2025 snapshot: in its follow-up study, developers increasingly refused to work without AI, which biased the sample, and the new estimates (an 18% speedup for returning participants and 4% for new recruits) have confidence intervals that still include a slowdown. Enterprise-wide telemetry shows where the bottleneck moves next.
• Faros AI organizational telemetry: Across 10,000+ developers and 1,255 engineering teams, Faros AI’s 2025 report observed that high AI adoption raised individual task completion by 21% and merged pull requests by 98%. Yet at the company level, Faros found no significant correlation between AI adoption and improvements in delivery. Surplus code piled up in review queues: average PR size jumped 154%, PR review time rose 91%, and bugs per developer climbed 9%. Its 2026 report, covering 22,000 developers across 4,000 teams, shows the gap widening: median review time is up roughly 5x, bugs per developer are up 54%, and incidents per pull request have more than tripled.
• DORA research (2024–2025): DORA’s 2024 report found that each 25% increase in AI adoption improved individual flow (+2.6%), job satisfaction (+2.2%), code review speed (+3.1%), and documentation quality (+7.5%), but correlated with an estimated 1.5% drop in delivery throughput and a 7.2% drop in delivery stability. The 2025 State of AI-Assisted Software Development report, surveying nearly 5,000 technology professionals, found that AI adoption now correlates with higher throughput while delivery instability keeps rising. Its core conclusion: AI is an amplifier that magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones.

The three hidden taxes inflating software TCO

Three measurable cost drivers explain why engineering budgets are not shrinking:

1. Runaway tokenomics and multi-agent compute: As teams move from fixed-seat autocomplete plugins to usage-billed autonomous agent loops, inference bills compound rapidly. Developers optimizing for personal convenience routinely route trivial edits and broad repository searches to expensive frontier models rather than smaller or open-weight alternatives. Jellyfish’s telemetry shows the heaviest token users producing roughly twice the pull-request throughput of the median engineer while consuming about 10x the tokens. In June 2026, Gartner predicted that AI coding costs will surpass the average developer’s salary by 2028; a year earlier, it had warned that over 40% of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value, and weak risk controls.
2. Codebase maintainability decay (“Write-Only Mode”): Coding assistants strongly favor adding lines over refactoring or consolidating abstractions. GitClear’s longitudinal study of 211 million changed lines (2020–2024) documents a structural erosion in modularity: copy-pasted lines climbed from 8.3% to 12.3% of changes, surpassing moved/refactored lines for the first time, and code blocks duplicating five or more lines grew 8x during 2024. Meanwhile, refactored (“moved”) code fell from 25% of changed lines in 2021 to under 10% in 2024. GitClear’s 2026 follow-up, covering 623 million changes, found error-masking constructs up 47%, and heavy AI users producing 9x more short-term churn than non-users. Separate analyses by CodeScene find initial AI speedups erased within two months by maintenance drag on unhealthy code, while SonarSource flags structural code smells in 90% of AI-generated output (aligning with the maintenance friction I measured in Part 2 of the hotel case study). That cloning pattern directly breaks COCOMO II’s Annual Change Traffic (ACT) maintenance assumptions: inflating physical KLOC with disconnected duplicate blocks multiplies the sustainment effort of every future security patch or rule change.
3. Security debt and exponential production remediation: In CodeRabbit’s analysis of 470 open-source pull requests, AI-co-authored PRs contained 1.7x more issues overall, 75% more logic and correctness issues, more than 3x the readability issues, and up to 2.74x more security issues than human-only PRs. Veracode’s 2026 GenAI Code Security report found that although models produce syntactically correct code nearly 100% of the time, roughly 44% of AI code generation tasks introduced a risky security vulnerability—barely changed since Veracode’s first report—with security pass rates of just 15% on cross-site scripting (XSS) and 12% on log injection. Apiiro’s telemetry across enterprise repositories similarly recorded a 10x rise in monthly AI-linked security findings between December 2024 and June 2025 (exceeding 10,000 new findings per month) even as syntax errors fell 76%. Because defect remediation scales exponentially—roughly $100 in design, $1,000 in unit testing, $1,500–$2,000 in QA, and $10,000 to $100,000+ in live production—and Faros AI found incidents per pull request more than tripled under high AI adoption, unchecked AI velocity pushes defects straight into the most expensive tier.

Jevons Paradox and global engineering ROI

Historically, five software abstraction waves—Assembly to C (2.5x fewer lines per function point), C to Java/Python (5–15x), Spring Boot (80% less boilerplate), Swift (70% reduction), and React (70% less setup boilerplate)—triggered Jevons Paradox: lowering unit construction effort expanded global developer headcount from 10–12 million in 2001 to 36.5 million in 2025 and enterprise software spending from $74 billion to $1.25 trillion. Whether GenAI sparks an equally elastic sixth demand wave depends on breaking the verification bottleneck; otherwise, organizations risk “so-so automation” that displaces entry-level tasks without reducing verified end-to-end system cost:

Total Development Cost = (Delivery Effort × Blended Team Rate) + Infrastructure & Token Spend + Rework + Ongoing Support

Because Delivery Effort × Rate plus rework outweighs hourly rate cards alone—an experienced AI-disciplined team at $45–$60/hr delivering in 1,500–2,000 hours ($67,500–$120,000) costs no more than a $25–$30/hr team spending 4,000 hours in high-churn rework ($100,000–$120,000)—global talent strategy increasingly weighs cost alongside engineering depth, English fluency, and time-zone overlap. Staffing marketplace Second Talent combines those factors into a proprietary Engineering ROI Score:

Region / Market	Typical AI Engineer Annual Base (USD)	General SWE / Market Context	Second Talent Engineering ROI Score (0–100)
United States	$140,910 (BLS median for computer and information research scientists)	Reference market for cost and time-zone comparisons	Not scored
Southeast Asia (Singapore)	$80,000 – $150,000	General SWE S$4.5K–S$20K+/mo; premier APAC financial and regional tech hub	51 (Cost: 4, Talent: 7, English: 10)
Latin America (MX / AR / BR / CO)	$58,075 (MX) / $55,900 (AR) / $40,800 (BR)	Colombia $19.7K–$38.2K; US time-zone overlap (9–10/10) and deep hiring pool in Brazil (9/10)	70 (BR & CO) / 65 (AR) / 64 (MX)
Eastern Europe (PL / RO / UA)	$55,200 (PL) / $50,400 (RO) / $40,800 (UA)	Strong systems architecture and deep-tech supply (7–8/10) with EU/US overlap	64 (UA) / 63 (RO) / 62 (PL)
Emerging Southeast Asia	$40K–$50K (MY) / $35K–$45K (ID)	Thailand $35K–$40K; Vietnam $30K–$35K; Philippines $12K–$30K	72 (PH) / 67 (VN) / 62 (ID) / 58 (MY, TH)
South Asia (India)	$17,323 (Median AI) / $45K–$75K (Senior ML EOR)	Agency rates $25–$49/hr; 5.8M IT workforce generating $55.7B R&D revenue	83 (Cost: 10, Supply: 10, English: 8)

---

4. Team topology: why 3-person “AI-native” pods break at enterprise scale

Meta’s Project OT and the limits of 3–5 person pods

Inspired by the revenue-per-employee ratios of AI-native startups, executives have tested shrinking product teams into small “AI-native” pods. In the most visible Big Tech test case, Meta’s internal Project OT (“Organization Transformation”) envisioned turning 10-to-20 person teams into 3-to-5 person “AI-native” teams doing the same work—a roughly 60% headcount reduction. Meta piloted AI-native pods and cut 10% of its staff, then canceled a planned second wave of cuts after an employee revolt, a string of outages, and a resignation wave.

While 3-to-5 person pods excel on zero-to-one greenfield prototypes, operational data shows four failure modes when mature production teams shrink below 6 to 8 engineers:

1. The 6-engineer 24/7 on-call threshold: Sustaining a healthy 24/7 production rotation requires at least 6 engineers. In a 3-to-5 person pod, one illness overlapping with one vacation leaves 1 or 2 people carrying round-the-clock pager duty, driving immediate alert fatigue and incident risk.
2. Dangerous bus-factor concentration: Bus factors are already thin: in Metabase’s analysis of the 1,000 most-starred GitHub repositories, nearly half had a bus factor of two or less. Downsizing a 30-person domain unit to 18 concentrates institutional context into single points of failure that agents cannot reconstruct from source files alone.
3. “AI brain fry” and supervision fatigue: Shrinking headcount does not shrink cognitive load—it turns remaining engineers into parallel air-traffic controllers. Faros AI shows developers on high-adoption teams touch 9% more tasks and 47% more PRs per day. A March 2026 Boston Consulting Group (BCG) study of 1,488 US workers coined “AI brain fry” for mental fatigue from excessive use or oversight of AI tools beyond one’s cognitive capacity: self-reported productivity peaked at three AI tools and eroded beyond that, and workers with brain fry reported 39% more major errors and higher intent to quit.
4. Zero slack for architecture and mentorship: Hyper-lean pods running at 100% reactive utilization lose the organizational slack required to pay down technical debt, refine specifications, maintain runbooks, and mentor newer engineers.

The collapse of the staffing pyramid and the QA crunch

Even as resilient product pods settle around 6 to 8 engineers, two structural shifts are reshaping internal org charts:

• The vanishing entry-level pyramid: Traditional consultancies and product orgs relied on a wide base of juniors writing routine code and unit tests beneath a narrow senior tier. With coding agents absorbing entry-level implementation, SignalFire found that new graduates made up just 7% of Big Tech hires, down from 15% before the pandemic, alongside “experience inflation” demanding 3–5 years of production background for entry roles. Seniority also shapes agent leverage: The Pragmatic Engineer’s 2026 survey of 906 engineers found that 63.5% of Staff+ engineers regularly use AI agents, versus 49.7% of other engineers. Cutting the junior rung lowers immediate payroll, but hollows out the 5-to-10 year pipeline of future systems architects.
• Thinner QA vs. pull-request floods: As teams hand test-script generation to AI, manual QA headcount is under pressure just as pull-request volume climbs (merged PRs rose 98% in Faros AI’s high-adoption cohort). Maintainers are feeling the crush directly: curl shut down its HackerOne bug bounty in January 2026 after the share of confirmed vulnerabilities fell below 5% under a wave of AI-generated slop reports, and Godot maintainers, facing more than 4,600 open pull requests, called AI-generated submissions “draining and demoralizing” and asked for funding to hire more maintainers.

To keep leaner feature pods from drowning in infrastructure, model-routing, and security overhead, 90% of organizations now have at least one internal platform and about three-quarters have dedicated Platform Engineering teams (per DORA 2025), scaling their governance and Software Engineering Intelligence (SEI) stack by headcount tier:

Headcount Tier	Infrastructure & Platform Topology	SEI & Governance Stack	Typical Annual Tooling Spend
Under 30–50 Engineers (Seed / Series A)	Generalist “you build it, you run it” DevOps; product engineers own app and cloud config	Lightweight flow tracking: GitHub Insights, Haystack, or CodePulse	$2,400 – $9,000 / yr
50 to 100 Engineers (Scaleups — “Yellow Light”)	CI/CD and approval friction surfaces; first 2–3 generalist platform hires	Team DORA/SPACE cockpits: Swarmia, Sleuth, or LinearB	$12,000 – $30,000 / yr
100 to 500 Engineers (Mid-Market — “Red Light” without IDP)	Mandatory 5–8 person Platform Team + PM delivering self-service Golden Paths	Enterprise AI ROI, PR queue, and token governance: Faros AI, LinearB, or DX	$30,000 – $100,000 / yr
500+ Engineers (Large Enterprise)	Hybrid topology: central platform core + embedded business-unit platform engineers	Board-level R&D capitalization, FinOps cost mapping, and agent telemetry: Jellyfish or DX	$100,000 – $150,000+ / yr

---

5. Workforce bifurcation and new practices for AI-era teams

Are engineers becoming generalists or specialists? Both.

Rather than moving uniformly toward generalization or specialization, the 2026 engineering labor market has bifurcated across architectural layers: organizations are collapsing narrow single-layer silos at the application layer into multi-hat generalists, while paying steep premiums for deep specialists at the foundation, verification, and security layers.

flowchart TD
    accTitle: Bifurcated engineering organization topology in the AI era
    accDescr: Application delivery consolidates into 6 to 8 person resilient pods of multi-hat Product Engineers and Forward-Deployed Engineers owning user outcomes end to end, supported by a centralized specialist layer covering Platform Golden Paths, Applied AI model routing, AI QA evaluation harnesses, and DevSecOps security gates.
    subgraph AppLayer ["Application Layer: Outcome-Oriented Generalists"]
        Pod["Resilient Product Pods (6–8 Engineers)<br/>Multi-hat Product Engineers &amp; Forward-Deployed Engineers<br/>User discovery, executable specs, UI prototyping, full-stack code &amp; telemetry"]
    end

    subgraph FoundationLayer ["Systems &amp; Verification Layer: Deep Specialists"]
        Plat["Platform Engineering<br/>Self-service Golden Paths,<br/>sandboxes &amp; PR routing"]
        AppAI["Applied AI &amp; LLM Systems<br/>Model routing, RAG context,<br/>KV-cache &amp; token FinOps"]
        Evals["AI QA &amp; Evals Architecture<br/>Deterministic harnesses, statistical<br/>evals &amp; adversarial red-teaming"]
        Sec["AI Security &amp; DevSecOps<br/>SAST/supply-chain gates against<br/>44% AI vulnerability rates"]
    end

    subgraph Pipeline ["Talent Continuity"]
        Junior["Structured Verification Apprenticeships<br/>Juniors trained on spec writing, failure reproduction &amp; architectural review"]
    end

    FoundationLayer --> Pod
    Junior --> Pod

• Track 1 — Application-layer consolidation (the multi-hat Product Engineer): Shipping a SaaS feature in 2020 often meant sequential handoffs across a PM, UI designer, frontend engineer, backend engineer, and QA tester. Agentic prototyping collapses those boundaries: speaking at Davos in January 2026, Microsoft CEO Satya Nadella described how LinkedIn merged roles such as product management, design, and frontend engineering into a single “full-stack builder” role. AI-era Product Engineers own user outcomes end to end—talking to users, writing executable specs, iterating UI prototypes, curating agent context, and monitoring production—because, as Addy Osmani notes, writing code is rarely the slowest part of delivery; requirements, design, review, testing, and coordination are. In enterprise B2B, the same multi-hat profile appears as the Forward-Deployed Engineer (FDE), embedding directly with customers to ship domain AI workflows with zero handoffs at $90–$300/hr.
• Track 2 — Systems-layer hyper-specialization: Generalists moving fast with coding agents create non-deterministic failure modes, token bills, and security exposure that require deep domain specialists:
  • Applied AI & LLM Systems Engineers: Specialists who design multi-agent orchestration, RAG context pipelines, cache-preserving harnesses, and cost-aware model routers.
  • AI QA & Evaluation (“Evals”) Architects: Daily work shifts from writing manual test scripts toward test and evaluation architecture—combining auto-healing deterministic UI/API pipelines with statistical LLM evaluation harnesses, synthetic datasets, and adversarial red-teaming.
  • AI Security & DevSecOps Engineers: With roughly 44% of AI code generation tasks still introducing a vulnerability and monthly AI-linked findings up 10x in Apiiro’s data, AI Security and DevSecOps specialists build automated supply-chain, sandbox, and pre-merge security gates that scale with generated code volume.

Role Archetype	Orientation	Core Responsibilities in AI Workflows
Product Engineer / Full-Stack Builder	Multi-hat generalist	End-to-end user outcomes: spec authoring, rapid UI prototyping, context curation, full-stack delivery
Forward-Deployed Engineer (FDE)	Client-embedded generalist	Translates ambiguous enterprise domain problems into deployed AI workflows without handoffs
Narrow Single-Layer / Junior SWE	Isolated execution	Standalone UI components, routine CRUD endpoints, or manual boilerplate from static tickets
Applied AI / LLM Systems Engineer	Deep specialist	Model routing, RAG context pipelines, agentic harness design, and token FinOps
AI QA / Evals Architect	Deep specialist	Test and eval architecture: LLM eval harnesses, synthetic data checks, auto-healing gates
AI Security & DevSecOps Engineer	Deep specialist	Automated SAST, sandbox policies, and supply-chain guardrails for generated code

Six operational practices for engineering leaders and architects

Taken together, the industry numbers point to a clear engineering playbook:

1. Retire physical KLOC and uncalibrated story points in favor of functional sizing, flow telemetry, and spec gates: Stop feeding AI-bloated KLOC into COCOMO backfiring tables or recalibrating Fibonacci points around shifting model capabilities. Anchor portfolio and procurement sizing in technology-agnostic IFPUG / COSMIC Function Points, and treat AI productivity adjustments—such as the proposed AI Assistance Usage driver—as provisional until you calibrate them against objective git churn and delivery data rather than developer self-reports. Apply net effort compression only where workflows are actually redesigned, and shift Work Breakdown Structure allocations from inner-loop coding toward outer-loop review, security, and refactoring. At the sprint level, enforce small PR batches to counter +154% PR size bloat, weight work around executable specifications, and track Cycle Time, Flow Efficiency, and Deployment Rework Rate.
2. Move commercial contracts off hourly T&M: Whether buying or selling software services, replace pure hourly billing on standard delivery with Fixed-Price milestones, vendor-neutral Function Point ($/FP) rate cards, shared-savings gain-share, or KPI-indexed VLAs backed by transparent delivery telemetry—while capping internal token burn on fixed-fee scopes.
3. Apply FinOps discipline through model routing and bounded harnesses: Reserve expensive frontier models for architecture, specification review, and gnarly cross-service debugging, while routing routine completions, copy-editing, and bounded code tasks to smaller, cheaper models inside a strong harness via an AI gateway. Cap autonomous CI repair loops (such as Stripe’s 2-round limit) and preserve prompt-cache prefixes to avoid 10x token cost blowups.
4. Scale deterministic verification before scaling agent autonomy: Never expand background agent PR volume without automated review routing (tools like gitStream alongside diff-viewer filtering cut reviewed lines by 22% to 31%), static analysis gates (SonarQube, linters, SAST), adversarial cross-model diff checks, and Diff Delta™ / 2-week churn monitoring to keep repositories out of “Write-Only Mode.”
5. Staff 6-to-8 person resilient Product Pods, not fragile 3-person islands: Respect the 6-engineer 24/7 on-call floor, track repository bus factor, cap simultaneous tool sprawl to prevent AI brain fry, and introduce dedicated Platform Engineering Golden Paths before passing 100 engineers.
6. Rebuild the junior rung around verification and systems thinking: Instead of eliminating entry-level hiring—and creating a senior architect cliff five years later—redesign junior roles as structured apprenticeships in specification writing, failure reproduction, deterministic test/eval harnesses, and architectural code review.

AI has not made software engineering effortlessly cheap or rendered architecture obsolete. It has made syntax cheap—which makes clear specifications, disciplined harnesses, security gates, and resilient engineering teams more valuable than ever.