Machine Learning Street Talk · Published 2026-03-03

The Dangerous Illusion of AI Coding? - Jeremy Howard

privateReview: unreviewedConfidence: high
llmsoftware engineeringinterpolationcognitive frictiontech debtsoftware-engineeringtech-debtcognitive-frictionspaced-repetitiondeveloper-productivityagent-evaluation
Open on YouTube ↗

Summary

Overview

  • Speaker: Jeremy Howard (interviewed by Tim Scarfe)
  • Channel: Machine Learning Street Talk
  • Main topic: The realities, illusions, and systemic risks of LLM-based software engineering and AI coding tools.
  • Purpose: To dissect the real-world utility, limitations, and cognitive traps of AI coding tools, separating hype from engineering reality. Jeremy Howard, deep learning pioneer and Kaggle grandmaster, sits down with Tim Scarfe on Machine Learning Street Talk to critically examine the current state of AI-assisted coding and large language models. They discuss how LLMs operate via interpolation across training corpora rather than true understanding, the dangerous illusion of control that AI coding tools provide, the problem of software engineering maintenance and tech debt, how knowledge is non-fungible and requires friction to form, the meta-lesson from Anthropic's C compiler experiment, and why treating AI as a replacement for human software engineering is a recipe for corporate obsolescence.

Topic Map

LLMs, Cosplay Understanding, and Interpolation

  • Explanation: Discussion on how large language models perform style transfer and interpolation across training data rather than genuinely reasoning about code or systems.
  • Key claims:
    • LLMs cosplay understanding by generating likely token sequences based on statistical correlations.
    • Fine-tuning models on a corpus allows them to predict the next word or token with high fidelity, but they lack out-of-distribution generalization.
    • Coding is a style-transfer and interpolation problem, which fits LLM strengths well within their training distribution.
  • Examples:
    • Fine-tuning a language model on movie reviews and predicting next tokens.
    • Anthropic's C compiler experiment replicating known open-source compiler structures.
  • Terminology:
    • LLM
    • interpolation
    • style transfer
    • training distribution
  • Why it matters: Understanding that LLMs interpolate rather than reason prevents misplaced reliance on AI for novel architectural design.

The Illusion of Control and Slot Machine Dynamics

  • Explanation: How AI-based coding tools act like slot machines, giving users a false sense of agency through prompting while hiding the underlying deterministic mechanics.
  • Key claims:
    • AI coding tools offer an illusion of control where users craft prompts and pull a lever.
    • When code fails, users tweak prompts and pull the lever again, creating a stochastic reinforcement loop.
    • This mimics gambling addiction dynamics, leaving developers drained and stressed.
  • Examples:
    • Spending hours tweaking prompts to get Claude Code to pass tests without deep understanding.
  • Terminology:
    • slot machine dynamics
    • stochastic reinforcement
    • illusion of control
  • Why it matters: Recognizing the slot machine effect helps developers avoid burning out on unproductive prompt engineering cycles.

Software Engineering, Maintenance, and Tech Debt

  • Explanation: Analysis of why software engineering is fundamentally about managing complexity, edge cases, and ongoing maintenance rather than typing code quickly.
  • Key claims:
    • Software engineering is an unusual discipline where typing code is a tiny fraction of the work.
    • Generating code quickly via AI without understanding creates massive technical debt.
    • Organizations relying entirely on AI-generated code without maintaining human engineering muscles will fail.
  • Examples:
    • The METR study showing developer productivity actually dropping when using AI tools on complex tasks.
    • Windows and macOS codebases deteriorating over decades despite advanced tooling.
  • Terminology:
    • technical debt
    • maintenance
    • complexity science
    • actor pattern
  • Why it matters: Failing to distinguish between writing code and software engineering leads to organizational collapse.

Knowledge is Non-Fungible and Requires Friction

  • Explanation: Exploration of cognitive science principles showing that memory and understanding require friction and active struggle to form.
  • Key claims:
    • Knowledge is protean and perspectival; it cannot be treated as a static database of facts.
    • Spaced repetition and active recall demonstrate that forgetting curves require friction to overcome.
    • Delegating cognitive tasks to AI erodes organizational and individual competence over time.
  • Examples:
    • Ebbinghaus spaced repetition research and Leitner system flashcards.
    • Jeremy Howard learning Chinese for 10 years using Anki.
  • Terminology:
    • spaced repetition
    • non-fungible knowledge
    • cognitive friction
    • protean knowledge
  • Why it matters: Eliminating friction in learning and coding destroys the development of human expertise.

