{
  "id": 17405355,
  "title": "The Secret of Fast Programming: Stop Thinking »",
  "url": "https://urgent.news/2026/10/31/the-secret-of-fast-programming-stop-thinking",
  "topic": "tech",
  "section": "Tech",
  "published": "2026-10-31T10:20:48.000Z",
  "source": {
    "name": "Lobsters",
    "slug": "lobsters",
    "url": "https://www.codesimplicity.com/post/the-secret-of-fast-programming-stop-thinking/"
  },
  "original_language": "en",
  "account": "Developers frequently express desire for simplicity in their code, but deadline constraints or other factors often result in complexity. While it's true that pressure can lead to complex code, it doesn't have to. Instead of lamenting that deadlines hinder simplicity, one could acknowledge, \"I am not fast enough to keep the code simple.\" The key to this lies in programming speed, which directly impacts code quality regardless of deadlines. So, how does one become faster? This isn't about innate talent or intelligence, but following one simple rule: stop thinking. When you find yourself pausing to think, it signifies a problem. These pauses often stem from a lack of understanding about certain symbols, words, or underlying concepts. For instance, a developer struggling with a simple service might realize they didn't fully grasp the meaning of a variable. Understanding the type of the variable can clarify the issue. This realization is crucial because once you understand, you no longer need to stop and think. This idea is also the core motivation behind my book, emphasizing the existence of unchangeable laws in software design that can help avoid \"stopping to think\" moments. If you're stuck, don't try to solve it in your head; instead, seek outside resources to understand what you don't comprehend. This could be as simple as drawing a diagram, consulting documentation, or asking for opinions. Sometimes, developers struggle because they can't juggle too many concepts simultaneously. In such cases, it's more efficient to create a visual representation or something tangible to help understand the relationships. The key is action leading to understanding. Other times, developers stop thinking because they lack a clear idea of what code to write first. The solution in this case is to start writing whatever code you can. Begin with the part of the problem you fully understand, even if it's a tiny, seemingly insignificant component. This could serve as the \"core\" of your application, which, by the way, can be a useful exercise in continuous delivery. This approach ensures you're creating something immediately useful, even if it's not a complete solution. If you're unsure about writing the core code, start with what you're confident about. Often, solving one part of the problem can make the next part clearer, leading to a step-by-step solution. Lastly, be aware of potential misunderstandings in the development sequence. For example, if your Bike object depends on Wheels, Pedals, and Frame objects, writing the entire Bike class before creating the dependent classes can lead to a lot of thinking. Instead, create the Wheels class first, then the Pedals, and finally the Frame, all while working incrementally on the Bike class. This method allows you to avoid unnecessary thinking and helps maintain the flow of development.",
  "summary": null,
  "key_points": [],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}