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
Apprenticeship Patterns

Apprenticeship Patterns

Guidance for the Aspiring Software Craftsman
Shape a software career that keeps expanding your skills, even when no formal apprenticeship exists.
by Dave Hoover 2009 165 pages
4.10
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat software mastery as a self-directed apprenticeship, not a promotion ladder

Own the learning journey. Apprenticeship here is not a job title or a formal training scheme. It is a deliberate way to shape a career around learning from skilled practitioners, improving through practice, and taking responsibility for filling knowledge gaps. The book describes a progression in focus: apprentices concentrate on their own growth, journeymen also strengthen connections and help others, and masters use their skill to advance the craft and develop new practitioners.

Dave Hoover’s own path began after two failed attempts to teach himself programming. At 26, he found mentors who helped him learn Perl through real work. The lesson is not that everyone needs an ideal workshop. Most developers must build their apprenticeship from the opportunities around them.

Analysis

The model is compelling because it makes career development an active practice rather than something delegated to an employer. It also resembles cognitive apprenticeship, a learning approach in which people develop by observing skilled work, trying tasks with support, and gradually taking on more responsibility. The medieval hierarchy is best treated as a metaphor, not a universal career ladder. People can remain excellent individual contributors, change fields, or prioritize family without making their careers failed apprenticeships.

Become fluent in one language before collecting shallow familiarity

Build a working foundation. Early in a career, choose a language that serves a real project or job goal and learn it well enough to solve problems without leaning constantly on others. A nearby expert matters: the book cites language designer Ralph Johnson’s advice that regular access to someone who knows the language can shape learning more than the language choice itself. A project, a learning sandbox, and small tests create frequent chances to check understanding.

Dave’s first substantial Perl learning happened while building a small work project with guidance from two experienced colleagues. This gave him practical feedback that isolated exercises could not. The authors also urge learners to join the language’s community, where idioms and hard-won explanations are shared.

Analysis

Fluency in one language creates a dependable base for comparison, much as a strong first language supports later language learning. The emphasis on a real project is especially useful because syntax becomes meaningful when attached to a problem and a result. Still, a first language is not a permanent identity. Employers, accessibility needs, and local opportunity can constrain the choice, so practical support and project relevance matter more than choosing a fashionable language.

When learning a new language, stop translating from your old one

Try the local way. The White Belt is the practice of approaching an unfamiliar tool or language with beginner’s curiosity, even after years of experience elsewhere. It does not mean discarding useful knowledge. It means temporarily suspending familiar assumptions long enough to discover what the new environment makes easy, difficult, or natural.

The book contrasts a Java programmer’s instinct to use loops with J, a language whose idioms can express a task in a compact form without the familiar loop structure. Reusing old habits might produce working code, but it can conceal the new language’s design. Dave also describes setting aside his Perl instincts while learning Ruby, then replacing awkward code with an idiomatic library method. The temporary loss of speed can buy a deeper understanding.

Analysis

This approach echoes the idea of conceptual change: new knowledge often requires revising the mental model used to interpret old experience. It is useful in programming because languages encode different trade-offs, not merely different spellings. Yet a beginner’s stance should be temporary and purposeful. Ignoring all prior knowledge can waste time; the aim is to test assumptions against the new system, then integrate what transfers and discard what does not.

Build a small, useful toy where failure costs only your pride

Practice without a client. Breakable Toys are personal software projects that resemble work problems in their tools but are limited enough to fail safely. A developer might build a personal wiki, a calendar, or a small game. The point is not to replace a polished product. It is to try unfamiliar techniques, make mistakes, and learn without putting a customer’s system at risk.

A wiki can begin as plain-text pages that users can view and edit. As it grows, the builder may encounter web protocols, search, databases, caching, concurrency, and data migration. Each new feature becomes a reason to learn. The toy should remain enjoyable and appropriately small. If it becomes another punishing production project, it loses the safety that makes it useful.

Analysis

A safe project creates what learning scientists call a low-stakes environment: experimentation is possible without the social and operational cost of failure in live work. The toy also connects separate skills through a coherent object, rather than presenting them as disconnected lessons. Its limit is time. Side projects can become an escape from difficult work or a source of unpaid labor, so the learning goal and the time budget should be explicit.

Name what you do not know, then make a plan to close the gap

Make learning visible. Expose Your Ignorance means asking direct questions and being honest about unfamiliar tools or requirements instead of pretending to understand. Confront Your Ignorance is the companion move: choose a relevant gap and work on it through reading, experimentation, a toy project, or help from a colleague. The first makes learning observable; the second prevents humility from becoming an excuse for staying stuck.

