My favorites
- Solid data on how real people are actually using AI tools in 2026 — useful gut-check against your own assumptions.
- Apple’s WWDC cognitive dissonance laid bare: leading with child safety rhetoric, closing with AI deepfake features. The normalization problem is real and worth sitting with.
- Hacking a WiFi smart bulb into a covert banned book server — a cyberpunk dead drop using Tasmota firmware. Clever, cheap, and delightfully subversive.
- Fowler’s CTO makes the case that AI didn’t just speed up coding — it made developer attention the real bottleneck, and the best devs now conduct agents rather than grind in flow.
Agile, Leadership and Product
- Skip-level 1:1s only work if you actively probe — not just listen. How to surface what your direct reports won’t tell you before people start leaving.
- Forwarding AI summaries isn’t knowledge transfer — it’s debt. A sharp read on what happens when comprehension lives in one person’s head and they walk out the door.
- Most companies chase AI efficiency gains — headcount cuts, faster processes. This challenges that reflex: the real leverage is growth, not just doing less with more.
- Most teams optimize what they know — few explore what’s possible. The explore/exploit balance explains why Kodak and Blockbuster failed while Apple thrived.
- In matrix orgs, your informal network matters more than your title. Research shows 3-5% of employees drive 20-35% of value — be intentional about who you build relationships with before you need them.
- The real risk isn’t being pro- or anti-AI — it’s holding your view as identity rather than evidence. A sharp framework for staying intellectually honest.
- Communication isn’t soft skill fluff — it’s a delivery mechanism. When it breaks down, assumptions fill the gaps and rework follows. Practical breakdown of where it goes wrong first.
- People hoard their best AI workflows out of job security fears, not ignorance. Worth understanding before you wonder why your AI adoption isn’t spreading.
- The middle of every org chart was always translation work. AI ate that layer — what survives is why and how.
- Will Larson updates his engineering leadership playbook for the AI era: migrations are now a solo sport, but your development harness matters more than ever.
- AI didn’t eat job titles — it ate translation tasks. A sharp read on why the middle of every org chart is getting restructured right now.
- When exec sponsors conflict, you’re not a mediator — you’re absorbing organizational failure. Five moves to stop being a shock absorber and start leading the actual work.
- Every growth stage introduces a new coordination tax. The teams that win keep ownership close to the work — not headcount close to the roadmap.
- The unglamorous part of an acquisition: what a TSA and SPA actually demand from the tech lead once due diligence wraps and lawyers take over.
- Why 95% of transformation projects fail isn’t tech or budget — it’s that nobody built a safe, structured way for frontline problems to surface before the kickoff.
- A sharp framework for engineering managers: sort your meetings into internal, boundary, and external signals to know when to fly high or dive into the weeds.
- Cutting entry-level roles to fund AI ROI feels efficient until your mid-level pipeline runs dry in a few years — a trade-off worth war-gaming before you make it.
- A former backend engineer’s path into technical product management — a solid read on why understanding the ‘why’ behind engineering decisions makes you a sharper PM.
- Rands’ decades-old All Hands format still holds up—steal the structure if your company meetings feel like a waste of everyone’s time.
- AI makes it easy to look polished fast — the real differentiator is judgment: knowing when to trust, question, or push back on the output.
Architecture, Development & Software development practices
- C# 12 primary constructors cut the DI boilerplate I’ve written a thousand times. One gotcha to know about, but the tradeoff is worth it.
- Solid walkthrough of state machines in .NET using an Uber-style trip lifecycle — covers illegal transition prevention, EF Core persistence, and race conditions you’ll actually hit in production.
- Solid deep-dive on database indexes — the hidden costs, why your index might be doing nothing, and the gotchas that bite you in production.
- A technical deep-dive into Conductor’s performance rewrite — what stack choices and architectural decisions made it twice as fast. Dogfooding at its finest.
- Performance isn’t a discipline problem or a tooling problem — it’s entropy. After 400 perf PRs at Vercel, the lesson is you need systems, not vigilance.
- Solid breakdown of Next.js App Router error handling — expected errors as return values, error boundaries for unexpected ones, plus Honeybadger integration for production visibility.
- Accessibility isn’t a checklist item—bake it into CI and code review like you would security or observability, before AI-generated UI ships broken screen-reader support.
- A sharp rethink of React performance for 2026 — skip the memoization reflex and fix state placement, effects, and rendering strategy instead.
- A field guide to money systems: precision handling, idempotency, and reconciliation patterns that keep fintech code trustworthy. Worth bookmarking as a reference.
- Kent Beck reframes YAGNI: it’s not about saving effort, it’s about the cost of committing to structure before you know what you actually need.
AI, LLM & Machine Learning
- Shipping an AI feature without observability is flying blind. Four signals you need: versioned prompts, structured traces, user scores, and LLM-as-judge.
- What actually changes when you ship AI features as a backend engineer — non-determinism, prompt design, agents in prod. The missing manual for developers crossing over.
- Sprints and story points were built for expensive human effort — AI breaks those assumptions. A sharp look at what SDLC actually needs to look like now.
- AI writes clean diffs and passes tests, but misses the subtle invariants your system depends on. A timely reminder that review depth matters more now, not less.
- Turns your LLM into a capable browser agent by giving it a terminal and Playwright — no multi-agent orchestration, just code. Works as a plugin for Claude Code and Codex.
- TypeScript harness for building real autonomous agents — not chatbot wrappers. Brings Claude Code-style architecture to your own agents with sandboxing, sessions, and skills built in.
- Design systems are becoming AI context engines — encoding intent, accessibility, and brand DNA for agents, not just humans. Worth reading if you’re thinking about how AI will consume your design infrastructure.
- Why AI projects keep dying after the demo: LLMs shatter your intuition about prototype-to-production effort. The fix is organizational, not technical.
- The harness is what you own when you rent an LLM — and engineering it properly is the difference between 30% productivity gains and AI slop disasters.
- Vibe coding’s dirty secret: AI defaults to insecure configs. Practical playbook for security context files and guardrails before your citizen-built prototype hits production.
- Practical guide to wiring linting, dependency rules, and mutation testing as automated guardrails that catch AI-generated code quality issues before they compound into real maintenance debt.
- Solid mental model for what actually replaces SaaS in an AI-native world — seven concrete layers from context retrieval to observability that separate demos from production systems.
- Microsoft launches seven in-house MAI models — reasoning, coding, voice, transcription, image — all trained without distillation. Worth knowing as they’re landing on OpenRouter and GitHub Copilot.
- AI made writing code cheap — now review is the bottleneck. Essential reading on why human understanding remains the scarce resource no tool has replaced.
- Microsoft just launched their own model family — MAI-Thinking-1, MAI-Code-1-Flash, and more. Worth knowing what’s in your stack if you’re using GitHub Copilot.
- Stop prompting agents yourself — design systems that do it for you. Addy Osmani breaks down the five building blocks of loop engineering that are already shipping in Claude Code and Codex.
- Context engineering, not better reasoning, was the unlock. PostHog’s onboarding wizard went from primitive to magical by building a context supply layer — a lesson every agent builder needs.
- Atlassian makes the case for a new role: someone who architects how context flows to your AI agents. The missing piece most orgs haven’t named yet.
- Self-hosted meeting transcription and summarization with Whisper/Parakeet and Ollama, fully local so sensitive calls never touch someone else’s cloud.
- Most AI strategies fail not because the tech doesn’t work, but because leaders chase urgency instead of clarity — worth a re-think before your next roadmap review.
- If you’re weighing self-hosted vs. proprietary LLMs, Kimi K3’s a strong case for routing complex coding work to open-weight models instead of always paying API tax.
- A sharp reframe for anyone building agents: you rent the model but own the harness, so invest your engineering there, not in waiting for a smarter model.
- Most bad AI output isn’t a model problem, it’s a spec problem: define done, feed clean context, and get fresh eyes to check the result.
DevOps, Observability & Security
- Unfiltered informer caches in Kubernetes operators can be OOMKilled by any user with edit rights. A subtle misconfiguration any developer could miss.
- GDPR isn’t just legal’s problem—penalties hit 4% of global revenue. Worth a skim so you know what your data flows actually need to satisfy.
Tools and things from Github
- Microsoft ships a native Windows build of GNU coreutils — same commands, same flags. Finally, your shell scripts just work without WSL or translation.
- Solid open-source API key server from Ory — handles issuance, revocation, and token derivation with proper security defaults. Worth knowing if you’re tired of rolling your own.
- A React code smell detector that reads whole components like a reviewer would — names the cost, proposes a fix, cites the docs, and knows when to stay quiet.
- A single Rust binary that brings Bun/Deno-style DX to stock Node.js — TypeScript runner, script runner, package manager, and version manager, without abandoning Node compatibility.
- Git worktrees have existed since 2015 but AI-assisted parallel coding finally makes them essential — swap contexts without stashing, keep your editor untouched, work multiple branches simultaneously.
- Compiler-first UI framework that turns plain JS classes into surgical DOM updates at build time — no virtual DOM, no hooks, just 121B hello world. Genuinely interesting alternative.
- Drop-in script that turns any webpage into a natural-language-controlled agent — no extensions or headless browsers, just text-based DOM manipulation and your own LLM.
- An open source, agent-ready design system built on React and StyleX — fully themeable if you want a customizable starting point instead of building from scratch.
- Zig-based inference stack that compiles once and runs on any GPU—NVIDIA, AMD, TPU, Trainium—no per-hardware rewrites. Worth a look if you’re tired of vendor lock-in.
- A TypeScript compiler that ships native binaries with no Node runtime — 320KB, 4ms startup, and it tells you exactly which lines still need the JS engine.
- Ever wanted to spin up a full macOS VM in Docker for CI or testing? This project pulls it off with KVM acceleration and a web-based viewer — no Hackintosh required.