AI Engineer · Published 2026-04-23

"Software Fundamentals Matter More Than Ever" — Matt Pocock

privateReview: unreviewedConfidence: high
software architectureai engineeringdomain-driven designtdddeep modulesai-coding-agentsdeep-modulesdomain-driven-designubiquitous-languagefeedback-loopscodebase-architecturecontext-engineering
Open on YouTube ↗

Summary

Overview

  • Speaker: Matt Pocock
  • Channel: AI Engineer
  • Main topic: Why software engineering fundamentals and code quality are more critical than ever in the age of AI coding tools
  • Purpose: To comfort developers worried about their skillset becoming obsolete and to provide practical tips for using AI coding tools effectively by applying proven software engineering design principles. Matt Pocock argues against the notion that software fundamentals are dead in the era of AI. Through six common failure modes experienced when using AI coding assistants (such as the AI not doing what you want, verbosity, code not working, doing too much, lacking code understanding, and cognitive overload), he demonstrates that bad code is more expensive than ever. Good codebases and foundational practices like ubiquitous language, Test-Driven Development (TDD), and deep modules (grey boxes) are essential to successfully leverage AI coding capabilities.

Topic Map

The Specs-to-Code Fallacy

  • Explanation: The flawed idea that developers can just write specs, let AI write code, and if something breaks, change specs without looking at the code. This leads to compounding complexity and garbage code.
  • Key claims:
    • Running the compiler over and over on unmanaged AI output leads to garbage code
    • Code is not cheap; bad code is the most expensive it has ever been
  • Examples:
    • Specs -> Code -> Worse Code -> Even Worse Code -> Garbage
  • Terminology:
    • Specs to code
    • Software entropy
    • Complexity
  • Why it matters: Ignoring code structure and relying solely on AI generation creates unmaintainable codebases that prevent developers from harnessing AI's true benefits.

Failure Mode 1 & Tip 1: Shared Design Concept

  • Explanation: Addressing the failure where AI doesn't do what you want by borrowing concepts from Frederick P. Brooks ('The Design of Design') on establishing a shared design concept before coding.
  • Key claims:
    • No-one knows exactly what they want initially
    • Using a skill like /grill-me forces the AI to relentlessly interview the user until a shared understanding is reached
  • Examples:
    • Using the /grill-me skill to walk down each branch of the design tree before creating code
  • Terminology:
    • Design concept
    • /grill-me
    • Plan mode
  • Why it matters: Reaching a shared design concept prevents communication barriers and misaligned requirements between the human and the AI.

Failure Mode 2 & Tip 2: Ubiquitous Language

  • Explanation: Fixing AI verbosity and miscommunication by establishing a shared vocabulary derived from Domain-Driven Design (Eric Evans).
  • Key claims:
    • A ubiquitous language aligns developer, domain expert, and AI conversations
    • Creating a UBIQUITOUS_LANGUAGE.md file improves planning and implementation precision
  • Examples:
    • Creating and referencing UBIQUITOUS_LANGUAGE.md while prompting the AI
  • Terminology:
    • Ubiquitous language
    • Domain-driven design
    • Domain model
  • Why it matters: A shared vocabulary reduces ambiguity and helps the AI think and write in concise, domain-aligned terms.

Failure Mode 3, 4 & Tip 3: Feedback Loops & TDD

  • Explanation: Tackling code that doesn't work and AI doing too much by enforcing strict feedback loops, static types, browser access, automated tests, and Test-Driven Development.
  • Key claims:
    • The rate of feedback is your speed limit
    • TDD forces the LLM to take small, deliberate steps rather than generating massive blocks of untested code
  • Examples:
    • Writing a test first, making it pass, then refactoring
  • Terminology:
    • Feedback loops
    • TDD
    • Speed limit
  • Why it matters: Without proper feedback loops and small steps, AI tends to outrun headlights and produce broken code.