The authors recommend writing down five things you do not understand about your work and keeping the list visible. That can feel uncomfortable, especially when others expect quick answers. But false confidence damages trust when estimates or solutions prove wrong. A more credible response is to explain what is unknown, how it will be investigated, and when the next update will come.

Analysis

This pairing turns uncertainty into a manageable work item. It resembles the distinction between psychological safety and accountability: people need enough safety to admit confusion, and enough responsibility to act on it. The book’s advice is strongest when paired with clear communication about delivery risks. In high-stakes systems, openness is not a substitute for supervision or review; it is what allows the right support and safeguards to be brought in early.

Use frequent feedback to catch mistakes before confidence hardens

Test your self-assessment. Create Feedback Loops are repeatable ways to compare what you believe about your work with evidence from outside yourself. Tests can expose incorrect assumptions in code; code review and pair programming reveal choices another developer would question; interviews or focused conversations can surface skills to improve. Feedback is most useful when it describes an observable result and suggests a behavior that can change.

The book warns that a strong team can make an apprentice feel more capable because colleagues prevent errors or quietly repair them. A weak team can create the opposite distortion. Patrick Kua’s account of receiving little review on unfamiliar framework code shows the risk: he copied a pattern without knowing it was the wrong approach. The earlier a mistake is noticed, the less costly it is to correct.

Analysis

This insight applies beyond programming: expertise is difficult to assess from the inside, so external signals help calibrate judgment. The strongest signals are close to the work and arrive quickly, which is why tests and reviews can be more informative than annual ratings. But not every metric measures quality. A team should use feedback to guide inquiry, not turn one convenient number into a proxy for skill, value, or future potential.

Choose stronger teammates, then earn trust through useful contributions

Learn beside skilled people. Be the Worst recommends joining a team whose members are more capable than you, provided the team welcomes learners and gives them ways to contribute. Working near experienced developers can expose tacit habits that are hard to learn from books. Rubbing Elbows describes hands-on collaboration, including pair programming, where one person can observe and question another’s decisions in real time.

That opportunity carries an obligation. Sweep the Floor means volunteering for necessary, unglamorous work, such as fixing bugs, improving documentation, or maintaining a build system. Paul Pagel’s apprenticeship began with setting up equipment and preparing training rooms before he could contribute much code. Such tasks helped him belong and build confidence. They should be a starting point for growth, not a permanent assignment to low-status work.

Analysis

Learning in a strong team combines observation, imitation, and immediate correction, the ingredients of many effective forms of workplace training. The advice also rejects prestige as a measure of progress: a junior role on an excellent team can teach more than a title that arrives before the skill. The danger is real, though. A team can exploit a learner’s eagerness for cheap support work, so contributions should lead toward greater responsibility and increasingly substantive practice.

Trace problems beyond tutorials into source, specifications, and underlying ideas

Understand the machinery. Dig Deeper means learning why a tool behaves as it does, not just memorizing the commands needed for a common task. Read source code, technical specifications, and original explanations of the ideas behind a system. This can reveal design trade-offs, known limits, and mistakes hidden by simplified tutorials.

The book gives a regular-expression example: a developer may use patterns successfully for years without understanding how the engine handles backtracking. On certain inputs, that hidden behavior can cause severe slowdown or a stack failure. The authors also recommend studying open-source projects, including their histories, so developers can see how real software changes as demands evolve. Depth helps diagnose unfamiliar failures, but it should not become an excuse to specialize narrowly or dismiss practical constraints.

Analysis

Looking beneath the interface builds causal understanding, which is more transferable than memorizing recipes. It makes debugging a form of scientific inquiry: observe a failure, develop an explanation, and test it against the system’s behavior. The scope needs discipline. Not every feature warrants reading a specification or reverse-engineering a library, and excessive depth can delay delivery. The practical test is whether deeper understanding changes a decision, improves reliability, or makes future problems easier to solve.

Protect your craft from career moves that remove you from programming

Choose the long horizon. The Long Road frames software development as a career of continuing learning, not a race toward a title or a quick claim of mastery. The authors urge apprentices to weigh learning opportunities alongside salary and status, because skills deepen through sustained practice. Draw Your Own Map means choosing a next step that fits personal goals, then breaking it into smaller moves rather than waiting for an employer to design the whole career.

