Latest / Mind Cast / The Evolution of Software Cost Estimation in the Era of Generative AI | From COCOMO to Hybrid Intelligence Frameworks

Transcript

The Evolution of Software Cost Estimation in the Era of Generative AI | From COCOMO to Hybrid Intelligence Frameworks · Mind Cast

• 0:00
  SPEAKER_00: Imagine two teams of analysts, same technology, same data, same question.
• 0:06
  SPEAKER_00: What is AI actually worth?
• 0:09
  SPEAKER_00: Team 1, Goldman Sachs, McKinsey, the big commercial forecasters, they come back with a number somewhere between$7 trillion and$25.6 trillion added to global GDP every year, permanently.
• 0:24
  SPEAKER_00: That is more wealth generated annually than the entire economies of Germany and Japan combined.
• 0:31
  SPEAKER_00: It is a number that justifies every AI investment, every restructuring, every bet the company pivot happening in boardrooms right now.
• 0:39
  SPEAKER_00: Team two is led by Darren Asimoglu.
• 0:42
  SPEAKER_00: He just won the Nobel Prize in Economics.
• 0:45
  SPEAKER_00: He teaches at MIT.
• 0:46
  SPEAKER_00: He spent years building the models that underpin how we understand labor, automation, and growth.
• 0:52
  SPEAKER_00: His answer is 1.1 to 1.6% GDP growth over the entire next decade.
• 0:59
  SPEAKER_00: That works out to roughly 0.05% per year.
• 1:04
  SPEAKER_00: Say that again slowly.
• 1:06
  SPEAKER_00: 0.05% per year.
• 1:10
  SPEAKER_00: So we have two groups of serious, rigorous, credentialed people looking at the same technology in arriving at projections that differ by a factor of somewhere between 30 and 100.
• 1:22
  SPEAKER_00: That is not a debate about rounding, that is a debate about the fundamental nature of what AI actually does to an economy.
• 1:30
  SPEAKER_00: And here is the thing I want you to carry with you into this episode.
• 1:33
  SPEAKER_00: That gap is not random.
• 1:36
  SPEAKER_00: It is pointing at something real, something specific, something that is quietly costing technology companies and the teams inside them enormous amounts of time and money right now.
• 1:47
  SPEAKER_00: Something that has broken 40 years of carefully built science in something that, if you understand it, gives you a genuine competitive advantage over every organization still working from the old playbook.
• 2:00
  SPEAKER_00: So, let's go find out what it is.
• 2:04
  SPEAKER_00: Hey, welcome to Minecast.
• 2:06
  SPEAKER_00: I'm Will.
• 2:07
  SPEAKER_00: This show is about the ideas that actually matter, the ones shaping how we work, build, invest, and think.
• 2:14
  SPEAKER_00: And today we are going deep on one of the most consequential and least discussed stories in all of tech right now.
• 2:20
  SPEAKER_00: The source material is a 2026 landmark research report titled The Evolution of Software Cost Estimation in the Era of Generative AI, from COCOMO to hybrid intelligence frameworks.
• 2:33
  SPEAKER_00: It synthesizes peer-reviewed economics from MIT and the National Bureau of Economic Research, real engineering telemetry from Farros AI and Google Cloud's DORA program, and theoretical breakthroughs from Frontiers in Artificial Intelligence.
• 2:49
  SPEAKER_00: This is rigorous academic and industrial research assembled into a picture that should genuinely change how you think about AI.
• 2:56
  SPEAKER_00: Here's what you are going to walk away with today.
• 2:59
  SPEAKER_00: First, a clear understanding of why the formula that has governed software cost estimation for 40 years, a formula used in virtually every major software project on Earth, has been mathematically invalidated by generative AI.
• 3:13
  SPEAKER_00: Second, hard data showing why more AI code is actually producing less reliable software, a counterintuitive finding that challenges the core promise of the AI productivity revolution.
• 3:25
  SPEAKER_00: And third, a tour of the new frameworks being built right now to replace what was broken, and three concrete things you can do about it.
• 3:33
  SPEAKER_00: This matters if you write code, it matters if you run a team that does.
• 3:37
  SPEAKER_00: It matters if you invest in companies that build on software.
