diff --git a/src/roadmaps/software-design-architecture/content/100-clean-code-principles/114-avoid-hasty-abstractions.md b/src/roadmaps/software-design-architecture/content/100-clean-code-principles/114-avoid-hasty-abstractions.md
index ce021f493..ae7fc77cd 100644
--- a/src/roadmaps/software-design-architecture/content/100-clean-code-principles/114-avoid-hasty-abstractions.md
+++ b/src/roadmaps/software-design-architecture/content/100-clean-code-principles/114-avoid-hasty-abstractions.md
@@ -4,15 +4,14 @@ Creating abstractions is an important part of software development, but creating
 
 Here are some ways to avoid hasty abstractions in system architecture:
 
-1. Understand the problem that needs to be solved before creating an abstraction.
-2. Start with a simple solution and only create an abstraction when it becomes clear that the solution is becoming too complex.
-3. Use code refactoring techniques to simplify the code before creating an abstraction.
-4. Avoid creating abstractions for the sake of creating abstractions.
-5. Use established design patterns and practices when creating abstractions, but do not force them into the code.
-6. Use automated testing to ensure that the abstraction does not introduce new bugs or break existing functionality.
-7. Create abstraction in a way that it's easy to test, debug, and reason about.
+- Understand the problem that needs to be solved before creating an abstraction.
+- Start with a simple solution and only create an abstraction when it becomes clear that the solution is becoming too complex.
+- Use code refactoring techniques to simplify the code before creating an abstraction.
+- Avoid creating abstractions for the sake of creating abstractions.
+- Use established design patterns and practices when creating abstractions, but do not force them into the code.
+- Use automated testing to ensure that the abstraction does not introduce new bugs or break existing functionality.
+- Create abstraction in a way that it's easy to test, debug, and reason about.
 
-By following these best practices, the system architecture will be more maintainable, testable, and less error-prone, and it will be easier to read and understand the code.
 
 Learn more from the following links: