Michael Stapelberg deleted the last cgo dependency from Debian Code Search by reimplementing the TurboPFor integer codec in pure Go — matching the C reference with AVX-512, then beating it with a positional-popcount trick.
Austin Z. Henley golfed a Python-subset interpreter into 1024 bytes of C — no macros, no libraries — by skipping the compiler pipeline entirely and re-parsing the source as its control flow.
Thoughtworks CTO Rachel Laycock argues code review was quietly doing five jobs at once — and that teams should shift judgment left and review by exception instead of automating the ceremony.
Dan Luu on why most people don't notice bugs in the software they love — and why quality blindness is a trainable skill.
The cost of specialized performance work has dropped by orders of magnitude. Dan Luu on why workload-specific optimization is now cheap enough to do routinely.
Superwall's Joseph Choi interviews Welltory CPO Asya Polony on the onboarding and paywall framework behind an $18M ARR Apple Watch app: six pitch ingredients, syncing health data as the first CTA (90%+ do it), showing users their own data as the strongest proof, and why fear beats benefits at the paywall.
Five Rust-level cache layout changes cut per-entry memory by 56% and freed ~100 TB across Cloudflare's DNS fleet — while making the cache 43% faster to insert into.
What if the executable format itself were a database? Farid Zakaria's SELF replaces ELF with SQLite — and packs a whole userland into one queryable file.
A 7-hour build-in-public stream where Janet A. Carr vibes an AI auto-clipper into existence on Render Workflows — upload a VOD, transcribe it with Whisper, score it with an LLM, cut clips with parallel FFmpeg jobs — and actually deploys it and renders real clips before sign-off.
A sharp restatement of the code/software distinction: AI is remarkably good at writing code, but engineering begins where judgment lives — and the real job is deciding where complexity belongs.
Anik Sikder walks an ERP from business capabilities to production — boundaries before frameworks, ownership before layers, and a modular monolith until distribution solves a real problem.
Cheap code generation dissolves the accidental inertia that protected software architecture — and reveals how much of what we called architecture was really expensive implementation. The regeneration test tells them apart.
Staff engineering's real job: finding problems worth solving. Lalit Maganti (Google, Perfetto) on absorbing problems instead of requests, letting them accumulate, finding the common shape, and pressure-testing before building.
Sean Goedecke argues the skill-atrophy case against AI misses the point: even if using AI degrades long-term ability, engineers may be obliged to use it anyway — because that is what the job pays for.
The fallback ladder that actually works from a datacenter IP: syndicated copies, Wayback, archive.ph, r.jina.ai, API pivots, real browsers — and what each one does and doesn't beat.
Elm's creator brings compiler-verified types and migrations to SQL: precise custom types, verified migrations, friendly errors, and end-to-end type sharing between client, server, and database.
GitHub's 7h47m August 17 outage was a capacity failure, not a code change — retry storms and shared dependencies turned one component into a platform-wide incident, and the CTO lays out the reliability work ahead.
A systematic review of 42 studies finds agile decision-making research is lopsided: heavy on formal planning decisions, nearly silent on the tacit micro-decisions of coding, testing, and release — and managers barely figure as agile decision-makers at all.
AI code review bots are slow, expensive, and noisy. Swizec argues that custom linters — deterministic, fast, editor-integrated — are the right guardrail for fast-moving teams shipping both human and agent-written code.
Lessons in reliability, observability, and failure-mode thinking from building autonomous warehouse robots — and why your next web app should ship with the same rigor.
Mark Seemann argues that if LLMs write code, the ORM's main justification — reducing SQL boilerplate — collapses. Why not ask the LLM to write fine-tuned parameterized SQL directly?
A defense of programming as a genuinely hard craft, and a rejection of the cliché that code was never the hard part — without romanticizing it into unautomatable art either.
Classifying into a 500-value taxonomy is expensive with structured outputs. Cheaper trick: let a dumb LLM invent fake classifications, then resolve them into the real vocabulary with embeddings.
Aaron Boodman explains durable objects in plain terms: stateful serverless functions, one running instance guaranteed, in-memory state instead of a shared database.
The scarce input was never typing — it was the ability to grade whether work is right. One former enterprise delivery lead shipped a production decision engine solo with two AI collaborators and argues everything collapsed except judgment.
A candid reflection on what developers lose as AI takes over writing code — years of craft, the validation of code that works, the zone — and where the satisfaction might move next.
Inside a prop trading firm where the business itself is the customer, latency is enemy number one, engineers own the full stack from custom hardware to custom kernels, and a single bug can wipe out the company.
The one skill that separates senior+ engineers from everyone else is reducing ambiguity — everything else on the senior checklist only becomes valuable once you know what you are building.
Human comprehension of a software system is an inherent architectural characteristic that silently decays and must be actively maintained — or the system becomes unevolvable.
When a config file needs an OS-defined magic value like O_NOATIME, the practical answer is compiling a tiny C program at runtime — the reverse of the data/code split.
The incentive problem behind over-engineering: complexity looks smart because evaluation systems reward it — and the fix is to make the judgment behind simplicity visible.