Key Points

AI Coding Tools are Style Transfer Machines

  • Explanation: LLMs trained on code repositories interpolate between known examples and styles rather than inventing new paradigms.
  • Evidence: Anthropic's C compiler experiment reproduced existing open-source compiler patterns from training data without inventing novel compiler architectures.
  • Practical implication: Do not expect LLMs to solve problems outside their training distribution.

Productivity Paradox in AI Coding

  • Explanation: While writing lines of code becomes faster, overall software engineering productivity can decrease due to debugging and verification overhead.
  • Evidence: METR study data showing developers taking longer to complete complex tasks with AI assistance.
  • Practical implication: Measure software engineering success by maintenance and slope, not raw line-of-code output.

Knowledge Erosion Through Delegation

  • Explanation: Outsourcing thinking to AI erodes human skill, leading to organizational atrophy.
  • Evidence: Call center and customer service examples where automation prevents institutional adaptation.
  • Practical implication: Maintain human-in-the-loop workflows that preserve cognitive engagement and skill growth.

Frameworks, Models & Processes

The Slope vs. Y-Intercept Framework

  • How it works: Focusing on continuous growth rate (slope) rather than starting capability (y-intercept) for long-term success.
  • Components:
    • Y-intercept (initial capability)
    • Slope (rate of growth and learning)
  • When to use: When deciding whether to rely on static tools vs. cultivating human engineering growth.

Cognitive Friction Learning Model

  • How it works: Knowledge retention and deep understanding require deliberate friction, spaced repetition, and struggle.
  • Components:
    • Active recall
    • Desirable difficulty
    • Spaced repetition
  • When to use: When designing educational curricula or deciding when to use AI assistance.

Examples & Case Studies

Anthropic Tasked Opus 4.6 with building a C compiler using agent teams.

  • Illustrates: LLMs can successfully interpolate complex codebases if trained on massive existing corpora.
  • Lesson: The result is a clean-room implementation of existing compiler design, not a fundamental breakthrough in computer science.

METR study on experienced open-source developers using AI tools.

  • Illustrates: Developers using AI took 19% longer to complete issues despite predicting they would speed up.
  • Lesson: AI assistance introduces verification and coordination overhead that counters raw code generation speed.

Actionable Takeaways

  • Immediate:
    • Recognize the slot machine effect of prompt engineering.
    • Incorporate cognitive friction into learning routines rather than relying entirely on AI summaries.
  • Strategic:
    • Prioritize slope (team learning and adaptability) over static output speed.
    • Maintain human engineering ownership to avoid institutional brain drain.
  • Questions to investigate:
    • How do we bridge the gap between AI code generation and long-term codebase maintenance?
    • What is the optimal balance of AI delegation in complex software systems?

Claims Worth Verifying

  • METR study showed developers took 19% longer to complete issues with AI tools. (empirical study result)
  • Anthropic's C compiler experiment used agent teams running in parallel over two weeks. (industry benchmark)

Notable Quotes

"The difference between pretending to be intelligent and actually being intelligent is entirely unimportant as long as you're in the region in which the pretence is actually effective." (at 0:38) "If you focus on just driving out results at the limit of whatever AI can do right now, you're only caring about the intercept." (at 75:11)

Compressed Summary

  • LLMs interpolate training data rather than reason.
  • AI coding tools create slot-machine addiction dynamics.
  • Software engineering is about maintenance and complexity, not typing code.
  • Knowledge requires friction and spaced repetition to form.
  • Keywords: llm, software engineering, interpolation, cognitive friction, tech debt
  • Core insight: AI coding tools accelerate code generation through interpolation, but software engineering success depends on human cognitive growth, maintenance, and managing complexity.

Core insights

7
Mental Modelmedium noveltymoderate evidence

LLM code generation is explicitly framed as interpolation/style transfer within the training distribution — capable of high-fidelity next-token prediction on a corpus but lacking out-of-distribution generalization, so code generation succeeds precisely because coding is a style-transfer problem that matches LLM strengths.

Why it matters

It gives an architectural boundary rule: delegate tasks whose solution space is densely covered by training data (idiomatic code, known compiler patterns, boilerplate) and keep human ownership of tasks requiring novel architecture or out-of-distribution design.