Stay in the Trenches addresses promotions that pull developers away from coding. The recommendation is to negotiate other forms of recognition, such as technical leadership, or seek a role that preserves hands-on work. This is not a rule against management. It is a reminder that a promotion is not automatically progress if it moves someone away from the work they want to master.

Analysis

The long horizon counters a common organizational bias: advancement is often made visible through hierarchy, while technical growth is harder to count. Career design is more robust when it includes multiple forms of reward and a picture of what a sustainable working life looks like. Still, hands-on practice is not the only meaningful contribution. Management, caregiving, or a different vocation may better fit a person’s circumstances, and the book explicitly treats those choices as legitimate.

Solve the customer's problem before polishing your own masterpiece

Make useful work well. Craft over Art asks developers to put the customer’s actual need ahead of the desire to show off technical elegance. Software can be beautiful, but beauty is not enough if it does not solve the problem. At the same time, usefulness does not justify careless work. The craft is in balancing timely value with quality and repairing design choices that do not serve the system.

The authors distinguish a useful, modest program from a technically impressive artifact that nobody can use. They also warn against waiting for inspiration before delivering dependable work. This requires judgment: sometimes a proven, plain solution is better than a novel one; sometimes investment in quality is essential because the software is important and will need to change. The customer’s needs and the community’s standards both matter.

Analysis

This is a useful corrective to engineering cultures that reward novelty more readily than maintenance or fit. It resembles design thinking, where success depends on whether a solution works in the lives of its users, not merely whether it is elegant in isolation. The tension cannot be settled by always choosing speed or always choosing polish. Developers need to make trade-offs explicit, because the apparent shortcut may impose much larger costs on future users and maintainers.

Analysis

Apprenticeship Patterns is less a manual for learning syntax than a guide to constructing the conditions in which professional judgment grows. Its core claim is that software skill develops through a mix of deliberate practice, exposure to better practitioners, honest self-assessment, and responsibility for increasingly consequential work. The pattern format suits this subject: each pattern names a recurring dilemma, offers a response, and points toward related dilemmas. Readers can use the book as a map of choices rather than a sequence of commandments.

The narrative makes the advice credible by showing a career assembled from imperfect situations. Hoover’s early struggles with self-teaching become more productive when mentors, real projects, and feedback enter the picture. Later examples broaden the message: a programmer moves countries to take on a challenge, an apprentice earns trust through mundane tasks, and a developer leaves an organization that blocks the work he wants to learn. These stories show that growth is not a straight line and that no single employer controls the whole apprenticeship.

The book’s strongest practical distinction is between revealing ignorance and addressing it. Candor alone can become helplessness; private study alone can preserve a culture in which everyone pretends to know. The complementary practices make learning both visible and accountable. Its insistence on feedback and reflection also challenges the comforting idea that years on the job equal expertise.

Some tensions deserve attention. The metaphor of masters and apprentices can imply a hierarchy that modern workplaces may not support, while the advice to accept junior status or take on extra learning can be misused to justify low pay or endless unpaid labor. The authors themselves caution against letting apprenticeship harm the team or consume a life. That caution should be central: learning is valuable, but it must be balanced with fair work, customer commitments, and personal sustainability. The book is most useful when its patterns are adapted to context, not followed as a checklist. Its lasting proposition is that professional growth is something practitioners can actively design, even when formal mentorship is unavailable.

Summary in 30 Seconds
Professional software skill grows through deliberate practice, frequent feedback, and collaboration with more experienced developers. Make learning visible by naming what you do not know, then choose practical ways to close those gaps. Small personal projects offer safe space to experiment, while studying source code and specifications reveals why tools behave as they do. Choose work that deepens expertise, and prioritize customer needs over technical display.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.10 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Apprenticeship Patterns is highly praised for its practical advice on software development careers. Readers appreciate its focus on continuous learning, humility, and growth mindset. Many wish they had discovered it earlier in their careers. The book's pattern-based approach is generally well-received, though some find it obvious or idealistic. It's considered especially valuable for early-career developers and students. Critics note it lacks work-life balance discussion and may reinforce hierarchical attitudes. Overall, it's widely recommended as an inspiring guide for aspiring software craftsmen.

Your rating:
4.5
181 ratings
Want to read the full book?

Glossary

Apprenticeship Pattern

Contextual career guidance

A named response to a recurring problem in a software developer’s learning or career. Each pattern describes the situation, the difficulty, and a possible course of action. Patterns connect to one another, but they are not algorithms or rules. Readers are expected to adapt them to their circumstances and use judgment about when they apply.

The White Belt

Beginner's learning stance

A way of approaching unfamiliar technologies or ideas with curiosity, even when the learner already has substantial expertise elsewhere. It involves setting aside familiar assumptions long enough to understand the new system on its own terms. The goal is not to erase prior knowledge, but to avoid forcing new problems into old habits before learning the local approach.

Breakable Toys

Safe learning projects

Small personal software projects designed to provide room for experimentation and failure without putting a customer’s system or team deliverable at risk. A toy should use relevant tools and teach useful skills, while remaining limited in scope. Examples in the book include a personal wiki, a calendar, and simple games.

The Long Road

Lifelong craft development

The view that becoming highly skilled in software is an ongoing career rather than a short race to status, promotion, or a final level of mastery. The pattern encourages developers to make long-term learning and sustained practice important career considerations. It does not require every developer to choose the same career or remain in software forever.

Be the Worst

Learn among stronger peers

A pattern of seeking a team whose members are more skilled than oneself, so daily work creates opportunities to observe and learn from stronger practitioners. The learner must also contribute, monitor whether the environment is supportive, and avoid becoming a passenger. The aim is to improve, not to remain the least capable person on the team.

Create Feedback Loops

Gather actionable performance evidence

A pattern for checking self-assessment against regular evidence from tests, code reviews, collaboration, or direct conversations. Feedback is useful when it arrives early enough to guide improvement and points to behavior that can be changed. The pattern warns that team skill levels can distort how competent a person feels, making external evidence important.

Sweep the Floor

Earn trust through useful tasks

A pattern in which a newcomer volunteers for necessary but often unglamorous work to help the team and demonstrate reliability. Tasks might include fixing bugs, improving documentation, or maintaining project infrastructure. The work should create a path toward greater responsibility rather than trapping the apprentice in menial duties.

Craft over Art

Prioritize useful quality

A pattern for balancing technical elegance with the customer’s need for working software. It discourages building impressive but unneeded artifacts or waiting for inspiration before delivering. It does not endorse careless expediency: useful software should meet appropriate standards of quality, and developers must judge when refinement serves the customer and the system.

FAQ

What's "Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman" about?

  • Focus on Software Craftsmanship: The book provides guidance for aspiring software developers who wish to master their craft through a series of patterns that address common challenges faced by apprentices.
  • Pattern-Based Approach: It introduces a pattern language that helps developers navigate their career paths, focusing on personal growth, learning, and skill development.
  • Mentorship and Community: Emphasizes the importance of finding mentors and engaging with a community of like-minded individuals to foster learning and growth.
  • Long-Term Career Development: Encourages readers to view their career as a long journey, focusing on sustainable motivations and continuous improvement.

Why should I read "Apprenticeship Patterns"?

  • Practical Guidance: Offers actionable advice for software developers at the beginning of their careers, helping them navigate common challenges.
  • Career Growth: Provides insights into how to develop a fulfilling and sustainable career in software development.
  • Community and Mentorship: Highlights the importance of community and mentorship in personal and professional growth.
  • Focus on Learning: Encourages a mindset of perpetual learning and self-improvement, which is crucial in the ever-evolving field of software development.

What are the key takeaways of "Apprenticeship Patterns"?

  • Embrace Lifelong Learning: The book emphasizes the importance of continuous learning and self-improvement throughout one's career.
  • Find and Learn from Mentors: It stresses the value of finding mentors and learning from their experiences and guidance.
  • Develop Concrete Skills: Encourages the acquisition of specific, demonstrable skills that can be immediately applied in a professional setting.
  • Balance Art and Craft: Advises developers to focus on delivering value to customers while maintaining high standards of quality and craftsmanship.

What is the "Be the Worst" pattern in "Apprenticeship Patterns"?

  • Surround Yourself with Experts: Encourages developers to join teams where they are the least experienced, allowing them to learn from more skilled colleagues.
  • Rapid Learning Environment: Being the least experienced member pushes you to learn quickly and improve your skills.
  • Avoid Complacency: Prevents stagnation by constantly challenging you to catch up with your peers.
  • Contribute Meaningfully: While learning, also find ways to contribute to the team, such as taking on less glamorous but necessary tasks.

How does "Apprenticeship Patterns" define a software craftsman?

  • Lifelong Learner: A software craftsman is someone who views mastery as a lifelong journey and is committed to continuous learning.
  • Focus on Quality: They prioritize delivering high-quality, well-crafted software that meets the needs of their customers.
  • Community-Oriented: Engages with a community of practice, sharing knowledge and learning from others.
  • Mentorship Role: As they progress, they take on the responsibility of mentoring others and passing on their knowledge.

What is the "Breakable Toys" pattern in "Apprenticeship Patterns"?

  • Safe Learning Environment: Encourages developers to create personal projects where they can experiment and learn without fear of failure.
  • Build Relevant Tools: Suggests building tools that are useful in your daily life, such as a personal wiki or a simple game.
  • Learn from Failure: Provides a space to make mistakes and learn from them, which is crucial for growth.
  • Overcome Limitations: Helps you understand the limitations of your current knowledge and pushes you to explore new areas.

What are the best quotes from "Apprenticeship Patterns" and what do they mean?

  • "He who knows not and knows not that he knows not, is a fool — shun him!": This quote emphasizes the importance of self-awareness and the dangers of ignorance.
  • "Craftsmen take on only eager apprentices who are willing to learn the craft of software development.": Highlights the value of enthusiasm and willingness to learn in an apprentice.
  • "If you come to me with a cup that is already full, how can you expect me to give you something to drink?": Stresses the need for an open mind and the willingness to learn new things.
  • "The best way to prepare [to be a programmer] is to write programs, and to study great programs that other people have written.": Encourages learning through practice and studying the work of others.

How does "Apprenticeship Patterns" suggest dealing with failure?

  • Embrace Failure as Learning: The book suggests viewing failure as an opportunity to learn and grow, rather than something to be feared.
  • Create Safe Spaces: Use the "Breakable Toys" pattern to create environments where you can fail safely and learn from your mistakes.
  • Reflect on Failures: Regularly reflect on your failures to understand what went wrong and how you can improve.
  • Learn How You Fail: Identify patterns in your failures to address and overcome them effectively.

What is the "Find Mentors" pattern in "Apprenticeship Patterns"?

  • Seek Guidance: Encourages finding experienced developers who can provide guidance and support throughout your career.
  • Learn from Experience: Mentors can offer insights and advice based on their own experiences, helping you avoid common pitfalls.
  • Build Relationships: Developing a relationship with a mentor can provide long-term benefits and support.
  • Diverse Mentorship: Suggests having multiple mentors to gain a variety of perspectives and knowledge.

How does "Apprenticeship Patterns" recommend constructing a curriculum?

  • Reading List: Maintain a list of books to read, prioritizing those that will provide the most value to your learning journey.
  • Study the Classics: Focus on reading classic texts that have stood the test of time and offer deep insights into software development.
  • Balance Theory and Practice: Combine theoretical knowledge with practical experience to develop a well-rounded skill set.
  • Continuous Update: Regularly update your curriculum to reflect new interests and areas of growth.

What is the "Craft over Art" pattern in "Apprenticeship Patterns"?

  • Focus on Utility: Prioritizes delivering useful software that meets customer needs over creating something purely for artistic expression.
  • Balance Quality and Functionality: Encourages maintaining high standards of quality while ensuring the software is functional and valuable.
  • Customer-Centric Approach: Emphasizes the importance of understanding and addressing customer requirements.
  • Avoid Perfectionism: Warns against getting caught up in making something perfect at the expense of delivering value.

How does "Apprenticeship Patterns" address the concept of sustainable motivations?

  • Align with Long-Term Goals: Encourages aligning your motivations with long-term career goals to maintain focus and drive.
  • Intrinsic Motivation: Suggests finding intrinsic motivations, such as a love for programming, to sustain you through challenges.
  • Avoid Burnout: Warns against overworking and emphasizes the importance of maintaining a healthy work-life balance.
  • Adapt to Change: Recognizes that motivations may change over time and encourages adapting to new circumstances and goals.

About the Author

Dave Hoover is a software developer and author known for his work on apprenticeship and craftsmanship in software development. He co-authored "Apprenticeship Patterns" to provide guidance for aspiring software craftsmen. Hoover emphasizes the importance of continuous learning, humility, and adaptability in the field. His approach focuses on practical patterns and strategies for personal and professional growth. Hoover's work draws from his experiences and observations in the software industry, aiming to help developers navigate their careers and improve their skills. His ideas have influenced many in the software development community, particularly those interested in mentorship and long-term career development.

Download PDF

To save this Apprenticeship Patterns summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.44 MB     Pages: 20

Download EPUB

To read this Apprenticeship Patterns 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.53 MB     Pages: 26
Want to read the full book?
Follow
Listen
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
600,000+ 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...