Newsletter #94
Enjoy Newsletter #94.
Inside the Claude Code source
After the Claude Code CLI source code was inadvertently exposed in late March 2026, Haseeb Qureshi read through its core modules and compared its architecture with OpenAI’s Codex CLI. The first surprise is that the terminal UI is actually a React application rendered via Ink, bringing a web mental model to the terminal, whereas Codex’s TUI is written entirely in Rust. The entire lifecycle of a request runs through an async generator pipeline: every event flows down a single stream consumed identically by the CLI, SDK, and IDE bridge, which differ only in how they render those events. To survive long coding sessions, Claude Code layers four context-compaction strategies (proactive, reactive, snip, and context collapse), whereas Codex relies on two.
The system prompt is assembled from roughly 15 functions and split in two by a cache-boundary marker: a static first half (~3,000 tokens of core instructions) cached globally across users, and a dynamic second half holding session-specific context like CLAUDE.md and MCP instructions. Internal Anthropic engineers even receive different prompt rules than external users—such as a strict 25-word limit between tool calls and an adversarial verification sub-agent. Bun’s compile-time feature flags strip dead code from public builds while revealing unreleased internal features like VOICE_MODE and KAIROS. The author’s takeaway: across ~500,000 lines of TypeScript, actual model API calls take up only a few hundred lines; the underlying model is the easiest part to swap out, while the surrounding harness encodes years of hard-won operational craft.
AI Will Accelerate Your Tech Debt
Chris Farris compares many engineering organizations to families living paycheck to paycheck: after years of prioritizing feature velocity over sustainable architecture, they are one major outage away from bankruptcy, and every minor incident burns the exact hours that should have gone toward paying down technical debt. Pouring AI coding tools into that environment, he argues, is like passing a tax cut on a structural deficit: it feels great and boosts short-term output, but makes the underlying fiscal problem worse. When the cost of generating code drops near zero, the natural economic friction that used to filter out half-baked features vanishes—leaving the same overstretched team with more code, a wider attack surface, and deeper system complexity.
On the security side, building on Rich Mogull’s “Core Collapse” scenario, the author warns that AI-equipped attackers will discover and exploit vulnerabilities faster than defenders can patch them, and organizations that don’t understand their own environments cannot use AI to defend them either. Unlike Mogull, he argues you cannot outsource technical-debt remediation. Instead, he proposes a “Technology Troika”—bringing Finance/FinOps, Security, and Platform Engineering together to shore up foundations before opening the AI floodgates. That means investing in unglamorous fundamentals like identity management, data classification, and dependency mapping, alongside having the courage to decommission legacy systems outright rather than endlessly refactoring them. Buying more AI tools won’t save a rotting foundation.
How Slack Rebuilt Notifications 📣
Slack’s engineering team recounts rebuilding their notification settings from the ground up to reduce notification fatigue. Notifications consistently ranked among the top three drivers of customer support tickets, and the problem wasn’t just volume—it was the architecture itself: desktop and mobile had four conflicting mental models, what you get notified about was tightly coupled to how it gets delivered, preferences didn’t sync cleanly across devices, and advanced overrides were scattered across hidden menus.
The redesign consolidated everything into a single unified model: every channel now offers three clear choices—“All new posts,” “Mentions only,” or “Mute”—while push delivery is toggled independently per device category (desktop vs. mobile). The hardest part was migrating millions of existing users safely. To preserve backward compatibility and allow instant rollbacks, the team avoided mutating legacy rows in the database and instead translated old preferences on read—for instance, mapping the old “Nothing” setting to “Mentions only” with push notifications turned off. They also removed the explicit “Save” button so changes apply immediately, shared React components across platforms, and rewrote some of Slack’s oldest iOS screens. Post-launch, engagement with notification settings jumped 5x and stayed elevated weeks later.
Better, Faster, and (Even) More
Michael Lopp (Rands) shares the tools and habits he has built over 90 days of working intensively with Claude Code, at a moment when the cost of going from “random idea” to “working software” has never been lower. Everything lives under ~/Projects/, with each project in its own Git repository alongside three special repos: dotfiles for machine configuration symlinked into place, a private credentials repo for API keys, and scripts for custom CLI utilities. Every project carries two markdown files: CLAUDE.md as static instructions on how to build and deploy the project, and WORKLOG.md as a running session journal recording what was investigated, changed, and decided so the next session can pick right back up.
Small daily workflow tweaks remove even more friction: having Claude pipe output straight to the macOS clipboard via pbcopy, capturing a screen region to the clipboard and pasting it directly into Claude instead of describing UI bugs in prose, and running a custom doctor script that verifies 30+ environment checks across his three Macs. He also breaks down how he separates Claude Code’s memories, skills, and hooks, configures his status bar to display rate-limit usage, and auto-titles terminal tabs by project name. Going faster, he notes, only makes you want to go faster still—every friction point removed builds momentum for the next.
Java Is Fast. Your Code Might Not Be.
Jonathan Vogel built a Java order-processing service for a DevNexus talk that worked outer-loop fine and passed every test—then fixed eight common performance anti-patterns without changing the architecture or upgrading the JDK. Processing time dropped from 1,198ms to 239ms, throughput jumped from 85,000 to 419,000 orders per second, and heap usage fell from over 1GB to 139MB. What makes these eight anti-patterns dangerous is that they compile cleanly, slip past code review, and only stand out under a profiler.
The eight culprits: string concatenation with + inside loops causing O(n²) copying (use StringBuilder); running a full Stream scan over a list inside a loop—the single biggest hotspot, eating nearly 71% of CPU samples, replaced by a single-pass accumulation using Map.merge(); calling String.format() on hot paths; autoboxing Long instead of primitive long, churning ~16MB of heap garbage per million elements; using exceptions for normal control flow; overly coarse synchronized blocks (replaced with ConcurrentHashMap and LongAdder); repeatedly instantiating expensive thread-safe objects like Jackson’s ObjectMapper; and pinning virtual threads on JDK 21–23 by performing blocking I/O inside synchronized blocks (fixed with ReentrantLock). Part two of the series will walk through the exact JFR profiler traces.
Go Naming Conventions: A Practical Guide
Alex Edwards puts together a comprehensive, practical guide to naming things in Go, starting from the language’s three hard rules for identifiers (only Unicode letters, digits, and underscores; cannot start with a digit; cannot match a reserved keyword) and moving into community conventions. Go uses mixedCaps (camelCase) for unexported identifiers and ExportedCaps (PascalCase) for exported ones, because the case of the first letter determines package visibility; snake_case is almost never used. Initialisms and acronyms keep consistent casing across the entire word: apiKey and APIKey are idiomatic, whereas ApiKey is not; likewise, write userID, never userId.
For identifier length, the guiding principle is that the farther an identifier is used from its declaration, the more descriptive its name needs to be: a loop index over three lines can be i, while a package-level variable needs a full, self-explanatory name. He advises against encoding types into variable names, shadowing built-in functions or standard-library package names like json or log, and exporting identifiers by default—citing The Pragmatic Programmer that exporting less makes internal refactoring much easier. Package names should be short, all-lowercase single words without underscores (ordermanager, not order_manager), avoiding names with special toolchain meaning like vendor, testdata, or internal.
samber/cc-skills-golang: 🧑🎨 A collection of Golang agentic skills that works
This open-source repository offers a curated collection of Go-specific agent skills compatible with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and Antigravity. Each skill is a modular instruction pack loaded only when relevant, keeping the coding agent’s context window lean. Bootstrapped with Claude Code from the author’s own production Go commits and then heavily edited, tested, and rewritten by hand, the project comes with a blunt warning from the author: purely AI-generated skills are useless.
The catalog spans code style, naming conventions, data structures, database patterns, design patterns, documentation, error handling, observability, performance, benchmarking, security, and testing. Skills are split into small, cross-referenced units—for instance, rules about logging errors live inside golang-error-handling rather than golang-observability. Each skill includes benchmarked error-reduction numbers comparing agent output with and without the skill, such as a ~40% reduction in style violations and a 53% improvement in documentation compliance. Skills can be installed via the skills CLI, the Claude Code plugin marketplace, or by copying them into your tool’s skill discovery directory.
Small Programming Tricks
Will Keleher argues that a surprising share of day-to-day engineering speed comes from accumulating “small programming tricks”—bite-sized techniques that don’t require deep theoretical study, but pay off immediately every day. His favorites include fuzzy-searching shell history with fzf on Ctrl+R (or atuin for even richer history), running SELECT without a FROM clause to quickly test database functions, using EXPLAIN ANALYZE to tune queries, word-boundary assertions (\b) in regular expressions, the “git pickaxe” (git log -S) to find commits that added or removed a specific string, and git checkout - to jump back to the previous branch or commit checkout.
He also calls out modern JavaScript conveniences like Array.flatMap, Object.entries, and Promise.withResolvers, and recommends ripgrep (rg) over grep alongside shell globs like **/*.md in place of verbose find invocations. Inside a company, tribal-knowledge tricks—like which internal dashboard actually shows the right logs for a given failure, or who on another team knows a legacy subsystem inside out—are even more valuable. At a previous job, the author posted one small trick a day in Slack; that daily cadence was lightweight enough not to overwhelm anyone while steadily leveling up the whole team.
Shell Tricks That Actually Make Life Easier (And Save Your Sanity)
Christian Hofstede-Kuhn rounds up terminal shortcuts and shell features that many developers miss once they get comfortable with basic ls, cd, and grep. The first half covers Emacs-style line-editing keybindings (depending on your shell configuration): Ctrl+W deletes the previous word, Ctrl+U and Ctrl+K cut to the start or end of the line, Ctrl+Y yanks the cut text back, and Ctrl+A / Ctrl+E jump to the beginning or end of the line; cd - toggles between your current and previous directory, while pushd and popd manage a directory stack. For scripts, set -e and set -u help catch errors early (though they have sharp edges and don’t replace explicit error handling, and pushd/popd aren’t part of POSIX sh).
The second half focuses on Bash and Zsh power tools: reverse history search with Ctrl+R, pressing Ctrl+X then Ctrl+E to open the current command line in your $EDITOR when crafting a complex multi-line command, brace expansion like cp file{,.bak} for quick backups or mkdir -p project/{src,tests,docs} to scaffold directories in one shot, process substitution like diff <(sort file1) <(sort file2), and disown to detach a long-running job from the current shell session. His advice: don’t try to memorize the whole list at once—pick one trick, force yourself to use it for a week, and then move on to the next.
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.
Comments