Generalization

Any agentic system's competence should be scoped by coverage of its training/interpolation manifold rather than by apparent fluency; fluency is not evidence of generalization.

LLMs cosplay understanding by generating likely token sequences based on statistical correlations.
Open source video
Fine-tuning models on a corpus allows them to predict the next word or token with high fidelity, but they lack out-of-distribution generalization.
Open source video
Coding is a style-transfer and interpolation problem, which fits LLM strengths well within their training distribution.
Open source video
Empirical Resulthigh noveltymoderate evidence

The Anthropic C compiler experiment is re-interpreted as a replication of existing open-source compiler structures via interpolation across training corpora, not a computer-science breakthrough — a clean-room reimplementation of known designs.

Why it matters

It undercuts using impressive agentic code demos as evidence of paradigm-invention capability; teams should test whether an agent produces a genuinely novel architecture or a memorized-adjacent reproduction before betting strategy on it.

Generalization

Benchmarks that only check whether a complex artifact can be built will be passed by interpolation; only tasks with no close training analog discriminate real generalization.

Anthropic's C compiler experiment replicating known open-source compiler structures.
Open source video
The result is a clean-room implementation of existing compiler design, not a fundamental breakthrough in computer science.
Open source video
Empirical Resulthigh noveltymoderate evidence

METR data is cited showing experienced open-source developer productivity actually dropping when using AI tools on complex tasks, despite faster line-of-code writing — the productivity paradox comes from debugging and verification overhead.

Why it matters

It argues for measuring engineering productivity by maintenance burden and growth rate (slope) rather than output volume, and for budgeting verification cost explicitly in any AI-coding workflow.

Generalization

Agent productivity metrics based on generation volume systematically misprice systems whose cost center is verification and long-term maintenance.

The METR study showing developer productivity actually dropping when using AI tools on complex tasks.
Open source video
Measure software engineering success by maintenance and slope, not raw line-of-code output.
Open source video
Failure Modemedium noveltyweak evidence

AI coding tools create a slot-machine dynamic: the user crafts a prompt and 'pulls the lever', and on failure tweaks the prompt and pulls again, forming a stochastic reinforcement loop that mimics gambling addiction.

Why it matters

It identifies a specific human-in-the-loop failure pattern — non-convergent prompt iteration without model-building — that burns developer hours and produces code the developer cannot reason about, which should be detected and broken by workflow design.

Generalization

Any interactive agent loop with stochastic success and fast retry exposes operators to variable-ratio reinforcement; harnesses should cap retries and force explicit hypothesis formation between attempts.

AI coding tools offer an illusion of control where users craft prompts and pull a lever.
Open source video
When code fails, users tweak prompts and pull the lever again, creating a stochastic reinforcement loop.
Open source video
This mimics gambling addiction dynamics, leaving developers drained and stressed.
Open source video
Mechanismmedium noveltymoderate evidence

Knowledge is claimed to be protean and perspectival rather than a static fact database, and cognitive friction (active recall, desirable difficulty, spaced repetition) is required to form it — so delegating thinking to AI erodes individual and organizational competence.

Why it matters

It frames AI delegation as a competence-depletion mechanism with organizational consequences: human-in-the-loop workflows should be designed to preserve cognitive engagement, not merely to keep a human present.

Generalization

Automation that removes the friction required for skill formation trades short-term throughput for long-term loss of adaptive capacity in the organization.

Knowledge is protean and perspectival; it cannot be treated as a static database of facts.
Open source video
Delegating cognitive tasks to AI erodes organizational and individual competence over time.
Open source video
Eliminating friction in learning and coding destroys the development of human expertise.
Open source video
Mental Modellow noveltymoderate evidence

Software engineering is reframed as complexity, edge-case, and maintenance management where typing code is a tiny fraction of the work, so generating code quickly without understanding manufactures technical debt rather than engineering value.

Why it matters

It locates the real cost of AI-assisted development in the abstraction boundary between writing and owning code, implying review, ownership, and maintenance responsibilities should scale with generated volume.

Generalization

Systems optimizing the visible cheap step of a pipeline while ignoring the dominant hidden step will degrade total throughput and quality.

Software engineering is an unusual discipline where typing code is a tiny fraction of the work.
Open source video
Generating code quickly via AI without understanding creates massive technical debt.
Open source video
Mental Modelmedium noveltyweak evidence