• 3:40
  SPEAKER_00: And at this point, that is pretty much every company.
• 3:43
  SPEAKER_00: Let's get into it.
• 3:44
  SPEAKER_00: Key Insight 1.
• 3:45
  SPEAKER_00: The death of Kokomo and the Zero Cost Coding Revolution.
• 3:50
  SPEAKER_00: Let me take you back to 1981.
• 3:52
  SPEAKER_00: The personal computer is brand new.
• 3:55
  SPEAKER_00: The internet does not exist, and a computer scientist named Barry Bohm publishes a paper that will quietly run the software industry for the next four decades.
• 4:05
  SPEAKER_00: He calls it Kokomo, the constructive cost model.
• 4:09
  SPEAKER_00: And its central insight is elegant.
• 4:11
  SPEAKER_00: Software costs money primarily because writing software requires human time, and human time costs money.
• 4:19
  SPEAKER_00: To estimate a project's budget, you first estimate its size, measured in source lines of code or SLOC, and then you feed that number into a formula.
• 4:30
  SPEAKER_00: Effort equals A, a calibration constant based on historical data, multiplied by the size of the project raised to the power B, an exponent capturing the fact that bigger projects get disproportionately harder, multiplied by a set of effort adjustment factors, accounting for team experience, platform complexity, and tooling.
• 4:52
  SPEAKER_00: Kokomo 2 arrived in 2000 with refinements, but the foundational logic stayed the same.
• 4:59
  SPEAKER_00: Count the code, estimate the labor, compute the cost.
• 5:02
  SPEAKER_00: It was taught in every software engineering program baked into every project management tool and trusted by procurement officers at governments and Fortune 500 companies worldwide.
• 5:14
  SPEAKER_00: And it worked right up until generative AI arrived because every single assumption the formula depends on has now been severed at the root.
• 5:25
  SPEAKER_00: Here is what happened.
• 5:27
  SPEAKER_00: A large language model can produce thousands of syntactically correct, functionally plausible lines of code in milliseconds, not hours, not minutes, milliseconds, which means the marginal cost of generating raw code has effectively hit zero.
• 5:45
  SPEAKER_00: And when the marginal cost of your primary input variable collapses to zero, the formula built around that variable becomes meaningless.
• 5:55
  SPEAKER_00: SLOC is now what the researchers call epistemologically void.
• 6:00
  SPEAKER_00: It carries no information about how much human effort a project will require.
• 6:06
  SPEAKER_00: Think about what this means concretely.
• 6:08
  SPEAKER_00: An estimator using SLOC today might see a project with 50,000 lines of code and budget six months of development time, because historically that ratio made sense.
• 6:20
  SPEAKER_00: But if an AI agent generated 45,000 of those lines in two days, the budget is wildly off before the project even starts, or flip it around.
• 6:30
  SPEAKER_00: A project that requires only 200 lines of precise, secure, cryptographic orchestration logic might look trivially small by SLOC and yet cause an LLM to hallucinate repeatedly for weeks, requiring exhausting human iteration every step of the way.
• 6:48
  SPEAKER_00: The formula breaks in two other critical places as well.
• 6:52
  SPEAKER_00: The scaling exponent, the B in the equation, was calibrated to capture human communication friction.
• 6:58
  SPEAKER_00: The bigger the team, the more coordination overhead, the slower the work.
• 7:03
  SPEAKER_00: But AI agents don't get bogged down in meetings or unclear requirements handoffs.
• 7:08
  SPEAKER_00: They have a completely different scaling problem: context window degradation.
• 7:13
  SPEAKER_00: As a code base grows, an AI starts to forget what it read earlier in the repository.
• 7:18
  SPEAKER_00: That is a machine memory constraint, not a human coordination constraint, and the B exponent was never built to model it.
• 7:26
  SPEAKER_00: And the personnel attributes cost drivers, the multipliers accounting for engineers' seniority and experience, are now inverted.
• 7:34
  SPEAKER_00: Junior developers armed with AI co-pilots frequently outpay senior developers in raw code volume.
• 7:41
  SPEAKER_00: The experience premium, which Cocomo treated as a given, has been disrupted in ways the model's architects never anticipated.
• 7:49
  SPEAKER_00: Agile story points break down for the same structural reasons.
• 7:53
  SPEAKER_00: The method assumes that perceived task complexity correlates with actual execution time, but an LLM might solve a classically high complexity task, say a massive boilerplate data pipeline, in 30 seconds because it recognizes a known pattern.
• 8:09
  SPEAKER_00: Meanwhile, a task that appears low complexity, adjusting one variable in a legacy system with undocumented dependencies, causes the LLM to hallucinate wrong solutions repeatedly, burning days of human time.
• 8:24
  SPEAKER_00: The complexity ordering has been inverted, and story points are blind to it.
• 8:28
  SPEAKER_00: The microeconomic consequences of all this are staggering.
• 8:32
  SPEAKER_00: We are watching the emergence of what researchers call the scalable boutique, engineering teams of four or five people shipping software that once required departments of 50.
• 8:43
  SPEAKER_00: The make versus buy decision for enterprise software has flipped.
• 8:47
  SPEAKER_00: When internal development costs approach zero for raw coding, building custom is suddenly cheaper than buying SaaS.
• 8:54
  SPEAKER_00: Traditional SaaS companies enjoyed 80 to 90% gross margins with predictable scaling economics.
• 9:01
  SPEAKER_00: AI augmented development operates on 50 to 60% margins with wildly variable per-user compute costs.
• 9:08
  SPEAKER_00: A chatbot reply might cost fractions of a penny.
• 9:12
  SPEAKER_00: A complex document analysis runs several dollars in inference compute.
• 9:16
  SPEAKER_00: Organizations are no longer scaling headcount, they are scaling compute capacity, and none of the legacy cost models account for any of it.
• 9:25
  SPEAKER_00: Key insight 2 The productivity reliability paradox.
• 9:30
  SPEAKER_00: Now, here is where the story gets genuinely surprising, and where most of the AI conversation is going completely wrong.
• 9:38
  SPEAKER_00: MIT, Microsoft, and the National Bureau of Economic Research ran one of the most methodologically rigorous field experiments in the history of software productivity research.
• 9:50
  SPEAKER_00: 4,867 developers, real companies, Microsoft, Accenture, a Fortune 100 electronics manufacturer, randomized controlled trials, meaning this was not a survey or a case study, it was a controlled scientific experiment.
• 10:07
  SPEAKER_00: And the headline result?
• 10:09
  SPEAKER_00: Developers with AI coding assistance completed 26.08% more tasks.
• 10:16
  SPEAKER_00: That number gets plastered on AI vendor slides constantly, and it is real data from real science.
• 10:23
  SPEAKER_00: But it is the beginning of the story, not the end.
• 10:26
  SPEAKER_00: Because there is a different data set that tells a completely different part of the story, one that changes how you interpret that 26% entirely.
• 10:36
  SPEAKER_00: First, notice this 30 to 40% of developers in the treatment groups chose not to use the AI tool at all, despite having access, despite low integration friction.
• 10:48
  SPEAKER_00: They cited quality concerns and personal workflow preferences.
• 10:52
  SPEAKER_00: So a blanket 26% productivity bonus applied to your entire engineering organization is not just optimistic.
• 11:00
  SPEAKER_00: It is statistically unsupported.
• 11:02
  SPEAKER_00: But the deeper challenge was formalized in 2026 by researcher Sabri Farag, drawing on real-world telemetry from Faros AI and Google Cloud's DORA program, data from over 10,000 developers across enterprise environments.
• 11:19
  SPEAKER_00: And what it shows is a phenomenon Farag named the Productivity Reliability Paradox.
• 11:26
  SPEAKER_00: Here are the four numbers that define it.
• 11:29
  SPEAKER_00: Pull requests merged per developer, up 98%, code review time per pull request, up 91%, software delivery stability, down 7.2%, average code churn, up 100%, doubled.
• 11:46
  SPEAKER_00: Let that sink in.
• 11:48
  SPEAKER_00: AI adoption nearly doubled the raw volume of code being produced, and simultaneously it nearly doubled the time required to verify that code, degraded the reliability of shipping software, and doubled the rate at which code had to be rewritten.
• 12:05
  SPEAKER_00: The speed gains in generation are matched almost precisely by friction gains in verification.