Failure Mode 5, 6 & Tip 4, 5: Deep Modules & Grey Boxes

  • Explanation: Solving AI misunderstanding and brain overload by structuring codebases into deep modules with simple interfaces and hidden complexity, inspired by John Ousterhout.
  • Key claims:
    • Shallow modules create tiny blobs that are hard for both humans and AI to understand and explore
    • Deep modules act as grey boxes where you design the interface and delegate implementation
  • Examples:
    • /improve-codebase-architecture skill to deepen modules and organize boundaries
  • Terminology:
    • Deep modules
    • Shallow modules
    • Grey boxes
    • Simple interface
  • Why it matters: Structuring code into deep modules saves mental energy and allows both developer and AI to interact via clean, testable boundaries.

Key Points

Code is not cheap; bad code is the most expensive it has ever been

  • Explanation: While AI makes generating lines of code cheap, bad codebases prevent you from utilizing AI effectively.
  • Evidence: Comparing software entropy and Ousterhout's definition of complexity.
  • Practical implication: Invest in codebase architecture and software fundamentals daily.

The rate of feedback is your speed limit

  • Explanation: Large AI tasks lead to failures. Small steps and fast feedback keep development on track.
  • Evidence: Pragmatic Programmer principles applied to AI code generation.
  • Practical implication: Use TDD and small prompts to avoid outrunning your headlights.

Design the interface, delegate the implementation

  • Explanation: Treat deep modules as grey boxes where boundaries and interfaces are human-designed, while implementation is delegated to AI.
  • Evidence: Contrasting flat shallow module grids with well-bounded deep module architectures.
  • Practical implication: Focus your brain on high-level system design and let AI handle tactical implementation details.

Frameworks, Models & Processes

The AI Engineering Design Framework

  • How it works: Combines traditional software design principles with AI agent skills to maintain high codebase quality and alignment.
  • Components:
    • Shared Design Concept (/grill-me)
    • Ubiquitous Language (UBIQUITOUS_LANGUAGE.md)
    • Tight Feedback Loops (Types, browser access, TDD)
    • Deep Modules & Grey Box Architecture (/improve-codebase-architecture)
  • When to use: When building and maintaining applications with AI coding agents.

Examples & Case Studies

Running compiler loops blindly on specs without code inspection

  • Illustrates: Software entropy and the specs-to-code fallacy
  • Lesson: Blindly generating code without foundational design leads directly to garbage code.

Actionable Takeaways

  • Immediate:
    • Use prompt skills like /grill-me to establish requirements before coding
    • Establish a ubiquitous language markdown file for domain terminology
    • Enforce TDD to limit AI task size and ensure test coverage
  • Strategic:
    • Invest in software architecture and design fundamentals every day
    • Refactor codebases into deep modules with simple interfaces
    • Act as a strategic programmer guiding tactical AI execution
  • Questions to investigate:
    • How do we structure codebases for optimal AI comprehension?
    • What are the best patterns for managing AI context and memory?

Claims Worth Verifying

  • Bad code is the most expensive it's ever been (theoretical)
  • Deep modules with simple interfaces improve AI comprehension and reduce cognitive load (empirical)

Notable Quotes

"It Ain't Broke: Why Software Fundamentals Matter More Than Ever" (at 0:18) "Complexity is anything related to the structure of a software system that makes it hard to understand and modify the system." (at 4:02) "Bad code is the most expensive it's ever been" (at 6:40) "The rate of feedback is your speed limit. Never take on a task that's too big." (at 18:17) "Invest in the design of the system every day." (at 28:18)

Compressed Summary

  • Software fundamentals matter more than ever in the AI era
  • Avoid the specs-to-code fallacy and software entropy
  • Use /grill-me for shared design concepts and plan mode
  • Establish ubiquitous language across prompts and codebase
  • Enforce TDD and tight feedback loops to prevent AI runaway errors
  • Structure code into deep modules and grey boxes to reduce cognitive load
  • Keywords: software architecture, ai engineering, domain-driven design, tdd, deep modules
  • Core insight: AI coding tools amplify existing codebase quality: good codebases become exponentially more productive, while bad codebases collapse into expensive garbage.