The slope-versus-y-intercept framework: long-term success depends on the continuous growth rate (slope) of capability rather than initial capability (y-intercept), implying static tool reliance should be traded against cultivating human engineering growth.

Why it matters

It supplies a decision criterion for tooling investment: prefer options that raise the rate of learning and adaptation over options that only raise the starting baseline.

Generalization

Any capability strategy should be evaluated on second-order growth effects, not first-order capability snapshots.

Focusing on continuous growth rate (slope) rather than starting capability (y-intercept) for long-term success.
Open source video

Deep dives

5

Out-of-distribution boundaries for coding agents

Research question

How predictably does coding-agent performance degrade as task distance from the training distribution increases, and can coverage-density estimates predict failures better than apparent fluency?

Why

If agent competence is bounded by interpolation coverage, then task routing, escalation, and benchmark design must be based on distribution distance rather than demo quality or model confidence.

LLMs cosplay understanding by generating likely token sequences based on statistical correlations.
Open source video
Coding is a style-transfer and interpolation problem, which fits LLM strengths well within their training distribution.
Open source video
Source video

Verification-cost accounting for AI-assisted engineering

Research question

Can the METR productivity drop be reproduced and decomposed into prompt iteration, verification, debugging, and rework, and what ratio of generation savings to verification overhead predicts net negative productivity?

Why

If verification is the dominant hidden cost, then productivity dashboards, harness design, and tooling investment must instrument verification effort rather than token or line throughput.

The METR study showing developer productivity actually dropping when using AI tools on complex tasks.
Open source video
Measure software engineering success by maintenance and slope, not raw line-of-code output.
Open source video
Source video

Structural novelty evaluation of agent-built artifacts

Research question

How structurally novel are agent-generated complex artifacts relative to the public corpus, and do such novelty scores discriminate out-of-distribution generalization from interpolated reproduction?

Why

Impressive agentic demos may be clean-room reproductions of known designs; teams need tests that detect interpolation before treating demos as evidence of paradigm-invention capability.

Anthropic's C compiler experiment replicating known open-source compiler structures.
Open source video
The result is a clean-room implementation of existing compiler design, not a fundamental breakthrough in computer science.
Open source video
Source video

Cognitive friction preservation in agent harnesses

Research question

How can an agentic harness preserve the cognitive friction required for skill formation while still automating meaningful work, and what design steps prevent competence depletion?

Why

Delegation that removes human reasoning steps may trade short-term throughput for long-term loss of adaptive organizational capacity.

Eliminating friction in learning and coding destroys the development of human expertise.
Open source video
Delegating cognitive tasks to AI erodes organizational and individual competence over time.
Open source video
Source video

Slot-machine reinforcement loops in AI coding workflows

Research question

Which interaction patterns in AI coding tools produce non-convergent prompt iteration, and can retry caps or forced hypothesis formation measurably break the stochastic reinforcement loop?

Why

Prompt iteration without model-building burns developer hours and produces code the developer cannot reason about, so the loop should be detected and broken by workflow design.

When code fails, users tweak prompts and pull the lever again, creating a stochastic reinforcement loop.
Open source video
This mimics gambling addiction dynamics, leaving developers drained and stressed.
Open source video
Source video

Article ideas

4

Fluency Is Not Generalization: Why Coding Agents Need Interpolation-Manifold Routing

Coding agents should be routed by training-distribution coverage, not by how convincingly they appear to reason, because high-fidelity token prediction on known patterns is not evidence of out-of-distribution generalization.

Angle

Translate the interpolation/style-transfer framing into an engineering routing rule for agentic systems, with escalation criteria for novel architecture.

Source video

Stop Measuring AI Coding in Lines: Verification Is the Real Cost Center

AI coding productivity must be measured by maintenance burden and capability slope rather than generation volume, because verification and debugging overhead can flip net productivity negative on complex tasks.

Angle

Use the METR productivity paradox to argue for verification-cost instrumentation as the primary metric of AI-assisted engineering.

Source video

The Compiler That Wasn't: Detecting Interpolated Demos Before Betting Strategy

Agent-built complex artifacts should be scored for structural novelty against known corpora before they are treated as evidence of generalization, because clean-room reproduction of known designs is not a computer-science breakthrough.

Angle

