Dieter Rams, the iconic German industrial designer, helped shape what we now recognize as modern minimalist design: clean, functional, and timeless.

Let’s explore how Rams’ philosophy can help us build better software.

1. Good design is innovative.

Design should push boundaries and offer new, smarter solutions to existing problems.

In software:
Innovation isn’t just about flashy new features — it’s about solving real problems in better ways.

• User-Centered Features: Don’t just add features for the sake of it. Ask yourself: What user need does this solve? Avoid feature bloat by focusing on improvements that add real value.

• Code Reuse & Abstraction: Avoid duplicating code. Reuse where possible. Whether it’s a helper function or an entire design pattern, prioritize modular, reusable components. Don’t reinvent the wheel.

2. Good design makes a product useful.

If a product doesn’t fulfill its purpose well, design fails — no matter how it looks.

In software:
Software should work efficiently, be maintainable, and evolve cleanly.

• Use Modern Architecture: Your system’s architecture must serve your needs. You should be using the correct modern Architecture to efficiently reach your goals of scalability, maintainability of your system. Your Monolith might not be the correct solution and you should switch to Micro Services, or the other way around - it depends on the problem. If the fundamentals are incorrect they will hold you back. (The same is true for using outdated version of most libraries and tools)
• Remove Bloat: - Eliminate dead code, outdated dependencies, and unused features. They add maintenance cost and confuse users. Focus on features that actively deliver value.

3. Good design is aesthetic.

Good design should be visually pleasing — but not at the expense of usability. It should enhance the function, not distract from it.

In software:
Aesthetics apply to the code itself, too. Clean code is not just elegant — it’s practical.

• Readability: You should be able to understand code at a glance. This means the code should follow guidelines. There should be good naming conventions, there should be a coding style guide. In Addition your code should be consistent of short functions, that break down the complex logic into smaller more easily understandable pieces.
• Predictable Folder Structure: A well-organized and consistent file structure amkes it significantly easier to understand the codebase and its overall architecture. Also ensure that the directories have a naming convention
• Formatting: With tools like linters and formatters, you can ensure that many rules are followed automatically, this reduces the mental load of thinking about all the rules all the time. (Just don’t get frustrated when you have to rewrite your code to satisfy the linter, the rules are there for a reason.)

4. Good design makes a product understandable.

Users shouldn’t have to think too hard about how something works — it should just make sense.

In software:
Clarity is key — for both end-users and developers.

• UI/UX Consistency: You should not force the user to think too much about your software. Stick to familiar patterns and conventions. (Note: You have to choose between a steep or smooth learning curve - with a steep learning curve you have to make sure users are guided.)
• Intuitive APIs (no matter who is using them): Think about the consumer of your APIs they have to be easy and intuitive to understand what is going on. It should be easy to integrate them with other systems. This is usually done by another developer so ensure that the API is well documented and that the developer knows exactly what to do to call the api and what he can expect the api to do.

5. Good design is honest.

Products shouldn’t promise what they can’t deliver. Be transparent about limitations and functionality.

In software:
Don’t mislead your users — or your developers.

• Keep the user informed: Let users know what’s happening — with loading states, progress bars, and meaningful error messages. You need to ensure that the user understands that the program is still running as expected, or what exactly has failed.
• Ensure Handling Failures: If your software stops working, display the error message, give the user the feedback that he can understand the state of the software. Don’t just say “Something went wrong.” Say what went wrong, why, and what the user can do to fix it (or at least understand the situation).
• Backend Failures: This also applies for the Backend, calling an API has to provide a good error message that includes why the call failed. Was it due to a third party system, every information that is possible to provide will make it easier to debug and fix the issue.

6. Good design is long-lasting.

Rams advocated for durability and timelessness over fleeting trends. A good product should be built to last, both physically and aesthetically. This reduces waste and promotes sustainability. He believed in designing products that wouldn’t become obsolete quickly due to changing fashions.

In software:
Code should be built to survive — readable, testable, and adaptable.

