TechBlocks Unveils Eight Engine to Shift AI Coding to Outcome Pricing

The AI Productivity Paradox: Phantom Value on the Ledger With TechBlocks — Ai4

Ai4

Enterprise AI adoption drops software delivery speed by 19% unless organizations replace point tools with an integrated operating model that ties vendor pay to production metrics.

AI-assisted summary of The AI Productivity Paradox: Phantom Value on the Ledger With TechBlocks — original source. Check the original for full context.

Source published: 2026-08-18

Detailed notes

## Background The AI Productivity Paradox: Phantom Value on the Ledger With TechBlocks was published by Ai4 on YouTube on August 18, 2026. The video features Prashant Kumar, CEO of TechBlocks, addressing why billions invested in AI developer tools have failed to deliver proportional enterprise outcomes. He presents a blueprint for moving past fragmented point solutions to an AI-native operating model and software factory.

## TL;DR Prashant Kumar argues that enterprise AI investments are repeating the costly mistakes of the cloud era by layering fragmented point tools over broken legacy workflows. Despite high tool adoption and developer perception of speed, real-world data shows minimal throughput gains, negative productivity impacts, and increased production risks. To unlock actual value, enterprises must transition to an AI-native operating model that unifies coding, intelligence, knowledge, agent orchestration, governance, and outcome-based measurement. TechBlocks introduces its 'eight' engine, which collapses disconnected vendor costs into guaranteed, outcome-aligned software delivery.

## Atmosphere & style The presentation is candid, sharp, and pragmatic, blending realistic tech-industry humor with hard-hitting data. Kumar adopts a direct, no-nonsense delivery, using clear historical parallels and real-world disaster studies to strip away vendor hype. The tone feels like an urgent, authoritative wake-up call for technology executives caught between board promises and real-world operational frictions.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) Prashant Kumar compares current enterprise AI adoption errors to past historical tech cycles, like pasting paper brochures onto websites during the internet era or moving unoptimized VMs to the cloud without changing operating models. - [02:00](https://www.youtube.com/watch?v=9R_4E1L8508&t=120s) The 2020 McKinsey study showed 75% of cloud migrations failed and went over budget, costing enterprises over $100 billion due to applying legacy spreadsheets and models to cloud transformation. - [03:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=202s) Enterprise leaders are repeating cloud-era mistakes by rushing to buy fragmented AI point solutions (coding assistants, attribution, governance) that yield localized gains rather than organizational productivity. - [04:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=262s) Despite a 93% AI tool adoption rate among 400 studied companies, DX research found median throughput gains were only 8%, drastically lower than the 3x-10x ROI promised to CFOs and boards. - [06:25](https://www.youtube.com/watch?v=9R_4E1L8508&t=385s) A METR controlled experiment with 430 senior developers showed that while engineers felt 20% more productive using AI tools, stopwatch-measured delivery actually dropped by 19%. - [07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) System integrators (SIs) and managed service providers (MSPs) simply attached Copilot licenses onto legacy headcount and hourly billing models without modernizing the core software delivery process. - [08:32](https://www.youtube.com/watch?v=9R_4E1L8508&t=512s) Ungoverned AI usage can lead to catastrophic production failures, as illustrated by Amazon's March 2026 AI-assisted deployment incidents that caused massive lost order volumes and forced a 90-day code freeze. - [10:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=622s) Enterprises over-index on optimizing the small slice of time developers actually write code (16%-30%), while ignoring the remaining 70%-84% spent on architecture, design, and testing. - [12:19](https://www.youtube.com/watch?v=9R_4E1L8508&t=739s) Transitioning to an AI-native operating model requires integrating six core building blocks: AI coding, actionable intelligence/telemetry, enterprise knowledge, agent orchestration, governance/observability, and outcome measurement. - [13:30](https://www.youtube.com/watch?v=9R_4E1L8508&t=810s) Uncoordinated AI adoption introduces risks like false velocity (more commits/PRs with zero roadmap impact) and cognitive debt (code generated faster than team mental models can understand). - [14:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=875s) Enterprises currently face fragmented financial waste across three separate vendor invoices: per-seat/token AI fees, engineering intelligence dashboards, and traditional time-and-materials vendor headcount. - [17:05](https://www.youtube.com/watch?v=9R_4E1L8508&t=1025s) TechBlocks introduced 'eight', an AI-native delivery engine designed to unify delivery agent pods, intelligence tracing, and governance under an outcome-based, risk-sharing pricing model. - [20:01](https://www.youtube.com/watch?v=9R_4E1L8508&t=1201s) Connecting measurement engines directly to vendor payout forces accountability, requiring vendors to absorb project risk, bug remediation costs, and AI inefficiency penalties. - [20:46](https://www.youtube.com/watch?v=9R_4E1L8508&t=1246s) Future market leaders will be defined by their ability to establish a superior AI-native operating model and software factory rather than accumulating the largest collection of AI tools.

## Detailed walkthrough Answering the user prompt requires no external YouTube tool call because the transcript content and context are provided directly in the prompt text. I will now process the transcript and generate the detailed walkthrough following all given instructions.Here is the detailed, faithful walkthrough of the provided transcript segment:

[00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) Introduction and Historical Patterns of Technological Hype

Prashant Kumar, CEO of TechBlocks, opens the session by inviting attendees to look up his background on LinkedIn by searching "Prashant Kumar TechBlocks." He transitions immediately into the main topic with a slide depicting human nature in tech adoption. He jokes that while he wanted to use the word "stupid" to describe how human species repeatedly make the exact same mistakes, his marketing team convinced him to use the word "predictable" instead.

He illustrates this predictable behavior through historical technology cycles: * **The Internet Era:** Companies took paper brochures, pasted them onto web pages, and called it "e-commerce". * **The Cloud Era:** A decade later, organizations took virtual machines, moved them unchanged onto someone else’s servers, and labeled it "digital transformation". IT organizations sat with Excel spreadsheets comparing core-to-core, server-to-server, and dollar-to-dollar, ending up with completely wrong answers because they used the wrong model. * **Failed Realities:** Even 20 years later, enterprises have largely failed to reimagine cloud-native architectures, operating models, and business approaches.

- A 2020 McKinsey study of 450 CIOs revealed that 75% of cloud migrations failed and went way over budget, with only 7% coming in below budget, costing companies over $100 billion. - One highlighted company was 50% over budget and three quarters behind schedule; their strategy to finish faster was to pay system integrators more money in the hope that higher spend equals faster delivery. - By 2019, to fix this spreadsheet error, the industry created a permanent certification track and discipline called **FinOps**—hiring the exact same companies that botched the migrations to fix the financial mess. - In enterprise tech transformations, "reimagining" is frequently branded as risky, while "cost containment" is falsely labeled as strategy.

---

[03:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=202s) The AI Productivity Paradox and False Metrics

Kumar argues that the enterprise world is repeating these exact cloud-era mistakes with Artificial Intelligence, but instead of servers, the target is now the entire software delivery lifecycle. Tech leaders are currently rushing across event floors buying fragmented point solutions—one tool for AI coding, another for attribution, and another for governance—focusing heavily on localized, individual productivity rather than whole-enterprise productivity.

When asking the audience for a show of hands on who has deployed AI tools, several hands go up. However, when asking if anyone can back to their board and prove that their software organization is delivering fundamentally better, measurable outcomes, not a single hand remains up. Kumar highlights the widespread "illusion" of productivity held by individual developers.

``` +-----------------------------------------------------------------+ | THE AI PRODUCTIVITY GAP | +-----------------------------------------------------------------+ | Promised ROI (to CFOs/Boards): 300% to 1000% (3x - 10x) | | Actual Median Throughput Gain: 8% | | Developer Perceived Gain: +20% to +24% | | Measured Real-World Impact: -19% (Controlled Time-Trial) | +-----------------------------------------------------------------+ ```

- **DX Industry Research (400 Companies):** Found a 93% adoption rate for AI tools, but actual throughput gains were only a median 8%, compared to the 3x to 10x ROI promised to CFOs. - **95th Percentile Outliers:** Top-performing organizations showed up to 40% throughput, representing less than 1% of total enterprises. - **Gartner Survey (500 CIOs):** 72% reported either breaking even or actively losing money on AI investments. - **MIT Enterprise Study:** 95% of enterprise AI pilots yielded zero measurable return or negative returns. - **METR Controlled Experiment (430 Senior Developers):** Senior developers on familiar codebases predicted AI tools would boost productivity by 24% and felt 20% more productive after testing. Stopwatch-measured results proved an actual **19% drop** in speed (-19%).

---

[07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) Systemic Failures in Enterprise Software Delivery

Kumar points out the glaring paradox: despite possessing advanced analytics tools that track every keystroke, line of code, and SDLC metric, vendors and internal IT teams refuse to adopt outcome-based economics or delivery transparency. System integrators (SIs) and managed service providers (MSPs) took their legacy 20-year-old business models—headcount, ticket volume, and time-and-materials (T&M)—and simply added a Copilot license on top without changing the fundamental delivery engine. SIs have not re-imagined software delivery; they have merely become integrators of third-party AI tools inside broken legacy workflows.

To demonstrate the real-world operational hazards of ungoverned AI, Kumar brings up Amazon's experience in March 2026. AI-assisted changes were merged without adequate human review processes, leading to two severe production incidents: 1. **Incident 1:** Caused 120,000 lost orders and disrupted 1.66 million site orders. 2. **Incident 2 (2 days later):** A 6-hour outage causing a 90% loss of orders. 3. **Response:** Amazon enacted a mandatory 90-day code freeze and instituted strict governance requiring software engineers to personally sign off on critical production changes.

On a typical corporate Tuesday, engineering buys GitHub Copilot or Claude, security purchases its own isolation tooling, and customer support buys a chatbot—none of which align under a unified corporate AI strategy. Furthermore, enterprise timing studies reveal developers spend only 16% to 30% of their time actually writing code; enterprises spend billions optimizing that small slice while ignoring the remaining 70% to 84% spent on architecture, design, and testing. In an MIT survey of 450 organizations, 40% claimed to have a "stated AI strategy," which usually just meant signing an enterprise agreement with Anthropic for Claude, while 90% of employees continued using personal AI tools for daily tasks anyway.

---

[12:19](https://www.youtube.com/watch?v=9R_4E1L8508&t=739s) The 6 Building Blocks of an AI-Native Operating Model

Kumar asserts that the standard pipeline of `People -> AI Tools -> Results` is fundamentally broken. Enterprises must shift to an **AI-native operating model** structured around six core building blocks and three interconnected operational streams:

``` +-----------------------------------------------------------------+ | 6 BUILDING BLOCKS OF AN AI OPERATING MODEL | +-----------------------------------------------------------------+ | [1] AI Coding: Tools like Claude Code, Devin, etc. | | [2] Intelligence Layer: Real-time actionable F1-style telemetry| | [3] Enterprise Knowledge: Decades of legacy decisions/brownfield| | [4] Agent Orchestration: Assigning, managing, routing agents | | [5] Governance: Sign-offs, safety guardrails, controls | | [6] Outcome Measurement: Tracking real-world business value | +-----------------------------------------------------------------+ ```

* **The 6 Building Blocks:** 1. **AI Coding:** Front-end generation tools (Claude Code, Devin, Copilot). 2. **Intelligence Layer:** Actionable, real-time telemetry like Formula 1 pit crews to diagnose and fix SDLC pipeline bottlenecks in real time. 3. **Enterprise Knowledge:** Unlocking decades of legacy decisions embedded in brownfield code bases that general AI tools cannot comprehend. 4. **Agent Orchestration & Governance:** Determining which specialized agent executes specific work items with full tracking. 5. **Governance & Observability:** Preventing catastrophic production failures through automated guardrails and manual checkpoints. 6. **Outcome-Based Measurement:** Tying engineering velocity directly to business deliverables.

* **Key Industry Risks Identified by DX:** * **False Velocity:** Shipping more code appears as progress (e.g., 40% more pull request commits in a sprint review), but yields zero impact on the actual product roadmap. * **Cognitive Debt:** AI generates code faster than the engineering team's shared mental model can absorb. When the sole engineer who understands how three AI-written services interact goes on a 2-week vacation, severe operational failure occurs.

---

[14:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=875s) Financial Waste and Unveiling the TechBlocks "eight" Engine

Kumar explains that vendors intentionally avoid providing end-to-end integration across all three core streams (**How work gets done**, **How work gets understood**, and **How work gets governed**) because uniting them forces vendors to accept financial accountability. Currently, enterprises pay three separate, redundant invoices: 1. **Invoice 1 (AI Tooling):** $20–$40 per seat for core software plus $180–$250 per developer per month for token consumption. 2. **Invoice 2 (Measurement/Analytics):** $50–$100 per developer per month for engineering intelligence dashboards. 3. **Invoice 3 (Vendor/SI Billing):** Traditional Time & Materials (T&M) headcount fees with zero delivery guarantees.

When developers write inefficient prompts or introduce bad code that requires refactoring in the next sprint, the enterprise customer bears 100% of the financial burden while holding empty outcome promises. This systemic misallocation is what TechBlocks terms the "phantom value on the ledger".

``` +-----------------------------------------------------------------+ | TECHBLOCKS "EIGHT" AI-NATIVE DELIVERY ENGINE | +-----------------------------------------------------------------+ | INPUTS: Standardized sprint requirements & historical SDLC | +-----------------------------------------------------------------+ | ENGINE: [1] Delivery Engine & Agentic Pods (Human/AI) | | [2] Intelligence Platform (Line/Dollar Tracing) | | [3] Governance & Observability Layer | +-----------------------------------------------------------------+ | OUTCOME: Outcome-based pricing, guaranteed delivery & quality | +-----------------------------------------------------------------+ ```

To solve this, TechBlocks spent two years building and field-testing an integrated solution with enterprise clients, officially unveiling **eight**: an AI-native delivery engine. Rather than acting as another point tool vendor, **eight** collapses all three vendor invoices into a unified operating model containing tools, frameworks, platform capabilities, and accelerators with full end-to-end accountability: * **Delivery Engine & Agentic Pods:** Coding, testing, and release agents operating across the SDLC with mandatory human oversight (engineers, architects, security, QA) at critical control points. * **Intelligence Platform:** Traces every user story, line of code, and dollar spent from requirement through production, tracking whether code remains active in production 30 to 60 days post-deployment. * **Governance & Outcome Alignment:** Replaces hourly billing with performance-aligned outcomes—transferring delivery risk, bug remediation costs, and AI inefficiency penalties back onto the vendor.

[20:01](https://www.youtube.com/watch?v=9R_4E1L8508&t=1201s) Outcome-Based Accountability and the Measurement Instrument

Prashant Kumar addresses the critical issue of accountability in software delivery, reminding the audience of the foundational question no traditional vendor or staff member can adequately answer: who actually takes responsibility if none of these AI investments turn into real business outcomes? TechBlocks addresses this by reframing their measurement layer entirely. Rather than selling it as just another standalone software product, TechBlocks treats their measurement engine as the very instrument that determines whether they themselves get paid.

This creates a fundamental structural shift in the industry landscape. For a dedicated measurement company to replicate this model, they would have to transform into a full delivery firm—hiring engineering pods, absorbing project risk, and signing outcome guarantees. Conversely, for a traditional IT delivery company to match TechBlocks, they would be forced to build unfalsifiable, code-level measurement systems—the exact type of rigorous tracking that makes billing traditional billable hours nearly impossible.

- The measurement layer operates as an objective instrument tied directly to vendor compensation rather than a simple SaaS subscription. - Traditional delivery companies face a structural conflict because transparent, code-level metrics directly undermine traditional hourly billing models.

``` +-----------------------------------------------------------------+ | AI-Native Operating Model | | | | +-------------------+ +---------------+ | | | Human & AI Pods | --( Delivers)----> | Code to Prod | | | +-------------------+ +---------------+ | | | | | | +-----------------+---------------------+ | | v | | +-------------------------------+ | | | Unfalsifiable Measurement | | | | (Keyboard-to-Keyboard) | | | +-------------------------------+ | | | | | v | | +-------------------------------+ | | | Outcome-Based Vendor Pay | | | +-------------------------------+ | +-----------------------------------------------------------------+ ```

[20:46](https://www.youtube.com/watch?v=9R_4E1L8508&t=1246s) Redesigning Software Delivery and the AI-Native Future

This engine is explicitly not designed to replace engineers, but rather to redesign software delivery from scratch. Prashant draws a direct historical parallel to the cloud-native revolution that forced a complete overhaul of IT infrastructure twenty years ago—a transformation that proved devastatingly late for organizations that resisted it. However, unlike past technology waves, leaders do not have to rely on vendor promises or pitch decks. Instead, they can inspect an automated system that tracks the entire pipeline end-to-end, measuring from the initial keyboard interaction through pull requests, production deployment, and the ultimate business outcomes generated.

Looking ahead five years, Prashant challenges technology leaders to consider how they will report to their boards: will they still be measuring productivity by raw headcount, or by the effectiveness of human and AI teams working in tandem? Ultimately, future market winners will not be the companies hoarding the highest number of AI tools, but those establishing the superior AI operating model. AI tools merely boost individual productivity, whereas an AI-native software factory fundamentally transforms enterprise productivity.

- Reengineering software delivery is compared to the cloud-native infrastructure shift from two decades prior. - Full end-to-end visibility tracks the pipeline directly from initial code submission to pull request (PR), production release, and business impact. - Individual developer velocity does not equal organizational productivity without a unified operating model. - Live platform demonstrations and deeper architectural discussions are offered at TechBlocks' event booth (Booth #847).

## Notable quotes > [00:00](https://www.youtube.com/watch?v=9R_4E1L8508&t=0s) The problem isn't that AI can't write code. The problem is that enterprises still manage software delivery as if AI doesn't exist. — Prashant Kumar

> [00:00](https://www.youtube.com/watch?v=9R_4E1L8508&t=0s) The next competitive advantage will not come from deploying another coding assistant, engineering intelligence platform, or specialized agent. It will come from designing an AI-native operating model that orchestrates these capabilities into an intelligent software factory where humans and AI work together as a coordinated, measurable delivery system. — Prashant Kumar

> [03:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=202s) In enterprise tech transformations, "reimagining" is frequently branded as risky, while "cost containment" is falsely labeled as strategy. — Prashant Kumar

> [07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) SIs have not re-imagined software delivery; they have merely become integrators of third-party AI tools inside broken legacy workflows. — Prashant Kumar

> [20:46](https://www.youtube.com/watch?v=9R_4E1L8508&t=1246s) Individual developer velocity does not equal organizational productivity without a unified operating model. — Prashant Kumar

> [20:46](https://www.youtube.com/watch?v=9R_4E1L8508&t=1246s) Future market winners will not be the companies hoarding the highest number of AI tools, but those establishing the superior AI operating model. — Prashant Kumar

## Mentioned Ai4, Amazon, Anthropic, Claude, Claude Code, Devin, DX, FinOps, Gartner, GitHub Copilot, LinkedIn, McKinsey, METR, MIT, Prashant Kumar, TechBlocks, eight

## Video description Prashant Kumar - CEO, TechBlocks

Over the past two years, enterprises have invested billions of dollars in AI-powered developer tools, coding assistants, engineering intelligence platforms, and intelligent agents with the expectation of transforming software engineering. Yet many technology executives are asking an uncomfortable question:

If every developer now has AI, why aren't organizations delivering better software outcomes: faster delivery, higher production quality, less rework, greater transparency, and measurable ROI?

Developers may be completing individual tasks faster. Organizations are not yet consistently delivering better outcomes.

The reality is that AI has accelerated portions of the software development lifecycle, but it has not fundamentally transformed software delivery. Organizations continue to layer AI onto traditional engineering processes rather than rethinking how work is planned, executed, governed, measured, and improved. The result is a growing ecosystem of disconnected AI coding tools, engineering intelligence platforms, and specialized agents operating in silos, creating fragmented workflows, inconsistent governance, limited visibility, and localized productivity gains that often fail to translate into sustainable business value.

The problem isn't that AI can't write code. The problem is that enterprises still manage software delivery as if AI doesn't exist.

The next competitive advantage will not come from deploying another coding assistant, engineering intelligence platform, or specialized agent. It will come from designing an **AI-native operating model **that orchestrates these capabilities into an intelligent software factory where humans and AI work together as a coordinated, measurable delivery system.

This session explores how leading organizations are evolving from isolated AI tools to AI-native software factories integrating AI coding, engineering intelligence, agent orchestration, enterprise knowledge, governance, observability, and outcome-based measurement into a unified operating model.

Attendees will leave with a practical blueprint for improving not only engineering velocity, but also software quality, production resilience, delivery transparency, governance, and measurable return on AI investment. More importantly, they will understand why the organizations that rethink their operating model, not merely expand their AI toolset- will define the next generation of software delivery.

[Source](https://www.youtube.com/watch?v=9R_4E1L8508)

中文简报

TechBlocks推出Eight引擎，推动AI编程转向成果定价企业引入AI使软件交付速度下降19%，除非企业用将供应商报酬与生产指标挂钩的集成运营模式取代单点工具。 Prashant Kumar指出，企业在AI领域的投资正在重蹈云计算时代的昂贵覆辙——将零散的单点工具叠加在脱节的旧有工作流程之上。尽管工具普及率很高且开发者主观感觉速度提升，但现实数据显示其实际吞吐量增幅微乎其微，甚至对生产力造成负面影响并增加生产风险。为了释放真正价值，企业必须转型为AI原生运营模式，将编码、智能、知识、Agent编排、治理以及基于成果的度量体系统一起来。TechBlocks推出了“eight”引擎，将割裂的供应商成本整合为有保障且与成果挂钩的软件交付。 Prashant Kumar将当前企业在AI应用上的误区与过去的历史技术周期进行了对比，例如在互联网时代把纸质宣传册直接照搬到网站上，或是在不改变运营模式的情况下将未经优化的虚拟机直接迁移上云。 (0:04) 麦肯锡2020年的一项研究显示，由于在云转型中沿用旧有的电子表格和模式，75%的云迁移失败且预算超支，给企业造成了超过1000亿美元的损失。 (2:00) 企业领导者正在重蹈云时代的覆辙，急于采购零碎的AI单点解决方案（如编程助手、归因分析、治理等），这些方案仅带来局部收益，而非组织层面的生产力提升。 (3:22) DX研究发现，尽管在受调研的400家企业中AI工具采用率高达93%，但吞吐量增长中位数仅为8%，远低于向CFO和董事会承诺的3至10倍投资回报率。 (4:22) METR针对430名资深开发者开展的对照实验显示，尽管工程师主观感觉使用AI工具使生产力提高了20%，但秒表实测的交付速度实际上却下降了19%。 (6:25)

Reading summary

TechBlocks CEO Prashant Kumar contends that enterprises are repeating the costly missteps of the cloud era by purchasing disjointed AI tools that create an illusion of developer velocity while delivering negligible, and often negative, measurable business returns. Historical Parallels in Enterprise Technology Adoption (0:04) Enterprises frequently mistake the adoption of point tools for structural transformation, echoing past cycles in internet and cloud adoption. Kumar points out that during initial cloud migrations, organizations transferred virtual machines unchanged onto remote infrastructure, relying on superficial spreadsheet comparisons that ignored operational architecture. Citing a 2020 McKinsey survey of 450 CIOs, Kumar notes that 75% of cloud migrations exceeded budgets and schedules—costing companies over $100 billion—which ultimately forced the industry to invent FinOps to manage the resulting financial waste. According to Kumar, corporate leaders are repeating these exact mistakes with artificial intelligence across the software delivery lifecycle. Rather than redesigning delivery models, organizations are purchasing isolated tools for coding, attribution, and governance. This approach characterizes cost containment as strategy and focuses on localized, individual tasks rather than overall enterprise productivity. The Empirical Gap in AI Productivity (3:22) While vendors routinely promise CFOs and boards a 3x to 10x return on investment from AI tooling, industry research highlights a stark reality. A DX survey of 400 companies with a 93% AI adoption rate found a median throughput gain of only 8%, with top-tier 40% gains limited to less than 1% of enterprises. Similarly, a Gartner survey of 500 CIOs reported that 72% either broke even or lost money on AI initiatives, and an MIT study indicated that 95% of enterprise AI pilots generated zero or negative returns. Kumar underscores a significant psychological bias among developers that masks this underperformance. In a controlled METR experiment evaluating 430 senior developers on familiar codebases, participants expected a 24% speed increase and felt 20% faster when using AI; stopwatch tracking, however, revealed an actual 19% drop in completion speed. Furthermore, enterprise time studies show developers spend only 16% to 30% of their working hours writing code, meaning organizations spend heavily to optimize a minor slice of the workflow while ignoring architecture, design, and testing. Operational Hazards and Fragmented Vendor Economics (7:35) Introducing automated code generation into legacy workflows creates severe operational vulnerabilities. Kumar references Amazon's experience in March 2026, when unreviewed AI-assisted code merges triggered two production incidents: one disrupting 1.66 million customer orders and a second two days later causing a six-hour outage that erased 90% of site orders. The fallout led Amazon to mandate a 90-day code freeze and require personal human sign-offs on critical production deployments. In addition, unmanaged generation fosters 'false velocity'—where pull requests surge with no impact on actual roadmaps—and creates 'cognitive debt' as codebases expand beyond team comprehension. This fragility is reinforced by traditional vendor procurement models. Systems integrators and managed service providers continue to bill for hours and headcount while adding AI licenses on top. Enterprise clients end up paying three uncoordinated invoices: software and token usage ($200 to $290 per developer monthly), analytics dashboards ($50 to $100 monthly), and time-and-materials consulting. Consequently, clients absorb all financial penalties and refactoring costs when AI produces flawed code. Realigning Incentives Through AI-Native Delivery (14:35) To eliminate what he terms 'phantom value on the ledger,' Kumar argues that organizations must adopt an AI-native operating model built on six blocks: AI coding, real-time pipeline telemetry, enterprise legacy knowledge integration, agent orchestration, governance guardrails, and outcome-based measurement. Rather than replacing human personnel, this structure uses specialized AI agents for coding and testing while mandating human oversight by engineers and architects at critical control points. Highlighting TechBlocks' proprietary 'eight' engine, Kumar advocates collapsing software licenses, analytics, and systems integration into a single delivery vehicle. By tracking requirements from keyboard input through 30- to 60-day post-deployment stability, the measurement system serves as the contractual benchmark for vendor payment. Kumar argues that tying vendor revenue directly to verifiable software delivery transfers the financial risks of bugs, refactoring, and AI inefficiency back to the service provider. Kumar concludes that future competitive advantages will belong not to enterprises accumulating the largest collection of AI tools, but to those redesigning their operating models around human-agent collaboration. The broader challenge remains whether traditional IT service firms will willingly abandon lucrative time-and-materials billing to embrace verifiable, outcome-contingent contracts.

精炼阅读摘要

TechBlocks 首席执行官 Prashant Kumar 指出，当前企业在人工智能领域的盲目投资正在重演云计算时代的覆辙；由于指标虚构与商业模式错配，AI 不仅未带来承诺的数倍效能跃升，反而造成了巨额财务浪费，企业亟须转向结果导向的 AI 原生交付模型。生产力悖论与主观度量偏差 (3:22) 企业管理层普遍被承诺 AI 能带来 300% 至 1000%（3 到 10 倍）的投资回报率，但实际业务数据却呈现出巨大落差。DX 针对 400 家企业的研究表明，虽然 AI 工具采纳率高达 93%，但企业交付吞吐量的中位数增长仅有 8%，仅有不到 1% 的顶尖企业达到了 40% 的增幅。Gartner 对 500 位首席信息官的调查显示，72% 的受访者在 AI 投资上仅能打平或处于亏损状态；麻省理工学院的研究也发现，95% 的企业 AI 试点项目回报为零甚至为负。研发人员的主观感受与客观现实存在严重脱节。在 METR 针对 430 名资深开发人员的受控对照实验中，开发者预估 AI 将提升 24% 的效率，测试后主观感知提效 20%，但基于秒表严格计时的实际测试结果却显示，编码交付速度实际下降了 19%。Kumar 认为，企业领导层依赖孤立的点状工具和主观感受，创造了一种研发高效的幻觉，无法在董事会层面证明任何实质性的业务产出。局部优化失衡与不可控交付风险 (7:35) 传统企业软件交付流程在引入 AI 时存在严重的资源错配。时间分析研究显示，开发人员仅将 16% 至 30% 的时间用于实际编写代码，其余 70% 至 84% 的精力消耗在架构设计、系统集成和测试环节。然而，企业却斥巨资优化编写代码这部分极小的时间占比，并采购碎片化的工具组合，使得安全、工程与客服部门各自为政。麻省理工学院调查发现，40% 宣称拥有 AI 战略的企业往往仅是签署了模型企业协议，而 90% 的员工仍在私下使用未经管控的个人 AI 工具。缺乏全局治理的 AI 生成代码正在引发灾难性事故与技术负债。Kumar 援引亚马逊 2026 年 3 月的事故指出，因 AI 辅助代码缺乏充分的人工审查直接合入生产环境，首次事故导致 12 万笔订单流失并波及 166 万笔网站订单，两天后再次出现长达 6 小时、订单损失达 90% 的严重宕机，迫使亚马逊实施为期 90 天的代码冻结并强制人工签字。此外，DX 提出的假性速度（Pull Request 提交量增加但对产品路线图零贡献）与认知负债（代码生成速度超越团队心智模型的理解极限），正在大幅抬高系统的维护与运维风险。传统工时模式与账面虚构价值 (14:35) 系统集成商（SI）和托管服务商（MSP）未能真正重塑软件生产方式，而是将拥有 20 年历史的人头数、工单量和按工时计费（T&M）的旧商业模式直接嫁接在 AI 之上。这导致企业目前需承担三重重叠成本：其一是每人每月 20 至 40 美元的工具许可加 180 至 250 美元的 Token 消耗费用；其二是每人每月 50 至 100 美元的工程分析监控费用；其三是无交付质量保障的传统服务商工时账单。 Kumar 将这种系统性资本错配称为“账面上的虚构价值”。当开发者写出低效提示词或生成需要后续重构的拙劣代码时，外包服务商不仅无需承担损失，反而能通过后续修复工时继续计费，导致企业全额承担了效率低下的经济代价。传统集成商之所以拒绝端到端整合工作流，根源在于透明、不可篡改的代码级监控体系将彻底击碎其依赖工时计费的商业基础。 AI 原生运营模型与结果对赌机制 (12:19) 为破除交付困境，企业必须摆脱“人员加 AI 工具等于产出”的粗放链路，转向包含六大要素的 AI 原生运营模型：AI 编码、具备 F1 赛车级实时诊断能力的遥测智能层、沉淀企业历史遗留知识的理解层、多智能体协同编排、防御性安全治理与观察层，以及基于业务结果的衡量机制。该模型要求将零散的代码编写重新整合到全生命周期的端到端工程框架中。针对传统模式的权责失衡，TechBlocks 推出了名为 eight 的 AI 原生交付引擎，将原先割裂的三重采购整合为一体化交付中枢。该引擎通过混合智能体单元执行研发与测试，并在关键控制点强制引入架构师与安全专家审查，同时追踪每行代码和资金流向，持续验证部署后 30 至 60 天内代码在生产环境中的实际留存状态。该方案的核心在于采用基于交付结果的定价模式，由供应商自身承担质量漏洞修复与交付延误的财务风险，使衡量指标直接与供应商报酬挂钩。 Kumar 强调，正如二十年前未及时完成云原生重构的企业遭受重创一样，未来五年市场的优胜者将属于构建了卓越 AI 原生运营模型的企业，而非囤积单点工具的组织；然而，要求交付服务商放弃工时账单并转而承担代码质量与交付风险的商业机制，能否在由传统外包商主导的 IT 生态中被广泛采纳，仍取决于行业对穿透式度量体系的推进力度。

Detailed notes — zh

## Background 本内容由频道 Ai4 于 2026 年 8 月 18 日发布在 YouTube 平台上，演讲者为 TechBlocks 首席执行官 Prashant Kumar。视频简介指出，过去两年企业在 AI 开发者工具上投入了数十亿美元，但整体交付效能和商业价值并未实现质的飞跃；本次演讲旨在揭示单点 AI 工具堆叠的弊端，并探讨如何通过构建人机协同的“AI 原生运营模型”与软件工厂，实现工程交付的可衡量 ROI 与全流程重塑。 ## TL;DR Prashant Kumar 指出，企业当前在 AI 上的投入正陷入与早期互联网和云计算时期相同的“换汤不换药”困境，高达 70% 至 95% 的 AI 试点项目处于亏损或未达预期状态。尽管工程师主观感觉效率提升，但客观计时与 DX、Meter 等严谨研究表明，单点 AI 工具带来的“局部加速”往往因认知负债、生产事故和架构割裂演变成端到端的效率负增长。企业将绝大部分预算错误地砸在仅占工时 16% 的纯编码环节，却忽视了占据交付周期 80% 的系统设计、跨团队协同与治理。为此，TechBlocks 推出了名为“8”的 AI 原生交付引擎，将智能体交付单元、智能分析平台与全局治理融为一体，倡导打破传统的工时计费（T&M）模式，转而由供应商端到端承担风险并严格按业务成果交付。 ## Atmosphere & style 整场演讲开篇充满讽刺与幽默感，演讲者以自嘲的口吻直指人类在技术变革面前不断重蹈覆辙的“盲目搬迁”历史，瞬间拉近了与技术高管受众的心理距离。现场互动环节犀利而发人深省，面对全场无一人能向董事会证明 AI 带来实质性业务提升的尴尬沉默，演讲逐步由轻松调侃转向对冰冷行业数据、巨额账单陷阱与生产宕机事故的深刻剖析。随着对割裂生态和商业利益冲突的层层揭露，演讲最终落脚在极具务实感与颠覆性的全新交付范式上，展现出一种洞悉行业弊病后力图推倒重来的笃定与魄力。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) 技术演进中企业屡犯同样的错误：互联网时代仅将纸质手册搬上网页，云计算时代仅将本地虚拟机搬到云端，如今引入 AI 依然只是在传统流程中嵌入单点工具。 - [00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) 麦肯锡调研显示，75% 的云迁移项目以失败超支告终，暴露出企业界习惯将业务重塑视为“高风险”，却把浅层成本压缩奉为“企业战略”的病态循环。 - [03:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=202s) 企业在 AI 工具上投入数十亿美元，但 DX、Gartner 与 MIT 的权威调研表明，绝大多数企业的交付吞吐量仅微增或处于负回报区间，ROI 出现严重塌陷。 - [06:39](https://www.youtube.com/watch?v=9R_4E1L8508&t=399s) Meter 受控实验揭示了研发人员的“生产力错觉”：资深工程师体感自评提效 20%，客观秒表测试其实际端到端交付效率却下降了 19%。 - [07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) 传统系统集成商与 MSP 固守工时计费（T&M）模式，在合同中加收 AI 席位费却缺乏按结果交付的动力，导致企业承担了所有试错与治理风险。 - [07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) 盲目加速编码缺乏全流程治理易酿成严重生产事故，例如亚马逊因未经严格审核的 AI 变更引发重大宕机，随后不得不实施 90 天代码冻结与强制人工审查。 - [10:28](https://www.youtube.com/watch?v=9R_4E1L8508&t=628s) 软件工程师纯敲代码仅占 SDLC 周期的 16% 至 20%，但企业却把 80% 至 90% 的 AI 预算投入纯编码环节，彻底忽视了架构、测试与运维等更庞大的交付周期。 - [12:07](https://www.youtube.com/watch?v=9R_4E1L8508&t=727s) 构建 AI 原生软件工厂需涵盖任务执行、系统理解与流程治理三大核心工作流，缺少度量会导致“虚假速度”，缺少治理会催生超出团队理解能力的“认知负债”。 - [15:01](https://www.youtube.com/watch?v=9R_4E1L8508&t=901s) 企业当前面临 AI 基础工具费、度量软件费与传统外包工时费“三张账单”的割裂支付，供应商分散脱责，使账本上的 AI 生产力沦为“幽灵价值”。 - [16:54](https://www.youtube.com/watch?v=9R_4E1L8508&t=1014s) TechBlocks 推出 AI 原生交付引擎“8”，整合智能体交付单元（Agentic Pods）、智能分析平台与全局治理层，为软件生命周期提供端到端负责的统一体系。 - [19:21](https://www.youtube.com/watch?v=9R_4E1L8508&t=1161s) 软件工程商业模式正从按工时付费转向为业务成果（Outcomes）买单，将试错风险从企业转移给供应商，以度量平台作为服务交付与结算的基准。 - [19:21](https://www.youtube.com/watch?v=9R_4E1L8508&t=1161s) AI 工具只能让个体单点变快，而重塑组织运作的 AI 原生软件工厂才是企业实现端到端真正生产力跃升的终极分水岭。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) 历史重演：从互联网、云计算到 AI 的“旧瓶装新酒” 演讲伊始，TechBlocks 首席执行官 Prashant Kumar 用幽默而自嘲的口吻切入主题。他调侃称，人类在技术变革面前表现得极度可预测——或者说得更直白一点，人类是个“相当愚蠢的物种”，总是在不断犯下同样的错误，并不断发明新的方式去重蹈覆辙。回顾互联网浪潮初起时，本该彻底重塑商业模式的革命，最终却沦为各家企业把传统的纸质宣传册扫描搬上网页，并将其冠以“电子商务（e-commerce）”之名。十年之后云计算时代来临，历史再次毫无偏差地复刻：各大企业只是简单地把原本运行在本地的虚拟机原封不动地搬到了别人的服务器上，然后将这一过程大张旗鼓地称为“数字化转型”或“云原生架构”。IT 部门的主管们整天围着 Excel 表格打转，一核一核地核算算力、一台一台地对比服务器、一分一厘地计算成本，但最终所有人都得出了错误的结论，因为他们从一开始就用错了电子表格。 ```mermaid flowchart LR accTitle: 技术演进中的重蹈覆辙模式 subgraph S1["互联网时代"] A["纸质宣传册"] --> B["搬上网页"] B --> C["美其名曰：电子商务"] end subgraph S2["云计算时代"] D["本地虚拟机"] --> E["搬至云端服务器"] E --> F["美其名曰：数字化转型"] end subgraph S3["人工智能时代"] G["传统软件交付流程"] --> H["嵌入单点 AI 工具"] H --> I["美其名曰：AI 生产力跃升"] end ``` 这种浅尝辄止的搬迁给企业带来了沉重的经济代价。麦肯锡（McKinsey）在 2020 年针对 450 位 CIO 进行的调研揭示了一个残酷的现实： - 75% 的云迁移项目以失败告终并严重超出预算，仅有 7% 勉强控制在预算以内，整个过程让企业累计损失超过 1000 亿美元。 - 调研中最具讽刺意味的案例显示，某家企业在项目已超支 50%、进度落后三个季度的情况下，其应对策略竟然是向系统集成商（SI）支付更多资金，幻想“钱花得越多，活就能干得越快”。 - 到 2019 年，这种由电子表格核算错误导致的混乱愈演愈烈，以至于业界不得不专门衍生出一套全新的职业认证与学科分支——FinOps（云财务运营），企业甚至回过头去雇佣当初搞砸迁移的同一批咨询公司来制定 FinOps 策略。正如 Prashant Kumar 所总结的，每当颠覆性技术出现时，企业界总会出现一种固化的病态循环：“颠覆重塑被扣上‘太冒险’的帽子，而压缩成本却被奉为‘企业战略’（Reimagination gets called risky and cost containment gets called strategy）。” --- ### [03:22](https://www.youtube.com/watch?v=9R_4E1L8508&t=202s) AI 工具狂欢背后的幻象与 ROI 塌陷如今，同样的闹剧正在整个软件交付领域重新上演。各家企业正狂热地为软件工厂的各个零散环节采购单点工具：有人买 AI 辅助编程，有人买代码归因层，有人买合规审计工具。展厅里的供应商们忙着向企业推销局部提效的灵丹妙药，但从来没有人把软件交付作为一个完整的有机生命体来看待。过去两年里，技术决策者们在 AI 领域砸下了数十亿美元，然而这种碎片化的工具堆叠并没有让整个企业级组织的交付效能产生实质性飞跃。面对台下的参会者，Prashant Kumar 发起了一场发人深省的互动提问：现场几乎所有人都部署了至少一款 AI 工具，但当被问及“有谁能够满怀信心地向董事会证明，自己的软件团队在工程或业务成果上取得了可衡量、可验证的实质性提升”时，全场无人举手。多项权威机构的严谨数据印证了这一投入与产出严重倒挂的悖论： - **DX 交付吞吐量研究**：在针对 400 家企业、AI 工具采用率高达 93% 的大样本调查中，交付吞吐量（throughput）的中位数实际增长仅为可怜的 8%，而当初管理层向 CFO 和董事会许诺的投资回报率却是 3 倍至 10 倍（3x to 10x）。 - **Gartner CIO 调研**：在对 500 位 CIO 的问卷中，高达 72% 的受访者明确表示其 AI 投资目前处于盈亏平衡甚至持续亏损状态。 - **MIT 企业级全景研究**：95% 的企业级 AI 试点项目要么完全无法产生可衡量的正向回报，要么处于负回报区间。 --- ### [06:39](https://www.youtube.com/watch?v=9R_4E1L8508&t=399s) 生产力错觉：主观体感与客观计时的巨大落差为了拆解为什么几乎每个工程师都“觉得自己变快了”，Prashant Kumar 引用了 Meter 在受控实验环境下开展的对比研究。研究团队深入 430 家成熟的软件工程组织，挑选出高资历的资深架构师与开发人员，让他们在各自极为熟悉的代码库中执行任务。 ```mermaid flowchart TD accTitle: 资深开发者在 AI 工具下的生产力主观预期与实际结果对比 A["任务前预期"] -->|"预测效率提升"| B["+24%"] C["任务后体感"] -->|"认为自己提效"| D["+20%"] E["客观秒表计时"] -->|"实际端到端结果"| F["-19% (负增长)"] ``` 在测试开始前，研究人员询问开发者：“如果给你配备你最喜欢的 AI 编码工具，你能提效多少？”资深工程师们自信地预测能提高 24%。在完成指定任务后，他们再次评估自己的表现，主观认为自己的效率提升了 20%。然而，当研究人员拿出全程客观记录的秒表时，真实测量结果却是 **-19%**。这一结果赤裸裸地揭示了现代软件工程中的“集体幻觉”：开发者误以为在打字或写函数那一瞬间的加速就等于端到端交付的提效。整个行业再次患上了云计算时代的通病——错误地把“工具采用率”和“个体活跃度”当成了衡量指标，而不是去真正追踪端到端的交付结果与业务价值。 --- ### [07:35](https://www.youtube.com/watch?v=9R_4E1L8508&t=455s) 供应商模式僵化与亚马逊生产事故的警钟造成这种局面的另一大推手在于外包商与系统集成商的商业利益冲突。企业花费七位数的巨额账单购买外包服务和路线图规划，但当 AI 席卷而来时，传统系统集成商与托管服务商（MSP）只是把一套运行了 20 年的工时与人头模式（T&M）换了个包装：依然按人头收费、按交付的工单（tickets）数量计费，无非是在合同里多列了一项由客户自掏腰包购买的 GitHub Copilot 授权。供应商没有任何动力推动以结果为导向的商业模式转型，因为彻底重塑交付体系将直接摧毁其依赖工时堆砌的盈利根基。更为严重的是，在缺乏整体治理机制的前提下盲目加速编码，正在生产环境中酿成灾难性后果： - **亚马逊三月生产事故**：由于未经完善审查的 AI 生成代码变更直接并入代码库，亚马逊在今年 3 月接连遭遇两次严重事故。第一起事故直接导致 120,000 笔订单流失、166 万个站点订单受影响；仅两天之后，系统再次发生长达 6 小时的严重宕机，损失了 90% 的当期订单。 - **治理代价与代码冻结**：事故发生后，亚马逊不得不实施长达 90 天的全局代码冻结（Code Freeze），并强制推行严格的治理机制，要求 AI 工程师必须对所有即将部署到生产环境的关键变更进行人工签字确认。 --- ### [10:28](https://www.youtube.com/watch?v=9R_4E1L8508&t=628s) 被忽视的 80% 交付周期与“影子 AI”的蔓延演讲最后，Prashant Kumar 直指当前企业 AI 战略的核心盲区：问题绝不在于“AI 不会写代码”，而在于企业在组织管理上依然假装 AI 不存在。一个典型的企业工作日往往充满了碎片化的混乱：工程团队自顾自采购 GitHub Copilot、Claude 或 Devin，安全部门自购安全扫描套件，客服部门另购智能问答平台，各个部门各自为战，全局战略彻底缺位。调研数据显示，一名软件工程师在整个软件开发生命周期（SDLC）中真正花在“敲代码”上的时间仅占 **16%**（即便放宽标准也至多 30%）。然而，当前企业却把 80% 到 90% 的 AI 预算全部砸在优化这仅占全天 16% 至 20% 的纯编码环节上，而占据开发生命周期 70% 到 80% 的系统架构设计、跨团队协作、集成测试与生产运维却被彻底忽视。 ```mermaid flowchart TD accTitle: 软件开发生命周期时间分配与 AI 资金投入错配 subgraph 资源错配现状 T1["纯编码环节: 占工时 16% - 20%"] --- C1["吸收了 80% - 90% 的 AI 投资预算"] T2["架构/设计/测试/运维: 占工时 70% - 80%"] --- C2["几乎处于被忽视与工具孤岛状态"] end ``` 更具讽刺意味的是，MIT 对 450 家企业的调查显示，在 40% 自称制定了“明确 AI 战略”的企业中，所谓的战略仅仅等同于“我们和 Claude 签署了企业采购协议并强制员工使用”。但实际情况是，超过 90% 的员工依然在使用自己的个人账号和私有工具处理工作任务。这种“买来工具、塞给员工、期待奇迹”的线性模式已经彻底破产，软件交付体系亟需从根本上重构其底层操作系统。 ### [12:07](https://www.youtube.com/watch?v=9R_4E1L8508&t=727s) AI 运营模型的六大构建模块与三大核心工作流企业当前必须转向的核心，是以 AI 原生软件工厂（AI Native Software Factory）构建的“人机协同 AI 运营模型”（People-AI Operating Model），并直接锚定业务成果。这一模型包含六大基础构建模块：第一是 **AI 编码**（AI Coding），即业界已广泛应用的 Claude Code、Devin 等工具；第二是**智能层**（Intelligence Layer），它绝非静态的仪表盘，而是能够像 F1 赛车实时诊断和调优引擎一样、实时洞察系统是否运转的可执行智能；第三是**企业知识**（Enterprise Knowledge），即埋藏在遗留系统深处的数十年决策历史，工具由于无法理解代码的前因后果，往往导致 AI 在棕地代码（Brownfield Code）上收益崩溃；第四与第五是**智能体编排与治理**（Agent Orchestration and Governance），决定哪个 Agent 执行哪项任务并全程追踪；第六则是**成果度量**（Outcome Measurement）。 ```mermaid flowchart TD accTitle: AI 运营模型的三大工作流与六大模块 subgraph Stream1 ["1. 任务执行 (How work gets done)"] A1["AI 编码 (AI Coding)"] A2["Agent 编排 (Agent Orchestration)"] end subgraph Stream2 ["2. 系统理解 (How work gets understood)"] B1["企业知识层 (Enterprise Knowledge)"] B2["智能洞察层 (Intelligence Layer - F1式实时调优)"] end subgraph Stream3 ["3. 流程治理 (How work gets governed)"] C1["全局治理 (Governance)"] C2["成果度量 (Outcome Measurement)"] end Stream1 --> Stream2 Stream2 --> Stream3 ``` 如果跳过成果度量，单纯多提交代码就会被误当成进展。研究机构 DX 将这种现象命名为“虚假速度”（False Velocity）——例如 Sprint 评审显示上季度代码提交量增加了 40%，而 CFO 却依然在质问：“为什么这完全没有反映在业务路线图上？”而一旦缺失治理，AI 生成代码的狂飙突进就会演变为“认知负债”（Cognitive Debt）：AI 编写代码的速度远远超过了团队整体建立共识与理解的能力。真正的灾难往往发生在极度依赖个体的时刻——“当唯一懂得这三个由 AI 编写的微服务究竟如何相互通信的工程师休了两周假时，真正的破坏就会爆发。” - **三大核心流向**：工作如何被执行（How the work gets done）、工作如何被理解（How the work gets understood）、工作如何被治理（How the work gets governed）。 - **行业痛点根源**：市面上没有任何一家供应商愿意同时承担这三项工作，这并非技术瓶颈，而是因为一旦供应商包揽这三件事，就必须承担端到端的全责，而这恰恰是当前软件服务行业极力规避的。 --- ### [15:01](https://www.youtube.com/watch?v=9R_4E1L8508&t=901s) 追查账单成本：多重发票与“幽灵价值”的根源企业在不知不觉中正为这三个割裂的环节向三家不同的供应商支付三份独立的发票。第一张发票是 **AI 基础工具与 Token 消耗**：每个席位除了 20 至 40 美元的工具订阅费外，专业开发者或 QA 测试人员每月在 Token 上的花销还高达 180 至 250 美元；第二张发票是**度量软件**：企业购买各种工程度量工具，每名开发者每月需再支付 50 至 100 美元；第三张发票则是**传统外包与编码供应商**，他们依然采用按工时与物料（Time and Materials）计费的模式，完全不背负交付结果。这种模式导致了利益机制的严重扭曲：“每当开发者写出低效愚蠢的 Prompt 导致组织账单暴涨时，谁在买单？答案是客户你。每当缺陷被打包推送进生产环境并在下个 Sprint 中带来更多修复工时账单时，谁在买单？依然是客户你。”行业里每个人都只售卖单个工具或局部问题，没有任何人对最终成果签字画押。最终承受所有负 ROI 恶果、端着烂摊子（Holding the bag）的永远是企业客户。账本上所谓的 AI 生产力，不过是割裂生态与计费机制催生出的“幽灵价值”。 --- ### [16:54](https://www.youtube.com/watch?v=9R_4E1L8508&t=1014s) TechBlocks 推出“8”：全流程端到端 AI 原生交付引擎在过去两年中，TechBlocks 彻底推倒重来，重新构想如果 AI 从第一天（Day 0）起就作为底层基座，软件交付体系应当如何运转。在与企业客户进行了 12 个月的闭门实战验证后，TechBlocks 正式对外发布全新 AI 原生交付引擎——**“8”**。该产品并非市面上又一个割裂的单点工具，而是一套将工具、技术、框架、加速器与平台融为一体的完整运营模型，旨在将企业原本的三份账单彻底合并为一份端到端负责的统一交付体系。 ```mermaid flowchart LR accTitle: TechBlocks 8 交付引擎架构 subgraph Inputs ["输入端"] I["标准化工作输入<br/>(基于历史与当前 Sprint)"] end subgraph CoreEngine ["8: AI 原生交付引擎"] direction TB E1["智能体交付单元 (Agentic Pods)<br/>(编码/测试/发布 Agent + 专家人工把关)"] E2["智能分析平台 (Intelligence Platform)<br/>(需求到生产全程追踪 + 30/60天代码存活度)"] E3["全局治理层 (Governance Layer)<br/>(全链路归因、标准化与可观测性)"] end subgraph Outputs ["输出端"] O["标准化、可验证的业务成果"] end I --> CoreEngine --> O ``` “8”的核心引擎由三大支柱构成： 1. **智能体交付单元（Agentic Pods）**：覆盖编码、测试、发布的完整生命周期 Agent，并在工程师、架构师、安全与 QA 等关键节点引入专业人员严格把关（Human-in-the-loop），专注于“完成工作”而非仅仅“观察工作”。 2. **智能分析平台**：实现从业务需求、代码提交到生产环境及发布后运维的全流程追踪，精准统计每张工单、每行代码与每一笔资金消耗；不仅能度量 AI 代码生成比例与人工重写比例，更会监测代码在生产环境中 30 天、60 天后的存活率（Code Survivability）。 3. **全局治理与可观测层**：跨越每个 Agent、每位工程师和链路的每一个环节，实现标准化的归因分析与全局治理。 --- ### [19:21](https://www.youtube.com/watch?v=9R_4E1L8508&t=1161s) 从工时计费转向结果交付：重构软件工程的未来工厂在 AI 加速的时代，“继续按照工时（Hours）付费纯粹是愚蠢的，企业应当只为成果（Outcomes）买单”。TechBlocks 将交付模式从评估“人月工时”转移到“交付结果”，将工程试错风险从企业转移到自身——一旦团队犯错，成本由供应商承担而非业务方买单，确保 AI 带来的降本红利真正流向客户。这一机制之所以成立，是因为度量平台不再是一个单独售卖的 SaaS 软件，而是作为决定 TechBlocks 自身能否获得报酬的结算工具。这种模式重构了交付公司的护城河：传统的度量工具公司若想模仿，就必须转型为承担交付风险、签署保障协议的交付公司；而传统的交付外包公司若想跟进，就必须建立不可篡改、代码级别的度量能力，但这会直接摧毁他们依靠拉长工时计费的商业基础。正如 20 年前云原生（Cloud Native）对基础设施的重构一样，AI 原生软件工厂正从底层重塑软件工程。 - **透明可追溯性**：企业无需盲信供应商的说辞，而是能通过系统端到端追踪从键盘敲击、PR 提交、投产价值到最终驱动业务指标的完整链条。 - **未来的核心竞争力**：未来 5 年，技术管理者向董事会汇报的关键不再是拥有多少“研发人头数”（Headcount），而是人类与 AI 团队协同作战的效能。 - **终极分水岭**：“AI 工具只会让个体变得更高效，而 AI 原生软件工厂才能让整个企业真正实现生产力跃升。” - **展台互动**：演讲最后，Prashant Kumar 邀请现场参会者前往 847 号展台观看“8”平台的实时演示，与团队深入探讨端到端企业落地实践。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=9R_4E1L8508&t=4s) 颠覆重塑被扣上‘太冒险’的帽子，而压缩成本却被奉为‘企业战略’（Reimagination gets called risky and cost containment gets called strategy）。 — Prashant Kumar > [06:39](https://www.youtube.com/watch?v=9R_4E1L8508&t=399s) 如果给你配备你最喜欢的 AI 编码工具，你能提效多少？ — Meter 研究人员 > [10:28](https://www.youtube.com/watch?v=9R_4E1L8508&t=628s) 问题绝不在于‘AI 不会写代码’，而在于企业在组织管理上依然假装 AI 不存在。 — Prashant Kumar > [10:28](https://www.youtube.com/watch?v=9R_4E1L8508&t=628s) 我们和 Claude 签署了企业采购协议并强制员工使用 — Prashant Kumar > [12:07](https://www.youtube.com/watch?v=9R_4E1L8508&t=727s) 为什么这完全没有反映在业务路线图上？ — CFO > [12:07](https://www.youtube.com/watch?v=9R_4E1L8508&t=727s) 当唯一懂得这三个由 AI 编写的微服务究竟如何相互通信的工程师休了两周假时，真正的破坏就会爆发。 — Prashant Kumar > [15:01](https://www.youtube.com/watch?v=9R_4E1L8508&t=901s) 每当开发者写出低效愚蠢的 Prompt 导致组织账单暴涨时，谁在买单？答案是客户你。每当缺陷被打包推送进生产环境并在下个 Sprint 中带来更多修复工时账单时，谁在买单？依然是客户你。 — Prashant Kumar > [19:21](https://www.youtube.com/watch?v=9R_4E1L8508&t=1161s) 继续按照工时（Hours）付费纯粹是愚蠢的，企业应当只为成果（Outcomes）买单 — Prashant Kumar > [19:21](https://www.youtube.com/watch?v=9R_4E1L8508&t=1161s) AI 工具只会让个体变得更高效，而 AI 原生软件工厂才能让整个企业真正实现生产力跃升。 — Prashant Kumar ## Mentioned TechBlocks, Prashant Kumar, McKinsey, Gartner, MIT, DX, Meter, Amazon, GitHub Copilot, Claude, Claude Code, Devin, 8 (TechBlocks AI Native Delivery Engine) ## Video description Prashant Kumar - CEO, TechBlocks Over the past two years, enterprises have invested billions of dollars in AI-powered developer tools, coding assistants, engineering intelligence platforms, and intelligent agents with the expectation of transforming software engineering. Yet many technology executives are asking an uncomfortable question: If every developer now has AI, why aren't organizations delivering better software outcomes: faster delivery, higher production quality, less rework, greater transparency, and measurable ROI? Developers may be completing individual tasks faster. Organizations are not yet consistently delivering better outcomes. The reality is that AI has accelerated portions of the software development lifecycle, but it has not fundamentally transformed software delivery. Organizations continue to layer AI onto traditional engineering processes rather than rethinking how work is planned, executed, governed, measured, and improved. The result is a growing ecosystem of disconnected AI coding tools, engineering intelligence platforms, and specialized agents operating in silos, creating fragmented workflows, inconsistent governance, limited visibility, and localized productivity gains that often fail to translate into sustainable business value. The problem isn't that AI can't write code. The problem is that enterprises still manage software delivery as if AI doesn't exist. The next competitive advantage will not come from deploying another coding assistant, engineering intelligence platform, or specialized agent. It will come from designing an **AI-native operating model **that orchestrates these capabilities into an intelligent software factory where humans and AI work together as a coordinated, measurable delivery system. This session explores how leading organizations are evolving from isolated AI tools to AI-native software factories integrating AI coding, engineering intelligence, agent orchestration, enterprise knowledge, governance, observability, and outcome-based measurement into a unified operating model. Attendees will leave with a practical blueprint for improving not only engineering velocity, but also software quality, production resilience, delivery transparency, governance, and measurable return on AI investment. More importantly, they will understand why the organizations that rethink their operating model, not merely expand their AI toolset- will define the next generation of software delivery. [Source](https://www.youtube.com/watch?v=9R_4E1L8508)

Source quotes

[0:04] Prashant Kumar: 颠覆重塑被扣上‘太冒险’的帽子，而压缩成本却被奉为‘企业战略’（Reimagination gets called risky and cost containment gets called strategy）。 [6:39] Meter 研究人员: 如果给你配备你最喜欢的 AI 编码工具，你能提效多少？ [10:28] Prashant Kumar: 问题绝不在于‘AI 不会写代码’，而在于企业在组织管理上依然假装 AI 不存在。 [10:28] Prashant Kumar: 我们和 Claude 签署了企业采购协议并强制员工使用 [12:07] CFO: 为什么这完全没有反映在业务路线图上？ [12:07] Prashant Kumar: 当唯一懂得这三个由 AI 编写的微服务究竟如何相互通信的工程师休了两周假时，真正的破坏就会爆发。 [15:01] Prashant Kumar: 每当开发者写出低效愚蠢的 Prompt 导致组织账单暴涨时，谁在买单？答案是客户你。每当缺陷被打包推送进生产环境并在下个 Sprint 中带来更多修复工时账单时，谁在买单？依然是客户你。 [19:21] Prashant Kumar: 继续按照工时（Hours）付费纯粹是愚蠢的，企业应当只为成果（Outcomes）买单 [19:21] Prashant Kumar: AI 工具只会让个体变得更高效，而 AI 原生软件工厂才能让整个企业真正实现生产力跃升。

Source quotes

[0:00] Prashant Kumar: The problem isn't that AI can't write code. The problem is that enterprises still manage software delivery as if AI doesn't exist. [0:00] Prashant Kumar: The next competitive advantage will not come from deploying another coding assistant, engineering intelligence platform, or specialized agent. It will come from designing an AI-native operating model that orchestrates these capabilities into an intelligent software factory where humans and AI work together as a coordinated, measurable delivery system. [3:22] Prashant Kumar: In enterprise tech transformations, "reimagining" is frequently branded as risky, while "cost containment" is falsely labeled as strategy. [7:35] Prashant Kumar: SIs have not re-imagined software delivery; they have merely become integrators of third-party AI tools inside broken legacy workflows. [20:46] Prashant Kumar: Individual developer velocity does not equal organizational productivity without a unified operating model. [20:46] Prashant Kumar: Future market winners will not be the companies hoarding the highest number of AI tools, but those establishing the superior AI operating model.

Original transcript

[0:04] Hello everyone. Um You guys can read about me on LinkedIn. I'm Prashant Kumar. Just enter Prashant [0:11] Kumar Tech blog. You'll find everything about me. I'll just move on to the topic. [0:14] So, I'll start with um a very interesting slide. This tells us we are remarkably um [0:22] politely speaking, uh I wanted the word stupid species, but my marketing team wanted to say [0:27] predictable. So, I just put predictable species. We commit the same mistakes again and again, [0:31] and we find new ways of committing the same mistakes all over again. Okay? So, [0:39] if you remember the internet era, internet came. All of a new way of reinventing a way of doing [0:45] business. We took all our paper brochures and put it on a web page and called it e-commerce. [0:52] 10 years later, a decade later, cloud came. Right? We took all our virtual machines, [1:01] moved it to somebody else's servers, right? Unchanged, and called it digital transformation. [1:08] Every IT organization sat with an Excel sheet, measured core to core, server to servers, [1:16] and dollar to dollar, and they all got the wrong answer because it was the wrong spreadsheet. [1:23] Everybody was How many of you guys were migrating virtual machines at 2018, [1:27] 2019, and calling it digital, you know, cloud native architectures and cloud transformations? [1:33] Right? Because we every time failed to create and 20 years till now, [1:37] we have still failed to reimagine cloud native businesses, architectures, operating models. [1:44] So, we decided to, you know, bring a statistics which is important because [1:49] it's important to understand what these mistakes cost us. At the height of this um migration wave, [1:56] McKinsey actually, in 2020, I think, uh did a study for 450 CIOs. [2:03] And what they found out that 75% of all the migrations had failed and they were way over [2:09] budget, 7% were below budget, and it had costed these companies more than 100 billion dollars. [2:14] My favorite detail in that study was this. One of the companies was 50% over budget and three [2:21] quarters behind in their migration. And you know what their strategy to get things done fast was? [2:26] They wanted to pay more to the system integrators in the hope that with more spend they can actually [2:31] do the work faster. Okay? By 2019, this had gotten so damn bad that we created a permanent discipline [2:41] just to fix a spreadsheet error. You know what that discipline was called? FinOps. [2:47] Imagine this. Just because and we hired the same companies who had screwed this entire [2:51] migration to actually give us a FinOps strategy. An entire certification track, [2:57] an entire discipline permanently created to fix a spreadsheet mistake that was done. Okay? [3:06] In every enterprise, whenever a transformational technology comes, you know what happens? [3:11] Reimagination gets called risky and cost containment gets called strategy. [3:19] It's happening again. That's what I'm driving at. [3:22] Today, we are doing it again. Only this time it is not servers, it's the entire software delivery. [3:27] At this time, the spreadsheet everyone's staring share everybody who is staring at is even worse. [3:35] And what are the consequences? We are living right in the middle, right? Because every [3:38] one of you can say, right, Prashant, you are a smart ass. Ha, you know, um hindsight is 20/20. [3:45] Tell me something that's happening now. So, let's look at like everybody going on these floors [3:51] is going to be buying new tools for one for AI coding, one for, you know, attribution layer, one [3:57] for governance layer. Speaker before me just told you about one one part of the larger problem, but [4:03] nobody talks about the entire problem. Everybody is too busy selling one tool to you. Right? So, [4:11] everybody is focused on individuals becoming productive, part of your software factory becoming [4:15] productive, part of your enterprise becoming productive, but that doesn't make the entire [4:20] enterprise productive, right? So, over past 2 years, enterprise technology leaders have invested [4:26] billions of dollars in AI. How many of you have actually bought multiple of these tools, if not [4:33] at least one? Right? Many of the organizations don't even understand all these categories exist, [4:38] how does this fit in the entire ecosystem, how to create an entire model. Everybody is just [4:44] madly running towards another tool that they want to buy and show productivity, right? So, [4:51] uh how many of you have at least deployed one of those AI tools? Raise your hand. Okay, good. [4:56] Um how many of you can confidently go back to your board and tell that your software organization is [5:00] fundamentally delivering better outcomes, whether it's engineering outcomes or business outcomes, [5:05] that is measurable and verifiable? How many of you can do that? None? I expected that. Um keep your [5:14] hand up if you personally personally feel that you are more productive day by day by using AI tools. [5:21] Okay, hold on to that feeling. I'm going to come back to that in 90 seconds, okay? [5:28] So, let's look at some of the data. DX did a research and this is what DX did. This is [5:34] measurable, verifiable, not what people said. There was 93% of industry-wide adoption for AI. [5:42] Um but across um yeah, across 400 different companies, real gain in delivery was in throughput [5:49] was 8%. But you know, in order to recover that investment what was promised to the CFOs and the [5:55] board? 3x to 10x. Your median gain is 8%. Okay? Now, I'll talk to the study about like how this is [6:03] low, but how in the 95th percentile of the company have shown about 40% throughput. What are those 1% [6:09] or less of companies doing to show that throughput is what we are going to talk about later in the [6:14] presentation. Gartner surveyed 500 CIOs. 72% said they were breaking even or losing money, [6:19] and it is not just software. When MIT did the same pattern at the enterprise-wide, 95% of AI pilots [6:27] were showing zero measurable return or negative returns. That's actual stats that's happening now. [6:35] Remember the Excel sheet I was talking about? This is real Excel sheet live, not in hindsight, [6:39] happening. Now, that feeling all you guys are holding on to, I said I'll come back to you in 90 [6:44] seconds. Meter Meter did a study in a controlled environment. They went after 430 different [6:51] mature software organizations, took all the senior software developers, [6:55] put them on a code base that they knew very well, and they said, "How much would you be [6:59] more productive if I give you the AI tools that you love?" You know what they said? 24%. [7:04] They were asked to use those tools, do the test. After that, they said, [7:08] "How much more productive do you think you were in this test?" They said 20%. Actual result? [7:16] Negative 19% on the clock. They confirmed the same illusion most of you people have. [7:23] Measured actually from one stopwatch from start to the end. Same disease that the cloud spread, we [7:30] are measuring tool adoption, individual adoption. We should be measuring outcome and delivery. [7:35] That's the problem. The industry has been solving the wrong problem. Let me ask you guys, [7:42] don't you find it it is very very strange that with all the tools that exist, analytics tools, [7:46] real-time measurement tools, that can track every keystroke, every line of code written, AI, non-AI, [7:53] what has been changed, all statistics associated with SDLC, no IT team, none of the vendors [7:59] are ever interested in making outcome-based economics and transparency work for you? [8:06] Isn't it strange? Again, as the industry has added a list of AI-based tools and softwares they [8:12] continue to buy and deploy to already a plethora of tools and technologies that we have. [8:18] So, let's look at why do we keep committing these kind of mistakes, right? [8:23] So, you already know you write seven-figures salaries and and and and invoices for beautiful [8:31] roadmaps that somebody else executes. How many of you have managed services contracts for GCCs where [8:36] you measure outcome by tickets delivered? How many of you would measure by tickets delivered, [8:39] but by actually engineering outcomes? I guess everyone, right? Because here is what happened. [8:47] You know, every system integrator, every managed services provider in your vendor list has exactly [8:52] one thing when AI did exactly one thing when AI arrived. They took the same engagement model that [8:59] they have sold you for 20 years, same headcount, same tickets, same T&M engine, just a Copilot [9:04] license now included. Oh, I'm just giving them more credit. They don't even pay for the Copilot [9:08] license or the you pay for it. Not because they won't answer, because their business model depends [9:14] on it and they will never be able to answer this. So, what have they actually become? Not [9:18] a re-imagineers of the software development life cycle system, they have become system integrators [9:24] of somebody else's AI tool in the same old SDLC. So, how do we change? How do we change this? [9:36] The speaker before me was talking about the cost of governance. You guys were in the presentation, [9:40] you heard the cost of governance. Let me give you an example what that cost. [9:45] If you continue with this approach, consider March of this year, AI assisted changes without review [9:49] process to match on contribute. Two separate incidents caused in Amazon. The first one, [9:55] 120,000 lost orders, 1.66 million site orders gone. Next, after 2 days, 6 hours of outage, 90% [10:04] um of the orders lost. What did Amazon do? Created a 90-day code freeze and [10:10] made it mandatory to create a governance mechanism where AI engineers would have to personally sign [10:14] off on any kind of critical changes that would be deployed in production. The problem is not [10:19] that AI can't write code. The problem is that we still continue to behave as if AI doesn't exist. [10:28] What happens on an ordinary Tuesday in enterprise? [10:30] You have engineering by Scopa pilot or Claude or Devin, security buys its own security software, [10:36] nobody in technology signs on to it, customer service buys its own chat form chat platform, [10:42] everybody but all the tools but there's no AI strategy for any one of them. [10:50] Another organization measured the entire SDLC and found out how much time is the software [10:55] developer spending on coding. Found out 16%. My CTO challenged it. I said, "Okay, you have a great [11:00] one. Let me give you 30%. But what about the rest 60 to 70%?" We are spending tens of billions of [11:07] dollars, 80 to 90% of your AI spend, optimizing 16 or 20% of your day, while the other two 70% [11:16] remains completely ignored. All the architecture, design, testing, all of that is vastly ignored. [11:28] One collab One MIT study that went for about 450 organizations and asked how many of the [11:35] organizations have stated um you know, strategy? They said 40% and you know, I'll simplify it for [11:42] you. What is the stated strategy? That we signed an enterprise agreement with Claude. [11:48] And they mandated everyone in the organization to use these tools, but did you know that 90% of the [11:54] people were still using their personal tools to actually develop and deploy stuff in their own job [11:59] functions. That means AI is already working and their AI strategy is already gone. So, [12:03] this is what you bought. This is the model people AI tools results. It's not working. I've proved [12:07] it three different ways. The new model that you should be focusing on is people AI operating model [12:13] created with AI native software factories which are directly tied to business outcomes. Now, [12:19] let's go into this quickly. What are the six building blocks of an AI operating model? [12:32] So, the first building block is AI coding. This is the part that industry has really done well with [12:37] Claude code, with Devin, with whatever you have. The second one is the building the intelligence [12:41] layer. It's not just measurable dashboards. It's actually actionable intelligence that's [12:46] supposed to tell you whether any of it is working. Provides you ability to fine-tune this engine in [12:51] real time. Like in a Formula 1. How many of you follow Formula 1? In real time, it diagnoses the [12:56] problems and fixes the problem. Right? The third layer is enterprise knowledge. The fourth layer is [13:05] agent orchestration and governance. So, enterprise knowledge is the decades of decision-making that's [13:11] buried into your legacy systems that no model ever knows or how to read. This is why AI gains [13:18] collapse on a brownfield code. The tools don't know why anything is the way it is. Right? Agent [13:24] orchestration. Who or what decides which agent does what piece of work and remem- and remembers [13:32] who orchestrates this. This is the job that is made real. I talked about govern- governance [13:38] and measurability, and I also talked about outcomes being being measured already. So, [13:44] now if you skip the outcome measurement, more code shipped looks like progress, [13:48] and the research firm DX has a name for it. It called it false velocity. A sprint review [13:55] happening every shows 40% more commits in the last quarter, and the CFO in the room is still asking, [14:01] "Why isn't it reflecting in my road map, business road map?" Skip the governance, [14:09] and more AI-generated code looks like speed. DX has a name for that, too, cognitive debt. [14:14] AI writes faster than your entire team's shared understanding can observe. [14:18] The real damage damage happens when one engineer, one who knows how these three AI- written services [14:25] actually talk to each other, is on a 2-week vacation. That's when the real damage happens. So, [14:35] three different streams, six different blocks, three different streams. One, [14:38] how the work gets done. How the work gets understood. And how the work gets governed. [14:46] The reason nobody sells you all the three jobs in one place isn't technical. [14:50] It is the moment a vendor takes all the three jobs, they become accountable. And accountability [14:56] is one thing this industry is not willing to do at all, total accountability, end-to-end. [15:01] So, let's follow the money on these three jobs because you are already paying for all of the [15:05] three of them, and just three different vendors, three separate invoices. So, the first one, [15:10] AI tools, right? How many of you have like 20 to 40 bucks paying for AI tools? Plus, [15:14] I'm assuming if you are a pro pro professional developer or a coder or a QA tester, [15:19] you are spending per seat about 180 to 250 on tokens. Correct? The second one [15:26] in the invoice, too, is the measurement software. Again, I remember I showed you a whole bunch [15:29] of tools. No one tool does the end-to-end accountability, but even if you bought one, [15:34] the speaker before me had another tool he was talking about. If you're starting to buy that, [15:38] it is anywhere between 50 to 100 bucks per developer per month. And the third one is your [15:46] basically your coder, the coding vendor. Time and materials, no accountability. Let me ask you this. [15:55] Every time a developer writes stupid prompts, and as an organization your bills go higher, who pays [16:02] for it? I can answer the question, you. Every time all the bugs get pushed into production, [16:10] and they come back in next sprint saying you're spending, who pays for it? It's you. [16:17] I can go on and on. I can give you 20 different examples of all the things that you pay that [16:21] you shouldn't be paying for. And what is the outcome? Nobody signed for the outcome. Who is [16:25] holding the bag? You, Mr. Customer. You are holding the bag for the end-to-end outcome, [16:30] which never never gets delivered. That's why you have all those studies with negative [16:34] returns on investments, because everybody's selling you a tool and a part of a problem. [16:42] This is what I'm talking about. The phantom value on the ledger is not one [16:46] item. It's the entire structure, the way industry operates and bills you. [16:54] So, we at TechBlocks in last 2 years sat down and decided [16:58] to reimagine how software would look like if AI existed right from day zero. If AI was right at [17:04] the foundation, how would software delivery look like? Right? And assuming that we had to prove [17:11] non-forgeable, verifiable, measurable outcomes, engineering outcomes, business outcomes, [17:17] the question led us to believe build something. We have been running it with our enterprise [17:21] clients for last 12 months. Today we are unveiling it publicly. It's called eight. [17:27] AI native delivery engine. We are not selling you any tools. [laughter] Not another tool vendor. We [17:34] have many tool vendors sitting down there. It is an entire operating model. It consists of tools, [17:39] technologies, frameworks, accelerators, platform all built into one. End-to-end accountability. [17:46] It is not just another tool for all the three invoices. All the three invoices that I was [17:50] talking into all collapsed into one. So if you look at the middle part, guys, I don't have a, [17:57] you know, something to point at. It consists of three parts. The AI native delivery engine, [18:02] which consists of human oversight people, core agents, I'm going to talk about in a second. [18:06] The second one is the analytics and the intelligent engine. And the third part is [18:10] the entire governance layer. And on the left side is the standardization of work inputs. [18:16] We come and standardize inputs based on sprints that you have been running historically, [18:21] currently, so and so forth for all the parts. And the outcome is all this standardized. [18:26] Okay. So what are the three different units? The delivery engine and agentic pods [18:32] is the one I was talking about. Coding, testing, release agents across all the entire life cycle [18:37] with human oversight at the every step that matters. Engineers, architects, security, QA. [18:42] This is the work getting done, not observed. The second layer is the intelligence platform where [18:47] every ticket, every line, every dollar traced from requirement to production and past production, [18:52] where we measure the code is still alive 30 days later, 60 days later. It's not just how [18:57] many lines of AI has been written, was written by AI, how many humans wrote, how many lines of [19:03] AI written code that was overwritten by humans, but actual outcomes. Governance, standardization, [19:09] attribution, observability across the third layer, across every agent, every human, every [19:15] every part of the chain. Those are the three layers that are part of this engine. [19:21] So, what does this do to the entire delivery model? It is an AI accelerated world paying [19:27] in an AI accelerated world paying for hours is plain stupid. You should be paying for outcomes. [19:39] The delivery units shifts the deal from effort to outcome and moves the risk to us. You're paying [19:44] for outcomes. We commit mistakes, the vendor pays or the engineering team pays, not the business. [19:51] AI savings reach you. They don't stay with the vendor. [19:55] A number that you can trust because it's very verifiable right from the requirement gathering [20:01] through QA to production beyond production and survivability. [20:06] So, earlier I asked a question that no vendor in your staff can answer. Who's accountable if [20:11] none of these things turns into outcome? Here is our answer. Our measurement layer [20:16] is not a product we are selling you. It is an instrument that decides whether we get paid. [20:21] Think about what mean it means structurally for a measurement company to match it, [20:25] they would have to become a delivery company, hire pods, engagement risk, sign guarantees. [20:29] This is a different business. For a delivery company to match it, they would have to build [20:33] unfalsifiable code level measurement, the very thing that makes the hours harder to build. [20:39] We got what 20 minutes ago. Why? That is not going to be done by the industry. Now, [20:46] this engine is not replacing engineers. It is redesigning the software delivery [20:50] right from the scratch. The same redesign that cloud native forced on infrastructure [20:55] 20 years ago, too late for many organizations. Every Except this time, [21:00] you don't have to take a vendor's word or a pop person's word for it. You can actually look at [21:06] a machine which measures keyboard to keyboard a pull request PR request a submission [21:12] a a code that was value put in production and the outcomes that were driven from it. [21:17] Five years from now the question is will you still be answering your board with amount of [21:25] head counts you have or the effectiveness of human and AI teams working together? [21:30] The organizations that will win in the future are not the ones with the most amount of AI tools. [21:37] The organizations that win in the future are going to be the ones that have the best AI operating [21:44] model or the best AI native software factory. The AI native software factories make enterprises more [21:51] productive. AI tools just make individuals more productive. Thank you so much. We are [21:57] that's the end of my presentation. If you want live demos, I obviously have not talked about this [22:03] whole platform and how the demos work. We are at booth number 847. There's an entire team sitting [22:10] there if you're interested in knowing how this works, how our enterprise clients are leveraging [22:13] this end-to-end, we'll be more than happy to showcase this to you. Have a good day. Cheers.