标签 · Essay — Glean

Recent picks

5picks · chronological

09-20

AI Coding Is a Framework, Not a Library

Piglei argues that AI coding tools are better understood as a framework than a library. Frameworks own the program's overall structure and buy convenience at low upfront cognitive cost; AI tools do the same, with natural language replacing code as the input. Using Django REST Framework as the case study, he shows a four-line ModelViewSet generating a full CRUD API, then details what customizing a create response or adding list filters actually costs: rewriting get_queryset and stacking if/else patches. Dropping to a plain ViewSet makes the code longer but surfaces the hidden cognitive debt. Two framework problems persist with AI: abstraction leaks, when prompts fail and you must debug down to variable names, and loss of control, as in vibe coding where the agent owns the structure. His advice: treat AI as a library, find the prompt sweet spot, design the structure yourself, encode constraints in AGENTS.md, and review generated code.

www.piglei.com · 4 min · AI Engineering · Code Review · Essay

09-16

20 Things I've Learned in my 20 Years as a Software Engineer

A Simple Thread co-founder distills 20 years of engineering into 20 opinions, prefaced by an honest account of his context: small teams and startups first, then consulting inside large companies, then growing his own firm from 2 to 25 people. The list runs against received wisdom: building the right thing is harder than building it well; the best code is code you never write; every system eventually rots, so aim for continuous improvement rather than elegance; the 10x programmer is a myth and the real win is keeping 0.1x programmers off the team; data outlives your codebase; interviews predict almost nothing about teammates; prefer durable "shark" technologies to fashionable ones. Aimed at working engineers who want to sanity-check their own judgment, with the caveat that all advice is contextual.

www.simplethread.com · 14 min · Career Advice · Engineering Culture · Essay

09-15

Write code that is easy to delete, not easy to extend.

The thesis: treat lines of code as lines spent, not lines produced. Every line carries a maintenance cost, and abstractions built for reuse bind callers to both the intended and unintended behaviour of an implementation, making later change more expensive. The goal should be disposable code, not reusable or extensible code. The author walks through tactics: don't write code at all; copy-paste a few times before extracting a function; keep stateless, application-agnostic helpers in a util directory with one utility per file; accept boilerplate so static library code stays away from fast-changing business logic; layer policy over protocol the way requests wraps urllib3; let one big ball of mud hold things together; split modules by what they don't share rather than by shared functionality; use uniform interfaces, HTTP caches/CDNs and feature flags as replaceable seams; handle errors at the outer edges (end-to-end principle), as Erlang's supervision trees do by restarting instead of recovering in place. Aimed at engineers maintaining long-lived codebases.

programmingisterrible.com · 20 min · API Design · Code · Essay

09-14

The Law of Leaky Abstractions

Joel Spolsky's classic essay starts with TCP, which promises reliable, ordered, uncorrupted delivery on top of IP, a protocol that guarantees none of those things. TCP is an abstraction, and like every non-trivial abstraction, it leaks. The examples span the stack: iterating a 2D array column-wise can trigger far more page faults than row-wise; logically equivalent SQL queries can differ by orders of magnitude in runtime; no C++ string class can make "foo" + "bar" compile, because string literals are char*; an NFS server outage silently drops mail that depended on a .forward file; ASP.NET fakes form submission from a hyperlink with generated onclick JavaScript, breaking when JavaScript is disabled. The practical consequence: abstractions save time writing code, not time learning. As tools get higher-level, debugging them still requires knowing what was abstracted away, so proficiency gets harder, not easier.

www.joelonsoftware.com · 12 min · Abstractions · Essay · Software Engineering

09-08

Software Craft vs Industry: Bun's Rust Rewrite, Agents, Seat Belts

Taking the 2026 Bun rewrite from Zig to Rust and the ugly public spat between Andrew Kelley and Jarred Sumner as its cue, this essay asks a question the author has carried through his career: is software production a craft or an industrial process? It combs through tabs-vs-spaces wars, the rise of formatters, Go's deliberate deskilling and work intensification, the Clojure community's hand-tool romance, woodworking hobby culture, and the US government's seat-belt mandates—all to build a metaphor for type systems and Rust's borrow checker. The author argues quality is subjective, 'slop' is in the eye of the beholder, and predicts coding agents will drive software further into industrialisation: language lock-in for small/medium projects disappears, hand craftsmanship becomes a hobby, and quality is increasingly quantified and automated. A thought-provoking culture essay with a clear pro-AI, industrialist viewpoint; not a technical tutorial.

newsletter.powderworks.dev · 76 min · AI Engineering · Claude Code · Essay