Newsletter #120
Enjoy Newsletter #120.
Lessons from building Claude Code: How we use skills
Thariq Shihipar, a member of the Claude Code team at Anthropic, distills lessons learned from building and using hundreds of internal skills. The central insight is that a skill isn’t just a single Markdown file of instructions—it is an entire folder that can bundle scripts, assets, reference data, hooks, and configuration. This structure enables progressive disclosure: the agent reads SKILL.md first and only loads auxiliary docs or helper scripts when the task actually needs them, keeping the context window lean. Shihipar groups skills into nine practical categories: library/API references, product verification, data analysis, workflow automation, code scaffolding, code review, CI/CD, operational runbooks, and infrastructure management.
When authoring skills, he advises skipping generic advice Claude already knows and focusing on instructions that nudge the model out of its default habits—especially a living “gotchas” section capturing recurring pitfalls, repo conventions, and edge cases added whenever the agent makes a mistake in practice. State high-level goals rather than rigid step-by-step micromanagement, give the skill a persistence mechanism (like log or JSON files) to maintain state across sessions, and bundle composable helper scripts so the agent doesn’t have to reconstruct boilerplate operations from scratch via token generation. For larger teams, skills can be committed directly to the repo or distributed through an internal plugin marketplace so engineers install only what they need without bloating context, while hooks track usage metrics to prune overly broad or unused skills.
Bulkhead Pattern - Go
Kamal Namdeo walks through implementing the Bulkhead Pattern in Go: isolating resources per downstream dependency so one slow or failing service cannot exhaust goroutines, sockets, and request budgets across your entire application. Instead of letting every outbound HTTP call share http.DefaultTransport, each downstream dependency gets its own three-layer bulkhead: a semaphore capping concurrent in-flight requests (using TryAcquire to fail fast when full), a dedicated connection pool via MaxConnsPerHost so one slow host cannot starve TCP connections to others, and tight timeouts that free resources quickly when an upstream stalls. That way, if the auth service is degraded, billing and S3 calls continue unaffected.
The post also shows how to size concurrency limits. Little’s Law relates average concurrency to throughput and average latency; plugging in p99 latency plus a 30% safety buffer is the author’s practical sizing heuristic rather than the law itself, showing why slower dependencies require more slots to sustain the same throughput. Blast radius during outages is contained through layered timeouts: ResponseHeaderTimeout (roughly 1.2x p99), Client.Timeout covering the full request lifecycle, a 1–2 second TCP dial/TLS handshake timeout, and a QueueTimeout derived by subtracting downstream latency from your SLA budget. Namdeo closes with common Go pitfalls: runtime.NumCPU() is the wrong basis for sizing I/O concurrency because goroutines blocked on network reads don’t consume CPU cores, response bodies must be drained before closing so connections can return to the idle pool, and MaxIdleConns should equal the sum of per-host idle limits so dependencies don’t evict each other’s pooled connections.
Max Consecutive Ones
Jaspreet Singh breaks down a foundational LeetCode problem in Java: given a binary array, find the maximum number of consecutive 1s. The brute-force approach starts at every index containing a 1, scans forward to count the streak, and updates the global maximum. While easy to explain in an interview, it repeatedly re-scans the same elements, resulting in O(N²) time complexity with O(1) auxiliary space.
The optimal solution rests on a simple observation: a streak of 1s grows as long as we keep seeing 1 and resets the moment we hit a 0, meaning we only ever need to track the length of the current streak. By maintaining two scalar variables—current streak length and maximum streak seen so far—we increment the counter and update the max on 1, and reset the counter to 0 on 0. That single pass runs in O(N) time and O(1) space without nested loops. Recognizing this “maintain running state, update global best, reset when the invariant breaks” pattern makes short work of many contiguous-subarray interview questions.
double, BigDecimal, or Fixed-Point?
Stefano Fago pushes back against blanket slogans like “always use BigDecimal for money” or “double is broken.” Under IEEE 754, double is a binary floating-point approximation, meaning base-10 fractions like 0.1 cannot be represented exact to the last bit—but that is a deliberate engineering trade-off. For domains that are inherently approximate, such as analytics, machine learning, or physics simulations, double is usually the right choice because it runs directly in hardware at blistering speed; you simply need to compare values using an epsilon tolerance instead of ==, handle NaN and -0.0 properly, and reach for techniques like Kahan or Neumaier summation, pairwise summation, or Math.fma() when minimizing accumulated rounding error.
Conversely, BigDecimal shines when exact decimal representation, explicit rounding modes, and auditability are mandatory—such as tax calculation, invoicing, and accounting—at the cost of heap allocations and software arbitrary-precision arithmetic. It also has its own footguns: calling new BigDecimal(0.1) bakes in the binary float inaccuracy (always use new BigDecimal("0.1") or BigDecimal.valueOf(0.1)), forgetting to reassign results on immutable instances, or calling equals()—which compares scale (2.0 != 2.00)—instead of compareTo(). For high-throughput financial engines, fixed-point arithmetic using long is often the pragmatic sweet spot: store $19.99 as 1999 cents, use Math.addExact and multiplyExact to catch overflows immediately, and convert to BigDecimal only at system boundaries. Fago also warns about losing trailing scale during JSON serialization and non-reproducible sums in parallel DoubleStream pipelines. Choose numeric types based on domain precision rules, rounding semantics, and performance constraints—not slogans.
Can Java Microservices Be As Fast As Go? A 2026 Benchmark Update
Six years after his original comparison, Mark Nelson revisits the question: can a small Java microservice match Go on raw performance? He benchmarks Go 1.26.3 using net/http against Helidon SE 4.4.1 (handling requests on virtual threads) running on Oracle JDK 26.0.1, alongside a variant using a Project Leyden AOT cache. The test service is deliberately small and synthetic: an endpoint generates payloads of 7, 128, 2048, or 8192 bytes, performs uppercase, lowercase, string reversal, and CRC32 calculations with WORK_FACTOR=10, and returns JSON. Each runtime is benchmarked sequentially with dedicated warmup passes and logging disabled. Before recording final numbers, Nelson noticed Helidon exhibiting a puzzling 44–48 ms latency floor on larger responses over reused HTTP/1.1 connections; enabling tcpNoDelay(true) eliminated the Nagle/delayed-ACK interaction immediately.
What stands out in the results isn’t a simplistic “Java beats Go” headline, but the shape of the scaling curves. At small payload sizes and low concurrency, all three configurations perform in roughly the same ballpark. As concurrent connections and payload sizes climb, however, the Java setups scale noticeably better: at 2 KB payloads, Go peaks around 17,000 requests/sec, whereas standard JVM reaches ~39,500 and Leyden AOT hits ~41,600. Leyden AOT posts the highest peak throughput across every payload size, while Go doesn’t win a single cell despite staying competitive at the smallest sizes. Nelson stresses that teams shouldn’t use synthetic microbenchmarks to dictate company-wide language mandates—measure your own workload, as runtime tuning, frameworks, hardware, warmup, logging, and socket options often matter just as much as the language itself.
Stop Using Conventional Commits
Sumner Evans argues against Conventional Commits because the format puts the emphasis in the wrong place. In his view, the single most valuable piece of information in a commit subject line is the scope—which subsystem, package, module, or service was touched. Developers scanning git log are usually rebasing, debugging, or triaging an incident, so they need to know immediately which part of the codebase changed. Conventional Commits instead puts a change-type category like fix, feat, or chore up front and makes the scope optional. Worse, the change type is usually obvious from the description anyway, and often ambiguous when a single commit fixes a bug, refactors a helper, and adds a small capability at once.
Evans then dismantles the usual selling points of Conventional Commits one by one. Auto-generating user-facing changelogs from commit history produces poor results because changelogs are written for end users while commit logs are written for maintainers—two audiences that need completely different levels of detail. Automating SemVer bumps from commit prefixes breaks down around reverts, breaking changes discovered after the fact, or follow-up fixes landed before release. Triggering CI/CD pipelines off commit message prefixes is even a security and reliability hazard, since automation should inspect which files actually changed in the tree rather than trusting human-typed subject lines. Instead, he recommends the scope-first convention used by Linux, FreeBSD, Git, Go, and Node.js—scope: description, such as net/http/cookiejar: add godoc links—where scopes mirror the natural structure of the project.
Stop using JWTs!
Sam Schlinkert argues for defaulting to server-side sessions for browser authentication, noting that revocation, logout, and lifecycle management are usually much simpler than rolling a custom stateless JWT scheme. That said, the gist’s claim that the JWT specification was designed strictly for short-lived tokens of around five minutes is factually incorrect: RFC 7519 imposes no such lifetime limit. A JWT is simply a signed or encrypted claims format; its security depends on the surrounding protocol, key management, and validation rules rather than every use of JWT being inherently insecure.
The post rightly warns that storing authentication tokens in localStorage magnifies the blast radius of any XSS vulnerability. For cookie-based sessions, Secure and HttpOnly flags provide important defense-in-depth, though applications still have to address CSRF, XSS, and session expiration at the architectural level. When JWTs are genuinely needed, RFC 8725 (JWT Best Current Practices) requires restricting accepted algorithms, verifying signatures, and validating claims like issuer and audience; alternatives like PASETO eliminate several cryptographic footguns by design, though they still don’t solve stateful session revocation on their own. For most web applications, the pragmatic default remains starting with your framework’s built-in session middleware backed by Secure, HttpOnly cookies and a fast store like Redis or Postgres, reaching for bearer tokens only when cross-service trust boundaries actually call for them.
Bonus
Images:

Videos: Running LLMs Locally for Learning and Privacy
This ByteByteGo video explains why running LLMs on your own machine is great for learning, experimentation, and privacy: sensitive data never leaves your device, you can work offline, and costs stay completely predictable. It also surveys the local LLM ecosystem—from Ollama, LM Studio, and MLX-LM for personal workflows to vLLM and SGLang for high-throughput inference serving.
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