Software engineering

Software engineering is not a single discipline but a stack of concerns: how systems are designed, how code is written and reviewed, how it is tested and deployed, how knowledge transfers between practitioners, and who is accountable when things fail. The sources here span all of those layers, and a consistent thread runs through them: adding speed without adding understanding tends to produce problems at the next layer down.

At the design level, the principle that modules should hide complexity behind narrow interfaces appears in AI Likes Deep Modules, which argues that deep modules reduce cognitive load for both humans and LLMs. Single Responsibility, the Distorted Principle makes a related point: SRP is about cohesion of accountable behavior, not atomization into the smallest possible classes, and over-granularizing violates the cognitive simplicity the principle is supposed to provide. A Better Way to Build Angular Components applies the same logic to component APIs, arguing that bloated input lists should be replaced with the Composite Components pattern so each concern stays encapsulated.

Testing is another layer where structural choices compound. Designing Playwright Tests That Survive UI Refactors argues that test brittleness stems from coupling to implementation details rather than semantic roles. Playwright Testing in Staging vs Production extends this into operational discipline, framing which flows belong in which environment as a deliberate architectural decision. Code Smells When You Get AI to Write Your Frontend Tests documents what happens when that discipline is absent: AI-generated tests over-mock, skip error paths, and sometimes test a buggy implementation rather than intended behavior.

Code review has its own failure modes. How AI Code Review Can Make Correct Code Worse shows experimentally that weaker fixer agents overstep review scope and break correct code — softer fixer instructions eliminate catastrophic regressions. The supply-chain dimension adds urgency: Supply-chain attack using invisible Unicode code describes 151 malicious npm packages encoding payloads in invisible Unicode variation-selector characters, undetectable by code reviewers and static analysis alike.

At the deployment and operations layer, What CI Actually Looks Like at a 100-Person Team describes a 575K weekly job pipeline where an AI agent handles triage automatically. The Unwritten Laws of Software Engineering distills harder lessons: roll back before debugging, treat every external dependency as a future outage. When Impressive Performance Gains Do Not Matter adds a sobering systems-level point: attention thresholds, discrete capacity increments, and pipeline backpressure mean even order-of-magnitude improvements often fail to change outcomes.

The AI-assistance question cuts across all layers. Several sources converge on a single risk: that delegating too much too fast erodes the judgment needed to evaluate what the tools produce. Agentic Coding is a Trap argues full agentic workflows invert developer priorities toward speed over understanding and create vendor dependency. The Perils of AI to the Software Engineering Profession argues vibe coding is categorically incompatible with safety-critical systems. The Tacit Dimension argues the most valuable engineering knowledge — pattern recognition, design intuition, unwritten conventions — is structurally inaccessible to AI and can only transfer through apprenticeship.

Not everyone is pessimistic. Formal Methods and the Future of Programming argues agentic coding has made formal verification newly cost-effective by lowering proof-writing costs while creating demand for guarantees that tests alone cannot supply. When Code Is Cheap, Does Quality Still Matter? acknowledges lower production cost but notes ownership cost remains unchanged: LLMs can generate well-formatted technical debt faster than any individual engineer.

The organizational layer matters as much as the technical one. The Bottleneck Was Never the Code argues the real constraints are shared context, specification clarity, and management coherence — coding agents amplify whatever alignment or misalignment already exists. Why Senior Developers Fail to Communicate Their Expertise names the translation gap between complexity management and uncertainty reduction as the core challenge of engineering seniority. Learn Algorithms for Interviews, Forget Them for Work points out that hiring processes test a narrow, trainable skill that weakly predicts production performance, while The Systemic Decay of Tech Hiring traces how error-asymmetry and Goodhart’s Law have made those processes structurally dysfunctional.

Across these layers, the pattern is consistent: engineering judgment — about design, tradeoffs, failure modes, and what to automate — remains the scarce resource, and the temptation to optimize any single layer without understanding the system it sits in is the recurring mistake.