Link Dump #240

Worry no more! The new set articles are here!

1. Software Development
   1. GitHub Copilot and me
      What happens when you use AI on a real-life, messy codebase for two years? The author provides a deep dive into using Copilot within IntelliJ for Java and React microservices. Discover the transition from simple inline assistants to sophisticated chat-based workflows, and learn why "situational demand" must dictate how much you rely on your AI pair programmer.
   2. AI writes code, architecture and tests keep it sane #PickOfTheWeek
      AI can generate code faster than ever, but code alone does not guarantee quality. Without well-defined architecture and meaningful tests, you lose control over what is being built and whether it actually works. 
   3. Compressed Cognition: The Cost of Faster Coding #PickOfTheWeek
      Agentic coding collapses the timeline of software decisions. What we gain in speed, we pay for in decision density and mental energy. Here's a deep dive into the trade-offs and how to work with them.
   4. Why Senior Engineers Still Do Manual Work in Highly Automated Environments
      If your highly automated environment still requires manual triggers and niche script knowledge, you’re not as automated as you think. Learn how to bridge the gap between "scripts that work" and "standardized workflows" to free up your most expensive talent.
      
2. Code Quality
   1. How Long Should a Function Be? (And Why It’s the Wrong Question to Ask)
      The most maintainable code isn't the shortest; it’s the code that keeps its context together. Find out why "fragmented cognition" is the hidden cost of the tiny-function dogma and how to use responsibility-based design to decide when a function has truly grown "too long."
   2. What is legacy software in the age of AI? #PickOfTheWeek 
      Software becomes legacy by succeeding long enough to accumulate the weight of every decision and shortcut made along the way. Users feel it as friction. Engineers feel their momentum slip. The business watches costs climb. AI changes two of those. The third may be getting worse.  
   3. What Is Code? #PickOfTheWeek 
      When we let AI jump straight to implementation, we skip the essential step of modeling the problem. This deep dive examines the difference between instruction and design, and why the "Shared Vocabulary" of your domain is the only thing that will keep your codebase from becoming a black box of AI-generated confusion.
   4. Code Review Responses: Add Context When It Counts
      This article explores the "social contract" of code reviews. Author breaks down how to handle risky edge cases, design trade-offs, and offline syncs. Discover how to use the "Obviousness Test" to determine when a simple "Done" is sufficient and when you need to document the "why" behind your code changes.
      
3. Testing 
   1. Scaling ArchUnit with Nebula ArchRules
      This deep dive into Netflix's latest tooling explores how they used Gradle's variant-aware dependency resolution to make ArchUnit rules "sticky" to the libraries they protect. Discover the technical implementation of "Standalone" vs "Bundled" rule libraries and how to implement an "Experimental API" guardrail that actually warns your downstream consumers.
      
4. Communication
   1. Good engineers talk, great engineers communicate #PickOfTheWeek
      Great technical decisions lose value when nobody understands them. Communication is the skill that turns knowledge into influence and alignment.