Newsletter #101
Enjoy Newsletter #101.
AI-Assisted Engineering: Q1 2026 Impact Report
DX’s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI’s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping 4x as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the “player-coach” model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save 4.9 hours per week, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.
The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is “no longer optional.” “Shadow AI” — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI’s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.
My AI Workflow (Without Losing My Skills)
Marc G shares how he leverages AI without losing his programming skills. His concern stems from the “automation paradox” (he cites an episode of the 99% Invisible podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he “vibe codes” freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an “Omega Mess,” in Sandi Metz’s terminology).
A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.
Managing Context in Long-Run Agentic Applications
Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is never carrying raw conversation history into subsequent agent calls; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren’t weighed down by accumulated stale context.
The first channel is the Director’s Journal, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the Critic’s Review, which scores the confidence of specialist agents’ findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the Critic’s Timeline, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director’s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.
How The Heck Does Shazam Work?
This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: throw away almost all the data, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a Fast Fourier Transform (FFT) to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse “constellation map”; background noise rarely produces prominent peaks, making this approach highly noise-resistant.
To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an inverted index — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.
Agents with Taste
Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain why a design choice works, then feed them to the agent. His argument is that taste isn’t magic — “almost every decision about taste has a rational explanation if you look closely enough,” and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.
The examples are concrete: animations should start from scale(0.95) rather than scale(0) because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as ease-out for elements entering the viewport and ease for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.
Floating Point from Scratch: Hard Mode
Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose bfloat16 (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a dual-path architecture: the “close path” handles subtraction when the exponent difference is less than 2, while the “far path” handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.
Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library’s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of 454 MHz under nominal conditions. One fun lesson: a leading-zero counter written simply with casez outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.
The Peril of Laziness Lost
Bryan Cantrill argues that LLMs are eroding one of a great programmer’s most important virtues: laziness, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a natural filter forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.
A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan’s output revealed redundant test suites, a “Hello World” Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and “grind” culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.
Cleaning Up Merged Git Branches: A One-Liner from the CIA’s Leaked Dev Docs
Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against master; his updated version for modern repositories compares against origin/main and excludes both main and develop:
| |
The pipeline chains three steps: git branch --merged origin/main lists merged branches, grep -vE strips out the current branch and primary branches to prevent accidental deletion, and xargs deletes each remaining branch using the lowercase -d flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his ciaclean) so you don’t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.
Agent Harness Engineering
Addy Osmani argues that the quality of a coding agent depends more on its harness — the operational scaffolding around the model — than on the model itself: “a mediocre model with a great harness will beat a great model with a bad harness.” The gap between what today’s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (AGENTS.md, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.
Key principles include the “skill issue” mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The Ratchet Principle treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its AGENTS.md under 60 lines, like a pilot’s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn’t disappear — it moves on to tackling harder problems.
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.
Comments