<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Engineering Culture on miti99</title><link>https://miti99.com/en/tags/engineering-culture/</link><description>Recent content in Engineering Culture 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-culture/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #121</title><link>https://miti99.com/en/post/2026/07/09/</link><pubDate>Thu, 09 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #121.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dial-up"&gt;&lt;a href="https://jkm.dev/posts/how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dialup/" rel="noopener noreferrer"&gt;How 2004 RuneScape fit a multiplayer RPG into 56k dial-up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post dissects how 2004 RuneScape ran a massively multiplayer world over 56k dial-up modems, where real-world throughput was just a few kilobytes per second and the Java applet client had only a single TCP connection. Rather than sending self-describing messages, the network protocol was co-designed as a shared state machine between client and server: both sides held the exact same collision map, ran the same pathfinding algorithm, and stepped forward on a 600 ms server tick. Thanks to all that shared implicit context never having to cross the wire, walking across the map cost roughly 7 bytes upstream and 9 bytes downstream per observer—the client only sent path waypoints where direction changed, and the server validated and reconstructed the rest.&lt;/p&gt;
&lt;p&gt;The most fascinating takeaway is how saving bytes goes far beyond generic compression. The most common state was made practically free: an idle player in your viewport cost a single bit, meaning standing among twenty stationary players took roughly five bytes per tick to confirm nothing changed. Newly appearing players were encoded using 5-bit relative coordinates offset from the local player rather than 16-bit global world coordinates. Bit-packing was reserved strictly for small, high-frequency movement updates; larger, rarely changing appearance blocks stayed byte-aligned so the server could cache and memcpy pre-built buffers directly. The architectural lesson: the smallest possible wire format comes from tightly coupling client and server assumptions, trading away the self-description, independent deployability, and easy debugging that modern HTTP/JSON APIs prioritize.&lt;/p&gt;
&lt;h2 id="how-does-struct-take-zero-bytes-in-go"&gt;&lt;a href="https://www.bud1m.com/blog/go-empty-struct/" rel="noopener noreferrer"&gt;How does struct{} take zero bytes in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why Go&amp;rsquo;s empty struct &lt;code&gt;struct{}&lt;/code&gt; occupies zero bytes and how it is idiomatically used to represent presence or signaling rather than data. Inspecting &lt;code&gt;unsafe.Sizeof&lt;/code&gt; confirms that an empty struct takes 0 bytes; used as the value type in &lt;code&gt;map[string]struct{}&lt;/code&gt;, it expresses a pure set where only key existence matters, and on a channel (&lt;code&gt;chan struct{}&lt;/code&gt;) it signals an event without carrying a payload. The author also notes that starting in Go 1.24, Go&amp;rsquo;s built-in maps use Swiss Tables under the hood, leaving almost no meaningful memory difference between &lt;code&gt;map[string]struct{}&lt;/code&gt; and &lt;code&gt;map[string]bool&lt;/code&gt;—so choosing &lt;code&gt;struct{}&lt;/code&gt; today is mainly about expressing intent clearly.&lt;/p&gt;
&lt;p&gt;At the runtime level, whenever a zero-sized value has to be allocated on the heap, &lt;code&gt;mallocgc&lt;/code&gt; checks for &lt;code&gt;size == 0&lt;/code&gt; and returns a pointer to a single global runtime variable named &lt;code&gt;zerobase&lt;/code&gt; instead of allocating heap memory. Whether the value escapes to the heap in the first place is decided by escape analysis: passing it to &lt;code&gt;fmt.Println&lt;/code&gt; (which takes &lt;code&gt;any&lt;/code&gt;) often triggers an escape to &lt;code&gt;zerobase&lt;/code&gt;, whereas built-in &lt;code&gt;println&lt;/code&gt; keeps it on the stack. This design creates two subtle gotchas worth remembering. First, multiple distinct &lt;code&gt;struct{}&lt;/code&gt; variables may share the exact same memory address, and the compiler is free to merge or not merge them, so you should never rely on pointer equality to distinguish zero-sized values. Second, placing a &lt;code&gt;struct{}&lt;/code&gt; as the final field inside a larger non-empty struct causes the compiler to add 1 byte of trailing padding (plus alignment) so that taking the address of that final field doesn&amp;rsquo;t point past the end of the allocation into an adjacent object; if you want zero overhead inside a struct, place the empty struct field anywhere except last.&lt;/p&gt;
&lt;h2 id="is-cloudflare-silently-killing-the-web-hosting-industry"&gt;&lt;a href="https://webhosting.today/2026/06/17/is-cloudflare-silently-killing-the-web-hosting-industry/" rel="noopener noreferrer"&gt;Is Cloudflare silently killing the web hosting industry?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Konrad Keck argues that Cloudflare isn&amp;rsquo;t killing traditional web hosting by becoming a better shared host—it is doing it by moving the starting point of how websites get built and deployed. Historically, a customer bought a domain, signed up for shared hosting, logged into cPanel, installed WordPress, configured SSL and email, and maybe put Cloudflare in front later for CDN and DDoS protection. Today, when a project starts inside Claude Code, Cursor, Lovable, Bolt, or Replit, the question is no longer &amp;ldquo;which hosting plan do I buy?&amp;rdquo; but &amp;ldquo;where do I deploy this?&amp;rdquo;, and Cloudflare, Vercel, and Netlify are built to capture that exact moment. Cloudflare is competing on workflow, not just infrastructure.&lt;/p&gt;
&lt;p&gt;Keck highlights two main levers: near-zero-cost deployment via Pages, Workers, static assets, and usage-priced R2/D1—which hollows out traditional hosting&amp;rsquo;s bread-and-butter market of landing pages, docs sites, frontends, and small APIs—and at-cost domain registration as a top-of-funnel wedge into the ecosystem. Cloudflare&amp;rsquo;s Registrar API closes the loop even further: an AI agent can scaffold a project, suggest available domains, check pricing, register the domain, configure DNS, and deploy to production without the user ever visiting a hosting control panel. Traditional web hosts aren&amp;rsquo;t disappearing overnight—legacy WordPress/WooCommerce and PHP apps, real business email, hands-on migrations, emergency support, local compliance, and non-technical SMBs still rely on human-backed services. The strategic shift is that traditional hosts must evolve into specialized managed service providers, because selling the default starting point of a website is slipping away.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://staysaasy.com/startups/2026/06/16/stacked-weaknesses.html" rel="noopener noreferrer"&gt;Don&amp;rsquo;t Stack Weaknesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy writes about an organizational failure mode that often hides in plain sight across leadership chains: stacking the same weakness across multiple layers of management. Almost every leader has at least one real weakness—someone might be a visionary strategist but poor at operational execution, or deeply technical but weak at executive communication—and on its own, that doesn&amp;rsquo;t sink an org. The danger comes when a leader hires or promotes direct reports who share the exact same blind spot. If both a VP and their directors are weak at operations, the odds of the teams underneath them having strong operational processes drop to nearly zero: leadership doesn&amp;rsquo;t know how to do it themselves, doesn&amp;rsquo;t know how to interview for it, and can&amp;rsquo;t accurately judge whether it&amp;rsquo;s being done well.&lt;/p&gt;
&lt;p&gt;Weakness stacking usually happens unconsciously: leaders naturally recognize and reward strengths that mirror their own, labeling that similarity &amp;ldquo;values alignment&amp;rdquo; or &amp;ldquo;culture fit&amp;rdquo; while actually cloning their own skillset and blind spots. Avoiding the trap starts with an honest self-assessment across six core axes—technical/domain depth, people management, process and operations, strategy, communication/presentation, and learning agility—and then deliberately hiring people who are significantly stronger than you in your weakest areas. The post also warns against comforting yourself with &amp;ldquo;I could do operations if I really wanted to,&amp;rdquo; which is almost always an excuse to avoid confronting a gap. An organization without stacked weaknesses is far more resilient to unexpected challenges.&lt;/p&gt;
&lt;h2 id="system-design-cheatsheet"&gt;&lt;a href="https://gist.github.com/SuyashDive2005/be5865a9755ca1dd50523f7aeeae4417" rel="noopener noreferrer"&gt;System Design Cheatsheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This gist serves as a compact checklist for system design interviews and architecture reviews, anchored on a core principle: good architecture is about picking the right battles and managing trade-offs. It outlines a familiar five-step loop: clarify scope through use cases and constraints; sketch a high-level design covering core services, storage, caching, and load balancing; dive into component details including APIs and data schemas; identify bottlenecks; and scale vertically or horizontally as needed. For newer engineers, its biggest value is forcing quantitative questions early, before jumping to technology choices: how many requests per second, what is the read-to-write ratio, how fast does data grow, does latency or throughput matter more, and where does the system sit on the consistency-versus-availability spectrum?&lt;/p&gt;
&lt;p&gt;The scaling section reviews foundational building blocks: multi-tier caching, load balancing, replication and sharding, MapReduce for batch data processing, and platform separation so components can scale independently. It also lists six core fundamentals worth mastering: concurrency, networking, abstraction boundaries, real-world hardware performance numbers, back-of-the-envelope estimation to rule out dead ends early, and fault tolerance in distributed environments. While brief and carrying a few older examples, it remains a solid mental checklist: characterize load, data shape, failure modes, and scaling paths before picking tools.&lt;/p&gt;
&lt;h2 id="sqlite-improving-performance-with-pre-sort"&gt;&lt;a href="https://andersmurphy.com/2026/06/07/sqlite-improving-performance-with-pre-sort.html" rel="noopener noreferrer"&gt;SQLite improving performance with pre-sort&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anders Murphy follows up on his earlier SQLite UUIDv4 vs. UUIDv7 benchmarks with a tougher scenario: what happens when your primary key must be a 160-bit cryptographically random value generated via &lt;code&gt;SecureRandom&lt;/code&gt;—such as a session token—where you cannot switch to time-ordered UUIDv7 because you need maximum entropy and zero timestamp leakage? When batch-inserting one million rows into a &lt;code&gt;WITHOUT ROWID&lt;/code&gt; table keyed by a &lt;code&gt;BLOB PRIMARY KEY&lt;/code&gt;, insert throughput starts around 100,000 rows per second and steadily degrades as the table grows. The bottleneck isn&amp;rsquo;t SQLite being slow; it&amp;rsquo;s the physics of a B+ Tree: because the tree stores keys in sorted order, sequential inserts append cleanly, whereas uniformly random keys scatter writes across leaf pages all over disk, triggering constant page splits and tree rebalancing.&lt;/p&gt;
&lt;p&gt;Murphy&amp;rsquo;s optimization is disarmingly simple: since the application is already inserting in batches, sort each batch in memory by primary key before inserting. Because SQLite compares &lt;code&gt;BLOB&lt;/code&gt; keys using &lt;code&gt;memcmp()&lt;/code&gt;, the application-side comparator just needs to match byte-wise ordering; Murphy grabs the first 8 bytes of each 20-byte token as an unsigned 64-bit integer to make the in-memory sort fast. Even including the CPU cost of sorting each batch, once the table reaches ten million rows, batch insert time drops from 11.1 seconds to 3.8 seconds—roughly a 2–3x speedup. The practical takeaway: batching doesn&amp;rsquo;t just amortize transaction overhead; it also gives you a window to reorder writes into a layout that is far friendlier to the underlying storage engine.&lt;/p&gt;
&lt;h2 id="why-is-meta-destroying-its-engineering-organization"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/why-is-meta-destroying-its-engineering" rel="noopener noreferrer"&gt;Why is Meta destroying its engineering organization?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz pieces together a tense picture of engineering inside Meta since April 2026, as the company pivots aggressively around AI. Historically, Meta was renowned for its strong bottom-up engineering culture: lightweight process, high individual autonomy, rock-solid internal tooling that let engineers &amp;ldquo;move fast,&amp;rdquo; and engineers treated as the core value creators. Under the direction of Mark Zuckerberg and Alexandr Wang, however, 30–50% of core software engineers across many teams—including infrastructure and security—were reassigned into a new ADO organization (roughly 6,500 people) to do data labeling, model output grading, and RLHF. Meta also rolled out mandatory keystroke and mouse tracking on engineering laptops to harvest training data with no opt-out (later walked back slightly after internal backlash), alongside ongoing layoff pressure and AI token-usage quotas.&lt;/p&gt;
&lt;p&gt;What stands out most isn&amp;rsquo;t just &amp;ldquo;Meta is pushing AI hard,&amp;rdquo; but how badly perverse incentives distort behavior. Once AI token consumption became a performance metric, engineers naturally gamed the metric (burning 60.2 trillion tokens in 30 days) rather than optimizing for software quality. And when AI-generated code reviewed only by AI gets pushed rapidly to production while security teams are gutted and reassigned, operational risk compounds fast: Orosz connects these dynamics to the May 30 Instagram account-takeover incident and the departure of Meta&amp;rsquo;s CISO shortly afterward. The broader lesson is not to confuse fast MTTR with system health: recovering quickly from outages cannot compensate for eroding human comprehension, weakened guardrails, and hollowed-out engineering ownership.&lt;/p&gt;
&lt;h2 id="cs-6120-advanced-compilers-the-self-guided-online-course"&gt;&lt;a href="https://www.cs.cornell.edu/courses/cs6120/2025fa/self-guided/" rel="noopener noreferrer"&gt;CS 6120: Advanced Compilers: The Self-Guided Online Course&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page hosts the self-guided version of CS 6120, Adrian Sampson&amp;rsquo;s PhD-level course at Cornell on programming language implementation and modern compilers. The curriculum progresses from core compiler foundations—intermediate representations, dataflow analysis, local and global optimizations, SSA form, and LLVM—into research-adjacent topics like dynamic compilers (JITs), garbage collection, parallelism, and fast compilation. Each lesson pairs lecture videos and written notes with classic academic papers and open-ended implementation tasks to turn abstract theory into working code.&lt;/p&gt;
&lt;p&gt;The self-guided track preserves the linear structure of the university course while removing deadlines, grading, and internal class discussion boards. Learners follow a clear rhythm: watch the lecture, read the companion paper, and implement compiler passes using either LLVM or Bril—a small, pedagogical intermediate representation designed to be much easier to hack on than jumping straight into a production compiler—culminating in a final project. It is an outstanding resource for internalizing that a compiler isn&amp;rsquo;t just &amp;ldquo;a parser bolted onto a code generator,&amp;rdquo; but a pipeline of representation choices, program analyses, optimizations, and trade-offs between correctness, compile time, and generated code quality. The best way to use it is writing the small transformation passes yourself as you go, since compiler concepts are notoriously easy to misunderstand if you only read about them.&lt;/p&gt;
&lt;h2 id="epoll-vs-io_"&gt;&lt;a href="https://sibexi.co/posts/epoll-vs-io_uring/" rel="noopener noreferrer"&gt;epoll vs io_uring in Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares &lt;code&gt;epoll&lt;/code&gt; and &lt;code&gt;io_uring&lt;/code&gt; through the lens of building TinyGate, a lightweight reverse proxy in C. The first prototype used a simple thread-per-worker model that was easy to reason about but hit a hard performance ceiling; moving to &lt;code&gt;epoll&lt;/code&gt; delivered a major speedup, yet still paid the fundamental tax of a readiness-based model: &lt;code&gt;epoll&lt;/code&gt; only tells you when a file descriptor is ready for I/O, leaving the application to issue its own &lt;code&gt;read()&lt;/code&gt; or &lt;code&gt;write()&lt;/code&gt; syscalls afterward. Every I/O event therefore incurs syscall and context-switch overhead on top of &lt;code&gt;epoll_ctl&lt;/code&gt; registration, which adds up quickly across tens of thousands of active connections.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;io_uring&lt;/code&gt; shifts to a completion-based model: the application writes I/O requests into a submission queue in shared memory, the kernel executes them asynchronously, and results land in a shared completion queue. A single &lt;code&gt;io_uring_enter()&lt;/code&gt; call can submit and harvest an entire batch of operations instead of paying a syscall per &lt;code&gt;read()&lt;/code&gt;/&lt;code&gt;write()&lt;/code&gt;. Enabling &lt;code&gt;IORING_SETUP_SQPOLL&lt;/code&gt; can even eliminate steady-state syscalls almost entirely, at the cost of dedicating a kernel thread that spins and consumes CPU to poll the submission ring. While the author recommends considering &lt;code&gt;io_uring&lt;/code&gt; for new high-performance Linux projects (available since Linux 5.1, though specific opcodes depend on kernel version), he cautions that production use requires care: using rings or registered buffers doesn&amp;rsquo;t automatically guarantee zero-copy I/O, errors arrive asynchronously via completion queue entries, and minimal tutorial examples omit many edge-case checks required in real servers.&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, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #110</title><link>https://miti99.com/en/post/2026/06/07/</link><pubDate>Sun, 07 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #110.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-podcast--086-just-use-postgres-man"&gt;&lt;a href="https://share.transistor.fm/s/5159e8a9" rel="noopener noreferrer"&gt;go podcast() | 086: Just use postgres, man&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this podcast episode, Dominic St-Pierre and Morten Vistisen revolve around a familiar question: should you store telemetry data in ClickHouse or just stick with PostgreSQL? Morten wants to try ClickHouse, while Dominic takes the pragmatic stance: below roughly 10 million rows, PostgreSQL performs nearly as well, and scaling rarely happens overnight, leaving plenty of time to migrate when you actually need to. Morten also recounts having to rewrite a component in his DeployQuad project because the LLM-generated code from the initial prototype didn&amp;rsquo;t behave as expected, underscoring the importance of truly understanding the code you ship.&lt;/p&gt;
&lt;p&gt;Dominic introduces StaticBackend v1.7.0, adding multi-account user support and expanded server-side functions powered by Goja (a JavaScript runtime written in Go), while lamenting how tedious releases are when updating multiple NPM packages compared to Go&amp;rsquo;s simple tag-and-push workflow. Toward the end, both hosts express skepticism about over-relying on AI code generation: it disrupts deep flow states while programming, causes skills to atrophy, and may not even deliver a net productivity gain. They remain convinced that core programming skills are as valuable as ever.&lt;/p&gt;
&lt;h2 id="that-one-time-i-used-go-panics-for-flow-control"&gt;&lt;a href="https://noncrab.net/posts/panic-as-flow-control/" rel="noopener noreferrer"&gt;That one time I used Go panics for flow control&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author recounts an overload incident on an in-memory Go data service: when query volume exceeded capacity, requests that normally took 1–2 seconds stretched to a full minute, and upstream retries only piled on more load. The root problem was that Go&amp;rsquo;s standard library sorting functions neither accept a &lt;code&gt;context&lt;/code&gt; nor return an error, so the service kept burning CPU cycles sorting results for queries whose callers had already timed out and walked away. That library design is normally reasonable, since sorting usually happens in batch jobs or over slices small enough that execution time is negligible.&lt;/p&gt;
&lt;p&gt;Rather than rewriting the entire sorting layer, the team used a &lt;code&gt;panic&lt;/code&gt;/&lt;code&gt;recover&lt;/code&gt; pair as an escape hatch: the comparison function checks whether the &lt;code&gt;context&lt;/code&gt; has been canceled and, if so, calls &lt;code&gt;panic&lt;/code&gt; with a dedicated sentinel value. A &lt;code&gt;defer&lt;/code&gt; wrapper around the sort catches that specific sentinel &lt;code&gt;panic&lt;/code&gt; and converts it into a normal error while re-panicking on anything else so real bugs aren&amp;rsquo;t swallowed. That let the system abort useless sorts immediately. The author readily admits this is &amp;ldquo;an ugly solution to an ugly problem,&amp;rdquo; strictly for narrow, tightly controlled situations.&lt;/p&gt;
&lt;h2 id="the-last-six-months-in-llms-in-five-minutes"&gt;&lt;a href="https://simonwillison.net/2026/May/19/5-minute-llms/" rel="noopener noreferrer"&gt;The last six months in LLMs in five minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is the annotated version of Simon Willison&amp;rsquo;s lightning talk at PyCon US 2026, recapping developments in large language models from November 2025 through May 2026. The standout trend is that coding agents crossed a decisive quality threshold: thanks to OpenAI and Anthropic applying reinforcement learning with verifiable rewards throughout 2025, agents went from &amp;ldquo;often works&amp;rdquo; to &amp;ldquo;almost always works&amp;rdquo; and became everyday workhorses. In November alone, the title of &amp;ldquo;best model&amp;rdquo; changed hands five times between Anthropic, OpenAI, and Google, while Willison continued using his signature benchmark of asking models to generate an SVG of a pelican riding a bicycle.&lt;/p&gt;
&lt;p&gt;The second major trend is local open-weight models blowing past expectations, including Google&amp;rsquo;s Gemma 4 family, China&amp;rsquo;s GLM-5.1, and Qwen3.6-35B-A3B, which weighs in at roughly 21GB and runs comfortably on a standard laptop. The talk also highlights OpenClaw, a personal AI assistant project that went so viral that &amp;ldquo;Claws&amp;rdquo; became the generic term for the entire category of personal agents and Mac Minis sold out as people bought them to run Claws at home.&lt;/p&gt;
&lt;h2 id="prompts-are-technical-debt-too"&gt;&lt;a href="https://www.seangoedecke.com/prompts-are-technical-debt-too/" rel="noopener noreferrer"&gt;Prompts are technical debt too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that prompts — including instruction files like &lt;code&gt;AGENTS.md&lt;/code&gt; and &lt;code&gt;CLAUDE.md&lt;/code&gt; — are a form of technical debt, and in some ways worse than code debt. When code doesn&amp;rsquo;t change, its behavior stays largely the same, and when it breaks it usually fails loudly; prompts, by contrast, silently degrade every time the underlying model is upgraded. A prompt painstakingly tuned to work around an older model&amp;rsquo;s quirks can become useless or actively counterproductive on a newer model without anyone noticing. According to Goedecke, an agent harness with elaborate prompts wrapped around an older model will almost always lose to a minimal harness running a newer model.&lt;/p&gt;
&lt;p&gt;From there, he offers concrete advice: stick to mainstream AI coding tools like Claude Code, Cursor, or Copilot with their default configurations, since their engineering teams continuously re-tune the system prompts for you; avoid installing extra MCP servers or skills unless strictly necessary; if you must write an &lt;code&gt;AGENTS.md&lt;/code&gt;, stick to core factual details about the project rather than trying to micromanage model behavior, and never check in model-generated instructions without reviewing them carefully. Finally, regularly prune custom prompts to keep maintenance overhead low.&lt;/p&gt;
&lt;h2 id="we-see-something-that-works-and-then-we-understand-it"&gt;&lt;a href="https://lemire.me/blog/2025/12/04/we-see-something-that-works-and-then-we-understand-it/" rel="noopener noreferrer"&gt;We see something that works, and then we understand it&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire pushes back against the &amp;ldquo;linear model of innovation&amp;rdquo; — the belief that theoretical understanding must come first and practical progress follows afterward. Borrowing Kevin Kelly&amp;rsquo;s term &amp;ldquo;thinkism,&amp;rdquo; he critiques the illusion that thinking hard enough in the abstract can solve any problem. That mindset dominates schools and bureaucracies, where rules are fixed in advance: students learn a concept first and then solve textbook problems designed to require only that exact concept. History usually works the other way around: pendulum clocks were keeping time in 1656, well before Newton and Hooke formulated the laws of force and motion that explained why they worked.&lt;/p&gt;
&lt;p&gt;In Lemire&amp;rsquo;s view, real R&amp;amp;D always happens with incomplete understanding; people entering industry often learn more in a single year on the job than across their entire university degree because real-world engineering demands continuous experimentation and observation. He draws two lessons: breakthroughs require prioritizing hands-on experimentation over abstract theorizing, and we shouldn&amp;rsquo;t expect AI to solve every complex problem purely from existing knowledge, because the physical world is always richer and messier than what we already know.&lt;/p&gt;
&lt;h2 id="how-vercel-cut-build-wait-times-from-90-seconds-to-5"&gt;&lt;a href="https://blog.bytebytego.com/p/how-vercel-cut-build-wait-times-from" rel="noopener noreferrer"&gt;How Vercel Cut Build Wait Times From 90 Seconds To 5&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article examines how Vercel cut build environment provisioning wait times from 90 seconds down to 5 seconds — an 18x speedup — using an internal platform called Hive. The core challenge is that Vercel runs untrusted build code from thousands of customers on shared hardware, meaning every build must be treated as potentially hostile. Standard containers aren&amp;rsquo;t isolated enough because they share the host Linux kernel, where a single kernel vulnerability could expose another customer&amp;rsquo;s workload. Instead of Kubernetes, Vercel built Hive on AWS Firecracker microVMs: each build runs inside a &amp;ldquo;cell&amp;rdquo; — a tiny virtual machine with its own dedicated kernel that boots in roughly 125 milliseconds. The architecture spans regional clusters where physical &amp;ldquo;boxes&amp;rdquo; host multiple cells, coordinated by a control plane.&lt;/p&gt;
&lt;p&gt;The speedup comes from three compounding optimizations: container image caching and disk snapshots cut cold starts from ~50 seconds down to 5 seconds; a warm pool of pre-booted cells waiting for work means most builds experience near-zero queue wait; and Firecracker&amp;rsquo;s millisecond boot times make maintaining and replenishing that warm pool economical. The trade-off is that keeping warm cells idle consumes resources and every cell must be destroyed after a single build for security, but owning the underlying infrastructure has unlocked new product capabilities for Vercel.&lt;/p&gt;
&lt;h2 id="the-anatomy-of-an-ai-native-org"&gt;&lt;a href="https://ajeygore.in/content/the-anatomy-of-an-ai-native-org" rel="noopener noreferrer"&gt;The Anatomy of an AI-Native Org&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ajey Gore argues that AI is reshaping organizational structure by eliminating the &amp;ldquo;translation layer.&amp;rdquo; For thirty years, software companies have operated across three tiers: leadership decides the &amp;ldquo;Why,&amp;rdquo; product defines the &amp;ldquo;What,&amp;rdquo; and engineering translates those decisions into code — the &amp;ldquo;How.&amp;rdquo; Much of the day-to-day work in that model consists of translating between well-defined inputs and outputs. According to Gore, AI doesn&amp;rsquo;t target a specific job title so much as that entire category of translation work — turning requirements into code or specs into UI components — making it orders of magnitude cheaper, while the strategic work at both ends remains just as hard as ever.&lt;/p&gt;
&lt;p&gt;The shape of an &amp;ldquo;AI-Native&amp;rdquo; organization shifts accordingly: the &amp;ldquo;Why&amp;rdquo; layer stays small; the &amp;ldquo;What&amp;rdquo; layer expands because judgment and taste become critical when directing AI; the human &amp;ldquo;How&amp;rdquo; layer shrinks sharply in headcount but rises in difficulty, focusing on architecture, security, and verification mechanisms that make AI output trustworthy; and AI agents handle routine translation under human supervision. Managers can no longer just coordinate — they must contribute directly — while engineers should move toward problem definition rather than competing with AI on raw code translation.&lt;/p&gt;
&lt;h2 id="how-to-stay-resilient-in-a-difficult-job"&gt;&lt;a href="https://andiroberts.com/executive-coaching/how-to-stay-resilient-in-a-difficult-job" rel="noopener noreferrer"&gt;How to Stay Resilient in a Difficult Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article outlines 7 practical, science-backed strategies for maintaining mental resilience when stuck in a difficult job — whether dealing with a poor manager, irregular shifts, or chronic stress. The author stresses that resilience here doesn&amp;rsquo;t mean forcing toxic positivity or pretending the job is fun; it means conserving energy, keeping an objective perspective, and maintaining a sense of agency so you can do good work, protect your health, and stay positioned for future moves.&lt;/p&gt;
&lt;p&gt;The strategies include: grounding yourself mentally at the start of the day and stabilizing your physiology with sunlight, hydration, and movement before work; focusing strictly on what lies within your control and upholding your own professional standards even when surrounding systems are messy; setting emotional boundaries so you don&amp;rsquo;t carry work stress home; finding at least one trusted colleague to confide in; and consistently taking small steps toward landing a better role.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://brooker.co.za/blog/2026/05/18/whats-easy-whats-hard.html" rel="noopener noreferrer"&gt;What&amp;rsquo;s Easy Now? What&amp;rsquo;s Hard Now?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker proposes the &amp;ldquo;feedback loop hypothesis&amp;rdquo;: over the long run, AI coding agents will find tasks with clear, measurable feedback loops &amp;ldquo;easy,&amp;rdquo; while tasks lacking effective automated feedback will remain &amp;ldquo;hard&amp;rdquo; — and this divide will be the primary determinant of agent capability. Opening with an analogy from electrical engineering, he notes that strong negative feedback can turn simple, nonlinear, even flawed components into remarkably accurate amplifiers.&lt;/p&gt;
&lt;p&gt;From that premise, he flips the conventional wisdom that web development is easy and systems programming is hard. A database storage engine like RocksDB has a relatively compact specification — an API plus safety and liveness properties — that can be verified automatically. Web development, by contrast, lacks an equivalent automated oracle and relies on slow, inconsistent human judgment. Current practice already reflects this: agents excel at performance optimization when given a solid benchmark suite, struggle with subjective architectural trade-offs, and get guided toward correct code in languages like Rust thanks to strict compiler errors. Consequently, formal specification languages, compile-time checks, and rigorous testing frameworks will only grow in importance.&lt;/p&gt;
&lt;h2 id="making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use"&gt;&lt;a href="https://medium.com/pinterest-engineering/making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use-2a56a928cae1" rel="noopener noreferrer"&gt;Making User-Sequence Data More Cost-Efficient, Faster, and Easier to Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest&amp;rsquo;s engineering team shares how they redesigned their user-sequence data platform — the ordered history of a user&amp;rsquo;s recent actions enriched with signals like embeddings, device context, and country. This data powers ML ranking, retrieval, and recommendation models across the Home feed, Related Pins, and search results, serving training pipelines, offline analytics, and real-time inference alike. Because it must be simultaneously fresh, complete, consistent between training and serving, and schema-stable, it is often one of the most expensive and brittle parts of a data stack.&lt;/p&gt;
&lt;p&gt;The core principle of the redesign is &amp;ldquo;One definition, multiple runtimes&amp;rdquo;: each signal is defined once and shared across real-time indexing, batch backfills for historical data, and online serving via a unified execution engine supporting both streaming and batch modes. That eliminates training-serving skew by construction. Combined with a Lambda architecture to balance freshness and completeness, plus columnar storage and time-based partitioning, Pinterest significantly cut storage costs and network bandwidth while turning the addition of new event types or signals into a mostly configuration-driven change.&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><item><title>Newsletter #87</title><link>https://miti99.com/en/post/2026/03/02/</link><pubDate>Mon, 02 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #87.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="on-cognitive-debt"&gt;&lt;a href="https://www.natemeyvis.com/on-cognitive-debt/" rel="noopener noreferrer"&gt;On cognitive debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;There has been plenty of talk lately about &amp;ldquo;cognitive debt&amp;rdquo;: when AI-generated code grows so fast that nobody understands how it works anymore, making it hard to extend, observe, and debug. Nate Meyvis agrees the phenomenon is real, but argues the panic is overblown. Compared at the same project size, cognitive debt in pre-AI codebases was often even worse; AI simply lets us move several times faster, so we hit that complexity wall much sooner. We miss this because much of what we treat as &amp;ldquo;normal engineering&amp;rdquo;—like a handful of senior engineers carrying all the implicit constraints in their heads—is actually the tax of cognitive debt. When a local change breaks a distant part of the system and tests don&amp;rsquo;t catch it, that usually means encapsulation had already failed.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, skilled AI users already know how to keep cognitive debt in check and will keep getting better at it. He shares several practices: emphasizing encapsulation in project-level AI instructions, clearly documenting subsystems, their interfaces, and data structures, leaning into large-scale refactoring with AI (which is much less painful now), and adding tests wherever cognitive debt starts to show. The takeaway: cognitive debt is real, but we fix it by using AI better rather than blaming AI for our own engineering habits.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://davidoks.blog/p/why-im-not-worried-about-ai-job-loss" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m not worried about AI job loss&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Oks responds to Matt Shumer&amp;rsquo;s viral essay &amp;ldquo;Something Big Is Happening,&amp;rdquo; which compared the present moment to February 2020 right before COVID hit and warned of mass unemployment. Oks believes AI will be as consequential as electricity or the steam engine, but argues its real-world impact on jobs will be much slower and more uneven. First, labor substitution is governed by comparative advantage, not absolute advantage: even if AI outperforms humans at every task, pairing humans with AI remains worthwhile whenever combined output is higher—which is visibly true in software engineering today. Second, the world is full of human-made bottlenecks: regulation, corporate culture, politics, habit, and above all resistance to change. That is why, even with capable models available for years, outsourced customer support still hasn&amp;rsquo;t been replaced wholesale.&lt;/p&gt;
&lt;p&gt;Third, demand for many goods and services is more elastic than we assume, so efficiency gains are often absorbed by rising demand, just as Jevons paradox predicts; every past leap in programming productivity ended up increasing demand for software engineers. Over the long run, humans will keep inventing new kinds of work that blur the line between labor and leisure. The author concludes that ordinary workers will be fine; the real danger is a populist backlash fueled by doomerism, which could lead to bans on data center construction and choke off the benefits AI can bring.&lt;/p&gt;
&lt;h2 id="why-i-don"&gt;&lt;a href="https://honnibal.dev/blog/ai-bubble" rel="noopener noreferrer"&gt;Why I don&amp;rsquo;t think AI is a bubble&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthew Honnibal, creator of the spaCy NLP library, sets aside the financial side of the &amp;ldquo;AI bubble&amp;rdquo; debate to answer the technical question: is AI progress about to plateau? The common argument is that recent gains came from brute-force scaling, returns are diminishing, and we are about to hit a wall. He admits he thought the same back in the GPT-1 and GPT-2 days, but underestimated reinforcement learning (RL). Reasoning models like Claude Opus or GPT-5 combine generative pre-training on massive text corpora with AlphaZero-style RL: the model generates intermediate steps, and chains of steps that lead to verifiable correct answers get reinforced. &amp;ldquo;Logic is work&amp;rdquo;: even in a purely symbolic system, deduction requires computation, so generating intermediate steps is essential rather than a parlor trick.&lt;/p&gt;
&lt;p&gt;The scaling-wall argument only applies to next-token pre-training. Reasoning opens up two new levers: letting models run longer at inference time to think through harder problems, and scaling up reinforcement learning; combined with the ability to backtrack from dead ends, models can search the solution space much like exploring moves in chess. Nor does RL face an obvious data wall, because verifying a successful chain of reasoning is far easier than generating one from scratch. While he doesn&amp;rsquo;t trust OpenAI as a company, he sees no technical reason to think progress is about to stop, and expects the new data centers to be put to productive use.&lt;/p&gt;
&lt;h2 id="i-guess-i-kinda-get-why-people-hate-ai"&gt;&lt;a href="https://anthony.noided.media/blog/ai/programming/2026/02/14/i-guess-i-kinda-get-why-people-hate-ai.html" rel="noopener noreferrer"&gt;I guess I kinda get why people hate AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from a hotel balcony in Hawaii nine days before starting a new job, the author wonders whether this will be the last job he ever has. Once, that question meant wondering whether he&amp;rsquo;d ever &lt;em&gt;need&lt;/em&gt; to work again; now it means wondering whether AI will make him unemployable. He doesn&amp;rsquo;t hate AI, but he understands why so many people do. The most obvious reason: AI industry leaders actively market their products by boasting that they will wipe out jobs—something unprecedented in the history of technology. If they genuinely believed that, he argues, they would be lobbying right now for trigger laws, such as automatic tax hikes to fund retraining or universal basic income if unemployment rises while GDP grows. That nobody is proposing this suggests they either don&amp;rsquo;t believe their own hype or don&amp;rsquo;t care about the fallout.&lt;/p&gt;
&lt;p&gt;Meanwhile, everyday encounters with AI for ordinary people are mostly negative: students pasting homework into ChatGPT, deepfake Elon Musk videos fooling his dad, AI slop flooding TikTok, cURL shutting down its bug bounty program under a wave of fabricated vulnerability reports, and RAM prices spiking. AI &lt;em&gt;sometimes&lt;/em&gt; helps people do high-quality work, but it &lt;em&gt;always&lt;/em&gt; makes generating slop nearly free. He proposes concrete mitigations: watermarking AI-generated content, stricter YouTube enforcement against AI misinformation, and letting major open-source projects opt out of automated AI vulnerability scanning. What worries him most is that the AI labs barely seem to be trying.&lt;/p&gt;
&lt;h2 id="uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/ubers-rate-limiting-system/" rel="noopener noreferrer"&gt;Uber&amp;rsquo;s Rate Limiting System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber handles hundreds of millions of RPCs per second across thousands of microservices. Historically, teams built their own rate limiters—typically backed by Redis counters—leading to inconsistent configuration, added latency, and operational toil. Because centralized counters cannot scale to hundreds of thousands of instances across regions, Uber built GRL (Global Rate Limiter) directly into its service mesh, allowing rate limits per caller or procedure without code changes. GRL has three tiers: in-mesh clients make local per-request decisions, zone-level aggregators roll up usage metrics, and a regional controller computes global utilization and pushes drop directives back down. An initial token-bucket design distributed quota unfairly across callers, so the team switched to probabilistic dropping: when aggregate load exceeds the limit, every client drops a fraction of requests equal to &lt;code&gt;(actual − limit) / actual&lt;/code&gt;, updated every second. The trade-off is a 2–3 second reaction delay.&lt;/p&gt;
&lt;p&gt;Eliminating Redis cut median latency by ~1ms, P90 by tens of milliseconds, and improved P99.5 by up to 90%; the system has absorbed 15x traffic spikes and mitigated DDoS incidents. GRL now processes roughly 80 million requests per second across more than 1,100 services. To keep limits from going stale, Uber also built RLC (Rate Limit Configurator), which periodically analyzes recent weeks of traffic, computes safe limits from historical peaks plus headroom, and automatically rolls out updated configurations with a dry-run shadow mode before enforcement.&lt;/p&gt;
&lt;h2 id="agents-feb-2026"&gt;&lt;a href="https://calv.info/agents-feb-2026" rel="noopener noreferrer"&gt;Agents (Feb 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Calvin French-Owen, who helped launch Codex Web at OpenAI, shares how he uses coding agents as of February 2026. His own time is now the scarce resource: he picks tools based on how much time he has and how much autonomy he wants to grant. The core mental model is understanding context: an agent is just predicting the next token, and everything must fit inside the context window. From that follow several rules: break work into small chunks, remember that context compaction always loses information, persist state to the filesystem (such as numbered plan files with checkboxes), and stay inside the &amp;ldquo;smart half&amp;rdquo; of the context window. Opus in Claude Code works across multiple context windows remarkably well, eagerly spawns parallel sub-agents, uses tools effectively, and explains itself clearly. Codex (GPT-5.3) writes noticeably less buggy code, but runs slower because it doesn&amp;rsquo;t yet fan work out across multiple context windows. So he plans with Claude Code and implements with Codex.&lt;/p&gt;
&lt;p&gt;His setup uses a &lt;code&gt;plans/&lt;/code&gt; directory of numbered plans, parallel git worktrees, preview deployments per branch, a plan–implement–review loop, and automated review bots to catch bugs. Skills chain and automate recurring workflows with minimal token overhead; he only creates a skill after repeating a task several times, gradually building up &lt;code&gt;/commit&lt;/code&gt;, &lt;code&gt;/worktree&lt;/code&gt;, &lt;code&gt;/implement&lt;/code&gt;, &lt;code&gt;/address-bugs&lt;/code&gt;, and &lt;code&gt;/pr-pass&lt;/code&gt;. The main barriers to continuously running agents are context management and prompt-injection defense; increasingly, ideas, architecture, and project sequencing are the real bottlenecks.&lt;/p&gt;
&lt;h2 id="the-software-industrial-revolution"&gt;&lt;a href="https://cannoneyed.com/essays/software-industrial-revolution" rel="noopener noreferrer"&gt;The Software Industrial Revolution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, late 2025 was the moment AI coding agents truly clicked, kicking off the &amp;ldquo;Software Industrial Revolution.&amp;rdquo; Just as the Spinning Jenny in 1764 turned single-threaded hand spinning into a parallel process and drove cotton cloth prices down by more than 90% over half a century, AI is automating software production—until now an extraordinarily labor-intensive craft. Software has eaten the world: the tech sector accounts for roughly 35% of the S&amp;amp;P 500, and nearly 50% when communication services are included. Yet because building software was so expensive, business models were pushed toward VC-fueled growth-at-all-costs to capture a market and then extract monopoly rents, leading to the &amp;ldquo;enshittification&amp;rdquo; Cory Doctorow describes. A textbook example is Epic, which holds 42% of the US acute-care hospital market with margins above 30%, where the sheer cost of building complex enterprise software chokes off competition.&lt;/p&gt;
&lt;p&gt;When software becomes orders of magnitude cheaper to produce, we will get vastly more of it, demand for engineers may actually rise, the old VC playbook will fade, and more sustainable business models will emerge. Anyone—from a cancer researcher to a small-business owner—will be able to have AI build the exact tools they need, sparking an explosion of bespoke software across every industry. While hand-typing code is losing its premium, core engineering skills like domain modeling, managing complexity, and understanding how software interacts with the real world will matter more than ever.&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><item><title>Newsletter #10</title><link>https://miti99.com/en/post/2025/04/05/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #10.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="gaining-years-of-experience-in-a-few-months"&gt;&lt;a href="https://marcgg.com/blog/2025/02/11/high-growth/" rel="noopener noreferrer"&gt;Gaining Years of Experience in a Few Months&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G. Gauthier, former VP of Engineering at Drivy, reflects on uneven learning curves in a career: those rare, intense stretches where you absorb so much so quickly that a few months feel like years of experience. For him, that moment came when Drivy was acquired by Getaround in 2019, forcing him to juggle technical, architectural, communication, management, business, and product challenges simultaneously under high stakes and tight deadlines. He distinguishes this from merely &amp;ldquo;stepping outside your comfort zone&amp;rdquo;: it pushes well past your current capabilities, carries a real risk of failure, and is impossible to sustain indefinitely.&lt;/p&gt;
&lt;p&gt;To frame this, he divides work into four zones: the &lt;strong&gt;Comfort Zone&lt;/strong&gt; (safe, but staying too long leads to stagnation), the &lt;strong&gt;Learning Zone&lt;/strong&gt; (healthy stretch challenges where you should spend most of your career), the &lt;strong&gt;High Growth Zone&lt;/strong&gt; (compressing years of growth into months, unsustainable and not always available on demand), and the &lt;strong&gt;Burnout Zone&lt;/strong&gt; if you stay in high growth too long. He sketches healthy career trajectories that alternate between the Learning and High Growth zones, or use the Comfort Zone briefly to recover after an intense sprint before returning to the Learning Zone. His closing advice: when a rare High Growth opportunity comes along, lean in and make the most of it—but watch your health closely, because none of the career gains matter if you burn out.&lt;/p&gt;
&lt;h2 id="writing-better-commit-messages"&gt;&lt;a href="https://refactoringenglish.com/chapters/commit-messages/" rel="noopener noreferrer"&gt;Writing Better Commit Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this chapter from &lt;em&gt;Refactoring English&lt;/em&gt;, Michael Lynch argues that commit messages are routinely treated as an afterthought, resulting in useless one-liners like &lt;code&gt;&amp;quot;Fix bug&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;Update UI&amp;quot;&lt;/code&gt;. The most important reader of a commit message, he notes, is your code reviewer—followed by teammates, library consumers, future bug investigators, and automated release-note generators. Because of that, you should structure commit messages like a journalist&amp;rsquo;s &amp;ldquo;inverted pyramid,&amp;rdquo; putting the most essential context right at the top and using section headings to break up longer messages.&lt;/p&gt;
&lt;p&gt;The subject line is the most critical piece because it&amp;rsquo;s what shows up in &lt;code&gt;git log --oneline&lt;/code&gt; and GitHub&amp;rsquo;s commit history view; it should describe the &lt;em&gt;impact&lt;/em&gt; of the change (e.g., &lt;code&gt;&amp;quot;Prevent database corruption when users register concurrently&amp;quot;&lt;/code&gt;) rather than the mechanics of the code edit. The body should explain how the change affects end users and, above all, the &lt;em&gt;motivation&lt;/em&gt;: why the change was needed and what constraints shaped the chosen solution. Depending on the situation, you can include breaking-change notices, non-obvious reference links, reasons for adding a new dependency, issue tracker links, testing instructions and limitations, and alternatives considered. Conversely, leave out anything already obvious from the diff, ephemeral review chatter, and temporary preview URLs—and remember that anything essential for ongoing code maintenance belongs in code comments, not buried in commit history.&lt;/p&gt;
&lt;h2 id="the-rotation-program-that-keeps-this-startup"&gt;&lt;a href="https://review.firstround.com/the-rotation-program-that-keeps-this-startups-engineers-learning-and-not-leaving/" rel="noopener noreferrer"&gt;The Rotation Program That Keeps This Startup&amp;rsquo;s Engineers Learning — and Not Leaving&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This First Round Review interview with Krista Moroder, VP of Engineering at Checkr, tells the story of an internal rotation program that drove voluntary attrition in her org down to nearly zero. A former high school teacher, Moroder borrowed an exercise from the faculty lounge: putting stickers next to the names of students who had a strong adult connection at school to spot which kids were falling through the cracks. She adapted that idea into a spreadsheet tracking every engineer, observing that when engineers leave after two or three years, it&amp;rsquo;s usually not just about equity vesting—it&amp;rsquo;s because they stopped learning and got bored, a restlessness only amplified by anxiety over falling behind in the AI wave.&lt;/p&gt;
&lt;p&gt;The program runs in three steps: maintaining a &amp;ldquo;sticker chart&amp;rdquo; spreadsheet with three columns (joined a rotation or cross-functional tiger team, worked on multiple teams, or received training for a new role) with the goal that every engineer has at least one box checked before their third anniversary; matching that list against quarterly company priorities to rotate engineers where they&amp;rsquo;re needed; and holding deliberate check-ins before making any transfer permanent. Roughly half of all rotations end with the engineer staying on the new team permanently, and one temporary AI tiger team evolved into a permanent core team. To persuade managers to let their top performers rotate out, she argues that having an &amp;ldquo;indispensable&amp;rdquo; single point of failure is actually a succession-planning bug, and that the whole engineering org needs to get an A together. The result: roughly 60% of Checkr&amp;rsquo;s Staff+ engineers have been with the company for six years or more.&lt;/p&gt;
&lt;h2 id="judge-your-coworkers"&gt;&lt;a href="https://blog.staysaasy.com/p/judge-your-coworkers" rel="noopener noreferrer"&gt;Judge Your Coworkers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Stay SaaSy post warns against a cultural failure mode the author calls &lt;strong&gt;Mutually Assured Mediocrity&lt;/strong&gt;: when everyone is performing at a mediocre level, they form an unspoken pact never to criticize one another out of fear that their own weaknesses will be exposed in return. The post traces how this creeps in as a company grows: new departments form, &amp;ldquo;you don&amp;rsquo;t understand our job, stay in your lane&amp;rdquo; becomes a defensive shield, leaders avoid holding peers accountable to avoid being judged themselves, and eventually the few people who dare to point out real problems get punished as troublemakers.&lt;/p&gt;
&lt;p&gt;To counter this, the author advocates encouraging employees to form healthy judgments about their coworkers&amp;rsquo; work, governed by three ground rules: never criticize peers publicly—share feedback only privately with your direct manager or in formal peer reviews; keep performance management strictly confidential; and remind everyone that nobody is promised flawless coworkers. Managers should explicitly tell reports early on that they are expected to have opinions on their collaborators&amp;rsquo; effectiveness, and check in on those opinions every 6–12 months. When a report praises someone, it&amp;rsquo;s a coaching moment to calibrate what great work looks like across seniority levels; when they complain, it surfaces hidden performance issues or role misunderstandings early (for example, mistaking a product manager for a project manager). The closing message: failing to hold people accountable is one of the worst disservices a company can do to its employees, and tech has pushed &amp;ldquo;blameless&amp;rdquo; culture way too far.&lt;/p&gt;
&lt;h2 id="my-llm-codegen-workflow-atm"&gt;&lt;a href="https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/" rel="noopener noreferrer"&gt;My LLM Codegen Workflow ATM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Harper Reed shares his current workflow for building software with LLMs, distilled into three stages: hone an idea into a spec, generate an execution plan, and execute in tight loops. For greenfield projects, he has a conversational model interview him one question at a time to turn a rough idea into a detailed &lt;code&gt;spec.md&lt;/code&gt;; next, he feeds that spec to a reasoning model to break it down into incremental steps—each written as a self-contained prompt for a coding agent—saved as &lt;code&gt;prompt_plan.md&lt;/code&gt; alongside a &lt;code&gt;todo.md&lt;/code&gt; checklist to preserve state across sessions. The entire planning phase takes about 15 minutes. For execution, he prefers Claude directly or Aider: paste a prompt, run the test suite, commit if green, or pack the codebase with &lt;code&gt;repomix&lt;/code&gt; and hand it back to the model to debug if red.&lt;/p&gt;
&lt;p&gt;For existing codebases, he pairs &lt;code&gt;repomix&lt;/code&gt; with &lt;code&gt;mise&lt;/code&gt; tasks to bundle repository context, then uses targeted prompts to review code, file GitHub issues, or identify missing test coverage. He admits it&amp;rsquo;s easy to get &amp;ldquo;out over your skis&amp;rdquo; when code is flying by that fast, which is why upfront planning and automated tests are non-negotiable guardrails. He also notes that these workflows are still largely single-player rather than team-friendly, and shares how he uses the idle minutes while waiting on model inference—often by kicking off the spec for the &lt;em&gt;next&lt;/em&gt; project.&lt;/p&gt;
&lt;h2 id="structured-logging-in-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/structured-logging-in-spring-boot.html" rel="noopener noreferrer"&gt;Structured Logging in Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yatin Batra&amp;rsquo;s tutorial on Java Code Geeks walks through setting up structured logging in Spring Boot. Unlike the plain-text log lines Logback emits by default, structured logging formats entries as machine-parseable JSON, making it far easier for log aggregation platforms like the ELK stack or Grafana Loki to parse, search, and filter events. The author shows how to add the &lt;code&gt;logstash-logback-encoder&lt;/code&gt; dependency to &lt;code&gt;pom.xml&lt;/code&gt;, configure &lt;code&gt;logback-spring.xml&lt;/code&gt; under &lt;code&gt;src/main/resources&lt;/code&gt;, and inspect the resulting JSON output from a sample application.&lt;/p&gt;
&lt;p&gt;Moving to advanced topics, the post covers injecting custom contextual fields via MDC (Mapped Diagnostic Context)—such as attaching a &lt;code&gt;userId&lt;/code&gt; to every log event—shipping logs to Logstash, and configuring Promtail to scrape and forward logs into Loki. Finally, the author introduces two standardized schemas: Elastic Common Schema (ECS) for unifying field names across the Elastic ecosystem, and Graylog Extended Log Format (GELF) for shipping structured logs to Graylog, comparing their core fields and trade-offs. This setup is essential for cloud-native deployments where centralized observability is a must.&lt;/p&gt;
&lt;h2 id="secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency"&gt;&lt;a href="https://gainjavaknowledge.medium.com/secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency-8253d57d692b" rel="noopener noreferrer"&gt;Secret Java Stream Hacks That Will Instantly Improve Your Coding Efficiency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Medium post by Gain Java Knowledge highlights several lesser-known Java Stream API tricks for writing cleaner, more expressive pipelines. A standout is &lt;code&gt;Collectors.teeing()&lt;/code&gt;, which lets you pipe a single stream through two separate collectors simultaneously and merge their results—for example, computing both the sum and the average in a single pass instead of iterating twice. The post also covers &lt;code&gt;takeWhile()&lt;/code&gt; (taking elements until a predicate turns false) and &lt;code&gt;dropWhile()&lt;/code&gt; (skipping elements while a predicate remains true) for concise short-circuiting stream slicing.&lt;/p&gt;
&lt;p&gt;Beyond those operators, the author touches on parallel streams, memory efficiency, handling checked exceptions cleanly inside lambdas, and composing multi-stage collectors. Practical tips include picking the most specific collector for the job, avoiding side effects inside stream operations, preferring method references over verbose lambdas where readable, and keeping pipelines short enough to scan easily. Understanding lazy evaluation is also key when weighing stream performance on large datasets.&lt;/p&gt;
&lt;h2 id="death-of-a-thousand-nits-code-review-best-practices"&gt;&lt;a href="https://bitfieldconsulting.com/posts/code-review" rel="noopener noreferrer"&gt;Death of a Thousand Nits: Code Review Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an excerpt from his book &lt;em&gt;Code For Your Life&lt;/em&gt;, John Arundel explores how to make code reviews less adversarial and genuinely useful. His number-one recommendation is &lt;strong&gt;pair reviewing&lt;/strong&gt;: instead of trading walls of text in pull request comments, hop on a quick call or screen-share. Voice tone and facial expressions convey far more nuance than text, a 15-second question can replace days of back-and-forth comment threads, and people are naturally kinder face-to-face.&lt;/p&gt;
&lt;p&gt;When asynchronous written review is unavoidable, every comment should genuinely add value to the code. Leave purely stylistic preferences to automated formatters; if you don&amp;rsquo;t recognize a language construct, look it up yourself first; if you don&amp;rsquo;t understand why the author took a particular approach, ask a genuine question; and even when suggesting an improvement or pointing out a likely bug, frame it as a question rather than a command. Start reviews by calling out what you liked, close with an encouraging note, and drop any trace of condescension. On the receiving end, when hit with a blunt or abrasive review comment, resist getting defensive and look for the kernel of truth inside it—and for pure style nitpicks, either ignore them politely or ask privately what the deeper concern is. Ultimately, the best way to build a kinder code review culture is to model it yourself.&lt;/p&gt;
&lt;h2 id="hash-functions-deep-dive"&gt;&lt;a href="https://www.kirupa.com/data_structures_algorithms/hash_functions_deep_dive.htm" rel="noopener noreferrer"&gt;Hash Functions Deep Dive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kirupa explains hash functions from first principles: a function that takes an arbitrary input—text, a file, or raw binary data—and maps it to a fixed-size output, powering everything from hash tables and password verification to file integrity checks, digital signatures, and deduplication. A good hash function needs eight properties: determinism (the same input always yields the same output), uniform distribution, fast computation (ideally O(1) for table lookups), the avalanche effect (a tiny change in input flips roughly half the output bits), fixed output length, low collision rate, pre-image resistance (one-way), and no correlation between similar inputs.&lt;/p&gt;
&lt;p&gt;To make these properties concrete, the author builds a toy hash function in JavaScript from scratch: summing the character codes of a string modulo a prime table size like 37. That naive version immediately fails on anagrams like &lt;code&gt;&amp;quot;hello&amp;quot;&lt;/code&gt; and &lt;code&gt;&amp;quot;olleh&amp;quot;&lt;/code&gt;, which produce identical sums; multiplying each character code by its positional weight fixes the anagram collision, yet the toy function still flunks nearly every other criterion on the list. The lesson is never to roll your own hash function in production; the author walks through how MD5 satisfies the structural criteria with its 128-bit (32-hex-character) output (noting that MD5 is no longer safe against deliberate collisions and that password storage requires dedicated slow hashes like bcrypt or Argon2). Hash functions sit quietly underneath almost everything we build, from fast in-memory lookups to verifying downloaded ISOs.&lt;/p&gt;
&lt;h2 id="xor-a-deep-dive-into-the-exclusive-or-operation"&gt;&lt;a href="https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/xor/" rel="noopener noreferrer"&gt;XOR: A Deep Dive into the Exclusive OR Operation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Tatham takes a deep dive into the XOR (exclusive OR) operation and its surprisingly rich applications across computer science. At the bit level, XOR outputs &lt;code&gt;1&lt;/code&gt; when its two input bits differ and &lt;code&gt;0&lt;/code&gt; when they match, and is both commutative and associative. Tatham shows that you can view the exact same operation through four equivalent mental models: a &amp;ldquo;not equal&amp;rdquo; bit comparison, a conditional bit-flipper controlled by a mask bit, addition modulo 2 (carryless bit addition), and parity calculation (counting whether the number of &lt;code&gt;1&lt;/code&gt; bits is odd or even).&lt;/p&gt;
&lt;p&gt;Each mental model unlocks classic applications. In cryptography, XORing plaintext with a keystream encrypts and decrypts symmetrically—where the entire security challenge lies in generating an unpredictable keystream, and raw XOR alone provides no message integrity protection against bit-flipping attacks. In retro computer graphics, XORing a sprite onto a framebuffer twice cleanly erases it and restores the original background pixels. Tatham also walks through the classic XOR swap trick, overflow-safe integer averaging, and carryless polynomial arithmetic (used in CRCs and Galois fields), showing how one humble bitwise operator looks completely different depending on the lens you bring to it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/6b437484-1fd8-4b59-ba05-46bb3352b053_2904x2559.jpeg" alt="SOAP vs REST vs GraphQL vs RPC"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3ecf2600-10d8-4180-8328-8d790fbba0cc_1280x1557.gif" alt="SQS vs SNS vs EventBridge vs Kinesis"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/217bf342-bfd4-4088-bba3-b2734f065a20_1280x1280.gif" alt="Top 5 common ways to improve API performance"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-inside-java"&gt;Bonus 2: Interesting videos from &lt;a href="https://inside.java/" rel="noopener noreferrer"&gt;Inside Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://inside.java/2025/02/22/devoxxbelgium-loom-next/" rel="noopener noreferrer"&gt;Project Loom and Virtual Threads: Next Phases&lt;/a&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, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #7</title><link>https://miti99.com/en/post/2025/03/16/</link><pubDate>Sun, 16 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #7.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-llm-curve-of-impact-on-software-engineers"&gt;&lt;a href="https://serce.me/posts/2025-02-07-the-llm-curve-of-impact-on-software-engineers" rel="noopener noreferrer"&gt;The LLM Curve of Impact on Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov proposes a hypothesis to explain the sharp divide over how useful LLMs really are: their day-to-day value depends heavily on an engineer&amp;rsquo;s seniority, tracing out a distinct curve. For Junior engineers who are still building their mental models of code, LLMs are a lifesaver when deciphering errors, implementing small features, or upgrading libraries. Yet this is also a danger zone: if they just copy and paste code back and forth without understanding why it works, their fundamental skills can stagnate. Mid-level engineers still write code and pick up new frameworks faster with LLMs, but increasingly run into tasks LLMs can&amp;rsquo;t handle—such as figuring out what a customer actually wants from a vague request, hunting down race conditions in a debugger, or handling a 2 a.m. production outage.&lt;/p&gt;
&lt;p&gt;Under this hypothesis, Senior engineers are the most skeptical group. They already hold the system&amp;rsquo;s architecture in their heads, spend a smaller fraction of their day typing boilerplate, and focus on work—roadmapping, debugging gnarly non-reproducible issues, writing design docs—that depends on deep organizational and system context the LLM doesn&amp;rsquo;t have; the more specialized the domain, the sharper the disillusionment. At the Staff+ level, however, the curve bends back up: their job often involves prototyping to blaze trails for other teams, and LLMs drastically speed up building proofs of concept, while their deep expertise lets them immediately spot and untangle whatever corners the model paints itself into. Understanding this curve, the author suggests, builds empathy: the skeptics and the enthusiasts are simply doing very different jobs.&lt;/p&gt;
&lt;h2 id="you-are-using-cursor-ai-incorrectly"&gt;&lt;a href="https://ghuntley.com/stdlib/" rel="noopener noreferrer"&gt;You are using Cursor AI incorrectly&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Geoffrey Huntley argues that most engineers—from juniors to principals—are using Cursor the wrong way: treating it as a Google replacement, writing bare-bones prompts like &amp;ldquo;implement XYZ,&amp;rdquo; using it as a text editor rather than an autonomous agent, and failing to realize that you can &amp;ldquo;program&amp;rdquo; the probability distribution of an LLM&amp;rsquo;s output. His solution is to build a personal &amp;ldquo;stdlib&amp;rdquo; (standard library) of thousands of rules stored in &lt;code&gt;.cursor/rules/&lt;/code&gt;, where each rule is a structured &lt;code&gt;.mdc&lt;/code&gt; file defining filters and actions, named with a consistent convention, and composed together like Unix pipes.&lt;/p&gt;
&lt;p&gt;With these rules in place, you can shape Cursor&amp;rsquo;s behavior permanently: when Cursor kept suggesting Bazel commands even though the author wanted Nix exclusively, he wrote a &lt;code&gt;no_bazel&lt;/code&gt; rule to banish Bazel suggestions altogether. Rules also automate development workflows, such as automatically inserting license headers into new files or committing changes once a task is complete. By the author&amp;rsquo;s estimate, current LLMs are only about 45% accurate out of the box and need constant steering, so continuously curating and refining your rule library is the key to getting real leverage out of Cursor.&lt;/p&gt;
&lt;h2 id="how-do-you-spend-your-time"&gt;&lt;a href="https://brooker.co.za/blog/2024/02/06/time.html" rel="noopener noreferrer"&gt;How Do You Spend Your Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker writes for engineers who feel constantly busy and get plenty done, yet worry they aren&amp;rsquo;t spending their time on the highest-value work for their team and projects. His approach is to set an explicit &amp;ldquo;time budget&amp;rdquo;: pick five or six broad categories of work along with a target percentage of time for each, stay flexible week to week while holding the line over the long run, and review the breakdown periodically with your manager. The act of writing the budget down is the most valuable part, because it forces you to think hard about what success actually looks like in your role. His own buckets include individual technical work (writing, reading, and reviewing code, debugging, design docs), mentoring and teaching, long-term strategy, day-to-day operational rhythm, learning (reading papers, prototyping algorithms), and talking with customers. The exact split matters less than doing the exercise deliberately.&lt;/p&gt;
&lt;p&gt;Sticking to a time budget requires learning to say &amp;ldquo;no.&amp;rdquo; Brooker warns against several traps: chasing high-visibility shiny objects or hype, getting sucked into urgent but low-importance chores, and letting your calendar run away from you—like a senior engineer sitting in 20 hours of meetings a week where nobody sees him contributing much, simply because everyone assumes someone else invited him for a good reason. He applies this same lens at the organizational level and borrows the economics concept of &amp;ldquo;revealed preference&amp;rdquo;: how we actually spend our hours reveals our true priorities, just like claiming you love salad while ordering a burger every day.&lt;/p&gt;
&lt;h2 id="we-are-destroying-software"&gt;&lt;a href="https://antirez.com/news/145" rel="noopener noreferrer"&gt;We are destroying software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a short, manifesto-style post, Redis creator Salvatore Sanfilippo (antirez) lists the ways we are collectively &amp;ldquo;destroying&amp;rdquo; software: piling on features and premature optimizations without weighing their complexity cost; adopting convoluted build systems; assembling absurd dependency chains that leave everything bloated and fragile; telling junior programmers &amp;ldquo;don&amp;rsquo;t reinvent the wheel&amp;rdquo; when reinventing the wheel is precisely how you learn how wheels work—and the first step toward inventing better ones; abandoning API backward compatibility; pushing rewrites of battle-tested code that already works; and chasing every new language, paradigm, and framework fad.&lt;/p&gt;
&lt;p&gt;He also criticizes the habit of underestimating the cost of wrestling with sprawling third-party libraries compared to writing a focused solution yourself, assuming generic industry standards are always better than custom-fit designs, dismissing code comments as useless, and treating software as a purely mechanical engineering discipline. We build systems that cannot &amp;ldquo;scale down&amp;rdquo;—where simple things ought to remain simple—and optimize for coding velocity over design quality. The end result, he warns, is a field stripped of the joy of hacking.&lt;/p&gt;
&lt;h2 id="nontraditional-red-teams"&gt;&lt;a href="https://zachholman.com/posts/red-teams" rel="noopener noreferrer"&gt;Nontraditional Red Teams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Former GitHub engineer Zach Holman expands the concept of a &amp;ldquo;red team&amp;rdquo; (adversarial testers who probe a system for weaknesses) beyond cybersecurity to three everyday roles every product team should have. First is the person who checks whether a new graphic or logo accidentally looks like genital or NSFW imagery: GitHub once came dangerously close to printing its very first highway billboard with an illustration that looked uncannily like the infamous &amp;ldquo;goatse&amp;rdquo; shock image, even after dozens of employees had signed off on it. After that near miss, major design launches at GitHub included a dedicated review step asking how a visual might be misread, mocked, or abused out of context. Second is the ad-blocker user, who speaks up whenever a site breaks navigation simply because a tracking script or HTML snippet got blocked—one of the most frustrating experiences on the modern web.&lt;/p&gt;
&lt;p&gt;Third is the password-manager user. Holman vents about how many teams botch even the most basic login forms with custom inputs that prevent 1Password and similar tools from autofilling credentials. None of these are fatal showstoppers since determined users will eventually work around them, he notes, but they are completely avoidable self-inflicted wounds. When a team is heads-down shipping new features, it&amp;rsquo;s easy to miss these rough edges—which is why having an adversarial &amp;ldquo;red team&amp;rdquo; look at the product with fresh, skeptical eyes pays off.&lt;/p&gt;
&lt;h2 id="ai-or-die"&gt;&lt;a href="https://www.rkg.blog/ai-or-die.php" rel="noopener noreferrer"&gt;AI or Die&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ravi Gupta (RKG) opens with Anthropic CEO Dario Amodei&amp;rsquo;s prediction that as early as 2026 we could see AI models smarter than a Nobel Prize winner across most disciplines, capable of autonomously executing multi-day tasks and running millions of instances in parallel at 10x to 100x human speed—&amp;ldquo;a country of geniuses in a datacenter.&amp;rdquo; Gupta asks: is your company ready to harness that capability, or compete against companies that do? Even today&amp;rsquo;s models can already perform a substantial share of economically valuable work, yet most people barely scratch the surface because they lack ambition, lack the patience to supply rich context, and lack clear thinking and communication.&lt;/p&gt;
&lt;p&gt;To prepare, RKG recommends dedicating a full week to studying what AI can do today and where it is heading; tasking a tiny group to build an &amp;ldquo;AI-native&amp;rdquo; version of your product with a team 10x to 100x smaller; accepting that customers will soon demand dramatically better products at a fraction of the price; going &amp;ldquo;AI-first&amp;rdquo; with the same urgency Facebook once brought to mobile; and auditing every role in the organization to understand who will be supercharged by AI and which functions will be replaced. This isn&amp;rsquo;t an incremental tweak, he argues, but a full-scale &amp;ldquo;refounding&amp;rdquo; of the company—harder the larger and more successful you already are, yet essential to meet a future where, as Sam Altman put it, &amp;ldquo;maybe everyone on earth will be able to accomplish more than the most impactful person can today.&amp;rdquo;&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, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>