<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>TDD on miti99</title><link>https://miti99.com/en/tags/tdd/</link><description>Recent content in TDD 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/tdd/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #46</title><link>https://miti99.com/en/post/2025/08/05/</link><pubDate>Tue, 05 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/05/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I&amp;rsquo;m going back to Claude Code :D (still my true love—I only jump to other agents when I&amp;rsquo;m worried about burning tokens).&lt;/del&gt; Enjoy Newsletter #46.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-pragmatic-engineer-2025-survey-what"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-pragmatic-engineer-2025-survey" rel="noopener noreferrer"&gt;The Pragmatic Engineer 2025 Survey: What&amp;rsquo;s in your tech stack?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz published the first part of The Pragmatic Engineer&amp;rsquo;s 2025 tech stack survey, based on nearly 3,000 valid responses. The &amp;ldquo;typical respondent&amp;rdquo; is a senior software engineer with 6–10 years of experience working on the backend at companies of all sizes. Up to 85% of participants mentioned at least one AI tool. GitHub Copilot took the top spot, used by one in two respondents; Cursor, despite launching in 2023 and spending nothing on marketing, came in second. Claude narrowed the gap with ChatGPT considerably, and Claude Code received quite a few mentions even though it had only officially launched a few days before the survey closed.&lt;/p&gt;
&lt;p&gt;Among programming languages in this readership sample, TypeScript was mentioned most often; Python stood out, and Swift dominated Objective-C in iOS development, while Ruby on Rails and Elixir were loved far above their usage share, and no language was disliked more than it was liked. JIRA was the most disliked tool—surpassing the next four combined—mainly for being slow and bloated, with Linear frequently cited as the alternative. Git is virtually the default for version control, though GitLab and Bitbucket retain sizable user bases, and GitHub Actions leads in CI/CD. In infrastructure, AWS leads, followed by Azure and Google Cloud, with Vercel standing out as the most prominent provider outside the &amp;ldquo;Big 3.&amp;rdquo; The takeaway: developers are quick to try new tools in fast-moving spaces like AI.&lt;/p&gt;
&lt;h2 id="algorithms-for-making-interesting-organic-simulations"&gt;&lt;a href="https://bleuje.com/physarum-explanation/" rel="noopener noreferrer"&gt;Algorithms for making interesting organic simulations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains techniques for creating organic-looking simulations aimed more at artistic expression than scientific accuracy. The starting point is Jeff Jones&amp;rsquo;s Physarum algorithm (2010): a large number of agents move across a 2D plane, each with a position and heading. On every step, an agent &amp;ldquo;senses&amp;rdquo; three points ahead (straight, slightly left, slightly right), turns toward the strongest trail, moves forward, and deposits a trail onto an image called a trail map; that image is then slightly blurred and multiplied by a decay factor to keep the system stable. With just four parameters (sensor distance, sensor angle, turn angle, and step size), a wide variety of behaviors already emerge.&lt;/p&gt;
&lt;p&gt;The most fascinating part comes from Sage Jenson&amp;rsquo;s &lt;em&gt;36 Points&lt;/em&gt;: instead of keeping parameters fixed, each parameter is computed as a function of the trail value at the agent&amp;rsquo;s current position, plus sampling offsets—bringing the total to roughly 14–20 parameters and producing surprisingly diverse behaviors. The author shares his own implementation (&lt;code&gt;physarum-36p&lt;/code&gt;) using GPU compute shaders via openFrameworks, consisting of four shaders for resetting counters, moving particles, depositing trails, and diffusing, running smoothly with millions of particles. It is a beautiful demonstration of how a few simple rules can give rise to complex behavior.&lt;/p&gt;
&lt;h2 id="ai-coding-tools-are-shifting-to-a-surprising-place-the-terminal"&gt;&lt;a href="https://techcrunch.com/2025/07/15/ai-coding-tools-are-shifting-to-a-surprising-place-the-terminal/" rel="noopener noreferrer"&gt;AI coding tools are shifting to a surprising place: The terminal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to TechCrunch, AI coding tools are shifting from code editors to the terminal. Since February, Anthropic, DeepMind, and OpenAI have each launched their own command-line tools (Claude Code, Gemini CLI, and Codex CLI), and they have quickly become some of these companies&amp;rsquo; most popular products. Mike Merrill, co-creator of the Terminal-Bench benchmark, bets that in the future 95% of interactions between LLMs and computers will happen through terminal-like interfaces. Meanwhile, editor-based tools are showing signs of turbulence: Windsurf was carved up through acquisitions, and a METR study of experienced open-source developers found that when using Cursor Pro, they thought they were about 20% faster when in reality they were about 19% slower.&lt;/p&gt;
&lt;p&gt;The difference lies in the scope of work. The previous generation of tools, measured by SWE-Bench, focused on fixing buggy code from GitHub issues; terminal tools look at the entire execution environment, including DevOps tasks like configuring a Git server, compiling a Linux kernel, or figuring out why a script fails to run. On the leaderboard cited by the article at the time, Warp solved just over half the tasks, showing there is still plenty of room to grow. Even so, Warp&amp;rsquo;s founder believes that tasks like bootstrapping a project, resolving dependencies, and getting it running can now be handed off almost entirely to AI.&lt;/p&gt;
&lt;h2 id="distributed-systems-reliability-glossary"&gt;&lt;a href="https://antithesis.com/resources/reliability_glossary/" rel="noopener noreferrer"&gt;Distributed Systems Reliability Glossary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jepsen and Antithesis jointly compiled a glossary of distributed systems reliability aimed at developers at every career stage. According to the authors, this is the first resource to gather in one place concepts that were previously scattered across multiple disciplines. The glossary is organized into sections covering foundational concepts, consistency models (what a system is allowed to do), availability models, anomalies, fault types (from data loss and clock skew to Byzantine faults), and testing techniques, accompanied by a further reading list. Each entry provides an intuitive definition alongside links to formal academic sources for deeper study.&lt;/p&gt;
&lt;p&gt;What makes it especially valuable is its practical spirit: the authors emphasize that it is a reference guide rather than required cover-to-cover reading, and that every time you write an integration test, you are already testing a distributed system. The testing section explains why distributed systems are hard: they are inherently concurrent and routinely experience partial failures. From there, it introduces techniques such as concurrency testing, fault injection, deterministic simulation testing, property-based testing, and test-case shrinking. A great resource to bookmark when working with databases or multi-node systems.&lt;/p&gt;
&lt;h2 id="test-driven-development-tdd-with-dbt"&gt;&lt;a href="https://xebia.com/blog/test-driven-development-tdd-with-dbt/" rel="noopener noreferrer"&gt;Test-Driven Development (TDD) with dbt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dumky de Wilde (Xebia) discusses applying Test-Driven Development (TDD) to dbt, the popular data transformation tool in analytics engineering. Instead of writing a model and hoping the numbers look right, you first define what &amp;ldquo;good data&amp;rdquo; means, write a test, watch it fail, and then write just enough SQL to make it pass. The author distinguishes several categories of tests: row-level checks on one or more columns (such as &lt;code&gt;not_null&lt;/code&gt; and &lt;code&gt;unique&lt;/code&gt;), aggregate tests across an entire model, unit tests for models (available since dbt 1.8, using mock data instead of production data), unit tests for macros, and model contracts. Contracts validate the output schema at build time so a structurally invalid model fails to build; how strictly the underlying database enforces each constraint depends on the platform and adapter.&lt;/p&gt;
&lt;p&gt;The article walks through writing a row-count limit test for a model that does not yet exist, forcing you to answer business questions like &amp;ldquo;why between 1 and 99 rows?&amp;rdquo; before writing a single line of SQL. In practice, the author recommends always running unit tests and contracts during local development and in CI/CD, running data tests selectively, and skipping unit tests in production. Use tags to group tests, craft small custom fixtures for edge cases, and document why each test exists. The core message is shifting your mindset from &amp;ldquo;build first, test later&amp;rdquo; to &amp;ldquo;define success first, then build.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="rethinking-oop"&gt;&lt;a href="https://max.xz.ax/blog/rethinking-oop/" rel="noopener noreferrer"&gt;Rethinking OOP&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author opens with an example from AP Computer Science A: the textbook definition &amp;ldquo;a class is a blueprint for creating objects, and an object is an instance of a class&amp;rdquo; is virtually meaningless to beginners. According to the author, teaching OOP too early without explaining why leads students to follow templates mechanically rather than considering whether the problem actually calls for them. Drawing inspiration from Professor Matthias Felleisen&amp;rsquo;s &amp;ldquo;design recipe&amp;rdquo; and Ethan McCue&amp;rsquo;s modern approach to teaching Java, the article proposes starting as simply as possible and introducing new language features only when learners hit the limits of their current toolkit.&lt;/p&gt;
&lt;p&gt;Specifically, learners can use JDK 25&amp;rsquo;s compact source files (or JShell) to write sequential statements right away without &lt;code&gt;public static void main&lt;/code&gt;. When they have to copy-paste the same prime-checking block across multiple variables, they naturally see the need for methods; when managing too many loose variables becomes unwieldy, they grasp the value of grouping data into a class. The author acknowledges that this approach lets students write &amp;ldquo;bad&amp;rdquo; code at first, but living with repetitive, clunky code is precisely what makes design choices meaningful. The conclusion is worth pondering: best practices don&amp;rsquo;t need to be memorized from a textbook—they can become intuitive by gradually scaling up program complexity.&lt;/p&gt;
&lt;h2 id="how-i-write-code-that-i-don"&gt;&lt;del&gt;&lt;a href="https://dev.to/resource_bunk_1077cab07da/how-i-write-code-that-i-dont-hate-reading-a-week-later-303b" rel="noopener noreferrer"&gt;How I Write Code That I Don&amp;rsquo;t Hate Reading a Week Later&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;A practical and useful article on writing readable code—an important skill that many developers overlook. The author shares a core philosophy: &amp;ldquo;Write code as if you&amp;rsquo;ll have to debug it at 2 a.m., half-asleep, with a deadline looming.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Key principles include giving variables and functions descriptive names (for example, &lt;code&gt;parsed_user_profile_data&lt;/code&gt; instead of just &lt;code&gt;d&lt;/code&gt;), writing comments that explain &amp;ldquo;why&amp;rdquo; rather than &amp;ldquo;what,&amp;rdquo; and prioritizing readability over &amp;ldquo;clever&amp;rdquo; code. Instead of writing dense one-liners to show off technical flair, break them into multiple easier-to-follow lines.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The best point is the principle of writing small, focused functions: each function should do one specific thing with a clear name like &lt;code&gt;handleLoginFormSubmission()&lt;/code&gt;. When code gets tangled, stop and refactor rather than piling on more complexity. The author also mentions helpful tools like Prettier, Black for Python, and even ChatGPT for refactoring. Simple yet highly practical advice for any developer who wants more maintainable code.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="7-habits-that-quietly-made-me-a-10x-developer-no-not-chatgpt"&gt;&lt;a href="https://dev.to/abubakersiddique771/7-habits-that-quietly-made-me-a-10x-developer-no-not-chatgpt-13c4" rel="noopener noreferrer"&gt;7 Habits That Quietly Made Me A 10x Developer (No, Not ChatGPT)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that becoming a &amp;ldquo;10x developer&amp;rdquo; comes not from innate genius or working 20-hour days, but from small habits maintained consistently—without needing an AI assistant. The first habit is writing code that writes code: using scripts, generators, and scaffolding tools to automate boilerplate, CRUD endpoints, test harnesses, or GitHub Actions workflows so you never solve the same problem twice. The second is designing for &amp;ldquo;future you&amp;rdquo; with descriptive commit messages, clear function names, sensible folder structures, and writing the &lt;code&gt;README.md&lt;/code&gt; before starting implementation. The third is keeping a brief &amp;ldquo;debug log&amp;rdquo; stating the problem, hypothesis, and plan before fixing a bug, because writing it down forces clear thinking.&lt;/p&gt;
&lt;p&gt;The remaining habits include building tiny personal tools (a CLI for renaming screenshots, a snippet generator), carving out 90-minute deep-focus blocks free from Slack or social media, studying how other developers structure their workflows rather than just copying their code, and running a Friday retro with three questions: what went well, what slowed me down, and what will I automate or improve next. According to the author, &amp;ldquo;10x&amp;rdquo; effectiveness is the compound result of many small improvements over time.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Claude Code really is my true love :D Fast execution, concise summaries, and getting better all the time. Wonderful!&lt;/em&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 #34</title><link>https://miti99.com/en/post/2025/07/23/</link><pubDate>Wed, 23 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #34.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-tdd-doesn"&gt;&lt;a href="https://tidyfirst.substack.com/p/why-tdd-doesnt-lead-to-dumb-code" rel="noopener noreferrer"&gt;Why TDD Doesn&amp;rsquo;t Lead to Dumb Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck pushes back against a common critique: that test-driven development (TDD) leads to &amp;ldquo;dumb&amp;rdquo; code because programmers write only the bare minimum to pass each test and never generalize. In his view, the design quality of TDD code is only as good as the design decisions its author makes—no different from code written without TDD. He illustrates this with a factorial function: start with &lt;code&gt;assert factorial(1) == 1&lt;/code&gt; and return &lt;code&gt;1&lt;/code&gt;, then add &lt;code&gt;assert factorial(2) == 2&lt;/code&gt; and temporarily return &lt;code&gt;2&lt;/code&gt;. Rather than piling on &lt;code&gt;if&lt;/code&gt; statements forever, the programmer notices the underlying structure: &lt;code&gt;2&lt;/code&gt; is really &lt;code&gt;2 * 1&lt;/code&gt;, where &lt;code&gt;2&lt;/code&gt; is the parameter &lt;code&gt;n&lt;/code&gt; and &lt;code&gt;1&lt;/code&gt; is the result of a recursive call, arriving at the general &lt;code&gt;n * factorial(n - 1)&lt;/code&gt; in tiny steps.&lt;/p&gt;
&lt;p&gt;The real difficulties lie elsewhere: sometimes you don&amp;rsquo;t yet have enough tests to constrain the code to only the right behavior, and sometimes you don&amp;rsquo;t yet see how to generalize and leave a few special cases in place for years—which is still fine as long as the code handles the cases that matter. What never happens is endless copy-pasting. Finally, Beck points out that a naive implementation is tightly coupled to the test suite, requiring code edits every time an assertion is added, whereas generalizing decouples them so you can add tests without changing code and vice versa.&lt;/p&gt;
&lt;h2 id="how-discord-indexes-trillions-of-messages"&gt;&lt;a href="https://discord.com/blog/how-discord-indexes-trillions-of-messages" rel="noopener noreferrer"&gt;How Discord Indexes Trillions of Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord recounts how it re-architected its message search system—originally built on Elasticsearch in 2017—to keep up with trillions of messages. The old setup was showing serious cracks: Redis-backed indexing queues dropped messages when backlogged, bulk indexing wasn&amp;rsquo;t fault-tolerant when an Elasticsearch index or node had trouble, large clusters were expensive to operate and painful to upgrade or rolling-restart, and indexes for massive servers (guilds) grew unwieldy. Their new architecture runs Elasticsearch on Kubernetes via the Elastic Operator, splits storage into many smaller clusters grouped into &amp;ldquo;cells,&amp;rdquo; replaces Redis queues with Google PubSub for durability and replayability, and introduces a Rust router built on Tokio to batch messages by target cluster and index before bulk indexing.&lt;/p&gt;
&lt;p&gt;The cell architecture also unlocked new product capabilities: direct messages (DMs) are sharded by &lt;code&gt;user_id&lt;/code&gt; inside a dedicated cell, enabling cross-DM search for a user. For &amp;ldquo;Big Freaking Guilds&amp;rdquo; that hit Lucene&amp;rsquo;s ~2-billion-document limit, Discord reindexes their messages into indexes with more primary shards inside a dedicated cell. The results: indexing throughput doubled, median query latency dropped from 500 ms to under 100 ms (p99 from 1 second to under 500 ms), the team now runs 40 clusters hosting thousands of indexes, and cluster upgrades happen automatically without user-visible impact.&lt;/p&gt;
&lt;h2 id="data-oriented-programming-dop-in-java"&gt;&lt;a href="https://nejckorasa.github.io/posts/data-oriented-programming-in-java/" rel="noopener noreferrer"&gt;Data Oriented Programming (DOP) in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Data-Oriented Programming (DOP) flips traditional object-oriented habits on their head: instead of bundling state and behavior together inside a class, you model data with simple passive structures and put logic in standalone functions that operate on that data. The post outlines four principles: model data immutably and transparently, model only the exact data needed, make illegal states unrepresentable, and separate operations from data. Modern Java supports this style cleanly through three features: &lt;code&gt;record&lt;/code&gt;s provide compact data carriers with &lt;code&gt;final&lt;/code&gt; fields (though they don&amp;rsquo;t automatically make referenced objects deeply immutable), &lt;code&gt;sealed&lt;/code&gt; classes restrict subtypes so the compiler knows every case, and pattern-matching &lt;code&gt;switch&lt;/code&gt; expressions enforce exhaustiveness, shifting bugs from runtime to compile time.&lt;/p&gt;
&lt;p&gt;In a &lt;code&gt;Shape&lt;/code&gt; example with &lt;code&gt;Circle&lt;/code&gt;, &lt;code&gt;Rectangle&lt;/code&gt;, and &lt;code&gt;Triangle&lt;/code&gt;, a &lt;code&gt;getCenter&lt;/code&gt; function written as a single &lt;code&gt;switch&lt;/code&gt; expression replaces adding methods across every subclass, removing the need for the Visitor pattern in this case. When a new subtype like &lt;code&gt;Pentagon&lt;/code&gt; is added, the compiler flags every &lt;code&gt;switch&lt;/code&gt; missing that branch—which is why the author advises avoiding &lt;code&gt;default&lt;/code&gt; branches that silence exhaustiveness checks. DOP also fits explicit result handling, such as a &lt;code&gt;Result&lt;/code&gt; type with &lt;code&gt;Ok&lt;/code&gt; and &lt;code&gt;Error&lt;/code&gt; variants that forces callers to handle both outcomes. Overall benefits include code that is easier to read, maintain, test, and refactor safely with lower coupling.&lt;/p&gt;
&lt;h2 id="why-performance-optimization-is-hard-work"&gt;&lt;a href="https://purplesyringa.moe/blog/why-performance-optimization-is-hard-work/" rel="noopener noreferrer"&gt;Why performance optimization is hard work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that performance optimization is hard not because engineers lack skill or knowledge, but because it is inherently exhaustive work that requires testing a huge number of possibilities. First is combinatorics: some optimizations only pay off when combined, others slow each other down, and ruling out &amp;ldquo;obviously bad&amp;rdquo; ideas upfront is mostly guesswork because a simple algorithm can win via vectorization while clever code loses to branch mispredictions. Second is continuity: algorithms with crossover thresholds, like hybrid sorts or FFTs, require tuning parameters empirically and re-measuring after every change, making an automated benchmark harness invaluable. Third is incompatibility: hardware constraints like two lookup tables that cannot fit in cache together or register pressure force hard trade-offs.&lt;/p&gt;
&lt;p&gt;The post also pushes back on the myth that &amp;ldquo;the compiler is smarter than you&amp;rdquo;: compilers don&amp;rsquo;t reason at the level of your domain abstractions and often allocate registers poorly, so you still have to inspect assembly and profile with tools like &lt;code&gt;perf&lt;/code&gt;. Documentation is another hurdle: x86 has detailed optimization manuals, whereas Apple Silicon has almost none, turning optimization into reverse engineering. In short, optimization means exploring dozens of variants, working around imperfect tooling, and reconciling conflicting wins—yet small improvements compound and are still worth the effort because they save real users&amp;rsquo; time.&lt;/p&gt;
&lt;h2 id="good-vs-great-animations"&gt;&lt;a href="https://emilkowal.ski/ui/good-vs-great-animations" rel="noopener noreferrer"&gt;Good vs Great Animations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski shares practical tips for taking UI animations from good to great. First, give animations a clear origin: a dropdown menu should expand from the button that triggered it by setting &lt;code&gt;transform-origin&lt;/code&gt;, and libraries like Radix expose CSS variables you can plug right in. Easing is the single most impactful lever; for an element already on screen that moves to a new position, &lt;code&gt;ease-in-out&lt;/code&gt; mimics natural acceleration and deceleration like a car, while &lt;code&gt;ease-out&lt;/code&gt; should be the default almost everywhere else. Built-in CSS easing curves are often too mild, so Kowalski nearly always reaches for custom curves and recommends easing.dev and easings.co.&lt;/p&gt;
&lt;p&gt;For cursor-driven interactions, tying values directly to mouse coordinates feels robotic; Motion&amp;rsquo;s &lt;code&gt;useSpring&lt;/code&gt; hook interpolates changes with spring physics so movement feels natural, though he advises saving it for decorative motion rather than functional charts like those in a banking app. Knowing your tools matters too: &lt;code&gt;clip-path&lt;/code&gt; makes tab-bar label colors transition cleanly in sync with the active indicator, while 3D transforms open up expressive effects. In Kowalski&amp;rsquo;s view, when baseline software quality is high everywhere, thoughtful motion is one of the clearest ways for a product to stand out.&lt;/p&gt;
&lt;h2 id="senior-engineers-should-make-side-bets"&gt;&lt;a href="https://www.seangoedecke.com/side-bets/" rel="noopener noreferrer"&gt;Senior engineers should make side bets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that junior engineers should stick closely to assigned work, because their tasks need experienced oversight and the fastest path to promotion is executing their core assignments well. Senior engineers, by contrast, shouldn&amp;rsquo;t just work down a ticket queue—they should spend 10–20% of their time on &amp;ldquo;side bets&amp;rdquo;: projects they believe are valuable to the company that nobody has asked for yet, such as a new feature, a performance optimization, or a developer-velocity improvement, provided the payoff is concrete. Side bets carry real risk: at worst you waste time and look to management like you&amp;rsquo;re working on the wrong things, and most bets will fail—in which case you quietly drop them and move on.&lt;/p&gt;
&lt;p&gt;The reason to make them anyway is that one winning bet pays for all the rest: anyone could have completed your routine ticket work, whereas the value of a successful side bet happened entirely because of you. When a bet pays off, share it proactively via an internal write-up or a chat with your manager; if you feel awkward showing it off, the benefit probably wasn&amp;rsquo;t concrete enough. Goedecke shares examples from GitHub: an &amp;ldquo;open in prompt editor&amp;rdquo; button saw zero adoption, whereas wiring AI inference permissions into GitHub Actions saw real usage. He lands two or three winning bets a year—and notes that if your bets never pan out, it&amp;rsquo;s a sign to stop making them.&lt;/p&gt;
&lt;h2 id="avoiding-skill-atrophy-in-the-age-of-ai"&gt;&lt;a href="https://addyo.substack.com/p/avoiding-skill-atrophy-in-the-age" rel="noopener noreferrer"&gt;Avoiding Skill Atrophy in the Age of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani warns of the paradox of AI coding assistants: productivity goes up, but core skills can atrophy if you aren&amp;rsquo;t careful. A 2025 study by Microsoft and Carnegie Mellon found a correlation between higher trust in AI and lower self-reported critical thinking, though the findings don&amp;rsquo;t prove long-term skill loss. The warning signs creep in gradually: stopping reading documentation, pasting error messages straight into AI instead of debugging, copying code without understanding why it works, shying away from architectural design, and forgetting basic syntax. Osmani worries this erodes both individual learning and team mentorship. While letting go of obsolete skills is normal, the key is distinguishing which tasks can be safely offloaded to machines and which fundamentals must stay sharp.&lt;/p&gt;
&lt;p&gt;His prescription is to treat AI as a collaborator rather than a crutch: always verify and understand its output, actively hunt for bugs and edge cases, and ask AI to explain code line by line; schedule &amp;ldquo;no-AI days&amp;rdquo; to code from scratch and read docs directly; spend 15–30 minutes tackling a problem yourself before prompting; review AI-generated code as rigorously as a teammate&amp;rsquo;s PR; log topics you repeatedly ask AI about so you can fill those knowledge gaps; and use AI in a pair-programming style where you stay in the driver&amp;rsquo;s seat. The core message: use AI to amplify your capability rather than replace it, preserving both the craft and the joy of problem-solving.&lt;/p&gt;
&lt;h2 id="cursor-best-practices"&gt;&lt;a href="https://x.com/paraschopra/status/1917466537637859544" rel="noopener noreferrer"&gt;Cursor best practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://pbs.twimg.com/media/Gpw1p1waYAAeAyY?format=jpg" alt="Cursor best practices"&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></channel></rss>