---
title: "Dex Horthy on Why AI Code Is Still Garbage With a Perfect Spec"
date: "2026-09-25"
video_id: "7689426260535086350"
tiktok_url: "https://www.tiktok.com/@wordman.dev/video/7689426260535086350"
creator: "@wordman.dev"
category: "Coding"
tags: ["dex horthy", "ai coding", "tramp data", "leaky abstractions", "humanlayer"]
excerpt: "Dex Horthy says AI agents follow architecture docs to the letter and still ship leaky abstractions and tramp data. What the terms mean and why tests miss them."
---
Dex Horthy, CEO of HumanLayer, says you can hand a coding model a strong architecture doc, watch it follow the doc exactly, and still get code full of leaky abstractions and tramp data. The quote is real and comes from a longer podcast episode. The clip stops before his explanation, which is that both defects pass every test and satisfy every spec, so nothing in the pipeline catches them.

## Where the clip comes from

A TikTok from @wordman.dev, the account of Jan-Niklas Wortmann, posts a short excerpt of Horthy saying "somehow the code is still garbage." Wortmann hosts The Weekly Dev's Brew and works as a JetBrains developer advocate for JavaScript and TypeScript.

The source is episode 21 of the show, ["Dex Horthy - What Actually Gets You 2-3x With AI Coding"](https://www.wordman.dev/podcast/dex-horthy-what-actually-gets-you-2-3x-with-ai-coding/), published 13 August 2026. The published transcript contains the clip's lines word for word, including "you can give it a really good architecture doc and the model can follow it to the letter," "there's still like leaky abstractions, tramp data everywhere," and "Mermaid charts, here's the modules, here's the new endpoints."

The on-screen header in the TikTok reads "The code is still garbage." The spoken line is "But somehow the code is still garbage." The header drops "But somehow," which is the part that carries his surprise.

## Who is Dex Horthy

Horthy is co-founder and CEO of HumanLayer, a Y Combinator Fall 2024 company founded in 2023. He wrote [12-Factor Agents](https://github.com/humanlayer/12-factor-agents), whose Factor 3 is "Own your context window." Before HumanLayer he spent seven years at Replicated, and he started programming at NASA's Jet Propulsion Laboratory.

That background matters here. The author of a context-engineering framework is arguing that good context alone does not produce good code.

## What is tramp data?

Tramp data is a catalogued code smell. [DevIQ](https://deviq.com/code-smells/tramp-data/) defines it as a piece of data that travels through several method calls as a parameter, where the intermediate methods neither use it nor care about it and only pass it along to the next call. Luzkan's code smell catalogue attributes the term to Steve Smith's 2013 course "Refactoring Fundamentals" and traces the idea to Steve McConnell's *Code Complete* (1993).

The phrase sounds like a transcription error. The video's own burned-in captions also render it as "tramp data," so it is what he said.

## What is a leaky abstraction?

The term comes from Joel Spolsky's essay [The Law of Leaky Abstractions](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/), published 11 November 2002. Its central claim is that all non-trivial abstractions are to some degree leaky. In practice a leaky abstraction is a module boundary that forces callers to know about the details it was supposed to hide.

## Why does a perfect spec still produce bad code?

Both defects compile and pass unit tests. A module boundary that leaks and a parameter threaded through four functions that ignore it both satisfy an architecture doc that lists modules and endpoints. The doc specifies structure, and the model already satisfies structure. The defects that remain are the ones nothing in the pipeline measures.

Horthy makes this argument in more detail on [The Pragmatic Engineer](https://newsletter.pragmaticengineer.com/p/context-engineering-with-dex-horthy). He says current coding models are likely trained in a way that makes codebases worse over time, because benchmarks such as SWE-bench reward reproducing known fixes and cannot score a bad architectural decision. His phrasing: "the cost function of bad architecture and bad program design cannot be evaluated by running a unit test."

He gives a specific incident. His team allowed unreviewed code generation starting in July 2025, and production broke within four months. A misrouted primary key spread through the codebase, took days to find, and cost three weeks to re-onboard people onto code they had never read.

He expanded the same argument in a July 2026 AI Engineer World's Fair keynote titled "Why Software Factories Fail," which runs 19:18 on his [AI Engineer speaker page](https://ai.engineer/speakers/dex-horthy). The thesis is that harness engineering (prompts, tool loops and orchestrators stacked on a model) cannot by itself produce a maintainable codebase at scale.

## How much faster does AI coding make you?

The clip leaves out the numbers the full episode is built around. The episode description says you cannot get 10x with AI coding and puts the realistic ceiling at 2-3x, as long as you refuse to ship slop. The episode page quotes Horthy: "You can get 99% of human-quality code, like very good code as if you had written every character by hand, but two to three times faster."

The Pragmatic Engineer interview splits that into two cases:

- Roughly 30-50% lift when a human reviews all AI-generated code.
- 2-3x when the human spends the saved time on design, architecture and key decisions instead of reading every diff.

The same interview gives context-window guidance. Target 300-400K tokens of a 1M window, and stop around 100K on smaller models. Past that point he says the model degrades into what he calls the "dumb zone."

## What Horthy recommends instead

On [Dev Interrupted](https://linearb.io/dev-interrupted/podcast/dex-horthy-humanlayer-rpi-methodology-ralph-loop) he describes RPI, short for Research, Plan, Implement. It is built for brownfield codebases. The agent has to produce intermediate design artifacts and settle architectural decisions before it writes code, so the decisions a unit test cannot check get made and reviewed up front.

## Bottom line

The quote is accurate and comes from a long interview. The two smells he names have standard definitions, and both slip past tests and specs, which is why a model can follow a doc perfectly and still produce them. The full episode and the Pragmatic Engineer interview hold the parts the clip cuts: the 2-3x ceiling, the 30-50% review regime, and RPI as his fix.

## Sources

- [Original TikTok from @wordman.dev](https://www.tiktok.com/@wordman.dev/video/7689426260535086350) - the clip crediting Dex Horthy.
- [Dex Horthy - What Actually Gets You 2-3x With AI Coding](https://www.wordman.dev/podcast/dex-horthy-what-actually-gets-you-2-3x-with-ai-coding/) - episode 21 of The Weekly Dev's Brew, with transcript.
- [The Weekly Dev's Brew](https://www.weeklybrew.dev/) - the show hosted by Jan-Niklas Wortmann.
- [Full episode on YouTube](https://www.youtube.com/watch?v=5FcHP22u0zs) - the video version of the episode.
- [Context engineering with Dex Horthy, The Pragmatic Engineer](https://newsletter.pragmaticengineer.com/p/context-engineering-with-dex-horthy) - SWE-bench argument, the July 2025 incident, speed figures and context thresholds.
- [12-Factor Agents on GitHub](https://github.com/humanlayer/12-factor-agents) - Horthy's framework, including Factor 3.
- [Dex Horthy speaker page, AI Engineer](https://ai.engineer/speakers/dex-horthy) - his background and the "Why Software Factories Fail" talk.
- [HumanLayer on Y Combinator](https://www.ycombinator.com/companies/humanlayer) - batch, founding year and founder.
- [Dex Horthy on Dev Interrupted](https://linearb.io/dev-interrupted/podcast/dex-horthy-humanlayer-rpi-methodology-ralph-loop) - the RPI method.
- [Tramp Data, DevIQ](https://deviq.com/code-smells/tramp-data/) - definition of the smell.
- [Code Smells: Tramp Data, luzkan](https://luzkan.github.io/smells/tramp-data/) - origin of the term.
- [The Law of Leaky Abstractions, Joel on Software](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/) - the 2002 essay.
- [Mermaid](https://mermaid.js.org/) - the diagramming tool Horthy mentions as "mermaid charts."


## Video description and verification notes

**This is a 27-second vertical clip (1080x1920, uploaded 2026-09-25 by @wordman.dev), sitting at 4,079 views, 80 likes, 30 comments, 11 saves, and 0 reposts at capture. TokDoc extracted 14 frames at 2-second intervals. The Whisper transcript runs 89 words across four sentences in four SRT cues, ending at 00:00:27.800. Every frame shows one man in a grey-brown henley and black over-ear headphones, speaking into a large black condenser mic with a pop filter in the lower right, against a textured beige wall. There is no b-roll, no code, no screen recording, and no logo anywhere in the clip. Frames 001 through 003 carry a static white card across the top third with black bold text reading "The code is still garbage."; the card disappears at frame 004 and never returns. Every frame carries a rounded light-grey caption pill at the bottom with the active word in black and the rest in grey, reading in order: "what we have", "working with", "that's like", "because you", "doc", "letter", "in your system", "here's the", "endpoints-", "specified", "is still garbage", "there's still like", "tramp data", "I'll get into why".**

## The burned-in captions and the Whisper transcript agree, including on the term that sounds like a mistranscription

Whisper produced this closing line:

> Somehow there's still like leaky abstractions, tramp data everywhere, and like I'll get into why I think this is.

"Tramp data" reads like an ASR error. It is not. Frame 013 shows the burned-in caption pill rendering "tramp data" with "data" as the active black word, so the video's own captioning pipeline landed on the same two words independently.

I found one discrepancy across all 14 frames. Frame 009 renders the caption as "endpoints-" with a trailing hyphen, while the Whisper transcript writes "here's the new endpoints, is exactly as specified." The hyphen in the burned-in caption marks the speaker breaking off mid-list. The comma in the Whisper output smooths it into a clean clause. Nothing else in the on-screen text conflicts with the audio transcript.

The static header card is a paraphrase rather than a quote. It reads "The code is still garbage." The spoken line at 00:19–00:21 is "But somehow the code is still garbage." The card drops the "But somehow," which is the part carrying the speaker's actual surprise.

## The clip comes from episode 21 of The Weekly Dev's Brew, published 13 August 2026

The description credits "Dex Horthy" and points to "Full ep on YT / Weekly Dev's Brew." Both check out.

@wordman.dev is Jan-Niklas Wortmann, host of The Weekly Dev's Brew and a JetBrains developer advocate for JavaScript and TypeScript. The handle is a translation pun: *Wort* is German for word.

The source episode is ["Dex Horthy - What Actually Gets You 2-3x With AI Coding"](https://www.wordman.dev/podcast/dex-horthy-what-actually-gets-you-2-3x-with-ai-coding/), episode 21, published 13 August 2026. Its published transcript contains the clip's lines verbatim, including "you can give it a really good architecture doc and the model can follow it to the letter," "there's still like leaky abstractions, tramp data everywhere," and "Mermaid charts, here's the modules, here's the new endpoints." The episode chapter list runs past 1:36:50, and chapter 3 is titled "Where AI coding actually fails" at 13:50, which is where this 27 seconds most plausibly sits.

That 13 August 2026 publication date anchors the "last six months" claim in the clip to roughly February through August 2026.

Dex Horthy is co-founder and CEO of HumanLayer, a Y Combinator Fall 2024 company founded in 2023. He wrote [12-Factor Agents](https://github.com/humanlayer/12-factor-agents), whose Factor 3 is "Own your context window." He spent seven years at Replicated before HumanLayer and started programming at NASA's Jet Propulsion Laboratory. That background matters for reading the clip, because "context alone doesn't save you" is the author of a context-engineering framework arguing against over-reading his own framework.

## Both smells he names have documented definitions, so the complaint is checkable

He does not say the code was vaguely bad. He names two specific defects.

**Leaky abstractions** traces to Joel Spolsky's essay [The Law of Leaky Abstractions](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/), published 11 November 2002, which states that all non-trivial abstractions are to some degree leaky.

**Tramp data** is a catalogued code smell. [DevIQ](https://deviq.com/code-smells/tramp-data/) defines it as a piece of data travelling through several method calls as a parameter where the intermediate methods neither use nor care about it and only pass it to the next call. Luzkan's code smell catalogue attributes the specific term to Steve Smith's 2013 course "Refactoring Fundamentals," with the underlying idea drawn from Steve McConnell's *Code Complete* (1993).

Both defects share one property that makes them relevant to the clip's argument. Neither one fails a unit test. A module boundary that leaks and a parameter threaded through four functions that ignore it both compile, both pass, and both satisfy an architecture doc that specifies modules and endpoints.

## Horthy's broader argument explains the mechanism the clip cuts off before reaching

The clip ends on "I'll get into why I think this is" and stops. The why is documented elsewhere.

On The Pragmatic Engineer, Horthy argues that current coding models are likely trained in a way that makes codebases worse over time, because benchmarks such as SWE-bench reward reproducing known fixes and cannot measure a bad architectural decision. His phrasing there: "the cost function of bad architecture and bad program design cannot be evaluated by running a unit test."

He backs this with a specific incident. When his team allowed unreviewed code generation starting in July 2025, production broke within four months. A misrouted primary key propagated through the codebase, took days to locate, and cost three weeks to re-onboard humans onto code they had never read.

He expanded the same argument into a July 2026 AI Engineer World's Fair keynote titled "Why Software Factories Fail," which runs 19:18 on the AI Engineer speaker page. The thesis there is that harness engineering, meaning prompts and tool loops and orchestrators stacked on a model, cannot by itself produce a maintainable codebase at scale.

That chain closes the loop on the clip. A perfect architecture doc specifies structure. Structure is what the model already satisfies. The defects that survive are the ones no artifact in the pipeline measures.

## The 27 seconds omits every number that makes the argument actionable

The hook survives the cut. The quantified claims do not.

The full episode is built around a specific figure. Its own description says you cannot get 10x with AI coding and positions the realistic ceiling at 2-3x, conditional on refusing to ship slop. The episode page quotes Horthy directly: "You can get 99% of human-quality code, like very good code as if you had written every character by hand, but two to three times faster."

The Pragmatic Engineer interview splits that into two regimes: roughly 30-50% lift when a human reviews all AI-generated code, and 2-3x when the human spends the saved time on design, architecture, and key decisions instead of reading every diff. That same interview gives context-window thresholds: target 300-400K of a 1M window, and stop around 100K on smaller models, past which the model degrades into what he calls the "dumb zone."

His proposed remedy is also absent from the clip. On Dev Interrupted he describes RPI, meaning Research, Plan, Implement, a methodology built for brownfield codebases that forces agents to produce intermediate design artifacts and settle architectural decisions before generating code.

A viewer who watches only these 27 seconds receives the diagnosis and none of the dosage.

## Key Takeaways

- The clip is a verbatim excerpt. Every line in the Whisper transcript appears in the published episode transcript for The Weekly Dev's Brew episode 21, dated 13 August 2026.
- "Tramp data" is a real code smell, not an ASR artifact. Frame 013's burned-in caption confirms it, and DevIQ and Luzkan's catalogue both define it, with the term attributed to Steve Smith's 2013 "Refactoring Fundamentals" and the concept to McConnell's *Code Complete* (1993).
- The one audio-to-caption discrepancy is frame 009, which shows "endpoints-" where Whisper wrote "endpoints,". The burned-in hyphen preserves a mid-list break that the transcript smooths over.
- The on-screen header card "The code is still garbage." drops the spoken "But somehow," removing the surprise that is the whole point of the segment.
- Horthy's mechanism, published elsewhere, is that benchmarks reward passing tests and cannot score architecture, so defects that compile and pass survive any spec the model follows correctly.
- The episode's headline number is 2-3x, with 30-50% as the lower regime when a human reviews all generated code. Both come from the episode page and The Pragmatic Engineer interview.
- **Unverified:** the exact timestamp of this 27 seconds inside the 1h36m+ episode. Chapter 3, "Where AI coding actually fails" at 13:50, is the best fit from the published chapter list, but no timestamped transcript I could reach pins the quote. Also unverified: a widely repeated claim that Horthy analysed 100,000 developer sessions and located the "dumb zone" in the middle 40-60% of a large context window. That figure surfaced in search-engine summaries, and I could not find it in the Dev Interrupted episode page or The Pragmatic Engineer article. The only context-window numbers I traced to a primary source are the 300-400K and 100K thresholds in the Pragmatic Engineer interview. Finally, the episode's exact runtime is not published on the episode page; the chapter list only establishes that it exceeds 1:36:50.

## Resources

- [The original TikTok](https://www.tiktok.com/@wordman.dev/video/7689426260535086350) - the 27-second clip, its description crediting Dex Horthy, and the engagement figures cited above.
- [Dex Horthy - What Actually Gets You 2-3x With AI Coding](https://www.wordman.dev/podcast/dex-horthy-what-actually-gets-you-2-3x-with-ai-coding/) - the source episode, number 21, published 13 August 2026, with the chapter list and the transcript containing the clip's lines verbatim.
- [The Weekly Dev's Brew](https://www.weeklybrew.dev/) - confirms Jan-Niklas Wortmann as host and the show's format of long-form interviews with people building the web.
- [What Actually Gets You 2-3x With AI Coding (ft. Dex Horthy) on YouTube](https://www.youtube.com/watch?v=5FcHP22u0zs) - the "Full ep on YT" the description points to.
- [Context engineering with Dex Horthy, The Pragmatic Engineer](https://newsletter.pragmaticengineer.com/p/context-engineering-with-dex-horthy) - source for the SWE-bench argument, the July 2025 unreviewed-generation incident and misrouted primary key, the 30-50% versus 2-3x split, and the 300-400K / 100K context thresholds.
- [12-Factor Agents on GitHub](https://github.com/humanlayer/12-factor-agents) - confirms Horthy's authorship and that Factor 3 is "Own your context window."
- [Dex Horthy speaker page, AI Engineer](https://ai.engineer/speakers/dex-horthy) - confirms his title at HumanLayer, the seven years at Replicated, the JPL start, and the 19:18 "Why Software Factories Fail" talk.
- [HumanLayer on Y Combinator](https://www.ycombinator.com/companies/humanlayer) - confirms the Fall 2024 batch, 2023 founding, and Dexter Horthy as founder and CEO.
- [Dex Horthy on Ralph, RPI, and escaping the "Dumb Zone", Dev Interrupted](https://linearb.io/dev-interrupted/podcast/dex-horthy-humanlayer-rpi-methodology-ralph-loop) - source for RPI meaning Research, Plan, Implement, and for its brownfield framing.
- [Tramp Data, DevIQ](https://deviq.com/code-smells/tramp-data/) - the definition of the smell Horthy names in frame 013.
- [Code Smells: Tramp Data, luzkan](https://luzkan.github.io/smells/tramp-data/) - attributes the term to Steve Smith's 2013 "Refactoring Fundamentals" and the underlying concept to McConnell's *Code Complete* (1993).
- [The Law of Leaky Abstractions, Joel on Software](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/) - the 11 November 2002 origin of the other term Horthy uses.
- [Mermaid](https://mermaid.js.org/) - the text-based diagramming tool Horthy references as "mermaid charts" in the spec artifacts that the model satisfies.
