Software

A month spent reverse-engineering a Jane Street ASIC from raw chip geometry — and an honest account of how nearly every detour along the way was self-inflicted.

A 668-developer survey found readers bail the moment they detect LLM-authored prose — and 71% avoid that author afterwards. Bryan Cantrill argues this makes LLM authorship self-defeating, not merely distasteful.

Glazer's data team recovers a 'broken' CronosPro database by cracking an obfuscated schema as an assignment problem, fixing wrong parser boundaries, and validating structure instead of trusting readable output.

A short essay arguing that the AI-replaces-programmers debate misses the point: programmers who code for the process itself will keep writing code by hand, regardless of what AI can do.

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.

The canonical resource for learning to design large-scale systems: system design interview prep, architecture tradeoffs, and Anki flashcards. 364k stars.

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.