• High Quality Tests: The only way to ensure good code is by ensuring high quality tests. The tests need to be well designed and ensure the correct functionality of your code.
• Use Pure Functions (when possible): A pure function is a piece of code without any side-effects. It just takes data in and returns data. It is not always possible to write such kind of code. But pure functions are easier to test and reuse. While not always practical, aim for them when you can.
• Touch Once / Design First: This would be nice if we would only have to write and create code once (that is unrealistic), what we can do is minimizing unnecessary changes and prioritizing well-thought-out design upfront. Techniques like DRY (Don’t Repeat Yourself) are crucial here. Code reviews also help prevent hasty or poorly considered modifications.

7. Good design is thorough down to the last detail.

Design isn’t just about the exterior appearance; it encompasses every aspect of the product – its internal workings, materials, manufacturing processes, packaging, and even marketing. Every detail should be considered with the same level of care.

In software:
Every part of the development process deserves care and attention.

• Care and Accuracy: Good design isn’t a one-time event; it demands attention to detail throughout the entire software development lifecycle. It requires a mindset of continuous improvement and striving for excellence in every aspect of the work, from initial requirements gathering to final testing and deployment. By prioritizing accuracy and care at every stage, we ensure that the software functions as intended, delivering an honest representation of its capabilities and minimizing costly rework later on.
• Refactoring: Good design isn’t static; it requires ongoing attention through strategic optimization and refactoring. While premature optimization should be avoided, regularly identifying and addressing performance bottlenecks is essential to maintain efficiency over time. (And yes it is also a bottle neck when new developers have difficulties to understand the code, that is a clear sign that the codebase needs work.)
• Ticket Management: While It is very easy to hate on JIRA how it is misused by managers in most software development processes. Don’t underestimate a well-designed ticket system. The ticket management system should be easy to use for the developers as well as the people creating the tickets. The design of that system will have a direct impact on the software development, as when developers do not look into the bug tracking system - the bugs will never get fixed. Clear, actionable issues and feature requests help keep development focused and efficient.

8. Good design is environmentally friendly.

A product should minimizing waste, using sustainable materials, and designing products that are energy-efficient and recyclable.

In software:
Digital systems still have a physical impact — and the “environment” includes your team.

• Team Members: Write code with your team in mind. Follow the Boy Scout Rule: leave the code better than you found it.
• Technical Environment You should be using efficient algorithms to use the minimal amount of memory and cpu power to solve the problem. When working for mobile you should be considerate of not wasting the battery. In a server environment you might take into consideration how fast and how much energy it will cost to scale your servers.

9. Good design is economical.

You should not be “cheap” - but be efficent on how you use your resources.

In software:
More features or code doesn’t mean better. Simpler is almost always smarter.

• Minimize Bugs: The highest cost in any software development project is fixing a bug. Because debugging is a very time consuming process and you do not know how long it will take. The highest cost is of course in production, where in additon to the debugging costs you have the production outage costs. You should always try to prevent bugs as early as possible. And yes the cheapest way to fix a bug is it found during writing tickets to implement the feature.
• Error Path Handling: While bugs cannot be prevented, they can be contained. By not only implementing the Happy Path of the application but also the paths where everything goes wrong - You not only create a better user experience, you also ensure that only a small part of the application will fail. In addition you are cutting down on the debugging time as you can quickly isolate and identify the piece of code that is not working correctly.

10. Less is more.

This is perhaps Rams’ most famous principle. Strip away the unnecessary and focus only on what truly matters.

In software:
Simplicity is your best friend.

• KISS (Keep It Simple, Stupid): Simplicity improves clarity, reduces bugs, and speeds up development. It encourages developers to avoid unnecessary complexity and over-engineering — if a simpler solution works, use it.

Summary

These timeless principles offer a practical reminder: less is more. In software, that means fewer features done better, fewer bugs thanks to clearer code, and fewer headaches caused by complexity.

Whether you’re writing a function, designing an API, or structuring a system — aim for simplicity. Simpler systems are easier to understand, easier to maintain, and easier to evolve. That’s not just good design — that’s good software.