Clean Craftsmanship: Disciplines, Standards, and Ethics

Robert C. Martin Series

by Robert C. Martin

In Clean Craftmanship: Programming with Pride , the legendary Robert C. Martin ("Uncle Bob") has written every programmer's definitive guide to working well. Martin brings together the disciplines, standards, and ethics you need to deliver robust, effective code quickly and productively, and be proud of all the software you write - every single day.

Martin, the best-selling author of The Clean Coder, begins with a pragmatic, technical, and prescriptive guide to five foundational disciplines of software craftsmanship: test-driven development, refactoring, simple design, collaborative programming (pairing), and acceptance tests. Next, he moves up to standards -- outlining the baseline expectations the world has of software developers, illuminating how those often differ from their own perspectives, and helping you repair the mismatch. Finally, he turns to the ethics of the programming profession, describing ten fundamental promises all software developers should make to their colleagues, their users, and above all, themselves.

With Martin's guidance and advice, you can consistently write code that builds trust instead of undermining it: trust among your users, and throughout a society that depends on software for its very survival.

Genres: Programming, Software, Computer Science, Technology, Nonfiction, Coding, Design

416 pages, Paperback

First published January 1, 2021

About the author

Robert Cecil Martin, commonly called Uncle Bob, is a software engineer, advocate of Agile development methods, and President of Object Mentor Inc. Martin and his team of software consultants use Object-Oriented Design, Patterns, UML, Agile Methodologies, and eXtreme Programming with worldwide clients.

He was Editor in Chief of the C++ Report from 1996 to 1999. He is a featured speaker at international conferences and trade shows.

Reviews

[Matthew Horvat · Rating 4 out of 5]

One thing you can count on, Uncle Bob will write another book with Clean in the title. As I read this book, it felt like something I had read a few times in the past. Of course, since Uncle Bob is a reliable source of technical knowledge he is worth reading, no matter how many times you hear the same stories and get the same knowledge.

The big focus of this book is TDD and Refactoring which drives the rest of the Disciplines, Standards and Ethics.

[Paul Sochiera · Rating 4 out of 5]

Explained the fundamentals really well!

I like his priorities: TDD (>50% of the entire book), Refactoring, Simple Design and Teaming.

[Mark Seemann · Rating 3 out of 5]

This is, in a sense, two books in one. The first 250 pages serve as an introduction to test-driven development (TDD), including many code examples that show how both tests and 'production' code evolve over time. I've always appreciated that Robert C. Martin has the nerve to dump two pages of source code listing. While this may, at first glace, look like waste of paper, it's a good example of the show, don't tell principle. Instead of explaining how the code changes, Martin shows it.

That said, there's nothing new here. You can find the same kind of walkthrough of TDD in Test-Driven Development: By Example. Granted, part I of the book is rounded out with a discussion of a few design principles (not the SOLID principles, but rather Kent Beck's rules for simple design), refactoring, and a few other good engineering practices.

After 250 technical pages, the book changes and becomes an exploration of the standards and ethics of software development. I find most of it reasonable, but there's nothing new. The Pragmatic Programmer already covered much of that ground in 1999. More recent efforts like Accelerate provide increased confidence that certain software engineering principles work well. Another recent effort in that space is Modern Software Engineering which was published the same month as Clean Craftsmanship.

What sets Martin apart from the other book is his emphasis on ethics. If you've heard or seen him talk about this in podcasts or at conferences, there's nothing new here. On the other hand, I think that this is the first time that he's published these thoughts in a book. I can see how this is valuable. A book is, after all, a source of reference more stable than then ephemerals of YouTube videos, podcast platforms, Twitter, etc.

In summary, this is already known content, now collected in book form. If you're familiar with the practices and ethics that Martin advocate, you'll find nothing new. The arguments about standards and ethics do, however, deserve to be collected in book form, and this is now a reality. On the other hand, I found the first 250 pages redundant.

[Amani · Rating 4 out of 5]

First of all, it is the 5th book authored by Robert C. Martin that I read. I have read before: Clean Code, The Clean Coder, Clean Agile and Clean Architecture. Among them all, I consider ‘Clean Craftsmanship’ the 2nd or the 3rd most important, after Clean Architecture and Clean Agile.

At the beginning I was surprised that the testing and TDD (Test Driven Development) part spans almost half of the book size, but during my reading journey I realized why. TDD is the basis of nearly all craftsmanship disciplines and the direct way to apply them easily. Refactoring essentially needs TDD. Simple design is built on TDD. Collaborative programming utilizes TDD. Even acceptance tests require TDD.

The TDD chapters contain detailed coding examples of its basics and steps among with comprehensive explanation of test doubles, the differences between them and when to use each. I liked this part a lot, specially its code is written in Java - one of my favorite programming languages. Test design is highly related to this and so important to consider while writing tests. This not only reflects the success of TDD, but also the clean architecture of the code beyond these tests.

