<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Engineering Management on miti99</title><link>https://miti99.com/en/tags/engineering-management/</link><description>Recent content in Engineering Management on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/engineering-management/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #125</title><link>https://miti99.com/en/post/2026/07/13/</link><pubDate>Mon, 13 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #125.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="275---khi-big-tech-chuyển-mình-thành-ai-factory"&gt;&lt;a href="https://newsletter.grokking.org/p/275-khi-big-tech-chuyen-minh-thanh" rel="noopener noreferrer"&gt;275 - Khi Big Tech chuyển mình thành AI Factory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This edition shares an inside look at how a major tech company is transforming its engineering organization into an &amp;ldquo;AI factory.&amp;rdquo; The author maps agentic automation across five maturity levels: starting with engineers copy-pasting snippets from a chatbot, moving to interactive coding agents guided turn by turn, then agents going autonomously from a written spec to a tested pull request, then humans acting solely as orchestrators of review and deployment, and finally agents autonomously deploying, monitoring production, and remediating incidents. Because each level grants agents broader autonomy, the company has to invest heavily in sandboxed execution environments, automated verification, fine-grained permissions, and hard guardrails that block destructive actions.&lt;/p&gt;
&lt;p&gt;As a result, the software engineer&amp;rsquo;s day-to-day role shifts from writing every line by hand to &amp;ldquo;packaging&amp;rdquo; work into well-bounded specifications with explicit goals and acceptance criteria—a transition that proves surprisingly tough for junior engineers accustomed to exploratory, trial-and-error coding. Human code review remains indispensable because critical product and system requirements often live in unwritten tribal context; automated AI review bots currently have only about half of their suggestions accepted and burn significant token budgets at scale. While individual programming languages are becoming increasingly interchangeable, deep fundamentals in operating systems, networking, security, infrastructure, data structures, and concurrency remain the bedrock that lets engineers evaluate and take accountability for AI-generated systems.&lt;/p&gt;
&lt;h2 id="the-8020-rule-for-your-whole-life"&gt;&lt;a href="https://yewjin.substack.com/p/always-be-curious" rel="noopener noreferrer"&gt;The 80/20 rule for your whole life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yew Jin Lim proposes applying the 80/20 rule across your entire life: dedicate the 80% majority of your resources to building a rock-solid, low-drama foundation, and treat the remaining 20% as a &amp;ldquo;laboratory&amp;rdquo; for bounded experiments. The governing mindset is evaluating your life as a portfolio rather than agonizing over every individual position. He illustrates this with personal examples: many of the 20%-time side projects he tried at Google went nowhere individually, yet together they shaped his career trajectory; his retirement portfolio grew roughly tenfold through automated contributions and the discipline not to tinker; and his meditation practice deepened simply by showing up every day.&lt;/p&gt;
&lt;p&gt;From that experience he distills three core habits: follow curiosity to expand your knowledge without demanding an immediate payoff, master decision-making by separating emotional reactions from individual outcomes, and stay consistent long enough for compounding to do its work. He draws a sharp distinction between short-term trading and long-term investing, noting that once your foundation is sound, &amp;ldquo;doing nothing&amp;rdquo; is often the highest-leverage move available. Experiments don&amp;rsquo;t need to succeed every time, so long as each bet is sized small enough that failure is cheap tuition rather than ruin—and the 80% foundation is never put at risk.&lt;/p&gt;
&lt;h2 id="three-bad-managers"&gt;&lt;a href="https://randsinrepose.com/archives/three-bad-managers/" rel="noopener noreferrer"&gt;Three Bad Managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) tells the story of three brilliant, commercially successful bosses who were terrible people managers, using them to draw a crisp line between leadership (charting a compelling direction for the organization) and management (helping individuals understand where they stand and navigating day-to-day execution). &amp;ldquo;The Artist&amp;rdquo; was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. &amp;ldquo;The Dictator&amp;rdquo; used forceful authority and intimidation to dominate rooms—for instance, casually reopening design directions the team had already spent weeks evaluating rather than trusting their expertise. &amp;ldquo;The Knife&amp;rdquo; was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.&lt;/p&gt;
&lt;p&gt;For each boss, Lopp found a different survival strategy: writing his own detailed performance review ahead of 1-on-1s so The Artist just had to react to it, doing exhaustive technical homework before meetings so he could push back on The Dictator as an equal, and simply staying out of The Knife&amp;rsquo;s blast radius to get work done independently. His core takeaway is that you will almost never change your boss—especially when they are senior and successful—but you can change how you prepare, communicate, and operate around them. Every working relationship requires calibration, and learning how to adapt to difficult personalities is a practical survival skill rather than an endorsement of bad management.&lt;/p&gt;
&lt;h2 id="cross-team-pragmatics"&gt;&lt;a href="https://philcalcado.com/2026/06/01/cross_team_pragmatics.html" rel="noopener noreferrer"&gt;Cross-Team Pragmatics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Calçado examines why cross-team collaboration almost always slows down and turns political as an engineering organization grows. The root causes are predictable: individual-focused performance review cultures incentivize local optimization, high-level strategic goals contradict each other once cascaded down different org branches (e.g., an infra team rewarded for cutting cloud spend while a product team is rewarded for shipping compute-heavy features), accountability is assigned without matching ownership, and minor disagreements constantly escalate up the management chain instead of getting resolved laterally. The only durable fix is a unified technical strategy that aligns how the business competes with team boundaries, ownership, incentives, and decision rights.&lt;/p&gt;
&lt;p&gt;While waiting for those slow structural fixes to take hold, Calçado shares four pragmatic tools for treating the immediate symptoms. Team charters turn unspoken assumptions into explicit boundaries, responsibilities, and interaction modes, cutting down repetitive renegotiation. Value-stream mapping traces how a feature actually flows from idea to production rather than looking at the org chart, exposing unnecessary handoffs and queues. The 80% rule states that a team should be able to complete at least 80% of its roadmap without blocking dependencies on other teams along the critical path, while Team Topologies gives organizations a shared vocabulary for intentionally choosing how teams interact. These tools buy breathing room and stability, though long-term health still requires continuously reshaping the org around how value is actually delivered.&lt;/p&gt;
&lt;h2 id="technological-involution"&gt;&lt;a href="https://rohan.ga/blog/technological-involution/" rel="noopener noreferrer"&gt;Technological Involution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rohan argues that the tech industry has entered a state of &amp;ldquo;involution&amp;rdquo;: more talent and capital pouring in than ever, yet producing increasingly homogeneous, incremental ideas. In his view, the obvious low-hanging fruit of consumer and SaaS software has largely been picked, standard application software is rapidly commoditizing, and Silicon Valley startup culture encourages young founders to borrow pre-packaged narratives from influencers and VCs rather than forming independent convictions from scratch. Hype manufactures consensus rather than real value, while society at large grows more cynical about tech&amp;rsquo;s future. Meanwhile, the genuinely hard problems sit in atoms, hardware, semiconductors, and messy real-world enterprise operations—domains where most young founders lack hands-on experience.&lt;/p&gt;
&lt;p&gt;AI excels at generating code and synthesizing conventional wisdom, but by design it gravitates toward the consensus mean rather than contrarian, high-impact insights. Rohan argues that this limitation is precisely what preserves the opening for human agency: people who immerse themselves deeply in a domain, test hypotheses from first principles, and have the courage to pursue non-consensus ideas will only become more valuable. The way out of involution is returning to intrinsic motivation—building something because the problem itself is intellectually gripping rather than optimizing for startup vanity metrics—and the success of independent, taste-driven new media proves that work built with genuine conviction still cuts through the noise.&lt;/p&gt;
&lt;h2 id="fintech-engineering-handbook"&gt;&lt;a href="https://w.pitula.me/fintech-engineering-handbook/" rel="noopener noreferrer"&gt;Fintech Engineering Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wojciech Pitula&amp;rsquo;s handbook distills core principles and architectural patterns for building software where money is the primary domain object, anchored on three commandments: never invent money or data out of thin air, never lose data, and never trust any single component blindly. On representing monetary amounts, he compares floating-point numbers (almost never acceptable), arbitrary-precision decimals, integer minor units (e.g., cents), and rational fractions, while warning that standard JSON parsers silently coerce numeric literals into IEEE 754 floats unless amounts are serialized as strings or integers. Every balance change is recorded in a double-entry ledger where money only ever moves between accounts and balances are derived from immutable journal entries—tracking transaction time, booking time, and settlement time as distinct timestamps.&lt;/p&gt;
&lt;p&gt;On the execution side, the handbook covers funds holds/reservations to prevent double-spending, strict idempotency keys, crash-resumable state machines, and at-least-once event delivery. When integrating with external payment processors and banks, systems must validate schemas at the boundary, persist every raw request and response payload for auditability, verify webhook signatures before querying the provider&amp;rsquo;s canonical API for state, and run independent automated reconciliation jobs to catch ledger drift early. Posted ledger entries are strictly immutable—mistakes are corrected via compensating reversal entries, never &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt;—and sensitive manual operations require four-eyes approval. End-to-end walkthroughs of crypto withdrawals, card top-ups, and currency exchanges show how these patterns interlock across multi-step failure scenarios.&lt;/p&gt;
&lt;h2 id="how-to-write-an-effective-software-design-document"&gt;&lt;a href="https://refactoringenglish.com/excerpts/write-an-effective-design-doc/" rel="noopener noreferrer"&gt;How to Write an Effective Software Design Document&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch shares a practical guide to writing software design documents that surface flawed assumptions before coding begins and align stakeholders on how to solve a problem. A design doc is worth writing when a project spans multiple people, takes longer than three months, will live in production long-term, crosses team boundaries, starts from ambiguous requirements, or carries high operational risk. To decide how much detail a section needs, Lynch suggests asking one simple question: &amp;ldquo;what is the cost of being wrong?&amp;rdquo; Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don&amp;rsquo;t belong in a design doc.&lt;/p&gt;
&lt;p&gt;An effective design doc typically covers background and goals, explicit scope and non-goals, architecture and data-flow diagrams, measurable SLAs/SLOs, security and privacy considerations, a milestone timeline, and a log of open and resolved questions. The document should focus on the hardest trade-offs and gathering early feedback rather than specifying every line-level implementation detail—if you&amp;rsquo;ve written pseudocode for every class, you&amp;rsquo;ve essentially written the code twice. Lynch also recommends using editable diagramming tools (like Mermaid or Excalidraw with source checked in), defining domain jargon in a glossary, documenting rejected alternatives so reviewers don&amp;rsquo;t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.&lt;/p&gt;
&lt;h2 id="the-cost-yagni-was-never-about"&gt;&lt;a href="https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-about" rel="noopener noreferrer"&gt;The Cost YAGNI Was Never About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck explains that YAGNI (&amp;ldquo;You Aren&amp;rsquo;t Gonna Need It&amp;rdquo;) was never really about saving typing or coding effort—it is an economic principle about &lt;em&gt;when&lt;/em&gt; to commit to a design decision. Building speculative structure before a feature actually demands it incurs two distinct costs that have nothing to do with how fast you can write code. The first is lost optionality: the team locks in a bet when they have the least information about the problem, and when real requirements inevitably diverge from the guess, they have to pay to work around or rip out that speculative abstraction. Even on the rare occasion when the guess turns out right, committing early still forfeits the option value of waiting until you know more; as Beck puts it, waiting isn&amp;rsquo;t procrastination—it is holding a valuable option.&lt;/p&gt;
&lt;p&gt;The second cost is net present value (NPV) and carrying cost: you pay the complexity, maintenance, and cognitive tax immediately while any hypothetical payoff arrives far in the future, meaning you lose economically whether your prediction was right or wrong. Now that AI makes generating code nearly free, the &amp;ldquo;save typing time&amp;rdquo; argument for YAGNI disappears, yet both the optionality cost and the carrying cost remain completely intact—in fact, AI makes it dangerously easy to hallucinate sprawling, speculative frameworks in seconds. Build structure when concrete demand arrives and gives you the information needed to design it right; YAGNI is economic discipline, not stinginess with keystrokes.&lt;/p&gt;
&lt;h2 id="a-cve-dispute"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/06/24/a-cve-dispute/" rel="noopener noreferrer"&gt;a CVE dispute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg recounts curl&amp;rsquo;s first formal CVE dispute since the project became a CVE Numbering Authority (CNA). With roughly 30 billion libcurl installations worldwide, publishing a CVE triggers a massive wave of triage, compliance scanning, patching, and backporting across the entire software industry. Because of that amplification effect, the curl security team evaluates reports based on realistic exploitability and occasionally declines to assign a CVE to bugs whose security impact is &amp;ldquo;lower than low&amp;rdquo;—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.&lt;/p&gt;
&lt;p&gt;The disputed report involved curl&amp;rsquo;s wildcard certificate hostname matching function when the URL&amp;rsquo;s hostname began with a leading dot (e.g., &lt;code&gt;.example.com&lt;/code&gt;). For this bug to be exploitable in practice, an absurd chain of preconditions had to hold simultaneously: a user had to request a hostname that is syntactically invalid in standard DNS, that invalid name had to resolve via something like a modified local &lt;code&gt;/etc/hosts&lt;/code&gt; file, an attacker-controlled server at that IP had to present a matching wildcard certificate from a trusted CA, and the attacker already needed local privileges to poison name resolution in the first place. The curl team fixed the bug in December 2025 as a normal defect but declined to issue a CVE. A security researcher appealed the decision to MITRE, and after multiple rounds of review in 2026, MITRE agreed with curl that it was simply a fixed bug rather than a security vulnerability because exploiting it required a privileged local attacker. The episode illustrates why not every bug in a network library deserves a CVE, and how the CNA dispute process provides an independent check when opinions differ.&lt;/p&gt;
&lt;h2 id="how-llms-actually-work"&gt;&lt;a href="https://www.0xkato.xyz/how-llms-actually-work/" rel="noopener noreferrer"&gt;How LLMs Actually Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This visual guide explains how autoregressive transformer language models generate text token by token without getting bogged down in heavy calculus. Incoming text is first split into subword tokens by a tokenizer and mapped to integer IDs; an embedding lookup table then converts each ID into a dense vector capturing learned semantic features, placing tokens with related meanings near one another in high-dimensional space. Because self-attention treats inputs as an unordered set by default, the model injects positional information—most modern LLMs use Rotary Position Embeddings (RoPE), rotating query and key vectors by an angle proportional to each token&amp;rsquo;s position in the sequence. Inside each transformer block, self-attention compares query vectors against key vectors to compute attention weights, deciding how much information to pull from each prior token&amp;rsquo;s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.&lt;/p&gt;
&lt;p&gt;After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model&amp;rsquo;s parameters and stored factual associations. Residual connections allow information to flow and accumulate across dozens of stacked layers without vanishing gradients, while layer normalization keeps activation magnitudes stable. At the very end of the stack, the final token&amp;rsquo;s hidden state vector is projected across the entire vocabulary and passed through softmax to produce a probability distribution over the next token; the runtime samples a token (shaped by temperature, top-p, or top-k), appends it to the sequence, and repeats the loop. While modern frontier models tweak attention variants, architectures, and training recipes, they all share this foundational autoregressive transformer loop.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LlLN!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe4d255e1-536e-4f66-ab48-e8baa1bdd4a4_2484x3002.png" alt="RAG vs Graph RAG vs Agentic RAG"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!15Bw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9b8f9d64-3eae-4237-b49f-ffde033f851a_2484x3002.png" alt="Redis Data Structures Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-ILW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F19ca7f08-d615-4769-8599-2aa9aaa5d6bd_2508x3000.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ydOn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe46aad28-2935-4b87-8cf4-72787b48a9d0_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_6cl!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fea738d9d-1ae5-4a26-9a50-79ec7720fd80_2360x2664.jpeg" alt="The Testing Pyramid"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #60</title><link>https://miti99.com/en/post/2025/10/12/</link><pubDate>Sun, 12 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #60.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="diff-algorithms"&gt;&lt;a href="https://flo.znkr.io/diff/" rel="noopener noreferrer"&gt;Diff Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Florian Zenker introduces &lt;code&gt;znkr.io/diff&lt;/code&gt;, a diff library in Go that he built from scratch because existing libraries didn&amp;rsquo;t meet his needs. It works on arbitrary slices as well as text, returning either structured results or the familiar unified diff format. At its core is Myers&amp;rsquo; algorithm with O(ND) complexity, chosen because it works even on types that aren&amp;rsquo;t comparable with standard operators and doesn&amp;rsquo;t require hashing. The API offers &lt;code&gt;Edits()&lt;/code&gt;/&lt;code&gt;Hunks()&lt;/code&gt; for comparable types, &lt;code&gt;EditsFunc()&lt;/code&gt;/&lt;code&gt;HunksFunc()&lt;/code&gt; for arbitrary types with a custom comparison function, and the &lt;code&gt;textdiff&lt;/code&gt; package for unified diffs.&lt;/p&gt;
&lt;p&gt;The most interesting part is how he optimizes it. Preprocessing trims common prefixes and suffixes and strips elements that appear on only one side, cutting worst-case runtime by up to 99%. An anchoring technique inspired by patience diff finds elements that appear exactly once to split the input into smaller subproblems, reducing runtime by up to another 95%. Postprocessing applies Michael Haggerty&amp;rsquo;s indentation heuristic to make diffs easier for humans to read. The library offers three modes: default (balanced), fast (sacrificing minimality), and minimal (shortest diff regardless of cost). His takeaway is that &amp;ldquo;different implementations of the same algorithm can produce wildly different results&amp;rdquo;: diff quality depends heavily on implementation details and postprocessing, not just on which core algorithm you pick.&lt;/p&gt;
&lt;h2 id="building-a-resilient-data-platform-with-write-ahead-log-at-netflix"&gt;&lt;a href="https://netflixtechblog.com/building-a-resilient-data-platform-with-write-ahead-log-at-netflix-127b6712359a" rel="noopener noreferrer"&gt;Building a Resilient Data Platform with Write-Ahead Log at Netflix&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Netflix&amp;rsquo;s data platform team explains why they built a shared Write-Ahead Log (WAL) abstraction. At Netflix&amp;rsquo;s scale, problems like data loss or corruption, inconsistency across data stores (such as dual writes to Cassandra and Elasticsearch), multi-partition updates, cross-region replication, and retrying failed messages in real-time pipelines had either caused outages or forced teams to roll their own bespoke solutions. WAL was created to give every critical application that level of protection out of the box: it records data mutations, guarantees durability, and reliably propagates changes to downstream systems.&lt;/p&gt;
&lt;p&gt;The API is kept deliberately simple with a single &lt;code&gt;WriteToLog&lt;/code&gt; endpoint. Each namespace configures where data is stored (Kafka, SQS, or a combination) along with settings like retry counts, allowing WAL to serve different roles depending on configuration: an SQS-backed delay queue to retry failed messages without hurting throughput, Kafka-backed cross-region EVCache replication, and two-phase-commit coordination for multi-partition writes in the Key-Value abstraction. Internally, producers and consumers are decoupled so backends can be swapped flexibly, every namespace gets a built-in dead-letter queue (DLQ) for failure handling, and WAL guarantees at-least-once delivery semantics. Teams using the Key-Value layer simply flip a flag to get all of these capabilities.&lt;/p&gt;
&lt;h2 id="vercel-vs-cloudflare-two-philosophies-of-building-for-developers"&gt;&lt;a href="https://bharath.sh/writing/vercel-vs-cloudflare" rel="noopener noreferrer"&gt;Vercel vs Cloudflare: Two Philosophies of Building for Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares Vercel and Cloudflare as two distinct philosophies for serving developers, rooted in each company&amp;rsquo;s origins and business model. Vercel grew out of frontend developer culture and puts developer experience and velocity first: infrastructure is nearly invisible, deployments feel &amp;ldquo;magical,&amp;rdquo; and the dashboard is kept minimal to stay out of your way. Cloudflare grew out of network infrastructure and prizes control and transparency, with dashboards exposing granular technical metrics. As the author sums it up: Vercel optimizes for user confidence, whereas Cloudflare sells guarantees.&lt;/p&gt;
&lt;p&gt;This contrast mirrors how the two companies make money. Vercel monetizes development velocity, encouraging developers to ship quickly and gradually upgrade to paid tiers. Cloudflare monetizes scale itself—sustained usage, bandwidth, and compute. Each side views the other critically: Cloudflare sees Vercel as hiding true costs, while Vercel sees Cloudflare as needlessly complex, yet both approaches make sense within their respective domains. As edge computing and AI workloads grow, the two platforms are converging, each striving to pair great developer experience with powerful underlying infrastructure.&lt;/p&gt;
&lt;h2 id="distracting-software-engineers-is-way-more-harmful-than-most-managers-think"&gt;&lt;a href="https://workweave.dev/blog/distracting-software-engineers-is-more-harmful-than-managers-think-even-in-the-ai-times" rel="noopener noreferrer"&gt;Distracting Software Engineers Is Way More Harmful Than Most Managers Think&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that interrupting software engineers is far more damaging than most managers realize, and that the problem has worsened with the rise of remote work since COVID. The author cites several stats: meetings per employee have risen 13.5% since 2020, virtual meetings are up 60%, 92% of people multitask during meetings, and a study at Meta found engineers get only about two one-hour focus blocks per week. Reaching a state of deep flow takes roughly 45 minutes, and every interruption resets that timer to zero. Tasks like code review and debugging require deep concentration yet often get squeezed hastily between meetings. Even with AI coding tools, deep focus leads to fewer bugs and faster skill growth.&lt;/p&gt;
&lt;p&gt;Proposed solutions include batching meetings into fixed time blocks, requiring a clear agenda, and inviting only people who are truly needed; eliminating recurring meetings, like Pylon&amp;rsquo;s engineering team keeping calendars empty and coordinating only as needed; rethinking mandatory peer reviews by trusting strong engineers to ship changes directly; and having managers lead by example in protecting focus time. The author concludes that engineers need 4–5 uninterrupted hours a day to produce quality work.&lt;/p&gt;
&lt;h2 id="common-problems-managing-senior-engineers"&gt;&lt;a href="https://emdiary.substack.com/p/common-problems-managing-senior-engineers" rel="noopener noreferrer"&gt;Common Problems Managing Senior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post describes four senior engineer archetypes that frequently challenge managers and how to coach each one. The Over-Engineer loves needlessly complex solutions; managers should anchor them to practical value by asking &amp;ldquo;what&amp;rsquo;s the simplest thing that could possibly work?&amp;rdquo;, requiring decision records that lay out options and trade-offs, and setting clear time or budget constraints. The Builder-First jumps straight into coding without designing first; show them that an imperfect design doc is fine, that design helps assess feasibility, estimate effort, and align the team, and that they can reuse familiar templates from past projects. The Ambiguity-Freezer freezes up when requirements are vague; coach them to ask clarifying questions about stakeholders, metrics, and success criteria, and apply inversion thinking—figuring out what would make the project fail and doing the opposite. The Soloist avoids delegating because doing it themselves feels faster; teach them to plan work in parallel streams, show how delegating frees them up for higher-impact problems, and use pair programming to build trust with teammates.&lt;/p&gt;
&lt;p&gt;The overarching message is that these engineers&amp;rsquo; struggles stem from habits and blind spots rather than a lack of ability. As the author puts it, &amp;ldquo;They don&amp;rsquo;t need micromanagement, they need coaching.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="career-advice-or-something-like-it"&gt;&lt;a href="https://brooker.co.za/blog/2025/06/20/career.html" rel="noopener noreferrer"&gt;Career Advice, or Something Like It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker advises staying away from &amp;ldquo;negative echo chambers&amp;rdquo; where complaining becomes the group&amp;rsquo;s shared identity. Such communities create a sense of belonging in the short term but harm both your career and mental health over time; Brooker sets a personal threshold and leaves when roughly 20% of a group&amp;rsquo;s content turns negative. He argues that people should consciously choose one of two paths: either focus on growing your career by looking for positives and things you can improve, or stay comfortable where you are and pour your energy into other parts of life, rather than getting stuck in cynicism.&lt;/p&gt;
&lt;p&gt;Instead of spaces dominated by griping, spend time in &amp;ldquo;yes, and&amp;rdquo; environments alongside people doing admirable work and living lives you aspire to. Communities degrade when negativity takes over, so protecting them requires leading by example, sharing constructive perspectives, and occasionally moderating discussions; he admits that &amp;ldquo;doing this is socially hard. At the very least, it requires visibly modeling the good.&amp;rdquo; In his view, sadness and anger rarely produce real change—only concrete action does.&lt;/p&gt;
&lt;h2 id="my-productivity-rules"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2025/10/08/studying-while-busy/" rel="noopener noreferrer"&gt;My Productivity Rules&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post shares practical tips for improving study productivity, emphasizing planning, energy management, honesty about effort, daily reviews, and minimizing distractions. It outlines rules such as planning the next day the night before, resting when energy is low, being honest about how much real effort you put in, reflecting on daily progress, and removing distractions like phones or tempting apps.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Plan the next day the night before to avoid morning procrastination&lt;/del&gt;
&lt;del&gt;- Match study intensity to your energy levels throughout the day&lt;/del&gt;
&lt;del&gt;- Be honest about how much real effort you are putting in&lt;/del&gt;
&lt;del&gt;- Reflect on daily progress to improve future plans&lt;/del&gt;
&lt;del&gt;- Eliminate distractions by keeping tempting apps out of sight&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="bonus-an-interesting-visual-from-bytebytego"&gt;Bonus: An interesting visual from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Today I ran into a pretty annoying issue from storing too many collected images directly in the repo. Specifically, it took over 17 minutes to build this site on another machine :v&lt;/em&gt;&lt;/p&gt;
&lt;pre tabindex="0"&gt;&lt;code&gt;...
 | VI
-------------------+------
 Pages | 587
 Paginator pages | 130
 Non-page files | 195
 Static files | 2
 Processed images | 361
 Aliases | 236
 Cleaned | 0

Built in 1043990 ms
...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;&lt;em&gt;So I decided to switch to using the original image URLs instead of committing images into the repo. The downside is that images might get taken down, and they won&amp;rsquo;t be processed to reduce file size, which increases page load time. I&amp;rsquo;ll try to update the images in older posts too (on some nice sunny day when I&amp;rsquo;m feeling diligent :3)&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!KwvJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8ac50da4-feb8-4781-8bb2-e74244aa889f_2250x2814.png" alt="TCP vs UDP"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>