Core insights

6
Architecturehigh noveltymoderate evidence

Module depth is reframed as an agent-comprehension property, not just a human-maintainability property: shallow modules decompose into 'tiny blobs' that both humans and the AI struggle to navigate and explore, while deep modules with simple interfaces act as grey boxes where the human designs the boundary and delegates the interior. This makes codebase shape a direct input to agent performance.

Why it matters

If agent success depends on the navigability of the module graph, then architectural refactoring becomes an investment in agent throughput rather than a purely hygiene activity, and interface design becomes the human's primary artifact.

Generalization

For any agent operating over a large artifact graph (code, schemas, service catalogs, docs), abstraction granularity and interface narrowness govern how much of the system the agent must load and reason about per task.

Shallow modules create tiny blobs that are hard for both humans and AI to understand and explore
Open source video
Deep modules act as grey boxes where you design the interface and delegate implementation
Open source video
Structuring code into deep modules saves mental energy and allows both developer and AI to interact via clean, testable boundaries.
Open source video
Mechanismmedium noveltymoderate evidence

TDD is used as a step-size governor for the model rather than merely a correctness ritual: writing a test first and making it pass constrains the LLM to small deliberate increments instead of emitting large untested blocks. The stated governing metric is feedback rate, framed as the speed limit of the whole system.

Why it matters

It gives a concrete harness-level control for the most common agent failure (outrunning verification) and implies that task decomposition should be driven by feedback latency, not by logical task boundaries.

Generalization

Any agent loop should be bounded by the latency and fidelity of its cheapest verification signal; the loop step size should be derived from time-to-feedback, not from the apparent size of the goal.

The rate of feedback is your speed limit
Open source video
TDD forces the LLM to take small, deliberate steps rather than generating massive blocks of untested code
Open source video
Without proper feedback loops and small steps, AI tends to outrun headlights and produce broken code.
Open source video
Mechanismhigh noveltymoderate evidence

Requirements elicitation is inverted into an agent-driven adversarial interview: a skill (/grill-me) forces the AI to relentlessly interview the user and walk down each branch of the design tree until a shared design concept exists before any code is produced.

Why it matters

It converts a known-human-hard problem (nobody knows what they want initially) into an explicit, repeating pre-code phase owned by the agent, reducing misalignment downstream instead of patching it after generation.

Generalization

For underspecified generative tasks, front-loading an interrogation phase that forces the spec's decision tree to be enumerated is a reusable harness pattern, applicable to config generation, migration plans, and data pipeline design, not just code.

Using a skill like /grill-me forces the AI to relentlessly interview the user until a shared understanding is reached
Open source video
Using the /grill-me skill to walk down each branch of the design tree before creating code
Open source video
No-one knows exactly what they want initially
Open source video
Practicemedium noveltymoderate evidence

Verbosity and miscommunication are treated as symptoms of missing shared vocabulary rather than a prompting defect, and the remedy is a persisted repository artifact (UBIQUITOUS_LANGUAGE.md) that is created and referenced during prompting so developer, domain expert, and AI converge on identical terms.

Why it matters

It moves domain context out of ephemeral prompts and into a versioned, reviewable file, which changes where context management lives in the system and makes terminology drift observable.

Generalization

Long-lived agent systems benefit from externalized, diffable vocabularies/schemas as first-class repo artifacts, because they are cheaper to keep aligned than repeatedly restated prompt context.

Creating a UBIQUITOUS_LANGUAGE.md file improves planning and implementation precision
Open source video
Creating and referencing UBIQUITOUS_LANGUAGE.md while prompting the AI
Open source video
A ubiquitous language aligns developer, domain expert, and AI conversations
Open source video
Failure Modemedium noveltymoderate evidence

