/Best Practices

"A Philosophy of Software Design" vs "Clean Code"

- Robert Martin John Ousterhout tl;dr: The document that features a dialogue between Robert "Uncle Bob" Martin and John Ousterhout discussing their differing software design philosophies. They debate three main topics: method length, comments and test-driven development.

featured in #623

The Perfect Commit

- Simon Willison tl;dr: For the last few years I’ve been trying to center my work around creating what I consider to be the Perfect Commit. This is a single commit that contains all of the following: (1) The implementation: a single, focused change. (2) Tests that demonstrate the implementation works. (3) Updated documentation reflecting the change. (4) A link to an issue thread providing further context

featured in #620

LLM Shibboleths Determine AI Effectiveness

- Brian Kihoon Lee tl;dr: “Coding assistants promise to revolutionize software development, but why do some developers sing praises while others find them useless? The answer lies between the keyboard and the chair, but it’s more than just simple user error. Your level of expertise silently shapes the way you interact with the AI, allowing two people to have completely different experiences despite interacting with the same AI on the same subject. In this essay I’ll discuss how this is possible and what you can do about it.”

featured in #620

Asserting Implications

- Alex Kladov tl;dr: When asserting implications, common code patterns can be confusing. Alex shares a clearer alternative. 

featured in #619

Better Error Handling

- Thanh Tschoepe tl;dr: “Error handling isn’t just a technical challenge - it’s a critical aspect of software safety and reliability. Yet in TypeScript and JavaScript, it remains something of a wild west. Today, I’ll share an overview of the current landscape and my preferred approaches.”

featured in #609

Claude Code: Best Practices For Agentic Coding

- Boris Cherny tl;dr: “This post outlines general patterns that have proven effective, both for Anthropic's internal teams and for external engineers using Claude Code across various codebases, languages, and environments. Nothing in this list is set in stone nor universally applicable; consider these suggestions as starting points.”

featured in #609

What Are Cursor Rules?

- Zack Proser tl;dr: “Cursor Rules allow you to codify the foundational decisions in your codebase, to reduce hallucinations across agentic composer and chat sessions. By placing these rules in special files, you can tailor Cursor’s suggestions or completions to match your team’s coding style and best practices.”

featured in #604

Use Abstraction To Improve Function Readability

- Palak Bansal Mark Manley tl;dr: The team at Google compares two functions and highlights how one is easier to follow due to its consistent level of abstraction, providing a top-down narrative of the code’s logic. createPizza is a high-level function that delegates the preparing, baking, and boxing steps to lower-level specialized functions with intuitive names. Those functions, in turn, delegate to their own lower-level specialized functions (e.g., heatOven) until they reach a function that handles implementation details without needing to call other functions.

featured in #604

Logging Practices I Follow

- Eliran Turgeman tl;dr: "There are many pitfall that can lead to useless, wasteful and confusing logs. Therefore I follow a specific set of practices which allows me to write better logs while also being consistent across the system." Eliran discusses here. 

featured in #603

The 4 Biggest API Challenges (and How To Beat Them)

tl;dr: APIs are the backbone of modern applications, but security vulnerabilities, latency issues, integration complexities, and compliance risks can turn them into a nightmare. From preventing data breaches to optimizing performance and ensuring seamless scalability, tackling these challenges requires the right strategies. This article dives deep into the most common API pitfalls and provides technical solutions engineers can apply today. Read the full breakdown to strengthen your API architecture and build more resilient systems.

featured in #602