My favorites
- Etienne argues the real 2027 risk isn’t your team’s AI adoption but customers quietly delegating to agents and vanishing from your dashboards. Worth reading before your next planning cycle.
- Zalando open-sources an identity broker that lets AI agents act for users without ever holding their provider tokens. Worth reading for the delegation-chain design and the user-agent permission intersection model.
- A jury just held Meta and Google liable for addictive design, and this MIT research shows good-faith design thinking can walk teams into the same trap. Useful ideas for guardrails: values-first KPIs and pausing before you scale.
- Martin Fowler admits he finds LLMs useful but doesn’t like them: the grating voice, confident bluffing, and the creators’ values baked in. A refreshingly honest take that’s worth a read.
- Margaret Hamilton led the 400-person team that wrote Apollo’s flight software and helped define software engineering itself. A worthwhile read on where error handling and priority scheduling come from.
- A new HBR study on how AI replaces “go ask Sarah” with “go ask the chatbot,” quietly eroding the transactive memory that makes teams work. Worth reading before your next AI rollout.
- Bramus rebuilt the 1997 GTA engine in JavaScript and WebGL, mostly by directing Gemini at open-source reimplementations and community docs. It’s playable now, and a fun look at what AI-assisted side projects can do.
Agile, Leadership and Product
- Practical walkthrough of syncing a React design system (shadcn/ui, Tailwind v4, Storybook) into Claude Design with /design-sync, so it uses your real components instead of inventing lookalikes.
- Agents can fill in domain gaps, but they can’t replace seeing the work. A practical case for getting your whole dev team hands-on with users’ real workflows early, especially in high-stakes domains.
- Most of us won’t become AI-native, and that’s fine. This frames AI-first as a deliberate redesign of workflows and autonomy boundaries, with a useful shift from execution to judgment.
- Figma makes the case for students building real products instead of slide decks. The takeaways translate to teams: shared workspaces, structured critique, and iterating on feedback beat describing ideas.
- A team skipped code reviews to move faster, then watched agents copy one “passable” implementation everywhere. Worth reading before you decide what review means when agents write the code.
- A talk on why software factories fail. I couldn’t pull the transcript, so I’m going by the title: worth a watch if you’re building process-heavy delivery pipelines and want to avoid the usual traps.
- Camille Fournier, author of The Manager’s Path, on what AI changes for managers in 2026: technical skills, signal processing, and people skills. A grounded take, not sci-fi hype.
- AI lets us do far more than we can do well, so the real skill is judging output. Useful framing for PMs, devs and leads on competence versus judgement.
- A walk through five eras of UX and which lessons still hold up now that AI is reshaping products. Useful if you’re a tech lead or PM deciding what to keep.
- A fresh take on product thinking: stop over-planning like a villain and build teams that read signals and adapt fast. Worth a read if your roadmap keeps colliding with reality.
- Hagiu and Wright argue platforms beat SaaS, licensing and scale-economy models on profitability, scalability and defensibility. Handy lens if you’re deciding what to build or whether your product has real network effects.
- Before you open PowerPoint, nail the story: distill a big idea, know your audience, then storyboard. Practical advice for anyone who presents to teams or execs and wants slides to be execution, not invention.
- Banning AI tools doesn’t stop usage, it just hides it, and six experiments suggest heavy-handed rules also make people take real threats less seriously. Worth reading before your next security policy.
- A sharp reminder that most “speed” is just skipped thinking, with the cleanup rebranded as iteration. Worth reading before your next planning meeting, especially if you’re the one asking to slow down and decide properly.
- Most leaders think they know what customers value, and the data says otherwise. A useful read for product folks on closing that gap before you build the wrong thing with great confidence.
- John Cutler on why we self-sabotage at work: those habits often protect something we value, and overthinking can’t replace actually feeling it. Useful lens for leaders and anyone stuck in their own way.
- Rands on why every big org has a sad path nobody documented, and why you need The Insider to survive it. A sharp reminder that process is documented culture, and worth reading before your next reorg.
- AI alert systems can quietly turn your people into reactive alarm-watchers. Using lessons from Three Mile Island and Columbia, this argues for keeping decision authority with front-line humans. Worth reading before rolling out AI governance.
Architecture, Development & Software development practices
- Offline support and real-time sync turn out to be the same problem: client IDs, optimistic mutations, conflict resolution. Hands-on notes from building with Verdant and TanStack DB. Read before adopting local-first.
- GitHub moved Primer off CSS-in-JS to CSS Modules without breaking the site, using feature flags and visual regression tests. A solid playbook for incremental migrations, and a reminder that native CSS often wins.
- Martin Fowler and Eric Evans sit down at DDD Europe 2026. I couldn’t pull a transcript, but if you care about domain modeling, an hour with these two is worth it.
- Circuit breakers are easy in-process, but twenty replicas each learning separately means your struggling dependency eats 20x the damage. This walks through Redis-backed shared state and the race conditions it introduces.
- The BFF pattern for SPAs is now formally IETF Best Current Practice (BCP 212). Keep tokens out of JavaScript and let a server-side confidential client handle OAuth. Handy citation for security audits.
- Guy Steele’s classic 1998 keynote, a masterclass in why languages, APIs and libraries must be designed to grow. Watch it for the clever format, stay for the design lessons.
- Shows how a graph model turns tangled corporate ownership into traceable effective stakes (80% × 60% × 60% = 28.8%) and flags changes. Useful if you build KYC or compliance systems.
- Cloudflare and VoidZero are building tsrs, a faithful Rust port of TypeScript, alongside the TypeScript team. Early numbers show up to 8x faster checks than 7.0, plus an honest take on why AI makes ports like this feasible.
- Jane Street rebuilt their feature engineering core after a 17k-line monolith made adding a simple ratio touch nineteen files. A useful read on composability, per-market compute, and when to rewrite.
- Platform-agnostic YAML spec for data contracts: schema, quality rules, SLAs, team roles and pricing in one place. Worth a look if you’re tired of undocumented data handoffs between teams.
- A tight, interactive refresher on Go concurrency: goroutines, channels, context, mutexes, atomics, testing, and scheduling. Run and tweak the examples as you read. Ideal for sharpening rusty fundamentals, and it’s AI-free.
AI, LLM & Machine Learning
- Imprint’s year of AI adoption, ending in a Linear-driven agent loop that audits goals, metrics and issues, then ships PRs. A practical blueprint if you’re figuring out the software factory pattern.
- Stripe’s homegrown coding agents merge over a thousand PRs a week, with humans still reviewing. A rare look at what one-shot, end-to-end agents look like in production, not a demo.
- StrongDM’s team ditched hand-written and human-reviewed code, using holdout-style scenarios instead of tests to keep agents honest. Provocative, but the scenario-vs-test distinction is worth stealing.
- Pi 1.0 is a deliberately minimal, extensible coding-agent harness that only adds features once they’ve proven themselves. Worth a read for the Codemode and deferred tool loading ideas, and Pi Durable for long-running agents.
- Define your agent team in YAML and boot Claude Code and Codex as one persistent, role-based system. Worth a look if you’re tired of juggling loose terminal sessions.
- A Microsoft hackathon built with Copilot coding agents, where non-developers shipped real features. The takeaway is that tests, repo instructions and PR reviews keep prompt-driven development from becoming vibe coding.
- A practical framework for judging the quality of context you feed AI agents, tying bad context to real costs: tokens, liability, and security. Worth reading before your next agent rollout.
- Same score, opposite causes: one change does the work better, another just learned what the eval rewards. Worth reading before you let an automated loop optimize against your benchmark.
- Mistral’s 1T-parameter, open-weight multimodal model, with weights due this month. Worth a look if sovereignty or refusal-free security work matters to you. The benchmark claims are still the vendor’s own, so test them.
- A rulebook for your AI coding agent that filters out the generic UI, filler copy, and AI-shaped code. It’s a filter, not a style guide, so direction stays yours. Worth a look.
- Praxist runs an autonomous R&D loop: parallel research peers, task-owned evaluators, durable evidence, and synthesis across generations. Worth a look if you have a measurable objective and no clear path to it.
- Treats your AGENTS.md and CLAUDE.md like weights: it mines real agent sessions for evidence, then proposes small, quote-backed edits you approve. Local-first, human-gated. Worth trying on a messy repo.
- AI just made rewriting Photoshop a side project, so what’s your moat now? A sober take on which defensibility dies, which gets more valuable, and why it matters for your roadmap.
- Doop is an MCP server that gives Claude Code, Codex and other agents a shared design canvas. You can watch their work stream in live and turn comments into tasks. Worth a look for multi-agent design workflows.
- Prompt stuffing and routed graphs both crack in production. Parlant takes a different route: rules, knowledge and tools are narrowed to the relevant context each turn. Worth a look if you ship customer-facing agents.
- Dan McAteer argues the agent harness is flipping to face the human, and Claude Mods let you script when Claude interrupts you and what it shows. Worth a read if you live in Claude Code.
- Prompt caching and semantic caching sound similar but solve different problems. This is a clear breakdown of where each one fits, plus the invalidation traps, so you can cut LLM cost and latency.
- Squad drops a team of AI agents into your repo as .squad/ files. Specialists work in parallel, remember decisions, and governance is enforced in code. Worth a look if you want agent speed with human review.
- Google Research’s open framework for improving an agent’s harness (prompts, tools, memory, skills) at runtime with fixed model weights. Worth a look if you tune agent scaffolding by hand.
- Open-source spreadsheet where you drop in documents, audio, video and emails, then run AI extraction and transcription over them. Runs fully local with private models, or plugs into OpenAI and Anthropic. Worth a look.
- A Danish team shares what it really took to build a software factory where agents handle everything between human kickoff and sign-off. The takeaway: context and measurable standards matter far more than code generation.
- NVIDIA’s open-source context layer that gives agents certified business definitions, lineage and provenance before they write SQL. Worth a look if wrong numbers are blocking your agentic analytics.
- Spec-driven development for AI coding assistants: agree on the spec first, then let the agent build against it. A lightweight way to cut the vibe-coding drift when you work with Claude Code or Cursor.
- Thoughtworks argues the agent harness (instructions, tools, permissions, context, evals) deserves product ownership, not scattered half-owned artifacts. Worth reading if your org has a model strategy but no accountable owner for the layer around it.
- Lilian Weng breaks down harness design patterns (workflow loops, file-system memory, sub-agents) and how they enable self-improving agents. Essential reading if you’re building anything like Claude Code or Codex.
DevOps, Observability & Security
- Microsoft Research’s micro-VM sandbox runs untrusted agent workloads in a Linux guest with hardware-enforced isolation, built on OpenVMM. Worth a look if you’re figuring out how to safely run agent-generated code.
- Anthropic merges 30,000+ changes a day and outgrew git, so they built their own version control system in five months. Worth reading if AI coding agents are about to flood your CI and monorepo.
- Cloudflare open-sourced the skill that seeded their vuln-hunting harness. It runs isolated agents through recon, hunting, and independent verification, so you get findings with source traces, not noise. Worth stealing for your own audits.
- Floci is a free, open-source AWS emulator on localhost:4566. Swap the LocalStack image for it, point your SDK, CLI or Terraform at it, and run integration tests in CI with no account or token.
- A crawl of 10,000 sites surfaces a fingerprinting script stuffed with ricin-dosage function names, apparently built to trip LLM safety filters. Worth reading if you reverse-engineer scripts with AI.
- Hooks into AI coding agents at the tool boundary to record every call, flag risky sequences like credential-exfil, and keep a tamper-evident audit trail you can forward to your SIEM. Public alpha, but worth a look if agents touch your repos.
Tools and things from Github
- Agents acting on a user’s behalf need more than a shared API key. This broker covers consent, an encrypted token vault, and RFC 8693 token exchange. Worth reading if you’re building agent auth.
- Self-hosted, AGPLv3 search engine that indexes the pages and files you actually read, with no telemetry. The MCP integration lets your AI assistant search your own knowledge, which is the part I’m keen to try.
- A skill pack that gives your coding agent real design vocabulary (/polish, /distill, /clarify) so it stops shipping beige, card-in-card AI slop. Works across Claude Code, Cursor, Copilot and more. Free, worth trying.
- A GPU-accelerated, native (no Electron) IDE and terminal multiplexer written in Go, with e2e-encrypted peer networking and a headless Docker mode. Worth a look if you hop between machines.
- Pull a face at your webcam and a matching meme lands on your head, piped into Zoom via virtual camera. Silly, but the MediaPipe pinning notes alone are worth a read.
- Free, MIT-licensed copy-paste React/Next.js components with live previews. The device mockups (iPhone, Apple Watch, iPod) and browser frames are handy for polished demos and landing pages without design work.
- Google’s open-source blueprint for a fully offline voice translator: Gemma 4 on LiteRT-LM running on a Raspberry Pi 5. Worth cloning to see what on-device inference looks like in practice.
- An MCP that lets your agent reverse engineer apps, from Electron and .NET to native binaries, and report the evidence behind its conclusions. It runs locally, so it’s worth a look when you wonder how a feature works.
- NVIDIA’s sandbox runtime for autonomous agents: kernel-level enforcement, credentials injected only for approved endpoints, and formal verification of policy changes. Worth a look before you hand agents real access.
- A GitHub org shipping pure-Rust, clean-room takes on Photoshop, Word, Excel, PowerPoint and video editing, all Apache-2.0. Worth a look for Rust architecture and how far AI-assisted rewrites can go.
- A self-hosted push inbox for your own apps: one Go binary, one SQLite file, and APNs straight to your phone with no relay or accounts. Handy for backups, deploys and cron alerts.
- Herdr is a Rust-based runtime that keeps your coding agents’ terminals alive across SSH drops. It also flags which agent is blocked, so you can stop babysitting a pile of tmux panes.
- Microsoft Research’s micro-VM sandbox for running untrusted agent workloads with hardware-enforced isolation, built on OpenVMM and booting Linux guests. Worth a look if you’re wondering how to safely contain agents.
- NVIDIA’s PAIR pools your RTX, DGX Spark, and Mac machines into one local inference cluster behind a single endpoint, proxying Ollama, llama.cpp, and LM Studio. Worth a look for private, idle-GPU-friendly agent workloads.
- A Windows debloater that shows you what’s running, lets you pick what goes, and reports what changed. The author’s return-to-basics story is a good lesson in resisting feature creep.
- A design skill for Claude Code, Cursor and Codex that lints its own output against the tells of machine-made UI: eyebrow labels, empty frames, fake form success. Worth trying if AI-built pages all look the same.
- A Git and filesystem linter that checks tracked files for things like CRLF line endings and trailing whitespace, with a –precommit mode and –fix. Zero-config and plugin-based, so it’s worth a look for repo hygiene.
- Run your GitHub Actions workflows locally in Docker instead of committing and pushing just to debug YAML. It’s a real time-saver for fast CI feedback, and it can double as a Makefile replacement.
- Static analyzer for Go that catches lock-order inversions, leaked files, and unjoined goroutines. It’s already found bugs in Docker and Kubernetes, and it runs as a go vet tool, so it’s worth a CI trial.