Re-interpret the Anthropic C compiler experiment as an interpolation test case and propose structural-novelty benchmarks.

Source video

Friction Is Not Waste: Designing Agent Harnesses That Preserve Human Competence

Human-in-the-loop agent workflows should deliberately retain cognitive friction, because automation that removes the effort required for skill formation erodes the individual and organizational competence on which delegation depends.

Angle

Turn the knowledge-formation argument into concrete harness design patterns such as forced hypothesis formation, explanation, and recall steps.

Source video

Project ideas

4

Coverage Router

beyond-evals

Task routers that estimate training-coverage density and route out-of-distribution coding tasks to humans will reduce downstream defect and maintenance rates compared with fluency-based or confidence-based routing.

Proof of concept

Build a router that classifies incoming coding tasks by embedding distance, model uncertainty, and novelty signals, then routes them to an agent, a human, or a hybrid workflow.

Measurement

Routing accuracy against expert labels, downstream defect density, rework rate, and maintenance cost per merged task.

Source video

Verification Cost Ledger

movement-lab

Instrumenting AI-assisted developer sessions will show that verification, debugging, and rework dominate time on complex tasks, and that generation-speed gains predict net productivity loss when verification ratio exceeds a measurable threshold.

Proof of concept

Create session telemetry that attributes time to prompt iteration, verification, debugging, and rework, then compare AI-assisted and control tasks on identical objectives.

Measurement

Net task completion time, verification-to-generation time ratio, defect escape rate, and rework time.

Source video

Structural Novelty Benchmark

beyond-evals

Coding benchmarks requiring genuinely novel architectural artifacts will discriminate interpolation from generalization, and agent solutions will score low on structural novelty against public corpora even when functional tests pass.

Proof of concept

Build a benchmark of novel architecture tasks with no close training analog and score solutions using AST/graph diffs, corpus similarity, and human expert novelty ratings.

Measurement

Structural novelty score, corpus similarity score, expert novelty rating, and correlation with out-of-distribution task performance.

Source video

Friction Harness

gatehouse

Forcing explicit hypothesis formation, explanation, or recall between agent retry attempts will reduce blind prompt iteration and increase developer comprehension without unacceptable throughput loss.

Proof of concept

Implement an agent harness that gates each retry behind a structured hypothesis and explanation step, then A/B test it against unrestricted prompt iteration.

Measurement

Retry count, time-to-convergence, developer comprehension checks, and defect rate.

Source video

Architectural implications

3

Verification and debugging overhead now dominates the AI-coding cost model, not generation.

Before

Productivity measured and optimized by lines of code or generation speed.

After

Productivity measured by maintenance burden and capability slope, with verification cost budgeted per task.

Consequence

Harnesses, tooling, and evaluations must instrument verification effort and long-term code ownership, not token or line throughput.

Source video

Agents are scoped by their interpolation manifold rather than by apparent fluency.

Before

Route tasks to agents based on how convincingly they appear to reason.

After

Route tasks by whether the problem space is densely covered by the training distribution, reserving novel architecture for humans.

Consequence

Task routers and capability boundaries become distribution-coverage problems, requiring explicit OOD detection or escalation criteria.

Source video

Delegation erodes the competence the delegation depends on.

Before

Treat AI assistance as a pure leverage multiplier with no effect on human skill.

After

Design workflows that preserve cognitive friction and active engagement of the human operator.

Consequence

Memory/context design and workflow automation must deliberately retain human reasoning steps rather than removing them for throughput.

Source video

Tradeoffs and failure modes

4

AI-assisted coding on complex tasks

Benefit

Faster generation of lines of code.

Cost or risk

Overall developer productivity can drop due to debugging and verification overhead, with productivity loss observed in the METR study.

The METR study showing developer productivity actually dropping when using AI tools on complex tasks.
Open source video
Source video

Prompt iteration as a control interface

Benefit

Fast retries and apparent agency over the model.

Cost or risk

Stochastic reinforcement loop that mimics gambling addiction dynamics, draining and stressing developers without building understanding.

This mimics gambling addiction dynamics, leaving developers drained and stressed.
Open source video
Source video

Outsourcing cognition to AI

Benefit

Short-term throughput and reduced effort on cognitive tasks.

Cost or risk

Erosion of individual and organizational competence over time.

Delegating cognitive tasks to AI erodes organizational and individual competence over time.
Open source video
Source video

