Newsletter #70
Enjoy Newsletter #70.
The developer productivity paradox: Why faster coding doesn’t mean faster software delivery
Trisha Gee (Gradle) distills a central theme from DPE Summit 2025: the developer productivity paradox. Nearly every developer now uses AI (~90%) and over 80% believe it makes them more productive, yet organizational delivery metrics have barely budged. The 2025 DORA report shows that AI is neither the problem nor the cure—it is a mirror and an amplifier of whatever strengths and weaknesses an engineering organization already has. Because AI models carry an inherent error rate, generating more code faster actually makes systems less stable unless the surrounding delivery pipeline is solid enough to catch defects. Context-switching costs also eat up the time saved: every interruption takes 15–20 minutes to recover from, and AI introduces new interruptions of its own as developers verify outputs, tweak prompts, or jump between tools to debug subtle mistakes.
To overcome the paradox, Gee argues for treating AI adoption as an organization-wide transformation grounded in Developer Productivity Engineering (DPE): invest in platform engineering and shared standards, strengthen rollback mechanisms, and tighten CI/CD feedback loops; shrink batch sizes, eliminate toil, and apply value-stream management; measure end-to-end flow and business outcomes rather than lines of code or pull request counts; and train engineers to critically evaluate AI-generated code instead of blindly clicking “Accept.”
What Actually Makes You Senior
According to the author, the core skill that separates senior engineers from everyone else isn’t technical trivia, but the ability to reduce ambiguity. A mid-level engineer can execute a well-defined spec cleanly, but when handed a vague problem like “we need to improve performance” or “users are complaining about the signup flow,” a senior engineer digs in: asking questions nobody else thought to ask, separating signal from noise, and deciding what to tackle now versus what to defer. They ask what the real problem is, who the users are and what frustrates them, which assumptions the plan depends on that might be wrong, and what the blast radius looks like if they ship and those assumptions fail. In doing so, they de-risk the project, turning “I have no idea what this even is” into “two small well-scoped projects and one thing we shouldn’t build at all.” Done well, this work is nearly invisible—projects simply run smoothly with fewer surprises and fewer outages.
The author criticizes tech hiring for fixating on keyword checklists, years of experience, and LeetCode puzzles, producing “senior” engineers who can invert a binary tree on a whiteboard but freeze in front of a half-baked spec. The good news is that reducing ambiguity isn’t an innate gift, but a skill built through practice: start with the next vague ticket in your queue and spend time clarifying it upfront instead of waiting to be spoon-fed requirements or jumping straight into code.
Becoming unblockable
Sean Goedecke shares practical tactics for becoming “unblockable”—always finding a way to keep moving forward when obstacles arise. First, keep more than one task in flight at a time, just like a CPU core switching threads while waiting on I/O; avoid juggling two urgent deadlines at once, and pick low-urgency background work like refactoring, performance tuning, or mandatory training rather than grabbing another feature ticket. Second, front-load the parts of a project most likely to get blocked (such as database migrations that require another team’s sign-off) or spark design debates. Be ruthless about your tooling: stick to mainstream development setups, treat a broken local environment with the same urgency as a production outage, and when you’re truly stuck locally, find workarounds like running tests in CI or deploying to a staging environment.
When you hit an error coming from another team’s service, don’t immediately declare yourself blocked—go read their source code and logs yourself; today you can even point AI agents like Codex or Claude Code at their repo, which Goedecke estimates gives the right answer about a third of the time. Beyond code, build goodwill with engineers on other teams by being helpful so you have fast informal backchannels when you need a favor, and secure “air cover” from directors or VPs by aligning your projects with top company priorities.
Treat test code like production code
Mark Seemann argues that test code deserves the same care as production code: the same coding standards, readability, structure, and code-review rigor. In practice, test suites are often treated as second-class citizens—properly indented, yet full of copy-pasted duplication, commented-out “zombie” tests, and arbitrary sleep calls in place of proper thread synchronization. Coding standards and design principles don’t exist to appease the compiler; they exist so humans—usually your future self—can understand and maintain the system. When a project has strong test coverage, the test suite is huge, making the DRY principle even more important: without it, a minor production API change triggers “Shotgun Surgery” across dozens of broken tests.
For test-specific design questions like structure, organization, naming, and determinism, Seemann recommends xUnit Test Patterns as the definitive reference. He also pushes back against the slogan that tests should be “DAMP, not DRY,” noting that descriptive, meaningful phrasing is a virtue whether code is duplicated or factored into helpers. There are still sensible exceptions, mostly around security when test code is never deployed: hardcoding dummy test passwords or skipping input validation in test helpers is fine. Platform-specific exceptions make sense too, such as relaxing .NET’s ConfigureAwait rule in tests or allowing orphan instances in Haskell test suites.
How good engineers write bad code at big companies
Sean Goedecke explains why big tech companies can hire armies of talented engineers and still produce terrible code. The core reason is that large companies are full of engineers working outside their area of expertise. With average tenure hovering around one to two years and frequent reorgs shuffling teams, many services are a decade old while most code changes are made by relative newcomers—engineers within their first six months at the company, in that codebase, or in that programming language. The few long-tenured veterans who deeply understand the system can catch issues in code review, but that stewardship role is informal and they are perpetually stretched thin by their own deliverables.
The typical big-company engineer is therefore a capable developer racing to hit a deadline inside an unfamiliar codebase—doing their best in an environment that isn’t set up to produce high-craft code. In Goedecke’s view, this is a deliberate executive trade-off: leadership prioritizes organizational flexibility and fungible headcount over deep codebase mastery and code quality, and individual engineers have very little power to change it. He contrasts “pure engineering” (self-contained domains like compilers, where bad code usually reflects low skill) with “impure engineering” (more like contract electrical or plumbing work under deadline pressure, where messy code is an inevitable byproduct of the environment). At big companies, bad code happens because almost everyone is perpetually working in unfamiliar territory.
The Success Trap
Mike Fisher explores how success can quietly narrow your freedom and options. He contrasts a waiter at a neighborhood diner—whose skills are portable enough to switch jobs or careers at any time—with a waiter at a Michelin-starred restaurant, whose mastery is far higher but whose exit options are much narrower without taking a step down. In organizational theory, the “success trap” describes becoming so good at exploiting your current strengths that you stop exploring new opportunities; it is closely related to Clayton Christensen’s Innovator’s Dilemma, except the innovator’s dilemma is disruption from the outside, whereas the success trap is rot from within.
Fisher illustrates this with three examples: an engineer promoted up the management ladder until he no longer built anything himself, who eventually took a pay cut at a startup just to write code again; Kodak inventing the digital camera in 1975 and shelving it to protect its film cash cow; and Radiohead deliberately reinventing their sound with Kid A right after the massive success of OK Computer. To escape the trap, organizations need to institutionalize curiosity through dedicated experimentation time, while individuals should regularly put themselves back in the beginner’s seat and value learning velocity over comfort. For leaders, it requires a mindset of stewardship—holding success lightly and optimizing for renewal rather than coasting on past wins—because freedom, not achievement, is the true measure of success.
Writing a good CLAUDE.md
This guide from HumanLayer starts from a simple fact: LLMs are stateless. At the beginning of every session, a coding agent knows nothing about your repository, and CLAUDE.md (or AGENTS.md) is the one file injected into every conversation by default. Its job is to onboard Claude into the codebase by answering three questions: WHAT (the tech stack and directory structure, especially in monorepos), WHY (the purpose of each component), and HOW (how to work in the repo—running tests, typechecks, and builds). The author notes that Claude frequently ignores CLAUDE.md because Claude Code wraps it in a system reminder telling the model to ignore instructions that aren’t “highly relevant to the current task”—so the more task-specific clutter you stuff into the file, the more likely Claude is to tune the whole thing out.
Key recommendations: fewer instructions are better, since frontier reasoning models reliably follow only about 150–200 instructions in total and Claude Code’s system prompt already uses ~50 of them; keep CLAUDE.md under 300 lines and as short as possible (HumanLayer’s own root file is under 60 lines), containing only rules that apply to every single task. Use progressive disclosure: put workflow-specific docs in separate Markdown files and link to them from CLAUDE.md, and reference file:line pointers instead of pasting code snippets that quickly go stale. Never use an LLM as an expensive linter—use deterministic linters and formatters wired into hooks or slash commands instead. Finally, don’t just run /init and call it a day: CLAUDE.md is the highest-leverage point of the entire agent harness, so craft every line deliberately.
We should all be using dependency cooldowns
William Woodruff argues that dependency cooldowns are a free, low-effort, and remarkably effective defense against the vast majority of open-source supply-chain attacks. Most supply-chain attacks follow the same playbook: an attacker compromises a popular project (usually via phished credentials or a CI/CD vulnerability), publishes a malicious release to PyPI, npm, or GitHub, downstream users automatically pull the update, security researchers spot the anomaly, and the registry yanks the malicious package. While the attacker’s preparation may take weeks, the window between publishing the malicious version and the registry taking it down is almost always just a few hours to a few days. Out of ten high-profile incidents analyzed, eight had an active compromise window of under a week—the notable outlier being xz-utils at roughly five weeks.
A dependency cooldown simply puts a minimum waiting period between when a package version is published and when your tooling considers it eligible for installation, giving the security community time to catch compromises first. Configuring one takes just a couple of lines—such as cooldown: default-days: 7 in Dependabot, or equivalent settings in Renovate and modern package managers. A 7-day cooldown would have blocked almost every attack on the list, and a 14-day cooldown would have stopped all of them except xz-utils. While it isn’t a silver bullet—since supply-chain security is fundamentally a social-trust problem—eliminating 80–90% of the risk at near-zero cost is a no-brainer.
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.
Comments