• 12:11
  SPEAKER_00: Farraga calls this the verification tax.
• 12:15
  SPEAKER_00: Human effort in AI-augmented development does not disappear.
• 12:18
  SPEAKER_00: It relocates.
• 12:20
  SPEAKER_00: It moves from the front of the pipeline, where engineers used to write code, to the back of the pipeline, where engineers now have to verify code they did not write and cannot fully predict.
• 12:30
  SPEAKER_00: Your QA team, your security team, your architects, they inherit every efficiency gain made at the authoring stage, all at once, under deadline pressure, reviewing non-deterministic output.
• 12:42
  SPEAKER_00: And this brings us to what I think is the most operationally important and least discussed finding in this entire body of research.
• 12:50
  SPEAKER_00: Could it be that your most expensive engineers are actually getting slower because of the AI tools you bought to speed them up?
• 12:58
  SPEAKER_00: According to the data, yes, an internal study across 250 developers at five organizations found that senior engineers spend an average of 4.3 minutes reviewing each individual AI-generated suggestion.
• 13:14
  SPEAKER_00: Junior developers spend 1.2 minutes.
• 13:17
  SPEAKER_00: Why the difference?
• 13:18
  SPEAKER_00: Because senior developers are responsible for architectural integrity.
• 13:23
  SPEAKER_00: When the AI generates code, it is the senior developer who has to evaluate whether that code respects the system's design patterns, security constraints, data flows, and long-term maintainability.
• 13:35
  SPEAKER_00: That is cognitively expensive work that cannot be rushed.
• 13:40
  SPEAKER_00: The result?
• 13:41
  SPEAKER_00: Senior developers experience a 12-19% productivity drop when using AI copilots.
• 13:48
  SPEAKER_00: Junior developers gain up to 35% in raw throughput.
• 13:52
  SPEAKER_00: But junior developers are also more likely to miss subtle architectural hallucinations.
• 13:58
  SPEAKER_00: Code that compiles and passes basic tests but silently violates constraints that will cause serious problems months later.
• 14:07
  SPEAKER_00: Legacy estimation tools, seeing the senior developers' lower output, register this as a productivity failure.
• 14:14
  SPEAKER_00: In reality, it is the single most important form of quality control in the pipeline.
• 14:19
  SPEAKER_00: The senior developer is no longer a coder.
• 14:22
  SPEAKER_00: They are what researchers call an execution integrity auditor, the professional responsible for verifying that AI-assisted work is sound before it reaches production.
• 14:34
  SPEAKER_00: And your project budgets almost certainly do not account for this, which is why so many AI-assisted projects are running over schedule and delivering less reliable software than their teams expected.
• 14:46
  SPEAKER_00: The tools are real, the productivity gains are real in limited contexts, but the hidden costs are just as real, and they are landing on your most experienced people.
• 14:57
  SPEAKER_00: Key Insight 3.
• 14:58
  SPEAKER_00: The new science of software cost.
• 15:01
  SPEAKER_00: So the old models are broken.
• 15:03
  SPEAKER_00: The quick fix, using AI to estimate AI costs, has been tried and failed.
• 15:09
  SPEAKER_00: In controlled experiments, AI-based estimation tools like GitLab Duo achieved accuracy rates of just 16%.
• 15:18
  SPEAKER_00: 16?
• 15:19
  SPEAKER_00: That is not a usable number in any professional context.
• 15:23
  SPEAKER_00: The problem is structural.
• 15:25
  SPEAKER_00: These tools function as black boxes that can output a number, but cannot provide the transparent, auditable mathematical reasoning you need to defend a budget in front of a CFO.
• 15:37
  SPEAKER_00: And they require decades of historically accurate, company-specific data to calibrate, data most organizations do not have.
• 15:46
  SPEAKER_00: So where does that leave us?
• 15:48
  SPEAKER_00: It leaves us at a genuinely exciting frontier.
• 15:51
  SPEAKER_00: The research community is building the next generation of estimation science right now, and the results are starting to come in.
• 16:00
  SPEAKER_00: The most systematic effort is happening at the University of Southern California, where researchers Brad Clark and Ray Medaki are developing Coco Mo3, a direct successor to Bohm's original model, rebuilt from the ground up to account for AI augmented development.
• 16:19
  SPEAKER_00: The central innovation is a brand new effort adjustment factor called AI assistance usage.
• 16:25
  SPEAKER_00: Rather than guessing at productivity gains from vendor benchmarks, the team used Delphi methodology, structured expert consensus, to empirically calibrate how different levels of organizational AI maturity should adjust cost projections.
• 16:42
  SPEAKER_00: The scale runs from very low, where teams use essentially no AI, to very high, where AI literacy is embedded across the organization with continuous learning and adaptation.
• 16:54
  SPEAKER_00: The financial leverage is substantial.
• 16:57
  SPEAKER_00: Moving from a low AI maturity state to a nominal AI maturity state, a well-managed, moderately integrated deployment with appropriate human verification, can reduce estimated annual project costs from$4.27 million to$2.51 million.
• 17:16
  SPEAKER_00: The return on investment break-even for that transition 0.36 years.
• 17:22
  SPEAKER_00: Less than four months.
• 17:28
  SPEAKER_00: That is a structural cost advantage available to organizations that do this deliberately and measure it rigorously.
• 17:36
  SPEAKER_00: But Kokomo 3 also requires new size metrics because, as we established, SLOC is dead.
• 17:44
  SPEAKER_00: Two replacements are emerging from the research.
• 17:46
  SPEAKER_00: The first is AI adjusted function point analysis.
• 17:50
  SPEAKER_00: Instead of counting code lines, function points measure what a system actually does for its users, how many inputs it accepts, outputs it produces, data files it manages, and external interfaces it connects to.
• 18:05
  SPEAKER_00: The profound advantage is stability.
• 18:07
  SPEAKER_00: Your system's functional requirements do not change based on whether a human engineer wrote the implementation or an AI generated it in seconds.
• 18:16
  SPEAKER_00: What the software does is the same.
• 18:19
  SPEAKER_00: Function points measure that invariant, the what, not the how.
• 18:24
  SPEAKER_00: The second emerging metric is query points, developed for complex systems engineering work.
• 18:30
  SPEAKER_00: Instead of counting code, query points measure the complexity of a system's architecture, how difficult it is for a human or AI agent to navigate, verify, and reason about the design of the system.
• 18:43
  SPEAKER_00: It is a measure of structural complexity, not construction volume.
• 18:47
  SPEAKER_00: And alongside these new metrics, two major theoretical frameworks are being built to replace the old cost drivers entirely.
• 18:56
  SPEAKER_00: The first is the hybrid intelligence framework, from a 2026 paper by Alaswad, Puvamal, and Aljadou in Frontiers in Artificial Intelligence.
• 19:06
  SPEAKER_00: They argue that in the AI era, software cost emerges not from human labor alone, but from the dynamic interaction between machine reasoning and human governance.
• 19:17
  SPEAKER_00: They identify five dimensions that now drive project cost.
• 19:22
  SPEAKER_00: LLM reasoning complexity, how much friction arises when you delegate a task measured by failed prompts and hallucination frequency, context and information completeness, whether the AI has all the architectural context it needs because missing context always produces rework, code transformation impact, the systemic ripple of AI-generated changes through a coupled code base, iterative reasoning cycles, the volume of back and forth required to coerce correct output, and human oversight effort, the cognitive load of auditing AI output, which is the financial embodiment of the verification tax.
• 20:03
  SPEAKER_00: The second framework is the specification governance model developed by Farrag.
• 20:08
  SPEAKER_00: The core insight, the primary cost of AI-assisted software development is no longer writing implementation code, it is writing the deterministic specifications, tests, and behavioral constraints that govern how an AI agent implements.
• 20:24
  SPEAKER_00: The human effort has moved from construction to governance.
• 20:27
  SPEAKER_00: The practical application of specification governance is a methodology called test-driven agentic development, T-DAD.
• 20:35
  SPEAKER_00: Write your tests, your acceptance criteria, your behavioral boundaries first.
• 20:39
  SPEAKER_00: Build the verification sandbox before you prompt the AI for an implementation.
• 20:44
  SPEAKER_00: Then let the agent work inside that sandbox.