Organizational reliance on AI-generated code

Benefit

Scaling code output without proportional hiring.

Cost or risk

Failure of organizations that stop maintaining human engineering muscles.

Organizations relying entirely on AI-generated code without maintaining human engineering muscles will fail.
Open source video
Source video

Open questions

5

How can an agentic harness preserve the cognitive friction required for skill formation while still automating meaningful work?

Why unresolved

The summary asserts friction is necessary for knowledge formation and that delegation erodes competence, but gives no mechanism for balancing the two in a working system.

Research direction

Prototype harnesses that force explicit hypothesis formation, explanation, or recall steps between agent attempts, and measure operator learning curves versus throughput.

Source video

What concrete metric operationalizes 'slope' (growth rate of engineering capability) at the team or organization level?

Why unresolved

The slope-versus-y-intercept framework is stated as a decision heuristic without a measurement definition.

Research direction

Define and validate longitudinal proxies for capability growth — e.g., maintenance cost trends, incident resolution, or novel-design throughput — and compare against line-of-code metrics.

Source video

Can LLM-based agents be evaluated for out-of-distribution generalization in coding, and does the Anthropic C compiler result fail such a test?

Why unresolved

The claim that the compiler was a clean-room reimplementation of known designs is a speaker interpretation, not a controlled generalization experiment.

Research direction

Design benchmarks requiring genuinely novel architectural artifacts with no close training analog, and score solutions for structural novelty against known corpora.

Source video

Why does AI assistance measurably slow experienced developers on complex tasks — verification cost, context switching, or over-trust in generated code?

Why unresolved

The summary reports the METR result but does not decompose the cause of the slowdown.

Research direction

Instrument developer sessions to attribute time to prompt iteration, verification, debugging, and rework.

Source video

Which tasks should be routed to agents versus humans given interpolation-bound competence?

Why unresolved

The distribution-coverage boundary is described qualitatively but not operationalized.

Research direction

Build task routers that estimate training-coverage density and measure routing accuracy against downstream defect and maintenance rates.

Source video

Key claims

8
causalVerification needed

LLMs generate likely token sequences from statistical correlations and do not genuinely understand; they lack out-of-distribution generalization.

Evidence

LLMs cosplay understanding by generating likely token sequences based on statistical correlations.

Question

Does performance on coding benchmarks degrade predictably as task distance from training distribution increases?

Source video
causalVerification needed

AI coding tools increase code-writing speed but overall software engineering productivity can decrease for complex tasks.

Evidence

The METR study showing developer productivity actually dropping when using AI tools on complex tasks.

Question

Can the METR productivity drop be reproduced and attributed to verification/debugging overhead rather than task selection?

Source video
comparativeVerification needed

Anthropic's agent-built C compiler reproduced existing open-source compiler patterns rather than inventing a new architecture.

Evidence

The result is a clean-room implementation of existing compiler design, not a fundamental breakthrough in computer science.

Question

How structurally novel is the generated compiler relative to the public corpus of compiler implementations?

Source video
causalVerification needed

Generating code quickly via AI without understanding creates massive technical debt.

Evidence

Generating code quickly via AI without understanding creates massive technical debt.

Question

Do codebases with high AI-generated share exhibit measurably higher maintenance cost or defect density over time?

Source video
opinionVerification not requested

Knowledge is protean and perspectival and cannot be treated as a static database of facts.

Evidence

Knowledge is protean and perspectival; it cannot be treated as a static database of facts.

Source video
predictionVerification needed

Delegating cognitive tasks to AI erodes individual and organizational competence over time.

Evidence

Delegating cognitive tasks to AI erodes organizational and individual competence over time.

Question

Do teams that delegate more reasoning to AI show declining independent problem-solving performance in longitudinal studies?

Source video
factualVerification needed

Software engineering work is dominated by maintenance and complexity management, with typing code a tiny fraction of the effort.

Evidence

Software engineering is an unusual discipline where typing code is a tiny fraction of the work.

Question

What fraction of engineering time is attributable to writing new code versus maintenance, review, and complexity management?

Source video
opinionVerification not requested

Long-term success depends on capability growth rate (slope) rather than initial capability (y-intercept).

Evidence

Focusing on continuous growth rate (slope) rather than starting capability (y-intercept) for long-term success.

Source video

Connections

5