My favorites
- Timeless rules from Rob Pike: measure before optimizing, keep algorithms simple, and let your data structures do the heavy lifting. Still relevant after 40 years.
- Terminal-based Nvidia GPU monitor that gives you a clean, real-time view of your GPU stats without leaving the command line.
- A sharp, unsparing critique of LLMs from someone who grew up dreaming of intelligent machines — and isn’t buying the hype. Required reading for anyone forming an opinion.
- Open-source mini robot from Hugging Face — a physical AI platform for experimenting with embodied intelligence. Robotics just got a lot more accessible.
Agile, Leadership and Product
- AI widens the gap between good and bad managers. If you’re not building with these tools yourself, you can’t set real expectations for your team.
- Individual brilliance doesn’t scale — systems do. A sharp look at how to build organizations that multiply talent rather than just accumulate it.
- A Platform PM open-sources 6 years of hard-won knowledge into a Claude agent — covering developer adoption, positioning, and the mental models that usually die when people change jobs.
- When everyone has valid but conflicting perspectives, consensus stalls. This breaks down why alignment is harder than agreement — and what to do about it.
- When to step in as a manager — a practical framework using the ‘below the waterline’ model. Intervention should be the exception, not the default.
- Technical folks over-explain and kill their stories with caveats. Hook first, depth later — your audience will ask when they want it.
- Bees balance exploitation and exploration simultaneously — and so should your product teams. A sharp lens on one of the hardest resource allocation problems in leadership.
- AI tools have flipped the calculus on staff engineering — if you’re not coding regularly, your tradeoff instincts are already stale.
- The ‘Design Engineer’ title confusion reveals a real discipline: end-to-end ownership at the design/frontend boundary. Worth reading if you’re hiring or building hybrid teams.
- Design sprints aren’t just for startups — the more stakeholders, the higher the misalignment risk. De-risk before you write a line of code.
- AI amplifies fast thinking — but the slow work of deciding what to build still needs human judgment. A sharp framework for knowing when to hit the brakes.
- Treat your org wiki like a knowledge graph, not a folder dump. Practical framework for documentation that people can actually find and trust.
- Most engineering orgs have no idea what their teams actually cost or generate. This post does the math — and it’s uncomfortable reading.
- Organizations sprint before understanding their own mechanics. This reframes deliberate low-stakes exploration as essential learning infrastructure, not wasted motion.
- Prevention work is invisible — until it isn’t. Classic systems thinking on why process improvements fail and how to make the invisible value of reliability actually stick.
- A CTO’s Claude Code setup — persistent workspace with personas, integrations, and daily workflows. The composability angle is what makes this worth reading.
- Great tutors obsess over mental models, not content. The lesson is diagnosing what’s broken in how someone thinks — a frame that transfers directly to code review and mentoring.
- The ceiling most CTOs hit isn’t technical — it’s the shift from optimizing for correctness to optimizing for commercial outcomes. Hard-won perspective on becoming a real business leader.
- AI shifts developers from authors to editors — but Agile’s core feedback loops matter more than ever. The PR review problem is real: smaller, intentional units of work.
- Managers spot team wins easily but miss their own. Lara Hogan helps you recognize your impact — because progress you can’t see, you can’t build on.
- AI agents are reshaping marketing org design — same structural questions apply to engineering teams. Worth reading to stay ahead of how agentic AI changes headcount and roles.
- Before pushing OKRs or discovery, fix your delivery pipeline. Outcome thinking is worthless if you can’t act on insights fast enough to matter.
- Why most B2B companies get stuck in pilot purgatory when scaling value-based solutions — and the capability-building phases that separate scalers from stagnators.
- Critical chain flips estimation on its head: cut estimates by 50%, pool the saved time as a shared buffer. Counterintuitive, but the case study shows it actually works.
- Before pushing OKRs or discovery frameworks, fix your delivery cadence. Insights go stale when you can’t ship fast enough to act on them.
- A sobering look at how senior leaders can unknowingly become the bottleneck — mistaking metrics for trust and missing the signals until someone brave enough reads the list.
- A clear-eyed breakdown of why most teams misuse metrics — and a practical framework for what to actually measure and why it matters.
- A sharp warning: AI won’t replace your glue people — it’ll just make their absence invisible until the structural damage is done.
Architecture, Development & Software development practices
- HyperLogLog lets you count billions of unique items with kilobytes of RAM. Essential knowledge if you’re building analytics or any system where cardinality estimates matter at scale.
- How Etsy migrated their database sharding layer to Vitess without downtime. Real-world war stories on resharding, cutover strategies, and the tradeoffs they hit.
- Why your teams get different numbers for the same metric — and how a proper semantic layer fixes it by making business definitions the authoritative source of truth.
- Rob Pike’s Go proverbs are still the best distillation of idiomatic Go thinking. If you write Go, these stick with you.
- A short doc capturing why you made an architectural decision — before everyone forgets. Keep them in the repo, never rewrite them, just supersede.
- Architecture isn’t about blueprints — it’s a small set of shared decisions that keep hundreds of independent choices coherent. The Winchester Mystery House analogy alone is worth the read.
- Traces React rendering from server-side MVC to Server Components — helps you pick the right strategy based on actual tradeoffs, not hype.
- Flip NestJS from code-first to contract-first: generate typed controller interfaces from your OpenAPI spec and let the compiler enforce the contract — not just document it.
- Solid rundown of Go naming conventions — the rules you need to internalize early so your code doesn’t stand out for the wrong reasons.
- Cuts through the EDA hype: events aren’t about scaling, they’re about decoupling. Most apps don’t need them — knowing why matters more than knowing how.
- Before reading a single line of code, run these git commands to instantly surface churn hotspots, bus factor risks, and bug clusters — a diagnostic picture most people miss.
- 113 hard-won lessons from scaling a Django monolith to 1M LOC. Packed with specific, actionable insights on DB performance, background jobs, and codebase organization.
- Clear breakdown of SCD Type 2 — how to track historical changes in dimensional data and load them incrementally without losing context.
- Seven hard-won truths every engineer learns by breaking things in prod — rollback first, test your backups by actually restoring them, and nothing outlasts a temporary fix.
- How a Red Hat team turned Storybook into a full behavioral verification engine using MSW — real routing, real data fetching, just a mocked network. Clever patterns that make tests actually trustworthy.
- A deep dive into Git’s internals — packfiles, sparse checkouts, partial clone — written for engineers who need to keep large repos fast.
- Laws you learn the hard way — Brooks, Conway, Goodhart. Worth a refresh to name what’s already happening on your team.
- Clever walkthrough of modal dialogs in React Router 7 using nested routes — zero useEffect, clean patterns for loading, errors, and animations.
- Four concrete design smells — rigidity, fragility, immobility — with real examples and fixes. Useful checklist for diagnosing why your codebase fights back.
- Stop avoiding pprof. This guide cuts through the confusion — CPU, heap, goroutine profiling explained with practical takeaways so you actually know what to do with the results.
- Software design is learned by doing, but Conway’s Law is the real boss — your architecture mirrors your org’s social structure, not your technical ideals.
- Wave Function Collapse explained through road-building simulations — a clever algorithm for structured randomness that’s genuinely useful for game maps, procedural generation, or anywhere you need constrained randomness.
AI, LLM & Machine Learning
- Stop letting AI context die with the session. Externalize decisions into a living doc so you can close the chat without losing everything.
- A sharp reality check on AI productivity hype — entropy and path dependence don’t disappear when you ship faster. Brooks’ No Silver Bullet still holds.
- Practical breakdown of where AI agents actually deliver in legal workflows — start with high-volume, low-risk contracts, measure real throughput gains, not tech vanity metrics.
- Karpathy’s autoresearch idea — one metric, constrained scope, automatic rollback — generalized beyond ML to any measurable goal. Set it running overnight, wake up to compounding gains.
- Local-first AI agent framework that runs on your hardware with Ollama integration. Cloud optional — finally a practical stack for personal AI that stays personal.
- Sandboxed runtime for AI agents with declarative YAML network policies. Finally — a way to let agents do real work without handing them the keys to everything.
- Data-backed guidance on AGENTS.md: less is more, auto-generated files hurt performance, and every line costs inference tokens. Know what to include and what to skip.
- Stripe, Ramp, and Coinbase converged on the same internal coding agent patterns. This open-source framework distills those production lessons so you don’t have to reinvent them.
- LLM Compressor v0.10 brings distributed GPTQ compression across multiple GPUs — 3.8x faster on 4 GPUs. Practical if you’re quantizing large models in-house.
- NVIDIA’s reference stack for running OpenClaw agents sandboxed inside OpenShell — early alpha, but worth watching if you’re thinking about secure autonomous agent deployment.
- ByteDance’s open-source super-agent harness that orchestrates sub-agents, sandboxes, and memory to tackle hours-long tasks. Worth watching if you’re serious about agentic AI.
- Multi-agent simulation engine that builds a ‘digital twin’ world to run what-if predictions at scale. Fascinating approach to forecasting via emergent collective behavior.
- A skill pack that fights LLM design bias — 20 steering commands and curated anti-patterns to stop AI from defaulting to Inter font and purple gradients.
- Solid overview of the MLOps stack — experiment tracking, model registries, pipelines, serving, and monitoring. Useful when you’re graduating from notebook experiments to production ML.
- Solid breakdown of where data science actually delivers in enterprise — from manufacturing OEE to GPU-accelerated text classification. Good reference for evaluating where AI investment makes sense.
- 15 engineers share their real-world AI-assisted workflows — practical patterns for multi-repo coordination, code review, and leaning on AI without losing control of your codebase.
- Structured AI-powered workflow for shipping software — from idea to code through specialized agents handling planning, architecture, and implementation in phases.
- Testing AI agents requires a fundamentally different approach — this walkthrough of eval-driven development shows how to move from manual testing to CI-integrated evaluations that actually catch regressions.
- How Anthropic broke through ceilings in agentic coding with a planner-generator-evaluator architecture. Solid insights on context management and multi-agent decomposition for long-running tasks.
- AI won’t kill developer demand, but it will obsolete low-level code literacy the same way high-level languages killed assembly knowledge. The new skill is culinary intuition, not knife work.
- Stop dumping vague tickets into AI tools. Structure your context first with a repository impact map, get human sign-off, then implement. The quality gap is real.
- Multi-agent framework for statistical package development — isolated Builder, Tester, and Simulator agents that never share specs, so convergence means genuine correctness.
- A language built for LLMs to write, not humans — structural references instead of names, mandatory contracts, compiler errors designed as LLM-readable fix instructions.
- Hard data on enterprise AI adoption — 29% of Fortune 500 have live deployments. Cuts through the survey noise with actual contract and usage data.
- Solid deep-dive into inference engineering — what it is, when it matters, and the techniques (quantization, batching, caching) that make LLMs faster at scale.
- Jupyter notebooks that build ML algorithms from scratch with live visualizations — gradient descent, backprop, k-means. Best way I’ve seen to actually understand what’s happening under the hood.
- Open-source framework for building AI SRE agents that investigate production incidents — includes synthetic failure simulations and scored RCA suites to actually train and evaluate them.
- Solid architectural principles for AI-assisted development: contracts over conventions, verification over generation, and never let the same AI write and judge its own code.
- The model is just one input — the harness is where the real engineering happens. Essential framing for anyone building or evaluating coding agents.
- A sharp, unflinching look at how LLMs will make customer service worse, not better — diffusing accountability while making it harder to reach humans who can actually fix things.
- Chip Huyen’s breakdown of the AI engineering stack — three layers, how it differs from ML engineering, and why it’s really just software engineering with LLMs thrown in.
- DESIGN.md gives coding agents a structured, persistent understanding of your design system — tokens plus rationale — so they stop guessing your colors and spacing.
- Built a self-audit prompt to score his own AI sessions against 30 habits. Metacognition is the actual moat — discipline separates insight from noise.
- Treats the LLM as a compiler — English in, software out — then defines the engineering discipline you need to make that pipeline actually reliable. Sharp mental model.
- Microsoft’s production-grade multi-agent framework for Python and .NET — graph-based orchestration, checkpointing, human-in-the-loop, and built-in OpenTelemetry. Serious infrastructure for teams moving agents beyond demos.
- Google’s pretrained time-series foundation model — drop it into your forecasting pipeline without training from scratch. 200M params, 16k context, quantile forecasts included.
- Practical sensors — linting rules, dependency checks, coupling metrics — that keep AI-generated code from quietly rotting your codebase. Essential reading if agents are touching your repo.
- LinkedIn’s tool for fact-checking AI-generated claims against real sources. Useful for anyone building or evaluating LLM pipelines where accuracy actually matters.
- Anthropic’s engineers explain how they broke through ceilings in autonomous coding using a GAN-inspired planner/generator/evaluator architecture. Practical insights on context management and multi-agent handoffs.
- Using AI to ship without engaging your brain is a slow skill leak. The posture matters more than the tool — ask conceptual questions, don’t just paste and ship.
- Survey data from 900+ engineers on AI’s real tradeoffs: less tedium, but eroding code quality, unrealistic business expectations, and junior devs struggling most.
- If your AI tools double coding speed but don’t halve maintenance costs, you’re mortgaging your future. A sobering, math-backed reality check every tech lead needs to read.
- Have the LLM interview you before it writes anything. One question at a time extracts better context than pages of prompts you write yourself.
- Sessions from Netflix, Uber, Dropbox, and others on actually measuring and scaling AI’s impact on developer productivity — less hype, more hard-won lessons.
DevOps, Observability & Security
- Creating a dedicated ‘DevOps team’ just builds new silos. This covers the anti-patterns that quietly kill DevOps transformations and how to actually fix them.
- Kubernetes-native job queuing that handles quotas, fair sharing, and preemption across tenants — essential if you’re running ML training workloads or batch jobs at scale.
- Your dashboard shows 22% CPU but the app is crawling. Learn to read process states — D-state processes are usually the real culprit.
- A Deputy CISO’s structured framework for risk reviews — eight focus areas that shift security from reactive firefighting to proactive posture.
- Clear breakdown of blue/green, canary, and other deployment strategies — good reference for picking the right approach when reliability actually matters.
- Pinterest’s war story on hunting CPU bottlenecks — zombie processes hiding in plain sight. Solid real-world debugging walkthrough worth stealing for your own incident playbook.
- Vibe coding creates real security debt. Prompting AI to ‘be secure’ isn’t enough — you need security context files, guardrails, and default-safe templates before anything ships.
Tools and things from Github
- Drop-in haptic feedback for mobile web apps with React, Vue, and Svelte hooks. Finally, native-feeling touch responses without the native app overhead.
- Offline-first survival server bundling local AI (Ollama+RAG), Wikipedia, maps, and Khan Academy in Docker. When the internet dies, your knowledge base doesn’t have to.
- PS4 emulator running Bloodborne and Red Dead Redemption on desktop — impressive systems-level C++ work, and a reminder of what open source communities can pull off in their spare time.
- Resisted tmux longer than I should have. Sessions that survive SSH drops, keyboard-driven splits, composable config — once it clicks, screen feels prehistoric.
- awk is one of those tools that pays dividends every time you touch a terminal. Solid practical reference if you’ve never moved past the basics.
- Skeleton loaders that mirror your actual UI structure at runtime — no separate components to maintain. Drop in a wrapper, done.
- Solid update to this streaming markdown component — staggered animations, inline KaTeX, and fixes for code blocks that actually matter in production AI chat UIs.
- Solid breakdown of the analytics tool landscape — useful for when you’re helping teams pick the right platform without getting lost in vendor marketing.
- Turns AI agents into structured PMs: PRD → epics → GitHub issues → parallel execution across git worktrees. Solves the context-loss problem that plagues multi-session AI development.
- One command spins up a full Metaflow stack locally — Kubernetes, Argo Workflows, UI, the works. Perfect for testing before touching your cloud account.
- Rands shares his Claude Code workflow: project-scoped CLAUDE.md files, WORKLOG.md session diaries, and small scripts that cut friction. Practical setup worth stealing.
- Drop-in guided tours for React apps. Define steps, ship onboarding — minimal config, fully customizable, accessible out of the box.
- Package manager for AI skills — write your context modules once, install to Claude Code, Cursor, Gemini CLI, and more with a single command.
- Teach your AI agent to actually understand Obsidian’s syntax and CLI. Drop these skills into your vault and Claude Code or Codex can create proper wikilinks, Bases, and Canvas files.
- Someone implemented a full 6502 CPU emulator in pure PostgreSQL — registers, flags, and 64KB of memory as tables, every opcode a stored procedure. Gloriously unhinged.
- TinyGo 0.41 lands ESP32 wireless support — run a web server on your microcontroller in the same language powering your backend. One language, edge to cloud.
- wrk meets grafana. Plow gives you real-time latency histograms and percentiles in the terminal AND a live web UI while your benchmark runs. Zero overhead, straightforward flags.
- Dead-simple SSH tunnel manager that lives in your terminal. If you’re juggling multiple tunnels across environments, this beats maintaining a mess of alias scripts.
- Kubernetes-native way to run isolated, stateful AI agent workloads — fills the gap between Deployments and StatefulSets with stable identity and warm pools.
- Classic open source roguelike with decades of depth. If you’ve never lost hours to permadeath dungeon runs, this is your entry point.
- Free, open-source roguelike with no ads or monetization. The kind of pure indie game you bookmark to play when you need a mental break from shipping.
- A polished open-source roguelike that’s genuinely hard to put down. Worth knowing as a benchmark for procedural generation and long-term game balance done right.