• 20:47
  SPEAKER_00: The data on this approach is striking.
• 20:50
  SPEAKER_00: Compared to standard conversational prompting, T-DAD raises issue resolution rates from 24% to 32%, and code generation success rates from 40% to 68%.
• 21:02
  SPEAKER_00: Those are enormous improvements in reliability from changing not the AI model but the human discipline surrounding it.
• 21:08
  SPEAKER_00: Here is the counterintuitive finding that should stop you cold if you manage an engineering team.
• 21:14
  SPEAKER_00: Giving an AI high-level conversational instructions, prompting it to write this securely or use test-driven development actually increases code-based regressions by 9.94%.
• 21:26
  SPEAKER_00: You think you are improving quality by directing the AI toward good practices.
• 21:30
  SPEAKER_00: You are making things measurably worse.
• 21:33
  SPEAKER_00: Vague natural language instructions to an AI are not a governance mechanism.
• 21:37
  SPEAKER_00: They are a false sense of control.
• 21:39
  SPEAKER_00: Specificity is the new competitive advantage.
• 21:42
  SPEAKER_00: Precise, deterministic, executable specifications written by humans before any code is generated are the actual lever of quality in AI assisted development.
• 21:52
  SPEAKER_00: The organizations that master this discipline will build more reliable software faster at lower total cost than those still treated.
• 22:00
  SPEAKER_00: Their AI tools like slightly smarter search engines.
• 22:03
  SPEAKER_00: The cost of building software has not dropped, it has transformed, from quantifying manual construction to calculating the transaction costs of human AI coordination, specification governance, and execution integrity.
• 22:16
  SPEAKER_00: Alright, three things.
• 22:18
  SPEAKER_00: Concrete, specific, actionable.
• 22:21
  SPEAKER_00: Starting this week.
• 22:22
  SPEAKER_00: Takeaway one, stop counting lines of code.
• 22:26
  SPEAKER_00: Start measuring functionality and specification quality.
• 22:29
  SPEAKER_00: If any dashboard, sprint review, or performance conversation in your organization uses lines of code or code volume as a signal of productivity or progress, retire that metric immediately.
• 22:42
  SPEAKER_00: It is not just inaccurate in the AI era, it is actively misleading.
• 22:47
  SPEAKER_00: It will reward behavior that creates code bloat and punish the careful, deliberate work of writing precise specifications and architectural tests.
• 22:57
  SPEAKER_00: Replace it with function points, which measure what your system actually delivers to users.
• 23:03
  SPEAKER_00: Supplement that with qualitative assessment of specification quality.
• 23:07
  SPEAKER_00: Are the behavioral boundaries being given to AI agents precise and testable?
• 23:12
  SPEAKER_00: Or are they vague natural language directions?
• 23:15
  SPEAKER_00: That latter question is now one of the most important engineering leadership questions you can ask.
• 23:22
  SPEAKER_00: The answer tells you whether your team is set up for reliability or set up for rework.
• 23:27
  SPEAKER_00: Takeaway 2.
• 23:29
  SPEAKER_00: Budget explicitly for the verification tax.
• 23:32
  SPEAKER_00: I want to be direct.
• 23:34
  SPEAKER_00: If your current project plans do not have a dedicated budget line for QA, security review, and architectural validation as a distinct category from development velocity, you are going to run overtime, over budget, or both.
• 23:48
  SPEAKER_00: The Dora data is not ambiguous.
• 23:51
  SPEAKER_00: A 7.2% drop in delivery stability across 10,000 developers is a serious systemic risk at scale.
• 23:59
  SPEAKER_00: Your senior engineers being slower on raw throughput is not a failure.
• 24:04
  SPEAKER_00: It is the sound of your most important quality control mechanism working.
• 24:09
  SPEAKER_00: The problem is when organizations interpret that slowdown through old productivity metrics and respond by reducing review time or pushing senior engineers toward more generation work.
• 24:21
  SPEAKER_00: That is the exact wrong response.
• 24:23
  SPEAKER_00: Protect the verification function.
• 24:26
  SPEAKER_00: Staff it deliberately.
• 24:28
  SPEAKER_00: Schedule it explicitly, and decouple your creation velocity dashboards from your verification velocity dashboards.
• 24:36
  SPEAKER_00: They are no longer measuring the same thing.
• 24:40
  SPEAKER_00: Takeaway three: Invest in specification discipline, not just AI tooling.
• 24:46
  SPEAKER_00: The market for AI coding tools is enormous.
• 24:49
  SPEAKER_00: Every team is evaluating co-pilots, agents, and autonomous workflows.
• 24:54
  SPEAKER_00: That investment is reasonable, but the research is unequivocal.
• 24:59
  SPEAKER_00: The model's capability is not the binding constraint on software quality in AI-assisted development.
• 25:06
  SPEAKER_00: The binding constraint is the quality and precision of the human written specifications that govern the model.
• 25:13
  SPEAKER_00: The organizations that win the next decade will be those that train engineers to write tight, deterministic, exhaustive behavioral specifications before code generation, that adopt test-driven agentic development as a core engineering discipline, and that use tools like GitHub's Spec Kit to formalize and scale that discipline.
• 25:36
  SPEAKER_00: These are not nice-to-haves.
• 25:38
  SPEAKER_00: They are the difference between an AI investment that delivers and one that creates a sprawling, fragile code base that costs more to maintain than it saved to build.
• 25:48
  SPEAKER_00: The marginal cost of generating code has hit near zero.
• 25:53
  SPEAKER_00: But the cost of building something reliable, something you would trust with your customers' data, your company's reputation, your own name on the product, that cost has not dropped one dollar.
• 26:04
  SPEAKER_00: It has simply moved from the keyboard to the specification document, from implementation to governance.
• 26:12
  SPEAKER_00: Alright, let's land this plane.
• 26:14
  SPEAKER_00: Three insights to take with you.
• 26:17
  SPEAKER_00: 1.
• 26:18
  SPEAKER_00: Kokomo, the 40-year formula that has governed software cost estimation since 1981, has been mathematically broken by generative AI because lines of code no longer correlate with human effort.
• 26:31
  SPEAKER_00: The size variable is meaningless, the scaling exponent is miscalibrated, the personnel multipliers are inverted, every variable in the formula has failed simultaneously.
• 26:42
  SPEAKER_00: 2.
• 26:43
  SPEAKER_00: The productivity reliability paradox shows that AI tools nearly double raw code output while degrading software reliability and slowing your most experienced engineers, because the verification tax absorbs the efficiency gains downstream in QA, security review, and architectural governance.
• 27:03
  SPEAKER_00: 3.
• 27:04
  SPEAKER_00: The new science of software economics, Kokomo 3's AI assistance usage driver, AI adjusted function point analysis, the hybrid intelligence framework, and the specification governance model tells us that software cost has not decreased, it has transformed into the cost of governing AI precisely and verifying its output rigorously.
• 27:26
  SPEAKER_00: Specificity is the new competitive moat.
• 27:30
  SPEAKER_00: If this episode gave you something genuinely useful, and I hope it did, here is what I am asking.
• 27:36
  SPEAKER_00: Hit subscribe wherever you listen.
• 27:38
  SPEAKER_00: Leave a review.
• 27:39
  SPEAKER_00: It takes 6-0 seconds, and it is one of the most effective ways to help new listeners find the show.
• 27:45
  SPEAKER_00: And share this with one person in tech or product management who would benefit from hearing it.
• 27:50
  SPEAKER_00: Just one.
• 27:50
  SPEAKER_00: The show notes have direct links to all the research cited today.
• 27:54
  SPEAKER_00: Two papers I especially want you to read: Sabri Farg's 2026 Productivity Reliability Paradox paper.
• 28:01
  SPEAKER_00: Find it on Archive, reference 2605.1160, and the Alice Wad, Puvamol, and Aljadou Hybrid Intelligence Framework paper in Frontiers and Artificial Intelligence.
• 28:14
  SPEAKER_00: Both are open access.
• 28:16
  SPEAKER_00: Both will change how you think about building software with AI.
• 28:20
  SPEAKER_00: I'm Will, this is Minecast.
• 28:22
  SPEAKER_00: AI did not make software free.
• 28:25
  SPEAKER_00: It made the thinking more expensive.
• 28:28
  SPEAKER_00: See you next week.