#703 – November 15, 2026
AI is speeding up code writing, but those gains shrink sharply by the time software actually ships
Five studies changing how I think about AI in software engineering
10 minutes by Brian Houck
Brian shares five recent papers that, read together, tell a consistent story: AI is speeding up code writing, but those gains shrink sharply by the time software actually ships. The bottleneck has moved downstream to review, verification, and integration. Developers are losing flow and cognitive clarity even as their output grows. The deepest risk is eroding shared understanding of systems, a form of debt that is easy to miss but hard to recover from.
New Extract API and 100+ Search Engine APIs
sponsored by SerpApi
Access real-time search data with SerpApi's 100+ specialized search engine APIs, then use the new Extract API to retrieve structured content from web pages. Try for free today.
It was never obvious. Start anyway.
9 minutes by Yew Jin Lim
Starting a career today feels uncertain, but it always was. The difference now is that skills can become obsolete within a single product cycle. Yew suggests focusing on two things: building genuine craft through repetition and obsession, and finding real problems that need solving. These feed each other. Skip chasing predicted hot skills, optimize your first job for learning over salary, and build real human connections instead of sending hundreds of resumes into the void.
Automating immersive reading
17 minutes by Shane Friedman
Storyteller matches ebook text to audiobook audio automatically, even when chapters are reordered or missing. It first uses a speech model to generate a rough text transcript of the audio, then finds matching text chunks between that transcript and the ebook to locate chapter boundaries. From there, a Viterbi algorithm efficiently finds the best frame-by-frame alignment between the audio and text, pinpointing the exact timestamp of each word and sentence.
Do not ask "Is A a B?": Inheritance and the Is-A trap
12 minutes by Denkstein
Experts have warned against overusing inheritance for decades, yet deep and tangled class hierarchies remain common. The root cause is a flawed rule taught in almost every programming course: use inheritance when one thing "is a" kind of another thing. This sounds intuitive but fails in practice, as a mutable square cannot truly substitute for a rectangle even though geometry says it should. Instead, ask whether every promise the base type makes still holds for the subtype, and whether both types will stay tightly linked over time.
Database indexing isn't magic
12 minutes by Sushant Dhiman
Database indexes work like a book's table of contents, letting the database jump straight to relevant data instead of scanning every row. Adding an index on the right columns can cut query time from several seconds to milliseconds. However, indexes slow down write operations since the database must update them on every insert or update. Indexes also don't always help with reads, especially when a query returns a huge number of rows spread across disk.
And the most popular article from the last issue was: