Enjoy Newsletter #22.

Identity Tokens Best Practices

Gabriel L. Manor (Permit.io) explains that an identity token is a signed package of claims issued by an identity provider to represent a user or service, typically built on OAuth 2.0, OpenID Connect, and the JWT format consisting of a header, a payload containing claims like iss, exp, and sub, and a digital signature. The article distinguishes common token types: JWTs, OpenID Connect ID tokens, opaque tokens (random strings whose underlying data is stored server-side), and API keys for service-to-service communication. The biggest advantage is delegated authentication: applications don’t have to handle passwords directly and only need to validate the token (signature, issuer, audience, and expiration), making single sign-on (SSO) and scaling microservices straightforward.

The most valuable section covers common anti-patterns: treating identity tokens as the source of truth for all authorization decisions, stuffing way too much data (permission lists, URLs, entire user objects) into token claims, setting expiration times too short or too long, and maintaining completely separate authentication flows for human users versus machines. The core recommendation is decoupling authentication (who you are) from authorization (what you are allowed to do right now) so policies can change without reissuing tokens. Beyond that, keep tokens small, stick to open standards, balance token lifetimes, plan for token revocation, always transmit tokens over HTTPS, keep them out of logs and URLs, and always verify JWT signatures. Note that since this is the blog of an authorization vendor, it includes a brief product pitch alongside the technical advice.

Tactical Work in the Age of Layoffs

Sean Goedecke observes that the golden era of 2010s tech—when companies actively protected work-life balance—is over; today’s leadership demands faster delivery and higher output against a backdrop of layoff anxiety. The naive response is keeping your existing work habits and simply working longer hours: that works in the short term, but leads to burnout, mistakes, and unsustainability. Instead, Goedecke advises deploying your time more tactically, because companies don’t care how many hours you work—they care about the volume of visible output you deliver.

Specifically, when under pressure, you can scale back work that is genuinely useful for the codebase but goes unrewarded as “free labor”: writing comprehensive tests, refactoring legacy code, proactively helping other teams unasked, exploring new technologies, or improving internal processes. The litmus test is simple: would you be willing to do that work for free? Goedecke isn’t advocating abandoning all craft—he still voluntarily writes a few integration tests for critical flows. His second piece of advice is to go all-in when your project has executive visibility (clues: your manager’s manager attends the kickoff, or the project gets mentioned in company-wide all-hands), and then coast to recover during quieter stretches, because nobody can sprint forever without burning out.

Tracing Thoughts in Language Model

Anthropic introduces its latest mechanistic interpretability research, likening the effort to building an “AI microscope” to peer inside a language model’s internals. Because language models are not programmed directly by humans—instead learning problem-solving strategies during training—even their creators don’t fully understand how they arrive at answers. Two companion papers extend Anthropic’s earlier work from identifying individual internal concepts (“features”) to linking them together into computational “circuits,” applying the method to study Claude 3.5 Haiku across ten representative behaviors.

The findings are full of surprises. Claude appears to think in a shared conceptual space across languages, and this language-agnostic representation grows larger with model scale. When writing rhyming poetry, the model selects the rhyming word at the end of a line in advance and then composes the line to land on it, even though it was trained purely to predict one token at a time. When doing mental arithmetic like 36+59, it runs two parallel pathways—one computing a rough magnitude estimate and another computing the exact ones digit—yet when asked to explain how it got the answer, it recites the standard textbook carrying algorithm instead. Researchers also caught the model fabricating plausible-sounding post-hoc reasoning to agree with a user’s incorrect hint, and found that by default Claude is wired to abstain from guessing unless a specific circuit suppresses that reluctance when it recognizes a known entity. The team notes that their current method still captures only a small fraction of the model’s total computation.

Why Duplicating Environments for Microservices Backfires

Arjun Iyer (Signadot) argues that in microservices development, the time it takes to test a code change in a production-like environment determines engineering velocity—and the common approach of spinning up full duplicate environments on demand for each developer or team (via VMs, Kubernetes namespaces, or dedicated clusters) breaks down as systems grow. Every environment requires the full set of services, load balancers, API gateways, databases, and message queues, making it painful to manage; teams resort to mocks that drift from reality, test data falls out of sync, environments quickly lag behind main, and provisioning gets slower and slower. The cloud bill is steep too: running a 50-microservice environment on an EC2 m6a.8xlarge instance costs roughly $11,232 per year, which multiplied across 50 copies exceeds $560,000 in compute alone.

