Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
The Clean Coder

The Clean Coder

A Code of Conduct for Professional Programmers
When a deadline slips, your next move can protect the code, the team, and your credibility.
by Robert C. Martin 2011 210 pages
4.26
9k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat production code as a responsibility, not a personal performance.

Responsibility follows expertise. Martin’s central claim is that professional status means being accountable for what code does, including the damage caused by foreseeable mistakes. He recalls shipping a release without completing a lengthy test. The result: customers lost a night of operational data, and a colleague had to absorb their anger. The developer had prioritized appearing on time over protecting users. The professional alternative was to disclose the unfinished testing and renegotiate the release.

Warnings need action. The book opens with the Challenger disaster: engineers knew cold weather threatened the shuttle’s booster seals and warned decision-makers, but the launch proceeded. Martin asks whether raising alarms was enough. Software rarely carries the same immediate physical danger, yet failures can still harm customers, businesses, and public trust. Responsibility means testing, communicating risk, and refusing to disguise uncertainty.

Analysis

What's striking is how this account treats technical expertise as an ethical obligation, not merely a credential. Safety engineering makes a similar point: people closest to a hazard need channels to report it, and organizations need procedures that can act on those warnings. Personal accountability matters, but it cannot substitute for institutional responsibility. An engineer cannot single-handedly control a launch decision, a release policy, or a manager's incentives. The useful standard is neither perfection nor scapegoating. It is making risks visible, reducing preventable harm, and learning from failures without confusing honest error with reckless concealment.

Say no early enough to negotiate a better yes.

Disagreement can serve the goal. Martin argues that managers and developers should defend their responsibilities rather than smooth over conflict with an unreliable “yes.” In one example, a manager demands a login page by the next day, although the full feature needs two weeks. The developer refuses the impossible date, then offers a working mock-up that supports the customer demonstration while postponing several features. The team gets a useful result without pretending the complete system is ready.

A false yes costs more. In an earlier project, a team under pressure agreed to a launch date despite known reliability problems. Users’ terminals repeatedly froze, and the system had to be shut down. The lesson is not to argue for its own sake. State what cannot be delivered, identify what can, and negotiate scope, timing, or both.

Analysis

The chapter's strongest insight is that conflict can reveal constraints that politeness conceals. This resembles negotiation theory, where parties often reach better agreements by separating the stated demand from the underlying need. A working demonstration may meet the real need even when a complete feature cannot. But constructive disagreement depends on power and trust. In a workplace where dissent is punished, “just say no” may be personally risky. Managers share responsibility for making honest estimates safer than optimistic fiction.

Commit only to actions you control, and flag risk as soon as it appears.

Make promises testable. The book distinguishes commitment from vague intention. A clear commitment names an action and a deadline, such as finishing a defined task by Tuesday. Phrases such as “we should,” “I hope,” or “we’ll try” can hide uncertainty or shift responsibility. When the outcome depends on another team, commit instead to actions within reach: arrange a technical discussion, build an independent test, or verify a dependency.

Renegotiate before failure. A developer who discovers that a bug is harder than expected should tell affected colleagues early, while they still have options. Martin’s example of a developer facing a Monday deadline shows that extra hours can be offered honestly, but not as a magical guarantee. Any overtime agreement should account for personal limits and recovery time. A professional yes is a specific promise, not a performance of confidence.

Analysis

This approach turns commitment into a coordination tool rather than a test of character. In project planning, early warnings preserve options: teams can change scope, move people, or reset expectations before a deadline becomes an emergency. The distinction between outcomes and controllable actions also resembles process control, where people are judged on actions they can actually influence. Still, precise language does not eliminate uncertainty. A useful commitment includes room to update assumptions, rather than making every missed date look like a moral failure.

Use fast tests to make clean code safe to change.

Feedback protects structure. Test Driven Development, or TDD, is a cycle in which a programmer writes a small failing test, writes enough code to pass it, and then improves the design while checking that the tests still pass. Martin recalls learning this through cycles of roughly thirty seconds, far faster than his previous habit of writing for an hour before testing. Frequent feedback makes defects easier to locate and gives developers confidence to refactor, meaning to improve code structure without changing its behavior.

Tests support maintenance. Martin reports that FITNESSE, a 64,000-line project, had more than 2,200 unit tests, about 90 percent reported coverage, and a test run of roughly 90 seconds. He argues that tested code is easier to revise and that preserving structure matters as much as delivering features. Tests do not guarantee good design, but they make regular improvement less hazardous.

Analysis

Short feedback loops are valuable because they reduce the distance between an action and evidence about its result. That principle appears in experimental science and skilled motor learning as well as software development. Tests can also function as executable examples, showing future maintainers how a unit is meant to behave. The limit is that coverage measures execution, not whether the tests ask the right questions. TDD is most persuasive as a disciplined way to expose assumptions early, not as a ritual that can guarantee correctness.

Give estimates as ranges and probabilities, not reassuring dates.

An estimate describes uncertainty. Martin separates an estimate, which expresses what may happen, from a commitment, which promises a result. His PERT method uses three task estimates: an optimistic case, a most likely case, and a pessimistic case. For a task estimated at 1, 3, and 12 days, respectively, the weighted expected duration is about 4.2 days, with a standard deviation of about 1.8 days. The three numbers communicate more than the deceptively confident answer “three days.”

Combine judgment. For larger plans, teams can estimate tasks together using methods such as Planning Poker: discuss a task, reveal estimates simultaneously, and investigate major disagreements. Breaking a large task into smaller ones can expose hidden work and make estimates more useful. It does not remove uncertainty, especially when risks affect several tasks at once.

Analysis

Probability-based estimates improve planning because a single point value invites people to mistake a guess for a guarantee. The method also gives managers information for contingency planning, rather than merely a date to repeat upward. Its mathematical clarity can be misleading, however. PERT calculations depend on judgments about optimistic and pessimistic cases, and task risks are not always independent. The discipline is most useful when teams revisit estimates as evidence changes and compare past forecasts with actual outcomes.

Turn vague requirements into examples everyone can execute and inspect.

Requirements emerge through use. Martin describes helping a service manager build a simple ticketing tool. The customer changed his mind repeatedly while seeing each version run. The experience showed why detailed specifications written far in advance can fail: people often understand what they need only after encountering a working system. At the same time, late discussion can leave crucial terms ambiguous. “Back up the logs daily,” for instance, might mean copying only yesterday’s file, while the customer expects a lasting archive.

Make agreement runnable. An acceptance test is an automated check created with business, testing, and development participants to define when a requirement is complete. One test might verify that a backup directory is created and that existing archived files remain after restart. The book places these checks alongside unit, integration, system, and exploratory testing. A QA manager’s manual test plan cost over a million dollars each time it ran, making automation a practical necessity.

Analysis

Executable examples create a shared object that business stakeholders, developers, and testers can inspect together. This is a powerful remedy for ambiguity because disagreement becomes concrete: participants can debate an observable behavior rather than a sentence that each interprets differently. Acceptance tests can still formalize the wrong requirement, so collaboration must include opportunities to challenge assumptions and revise examples. Automation is best understood as a way to preserve agreement and repeat verification, not as a replacement for human judgment.

Under pressure, protect the practices that prevent tomorrow's crisis.

Fatigue distorts judgment. Martin recalls writing a design mistake at three in the morning after a long day of coding. The workaround created timing problems and feedback loops that burdened the system for years. He argues that dedication is not measured by hours at the keyboard. Sleep, distraction, and unresolved worries affect concentration, while breaks and a change of activity can help restore it. He also describes “focus-manna,” his metaphor for the limited attention available for demanding work.

Do not manufacture hope. Track progress, communicate possible delays early, and resist shortcuts that hide a schedule problem. Overtime may help briefly, but Martin recommends it only when the developer can afford it, the period is short, and management has a fallback plan. When trouble does arrive, slow down, use established practices, and ask for help rather than rushing into a larger mess.

Analysis

The chapter challenges a familiar but poorly tested workplace myth: that visible exhaustion proves commitment. Cognitive science supports the narrower claim that fatigue and interruptions impair attention, although individual differences and task types matter. The “focus-manna” metaphor is useful as a prompt to notice changing capacity, not as a literal biological measurement. The practical test is whether extra hours improve the work or merely postpone a difficult conversation about scope, staffing, and risk.

Practice outside delivery, then spread skill through pairing and mentoring.

Performance is not practice. Martin compares programming to music and martial arts: doing paid work exercises a skill, but deliberate practice isolates a technique for improvement. A coding kata is a short, repeatable programming exercise, such as calculating prime factors, performed to sharpen problem-solving habits, editor fluency, or a testing discipline. In a Coding Dojo, programmers practice together. One format has partners alternate between writing a test and making it pass; a group format passes the keyboard from one participant to the next.

Teach the craft. The book proposes a progression from closely supervised apprentices to increasingly independent journeymen and experienced masters. Pairing helps juniors learn the code and helps experienced developers exchange knowledge. Martin also urges programmers to broaden their experience through new languages and open-source work. The underlying claim is that technical judgment and professional conduct are learned through guided repetition, observation, and feedback.

Analysis

The analogy to deliberate practice is apt: expertise grows when learners receive focused feedback on specific skills, rather than merely accumulating years of exposure. Pairing can make tacit decisions visible and give novices a safe route into unfamiliar code. Yet the book assigns substantial responsibility to individuals and senior colleagues, while access to mentorship and discretionary time varies widely across workplaces. Organizations that value craftsmanship need to schedule learning and teaching, not rely solely on personal sacrifice.

Build persistent teams that learn each other's work, not project fragments.

Teams need time to gel. Martin criticizes staffing small projects with the same people split across several unrelated teams. A quarter or half of a person cannot be switched cleanly between competing priorities; every handoff carries context and coordination costs. He favors persistent teams, often around a dozen people, that move from project to project and develop shared working habits. He estimates that this process can take six months to a year.

Share ownership. A gelled team includes developers, testers, analysts, and a project manager. Its members collaborate, help one another, and can shift attention when business priorities change. Martin also argues against code ownership that prevents colleagues from reviewing or modifying a module. Shared ownership reduces dependence on a single specialist and helps the group maintain the system as a whole.

Analysis

Persistent teams preserve relationships and accumulated context, assets that disappear when staffing is organized as a succession of short-lived project assignments. The model also makes collaboration easier to practice because people repeatedly solve problems together. Stability is not automatically healthy, however. A long-lived team can become insular, and shared ownership needs clear review and decision practices to avoid diffusion of responsibility. The strongest version pairs continuity with cross-team learning and transparent accountability.

Analysis

The book treats software professionalism as a social contract. Developers receive trust and discretion because they possess knowledge that customers and managers cannot easily reproduce. In exchange, they must make uncertainty visible, protect users from avoidable failures, and maintain the technical conditions that allow future change. Testing, estimation, refactoring, and communication are therefore not isolated techniques. Together they make the developer's claims about readiness more credible.

Its narrative gains force from the author's own failures: a release shipped without adequate testing, a deadline accepted under coercion, and code written while exhausted. These are not abstract case studies. They show how ordinary incentives, saving face, winning praise, avoiding conflict, can convert technical shortcuts into organizational risk. The Challenger story extends that responsibility to high-stakes engineering, while also exposing a limitation in an individual-centered code of conduct. Expertise cannot make a warning effective when leadership ignores it. Professionalism requires structures that protect dissent, not just individuals brave enough to dissent.

The book's strongest practical idea is that trust is built through observable behavior. A test suite makes a claim about code inspectable. An estimate with uncertainty makes a schedule discussable. An acceptance test lets different departments agree on what a feature means. These practices turn vague assurances into evidence and shared decisions. That is a deeper argument than simply urging developers to work carefully.

Some prescriptions need context. The expectation of substantial unpaid practice time risks defining professionalism in ways that exclude caregivers and people without spare time. Likewise, overtime can be framed as a bounded choice, but workplace power can make refusal difficult. The most durable interpretation is not that every failure belongs to the programmer. It is that professionals should act honestly within their authority, while organizations must make honest reporting, sustainable work, and technical quality possible. Craft is individual discipline supported by collective design.

Summary in 30 Seconds
Professional software work means making risks visible, negotiating scope when dates are unrealistic, and committing only to actions within your control. Frequent small tests make changes safer, while automated acceptance checks turn ambiguous requests into verifiable agreements. Estimates are more honest when they include optimistic, likely, and pessimistic cases: a task estimated at 1, 3, and 12 days has an expected duration of about 4.2 days. Pairing, deliberate practice, and persistent teams build skill and shared ownership.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.26 out of 5
Average of 9k+ ratings from Goodreads and Amazon.

The Clean Coder receives mixed reviews, with many praising its insights on professional software development. Readers appreciate the author's anecdotes and advice on work ethics, estimation, and communication. Some find the book outdated or extreme in its expectations, particularly regarding work hours. Critics note repetitive stories and a self-centered tone. Despite disagreements, most reviewers recommend it as a valuable resource for aspiring professional programmers, highlighting its emphasis on discipline, responsibility, and continuous learning.

Your rating:
4.59
333 ratings
Want to read the full book?

Glossary

Test Driven Development

Tests guide code design

A programming discipline in which developers write a small failing unit test before writing the production code that satisfies it. They repeat short cycles of testing and implementation, then improve the design while keeping tests passing. The tests provide rapid feedback and describe intended behavior, but they do not guarantee sound tests or correct requirements.

Acceptance test

Executable requirement check

An automated test developed collaboratively by business stakeholders, testers, and programmers to specify the behavior that makes a requirement complete. It typically checks the system through a component or external interface and is written in a form that business participants can understand. Passing the agreed tests provides an observable definition of done.

PERT

Three-point task estimation

Program Evaluation and Review Technique, an estimation method that uses optimistic, nominal, and pessimistic durations to represent uncertainty. A weighted average estimates expected duration, while the spread between optimistic and pessimistic values estimates variability. Teams can combine estimates across sequential tasks to make schedules more realistic than a single best guess.

Coding Dojo

Group programming practice

A structured session in which programmers practice coding skills together, often by solving a small problem with test-driven development. Participants may follow a demonstration, work in pairs, or pass control from one person to another. The purpose is to build fluency, compare approaches, and learn practices outside the pressure of production delivery.

Kata

Repeatable coding exercise

A short programming problem repeated to train specific habits and techniques rather than to discover a novel solution. A programmer might repeat an exercise to improve test-driven development, code navigation, or familiarity with a language. Repetition makes common decisions more fluent, leaving more attention available for the larger design problem.

Wideband Delphi

Collaborative task estimation

A group estimation approach in which people discuss a task, make estimates independently, reveal their judgments, and examine substantial disagreements. The goal is not to average away differences, but to uncover distinct assumptions about scope, difficulty, and risk. Planning Poker and simultaneous finger voting are lightweight forms of this consensus-oriented method.

Focus-manna

Metaphor for attention capacity

Martin's metaphor for the limited concentration available for demanding programming work. In this model, meetings, worry, interruptions, and poor sleep deplete attention, while breaks, rest, or physical activity help restore it. The term is a practical way to discuss fluctuating focus, not a measured biological substance.

Gelled team

Established collaborative team

A persistent group whose members have worked together long enough to understand one another's strengths, habits, and responsibilities. Such teams share knowledge, coordinate with less friction, and can move among projects without repeatedly rebuilding relationships. Martin argues that organizations should preserve these teams rather than assemble temporary groups from people divided across many assignments.

FAQ

What's "The Clean Coder" about?

  • Professionalism in Programming: "The Clean Coder" by Robert C. Martin is a guide to professional conduct for software developers, emphasizing the importance of professionalism in the field.
  • Code of Conduct: It outlines a code of conduct for programmers, focusing on responsibility, accountability, and ethical behavior in software development.
  • Practical Advice: The book provides practical advice on how to handle common challenges faced by programmers, such as dealing with pressure, managing time, and saying no.
  • Improving Software Craftsmanship: It aims to improve the craft of software development by encouraging developers to adopt disciplined practices and continuous learning.

Why should I read "The Clean Coder"?

  • Enhance Professionalism: Reading this book can help you enhance your professionalism and improve your reputation as a reliable software developer.
  • Practical Guidance: It offers practical guidance on handling real-world challenges in software development, making it a valuable resource for both new and experienced programmers.
  • Ethical Framework: The book provides an ethical framework for making decisions, which is crucial in maintaining integrity and trust in the workplace.
  • Career Growth: By adopting the practices and principles outlined in the book, you can advance your career and contribute positively to your team and organization.

What are the key takeaways of "The Clean Coder"?

  • Responsibility and Accountability: Programmers should take responsibility for their work and be accountable for their mistakes, striving to deliver high-quality software.
  • Saying No: Learning to say no is crucial when faced with unrealistic demands or deadlines, ensuring that commitments are realistic and achievable.
  • Continuous Learning: Developers should continuously learn and practice their craft to stay relevant and improve their skills.
  • Testing and Clean Code: Emphasizes the importance of writing clean, maintainable code and using test-driven development to ensure software quality.

What is the "do no harm" approach in "The Clean Coder"?

  • Avoiding Bugs: Programmers should strive to avoid introducing bugs into the software, as they can cause significant harm to the project and the business.
  • Testing Thoroughly: Code should be thoroughly tested to ensure it works as intended, with automated tests providing a safety net for changes.
  • Maintaining Structure: The structure of the code should be maintained to ensure it remains flexible and easy to change, preventing future issues.
  • Continuous Improvement: Developers should continuously refactor and improve the codebase to prevent it from becoming rigid and difficult to work with.

How does "The Clean Coder" suggest handling pressure?

  • Avoiding Pressure: The book advises avoiding pressure by managing commitments carefully and maintaining clean code to prevent last-minute crises.
  • Staying Calm: Under pressure, developers should remain calm and rely on their disciplines and training to guide them through challenging situations.
  • Effective Communication: Communicating effectively with the team and stakeholders can help manage expectations and reduce pressure.
  • Seeking Help: When under pressure, seeking help from colleagues and collaborating can provide support and lead to better solutions.

What is the role of acceptance testing in "The Clean Coder"?

  • Defining Done: Acceptance tests help define what "done" means for a feature, ensuring that all parties agree on the requirements and expectations.
  • Automated Tests: These tests should be automated to provide a reliable and repeatable way to verify that the software meets the specified requirements.
  • Collaboration: Acceptance tests are created through collaboration between developers, testers, and stakeholders, ensuring that all perspectives are considered.
  • Reducing Ambiguity: By specifying requirements in the form of tests, ambiguity is reduced, leading to clearer communication and fewer misunderstandings.

What does "The Clean Coder" say about saying no?

  • Importance of Saying No: Saying no is crucial when faced with unrealistic demands or deadlines, protecting the quality of the work and the well-being of the developer.
  • Professional Responsibility: It is a professional responsibility to push back against requests that cannot be reasonably fulfilled without compromising standards.
  • Negotiation: Saying no should be part of a negotiation process to find a mutually agreeable solution that meets the needs of the business and the capabilities of the team.
  • Avoiding Overcommitment: By saying no when necessary, developers can avoid overcommitment and ensure they can deliver on their promises.

How does "The Clean Coder" define professionalism in programming?

  • Taking Responsibility: Professionalism involves taking responsibility for one's work and being accountable for the outcomes, both good and bad.
  • Continuous Improvement: Professionals continuously seek to improve their skills and knowledge, staying current with industry trends and best practices.
  • Ethical Behavior: Ethical behavior is a cornerstone of professionalism, ensuring that developers act with integrity and honesty in all their dealings.
  • Commitment to Quality: Professionals are committed to delivering high-quality software, adhering to best practices and standards to achieve this goal.

What is the significance of test-driven development (TDD) in "The Clean Coder"?

  • Ensuring Quality: TDD is a discipline that helps ensure the quality of the software by writing tests before the code, guiding development.
  • Confidence in Code: By having a suite of tests, developers can have confidence that their code works as intended and that changes won't introduce new bugs.
  • Design Influence: TDD influences design by encouraging decoupled and testable code, leading to better architecture and maintainability.
  • Professional Practice: TDD is presented as a professional practice that developers should adopt to improve their craft and deliver reliable software.

What are the best quotes from "The Clean Coder" and what do they mean?

  • "Professionalism is all about taking responsibility." This quote emphasizes the importance of being accountable for one's work and actions as a software developer.
  • "QA should find nothing." This highlights the goal of developers to deliver software that is so well-tested and reliable that QA finds no issues.
  • "Saying yes to dropping our professional disciplines is not the way to solve problems." This warns against compromising standards and practices in the face of pressure or deadlines.
  • "The only way to prove that your software is easy to change is to make easy changes to it." This underscores the importance of maintaining clean and flexible code that can be easily modified.

How does "The Clean Coder" address time management?

  • Prioritizing Tasks: Developers should prioritize tasks based on their importance and urgency, focusing on what delivers the most value.
  • Avoiding Meetings: Unnecessary meetings should be avoided to maximize productive time, with developers attending only those that are essential.
  • Using Techniques: Techniques like the Pomodoro Technique can help manage time effectively by breaking work into focused intervals.
  • Balancing Work and Life: Time management also involves balancing work with personal life, ensuring that developers maintain their well-being and avoid burnout.

What is the role of mentoring in "The Clean Coder"?

  • Guiding New Developers: Mentoring is crucial for guiding new developers, helping them learn best practices and develop their skills.
  • Sharing Knowledge: Experienced developers should share their knowledge and experience with less experienced colleagues to foster growth and development.
  • Building a Culture: Mentoring helps build a culture of learning and improvement within a team, encouraging continuous development.
  • Professional Responsibility: It is a professional responsibility for senior developers to mentor and support junior team members, contributing to the overall success of the team.

About the Author

Robert Cecil Martin, known as Uncle Bob, is a renowned software engineer and consultant. He advocates for Agile development methods and is the President of Object Mentor Inc. Martin's career spans decades, during which he has consulted with global clients on Object-Oriented Design, Patterns, UML, and Agile Methodologies. He served as Editor in Chief of the C++ Report from 1996 to 1999. A prominent figure in the software development community, Martin is a sought-after speaker at international conferences and trade shows. His expertise and long-standing influence in the field have made him a respected voice in software engineering practices and professional development.

Download PDF

To save this The Clean Coder summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.39 MB     Pages: 19

Download EPUB

To read this The Clean Coder summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.41 MB     Pages: 26
Want to read the full book?
Follow
Listen8 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...