The specs-to-code loop is named as a fallacy with a compounding-entropy signature: write specs, generate code, and on failure edit specs without reading the code, producing Specs -> Code -> Worse Code -> Even Worse Code -> Garbage. The speaker's counter-position is that generation cost falling does not make code cheap, because bad code is now the most expensive it has ever been.

Why it matters

It identifies a specific, self-reinforcing loop (compiler-as-oracle with no code inspection) that degrades a codebase faster than the generation speed that feeds it, contradicting the common assumption that cheap generation makes quality secondary.

Generalization

Any system where an agent can regenerate artifacts without inspecting the prior artifacts risks runaway complexity accumulation; the loop needs a read/verify step, not just a regenerate step.

Running the compiler over and over on unmanaged AI output leads to garbage code
Open source video
Specs -> Code -> Worse Code -> Even Worse Code -> Garbage
Open source video
Code is not cheap; bad code is the most expensive it has ever been
Open source video
Mental Modelmedium noveltymoderate evidence

Six observed AI-assistant failure modes (not doing what you want, verbosity, code that doesn't work, doing too much, lacking code understanding, cognitive overload) are each mapped to a known classic engineering discipline rather than to model capability gaps, and the fixes are packaged as agent skills the tooling can invoke (/grill-me, /improve-codebase-architecture).

Why it matters

It supplies a diagnostic table: an agent failure signature implies which engineering practice is missing, and whether the fix belongs in the harness (skills) or in the codebase (architecture).

Generalization

Agent failures can be triaged as missing engineering discipline instead of model deficiency, which redirects remediation from prompt tuning to harness and architecture design.

Tackling code that doesn't work and AI doing too much by enforcing strict feedback loops, static types, browser access, automated tests, and Test-Driven Development.
Open source video
/improve-codebase-architecture skill to deepen modules and organize boundaries
Open source video
Solving AI misunderstanding and brain overload by structuring codebases into deep modules with simple interfaces and hidden complexity
Open source video

Deep dives

5

Module depth and interface narrowness as determinants of agent comprehension

Research question

Does increasing module depth (fewer, wider interfaces, hidden interiors) measurably improve agent task success and reduce context/token consumption per task, at constant functionality?

Why

If codebase shape is a direct input to agent performance, then architectural refactoring can be budgeted as agent-capability work, and interface design becomes the human's primary artifact and review surface.

Shallow modules create tiny blobs that are hard for both humans and AI to understand and explore
Open source video
Deep modules act as grey boxes where you design the interface and delegate implementation
Open source video
Structuring code into deep modules saves mental energy and allows both developer and AI to interact via clean, testable boundaries.
Open source video
Source video

Feedback latency as the step-size governor for agent loops

Research question

Is end-to-end agent throughput and acceptance rate bounded by time-to-feedback, such that reducing verification latency proportionally raises completed-task rate and shrinks generated step size?

Why

It converts 'use TDD' from a correctness ritual into a harness-level control parameter, and implies task decomposition should be derived from verification latency rather than from logical task boundaries.

The rate of feedback is your speed limit
Open source video
TDD forces the LLM to take small, deliberate steps rather than generating massive blocks of untested code
Open source video
Without proper feedback loops and small steps, AI tends to outrun headlights and produce broken code.
Open source video
Source video

The generate-regenerate loop without an inspect step and its entropy signature

Research question

Does a spec-edit-and-regenerate loop that never inspects the produced code measurably accelerate complexity growth compared with an identical loop that includes an explicit read/verify step?

Why

It isolates a self-reinforcing degradation loop and contradicts the assumption that falling generation cost makes code quality secondary; remediation is a missing read step, not a better prompt.

Running the compiler over and over on unmanaged AI output leads to garbage code
Open source video
Specs -> Code -> Worse Code -> Even Worse Code -> Garbage
Open source video
Code is not cheap; bad code is the most expensive it has ever been
Open source video
Source video

Persisted domain vocabularies as versioned repo artifacts and their drift

Research question

Which persistent artifact form (glossary file, agent-facing doc, retrieval index) minimizes terminology drift and context cost across long-running projects, and what enforcement keeps it synchronized with code and tests?

Why

It relocates context management from ephemeral prompts into diffable repository state, which changes where context lives and makes terminology drift observable and enforceable.

Creating a UBIQUITOUS_LANGUAGE.md file improves planning and implementation precision
Open source video
Creating and referencing UBIQUITOUS_LANGUAGE.md while prompting the AI
Open source video
A ubiquitous language aligns developer, domain expert, and AI conversations
Open source video
Source video

Agent-driven adversarial interrogation as a reusable pre-generation phase

Research question

Does forcing an agent to enumerate the spec's decision tree before generating anything reduce downstream requirement failures more cheaply than post-generation repair?

Why

It converts a known-human-hard problem into an explicit, repeating pre-code phase owned by the agent, and generalizes beyond code to configs, migration plans, and pipeline design.

Using a skill like /grill-me forces the AI to relentlessly interview the user until a shared understanding is reached
Open source video
Using the /grill-me skill to walk down each branch of the design tree before creating code
Open source video
No-one knows exactly what they want initially
Open source video
Source video

Article ideas

4

Architecture Is Now an Agent Input, Not Just a Human Courtesy

Refactoring toward deep modules is no longer a maintainability chore paid for by human onboarding cost; it is a direct investment in agent throughput, which means interface design quality is the binding constraint on agent reliability and the interface itself becomes the primary review surface.

Angle

Reframe architecture work as capability work: show how shallow-module codebases turn agent tasks into wide-context navigation problems, and argue the human's job migrates from reviewing implementations to designing boundaries.

Source video

Bad Code Is the Most Expensive It Has Ever Been

Cheap generation does not make code cheap: the specs-to-code loop has no read/verify step, so each regeneration cycle deposits unmanaged output that degrades the very codebase the agent must work in next, making quality a throughput variable rather than a hygiene concern.

Angle

Name the entropy loop explicitly and specify the missing step — inspection of prior artifacts — as the fix, rather than arguing for better prompts or larger models.

Source video

Stop Decomposing Tasks by Logic; Decompose Them by Time-to-Feedback

If the rate of feedback is the system's speed limit, then step size should be derived from the latency of the cheapest verification signal rather than from the apparent logical shape of the goal, which reorganizes planning around test runtime, type checking, and browser access instead of task boundaries.

Angle

Turn a slogan into a scheduling rule: walk through how feedback latency sets a hard cap on step size and why easy-but-hard-to-test work is the throughput bottleneck.

Source video

Move Domain Context Out of the Prompt and Into the Repository

Treating verbosity and miscommunication as prompt defects is a category error; persisting a shared vocabulary as a versioned repo artifact makes context diffable and terminology drift observable, at the cost of a permanent synchronization obligation between glossary, code, and tests.

Angle

Argue for externalized vocabularies as first-class repo citizens, then confront the drift problem the approach creates instead of treating the glossary as a one-time artifact.

Source video

Project ideas

4

Agent Comprehension Bench

beyond-evals

At identical functionality, agent task success rate rises and tokens/steps per accepted change fall as module depth increases (fewer, wider interfaces with hidden interiors).

Proof of concept

Implement the same application at three module-granularity levels — many shallow modules, one monolith, deep modules with narrow interfaces — and run an identical task suite against each with the same coding agent, recording navigation and edit traces.

Measurement

Task success rate, tokens per accepted change, tool-call steps, and rate of edits landing in unintended modules, compared across the three granularity variants.

Source video

Feedback-Latency Governor

movement-lab

Accepted-changes-per-hour in an agent loop is bounded by time-to-feedback, so cutting verification latency (test runtime, type-check time, browser round-trip) raises completed-task rate proportionally and shrinks generated step size.

Proof of concept

A harness that measures time-to-feedback per step and automatically caps the agent's step size at that bound, run over a fixed task set against a batch-generation baseline with no such cap.

Measurement

Wall-clock throughput (accepted changes per hour), rework rate per accepted change, and total tokens per accepted change, with and without the latency-derived step cap.

Source video

Glossary Drift Gate

gatehouse

Automated drift detection between persisted glossary terms, code identifiers, and test names reduces agent requirement-conformance failures relative to an unenforced glossary file.

Proof of concept

A checker that maps UBIQUITOUS_LANGUAGE.md terms to identifiers and test names, flags divergence as a blocking gate before agent runs, and injects the reconciled vocabulary into the prompt.

Measurement

Count of detected term/identifier divergences over time, requirement-conformance rate on a fixed task set, and prompt verbosity (tokens spent restating domain context).

Source video

Interrogation-Before-Generation Skill Eval

new

An adversarial pre-code interrogation phase that enumerates the design decision tree reduces requirement-conformance failures per accepted change more cheaply than repairing misaligned output after generation.

Proof of concept

A /grill-me-style skill that iteratively questions the user down each design branch until a shared design concept is recorded, benchmarked against direct generation on the same underspecified task set.

Measurement

Number of design branches resolved pre-code, rework rate, tokens per accepted change, and fraction of generated code discarded after first review.

Source video

Architectural implications

3

The human/agent responsibility split is drawn at the module interface rather than at the line of code.

Before

Humans wrote implementations and reviewed AI output line by line.

After

Humans design interfaces and boundaries; agents own implementation behind those boundaries, and an agent skill refactors the codebase toward deeper modules.

Consequence

The interface becomes the primary review surface and the primary context-passing unit, so interface design quality directly bounds agent reliability.

Source video

Domain context is externalized from prompts into repository artifacts.

Before

Domain terms and constraints were restated per conversation or held in the model's context window.

After

A UBIQUITOUS_LANGUAGE.md file lives in the repo and is referenced during planning and implementation.

Consequence

Context becomes versionable, diffable, and shareable across agents and humans, but introduces a synchronization obligation between the glossary, code, and tests.

Source video

Codebase shape becomes an input variable to agent performance.

Before

Refactoring was justified by human maintainability and onboarding cost.

After

Module depth and interface narrowness are treated as determinants of whether an agent can comprehend and explore the system.

Consequence

Architecture work can be budgeted as agent-capability work, and codebase metrics could be evaluated against agent task success rather than only human effort.

Source video

Tradeoffs and failure modes

4

Tight feedback loops (types, browser access, automated tests, TDD)

Benefit

Small verified steps keep the LLM inside a tight loop, catching breakage before it compounds and preventing large untested generations.

Cost or risk

Every step carries verification and setup overhead; all work must be decomposed to fit the feedback cadence, which caps achievable step size and may slow throughput on tasks that are easy but hard to test.

The rate of feedback is your speed limit
Open source video
Source video

Deep modules as grey boxes

Benefit

Simple interfaces over hidden complexity save mental energy and give both developer and AI a clean, testable boundary to interact through.

Cost or risk

Interfaces must be designed before the implementation is understood, and the delegated interior becomes opaque — correctness lives behind a boundary the human is no longer inspecting.

Deep modules act as grey boxes where you design the interface and delegate implementation
Open source video
Source video

Pre-code adversarial interrogation (/grill-me)

Benefit

Forces the design tree's branches to be resolved up front, producing a shared design concept before any code exists.

Cost or risk

Adds an explicit up-front phase before any output; if the interview is unfocused it consumes effort proportional to the ambiguity rather than to the value of the resulting design.

Using the /grill-me skill to walk down each branch of the design tree before creating code
Open source video
Source video

Regenerating from specs without inspecting code

Benefit

Fast iteration: when output is wrong, adjust the spec and regenerate rather than reading and repairing the artifact.

Cost or risk

Compounding complexity and garbage code; the loop has no read/verify step, so each cycle adds unmanaged output that degrades the codebase the agent must later work in.

Running the compiler over and over on unmanaged AI output leads to garbage code
Open source video
Source video

Open questions

4

How do we structure codebases for optimal AI comprehension?

Why unresolved

The summary asserts shallow modules are hard for AI to explore but provides no measurement of comprehension or task success against module depth or interface surface size.

Research direction

Benchmark agent task success and token/step cost as a function of module depth, interface count, and fan-out in controlled codebases.

Source video

What are the best patterns for managing AI context and memory?

Why unresolved

UBIQUITOUS_LANGUAGE.md and design-concept artifacts are shown as examples, but the summary gives no comparison of artifact formats, retrieval strategies, or staleness handling.

Research direction

Compare persistent artifact styles (glossary files, AGENTS-style docs, retrieval indices) on precision, drift, and context cost across long-running projects.

Source video

Does constraining an LLM to TDD-sized increments reduce total throughput more than it improves first-pass success rate?

Why unresolved

'The rate of feedback is your speed limit' is asserted as a principle but the summary reports no measurement of step size versus success rate or wall-clock cost.

Research direction

A/B agent runs on the same task set with and without test-first step constraints, measuring completion rate, rework, and total tokens per accepted change.

Source video

How does a persisted ubiquitous language stay synchronized with the code and tests it describes?

Why unresolved

The summary presents the glossary as improving planning precision but does not address drift, update triggers, or enforcement.

Research direction

Prototype drift detection that flags identifiers and test names diverging from glossary terms, and measure whether enforcement reduces agent miscommunication.

Source video

Key claims

7
comparativeVerification needed

Bad code is the most expensive it has ever been.

Evidence

Bad code is the most expensive it's ever been (theoretical)

Question

Can cost of poor code quality be measured in an AI-assisted workflow (rework time, agent failure rate, tokens per accepted change) and compared to pre-AI baselines?

Source video
causalVerification needed

Running the compiler repeatedly over unmanaged AI output leads to garbage code.

Evidence

Running the compiler over and over on unmanaged AI output leads to garbage code

Question

Does a generate-compile-regenerate loop without code inspection measurably increase complexity metrics versus a loop with an inspection step?

Source video
causalVerification needed

TDD forces the LLM to take small, deliberate steps rather than generating massive blocks of untested code.

Evidence

TDD forces the LLM to take small, deliberate steps rather than generating massive blocks of untested code

Question

Does test-first prompting reduce unbounded generation and improve acceptance rate relative to batch generation?

Source video
causalVerification needed

The rate of feedback is your speed limit.

Evidence

The rate of feedback is your speed limit

Question

Is end-to-end agent throughput bounded by feedback latency — i.e., does reducing verification time proportionally raise completed-task rate?

Source video
causalVerification needed

Shallow modules create tiny blobs that are hard for both humans and AI to understand and explore.

Evidence

Shallow modules create tiny blobs that are hard for both humans and AI to understand and explore

Question

Does increasing module depth (fewer, wider interfaces) measurably improve agent navigation accuracy and reduce context consumption?

Source video
causalVerification needed

A ubiquitous language aligns developer, domain expert, and AI conversations.

Evidence

A ubiquitous language aligns developer, domain expert, and AI conversations

Question

Does supplying a shared glossary artifact reduce prompt verbosity and increase requirement-conformance rate in agent output?

Source video
causalVerification needed

Large AI tasks lead to failures, while small steps and fast feedback keep development on track.

Evidence

Large AI tasks lead to failures. Small steps and fast feedback keep development on track.

Question

What is the failure-rate curve as a function of agent task size, and where is the inflection point?

Source video

Connections

5