The alternative Iyer proposes is sharing a single baseline environment with request-level isolation via lightweight “sandboxes,” similar to Uber’s end-to-end testing architecture: only the modified services are deployed into a sandbox, while requests are dynamically routed based on headers. This saves compute, produces consistent results, simplifies maintenance, spins up sandboxes nearly instantly, and stays much closer to production. Implementing it requires three pieces: context propagation across service boundaries (using OpenTelemetry baggage and tracecontext standards), data isolation so tests cannot mutate shared baseline records they didn’t create, and message-queue routing so sandboxes don’t compete for the same events.

Logging Practices I Follow

Eliran Turgeman shares the logging principles he follows, starting from the observation that logs are the most fundamental observability tool and that their primary audience is developers themselves. Before adding a log statement, ask yourself: is this log truly necessary, or does it duplicate information already logged elsewhere in the same flow; could the logged object blow up in size in production—and if so, can you log just a count or a few key fields instead; and does this message actually help someone debug or understand the execution path? Next, keep log formatting consistent across the entire system—for example, always prefixing messages with [serviceName](functionName) so engineers can locate the exact call site without even opening the codebase.

For log levels, Turgeman sticks mainly to four: ERROR when part of a flow fails and needs to page someone on call, WARNING for abnormal behavior worth investigating, INFO for major milestones in a request flow, and DEBUG for fine-grained inspection of objects and data structures; the most common mistakes are logging way too much detail at INFO or never using DEBUG at all. Finally, be mindful of cost: dumping a massive JSON payload into logs is both unreadable and expensive—at roughly $0.50 per GB in AWS CloudWatch, a single noisy log line can easily cost thousands of dollars a month. Making every log message unique across the codebase, aided by the service and function prefix, makes troubleshooting much faster.

Sync and Async

Ted Neward argues that the “work from home (WFH) versus return to office (RTO)” debate focuses on the wrong question: the real issue isn’t where work happens, but how work happens—specifically, synchronous versus asynchronous work. After recapping the pandemic shift to remote work and the subsequent wave of hybrid policies and RTO mandates, Neward lays out his premises: we still have no objective metric for developer “productivity,” remote teams can be led effectively by skilled managers, talent is distributed everywhere, yet human relationships deepen faster face-to-face—and commuting into an office just to sit on Zoom calls with headphones on makes no sense.

He defines “synchronous” work as tasks that require back-and-forth interaction with others to make progress, and “asynchronous” work as tasks where you can move forward independently without waiting on new input. Writing code and debugging are largely asynchronous (even if rubber-ducking a bug with a colleague helps); pair programming and requirements gathering with stakeholders are synchronous; code reviews and architecture brainstorming alternate between both. Rather than a binary, sync and async form a spectrum, which Neward maps across two axes: degree of synchronicity and communication fidelity (bandwidth). Activities high on both axes—like pair programming or design brainstorming—benefit most from being in the same room, while activities low on both—like heads-down coding—can be done from anywhere.

Making Uber’s Experiment Evaluation Engine 100x Faster

Uber’s engineering team recounts how they cut A/B experiment evaluation latency for Go backend microservices by 100x, dropping p99 latency from roughly 10 ms to 100 µs. Previously, every active experiment was evaluated via remote RPC calls to a centralized Parameter Service. That approach was too slow for Uber’s real-time paths, turned the central service into a single point of failure, and forced developers to rely on batch prefetching—requiring them to know upfront which parameters a request would need, with any omission causing bugs. Their solution was moving to local evaluation: distributing experiment metadata to every host over Uber’s existing Flipr configuration distribution channel and running the evaluation logic inside an in-process ExperimentPlugin within the client library.

To guarantee correctness during the migration, the team ran shadow testing across a sample of roughly 20 million evaluations per second, comparing legacy and local results, fixing 13 edge-case bugs, and achieving over 99.999% parity. Because faster evaluations also meant impression logs were pushed to Kafka at a much higher rate, they added monitoring, alerting, and an in-memory LRU cache that deduplicated roughly 80% of redundant exposure logs, along with internal kill-switch parameters to disable features instantly without redeployment. Today, more than 100 services representing nearly 70% of experiment traffic have migrated, cutting UberEats search autocomplete indexing latency by 20%. Their takeaway: start with a simple centralized architecture, and only decentralize once your platform is mature enough to handle it.


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.