The refactoring chapter was small and abbreviated in my opinion. I expected more details, examples and methods. Maybe the author depended on the refactoring details mentioned earlier in the TDD parts.

After that comes the simple design, collaborative programming and acceptance tests. Again, they need more space and details. How come collaborative programming get explained in just 3 pages?! But still useful after all.

The second and third parts about 'The Standards' and 'The Ethics' are clearly the “nutshell" of all the ethics and the standards that programmers and their managers need to follow in this industry.

I highly recommend this book for everyone in the software industry. Whether you are an engineer or a manager, definitely you need it. Maybe non technical managers don’t need to go deep into the first chapters regarding the TDD technical details, but for sure they need the other parts starting from chapter 7 to the end of the book.

My rate: 3.5 out of 5.

Alexandria, Egypt - 18 Sep. 2025.

[Tbueno · Rating 3 out of 5]

Uncle Bob is a prolific author in the Software Engineering genre of computer science books, along with his peers like Martin Fowler, Kent Beck, Jez Humble and others. And in this book, he suffers from the pains of his earlier success. Clean Craftsmanship adds too little for readers of the previous books of the "Clean" collection. If on top of that, the reader had also read the previously mentioned authors, there is not much else to learn here.

It is hard to understand where Clean Craftsmanship fits in the series of book written by Robert C. Martin. In some cases, it goes to lengthy explanations with long examples of TDD examples, in others the same happens for code refactoring. And these are examples of topics that are covered more in depth in Test-Driven Development: By Example and in Refactoring: Improving the Design of Existing Code respectively. So, i would say that this is more like an intermediate-level book that covers several technical (TDD, Refactoring, Engineering...) and excellence (quality, process, continuous learning...) topics.

There is still value in some of the more advanced parts sprinkled through the book, in regards to things like test quality, build time, developers courage, etc...

All things considered, Uncle Bob is still a good writer and this book can be a good reference for Jr./Intermediate developers that have finished Clean code and want to take their next step in their career, since the book is fool of good quotable sentences. But for those who have read some of his other previous books, this one might be a skippable entry in the "Clean..." series.

[Ahmed Alkatheeri · Rating 5 out of 5]

The ‘Clean Craftmanship’ book serves software developers as a guide for seeking to enhance their craft and uphold high standards in their work. It starts by clarifying the Craft philosophy and promotes the idea that software development is a craft that requires dedication, skill, and commitment to quality.

The book recommends Extreme Programming practices such as Test-Driven Development with examples and Code Refactoring. It also promotes the disciplines of Clean Code through the importance of readability, simplicity, and avoiding unnecessary complexity.

Uncle Bob discusses the essential standards and best practices that developers should adhere to, such as the Single Responsibility Principle and the Open/Closed Principle—they are part of the SOLID principles of Software Architecture.

One important theoretical awareness part of the book was the Ethics of Software Development. The author highlights the ethical responsibility of software developers, stressing that they should take ownership of their work and strive for excellence, as software can significantly impact people’s lives.

There was much advice and guidance mentioned, such as the encouragement of Continuing Learning, keeping up with new technologies, including programming languages and framework updates, and new methodologies, which helps to improve their skills.

Overall, it is a very good book and is recommended for software developers, whether they are new or have mid- and advanced experience in their field!

[Łukasz Słonina · Rating 4 out of 5]

Mixed feelings. On one side nothing new for somebody already familiar with Uncles Bob books and videos. Same well known examples of refactoring bowling game, rental calculator, etc. On the other presented topics should be practiced constantly by every programmer thinking about improving his skills. And from that angle I would definitely recommend this book for every software craftsman.

[Djamel Benali · Rating 5 out of 5]

I enjoyed reading this book, the book explains TDD in great details with good examples and how beginners face problems using TDD, the last part of book is full of advices in work (team, time management, CD/CI ,deadlines, productivity ....).

[Julio César · Rating 4 out of 5]

There's always something to learn from "Uncle Bob". I specially enjoyed the companion videos where we fellow programmers could enjoy the craft of an experienced colleague as he's doing his job. The rules and guiding lines will be considered in my practice.

[Nicola · Rating 4 out of 5]

The first part of the book about TDD could have been compressed a bit, in my opinion. But otherwise the book is very easy to read and it makes some very good points about software development ethics and processes.
The first two parts of the book are relatively technical, while the last one is not.

[Shreyas · Rating 4 out of 5]

Nothing new here, a rehashing of the themes from Uncle Bob's Twitter feed.

Having said that, still an excellent read to reaffirm some fundamentals.

[Jevgenij]

Seemed too basic and generic

[Tim]

If you like "Uncle Bob's" other books, you'll like this one too. The TDD 1/2 -2/3 is really good.

[Ethan Glover · Rating 5 out of 5]

Necessary

Great ideas and advice from start to finish. This was a really satisfying read that motivates me to be better in my job.

[Vitali · Rating 4 out of 5]

nice compilation from prev works (clean code / clean coder) + motivating stuff

[Must Tahir · Rating 5 out of 5]

Really enjoyable reading