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
Learning Agile

Learning Agile

Understanding Scrum, XP, Lean, and Kanban
Choose agile practices that improve feedback, code quality, and delivery flow.
by Andrew Stellman 2013 417 pages
4.09
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat agile as a team mindset, not a collection of ceremonies

Practices need a purpose. Agile is not simply a set of meetings, cards, and technical tools. Its central idea is that people work together to build useful software, learn from what happens, and adjust their approach. The Agile Manifesto puts people and communication ahead of rigid processes, working software ahead of exhaustive paperwork, customer partnership ahead of defensive negotiation, and adaptation ahead of blind loyalty to a plan.

One feature, four views. On a jukebox project, a developer interpreted a request for new songs as permission to play every new release. The product owner knew that newer songs carried higher royalty costs. They had adopted user stories, but had not shared what the story meant to each person. The team improved its practices, yet retained the disconnected habits that made misunderstandings likely.

Analysis

What's valuable here is the distinction between a practice and the social purpose it serves. A daily meeting can create shared awareness or merely give a manager a faster way to collect status. This resembles the difference between a tool and the institutional setting in which it is used: the same mechanism can distribute authority or reinforce hierarchy. Still, shared understanding should not mean identical perspectives. Developers, users, and managers notice different risks. The goal is to make those differences discussable before they harden into costly assumptions.

Show users working software before old assumptions become expensive

Feedback beats prediction. A hypothetical ebook reader took 15 months to build from a complete up-front specification. By launch, an industry-standard format had appeared, retailers had changed their plans, and a competitor offered a more useful way to transfer documents. The team had delivered what stakeholders once requested, not what they now needed.

Deliver in useful slices. Agile teams work in short iterations, demonstrate working software, gather feedback, and reprioritize. A partial release can create value and reveal misunderstandings while there is still time to respond. In this approach, working software is the clearest evidence of progress, while documentation is useful when it helps people build, communicate, or meet a genuine external requirement. The aim is not to avoid planning, but to keep plans responsive to evidence.

Analysis

Frequent delivery functions like a feedback-control system: the team observes the result, compares it with the desired outcome, and corrects its course. That is especially useful when users cannot fully imagine a product from a written description. But feedback is only as good as its source and interpretation. A small group of early users may not represent everyone, and frequent releases can create confusion if customers or support teams are unprepared. Iteration shortens the learning cycle; it does not remove the need to decide whose learning matters.

Make Scrum a shared commitment, not a daily status ritual

The team owns the plan. Scrum organizes work into timeboxed sprints. A Product Owner prioritizes features by business and user value, a Scrum Master helps the team follow the process and remove obstacles, and the team decides how to do the work. In the book's Lolleaderz.com story, a daily meeting became a round of status reports and assignments from the team lead. Features slipped, estimates became blameworthy promises, and the Product Owner felt overloaded.

Use meetings to adapt. An effective Daily Scrum lets the whole team inspect progress, identify blockers, and choose useful next work. Sprint reviews expose working software to stakeholders; retrospectives turn experience into specific improvements. Collective commitment means responsibility for delivering valuable work together, not merely completing individually assigned tasks.

Analysis

Scrum's strongest organizational claim is that people make better plans when those doing the work help shape them and can revise them as facts emerge. That connects with research traditions emphasizing autonomy and shared responsibility, rather than compliance alone. Yet self-organization is not the same as having no leadership. Teams still need authority boundaries, a capable Product Owner, and protection from conflicting demands. The book's model also assumes considerable access to business decision-makers, which may be difficult in organizations where product expertise is fragmented or tightly controlled.

Build changeable code by testing, integrating, and refactoring continuously

Quality makes change cheaper. Extreme Programming, or XP, combines practices such as test-first development, pair programming, frequent integration, and a fast automated build. In test-first development, a programmer writes a test for expected behavior before writing the code. The failing test guides implementation and can catch regressions when the code changes. XP's 10-minute build aims to make testing and integration frequent enough to be practical.

Keep designs small. Refactoring changes code structure without changing its behavior. Done regularly, it helps reduce code smells such as tangled dependencies that make one small change require many others. XP's incremental design delays detailed decisions until the team has better information, rather than building elaborate frameworks for imagined future needs. The practices reinforce one another, but treating them as boxes to check can leave the team's habits unchanged.

Analysis

The important insight is that maintainability is not a finishing touch. It is a capability that determines how safely a team can respond to new evidence. Automated tests make structural change less frightening, while integration catches incompatible work before more code accumulates around it. A useful caveat is that tests can become brittle or overcomplicated, especially when they encode implementation details rather than desired behavior. The measure of a testing practice is not the number of tests produced, but whether it gives the team reliable information at a useful cost.

Find waste in the whole delivery path, not just the code

Look beyond individual effort. Lean thinking asks teams to identify work that does not help deliver valuable software. The Seven Wastes of Software Development include partially completed work, unnecessary processes, extra features, task switching, waiting, unnecessary motion, and defects. In one value-stream example, a feature took 71 days to reach users, with 35.5 days spent waiting. The map made delay visible even though team members seemed busy throughout.

Trace causes, not culprits. A value-stream map records the actual steps a feature takes, including working and waiting time. The Five Whys technique probes a recurring problem by repeatedly asking why it occurred. A long delay, for example, may stem not from a slow developer but from a late management review that repeatedly sends completed work back for changes.

Analysis

Lean's systems view helps distinguish individual diligence from overall performance. A person can be busy while the product remains stuck in queues, approvals, or rework. This resembles operations research, where the throughput of a system depends on the whole route, not simply the speed of one worker. The caution is that waste depends on the objective being measured. Regulatory records or accessibility work may not appear to add immediate feature value, yet protect users and the organization. Teams should question low-value work without confusing short-term output with total value.

Limit work in progress to stop queues from swallowing delivery

Make overload visible. Kanban helps a team improve its existing workflow rather than prescribing a complete project method. A kanban board shows work items moving through the team's real process. Work-in-progress limits set a maximum number of items allowed in a stage. When a stage is full, the team shifts attention instead of pushing still more work into a queue that cannot be cleared.

Control the wait. Little's Law describes a stable system: average lead time equals average work in the system divided by the average arrival rate. In the book's doctor's-office example, seven patients in the system and 11 arrivals per hour imply about 37 minutes of average time; four patients and 10 arrivals per hour imply 24 minutes. Limits and measurement help teams experiment with flow, rather than assume extra work can be absorbed.

Analysis

WIP limits counter a familiar managerial illusion: starting more tasks feels productive, even when it only creates more unfinished work. Queueing theory explains why reducing the pile can improve delivery time without making each task faster. The doctor's-office example makes the principle intuitive, but software work varies more than patient appointments, and urgent work can disrupt a stable flow. A limit is not a universal magic number. It is a policy that must be negotiated, observed, and adjusted, with clear exceptions for genuinely urgent needs.

Keep technical and product choices open until evidence narrows them

Separate promises from possibilities. Options thinking distinguishes a commitment from an option: a commitment is a promise to achieve an outcome, while an option preserves a possible route without promising to take it. Scrum teams can commit to delivering valuable working software without fixing every task months in advance. XP teams preserve choices in code by keeping components small and independent.

Learn before locking in. Set-based development means exploring more than one plausible solution long enough to compare them. A team uncertain about two technical approaches might investigate both before choosing. A/B testing applies a similar idea to alternative user-interface designs. These experiments require time, so they should focus on decisions where new information could materially improve the outcome. Delaying a decision is useful when learning is possible, not when it merely postpones responsibility.

Analysis

This is closely related to real-options reasoning in economics: a reversible choice has value because it preserves the ability to act when uncertainty falls. The idea is especially powerful in software, where a premature architecture decision can constrain later work. But optionality is not free. Maintaining parallel prototypes or postponing a decision can consume scarce capacity and create coordination costs. The practical test is whether the expected value of information exceeds the cost of keeping alternatives alive. Some choices are reversible; others, such as safety-critical foundations, deserve early scrutiny.

Choose Scrum, XP, Lean, or Kanban by the problem to solve

Different tools target different bottlenecks. Scrum structures project work through roles, backlogs, and sprints, with an emphasis on team ownership and delivery. XP concentrates on programming practices and code that can absorb change. Lean is a way of thinking about value, waste, learning, and the whole system. Kanban is a method for improving an existing workflow through visualization, work limits, and measurement. They overlap, but they are not interchangeable labels for one universal process.

Context matters. The book rejects a single silver-bullet method, and notes that a waterfall approach can work when requirements are stable and communication and technical practices are strong. Teams can adopt agile practices without sharing the values behind them, but should not mistake modest improvement for a complete transformation. Start with the problem: delivery uncertainty, brittle code, workflow delays, or disconnected perspectives.

Analysis

The comparison is useful because it treats methods as responses to different constraints rather than competing brands. In organizational design, a process should fit the work's uncertainty, dependencies, and decision rights. A regulated project with stable requirements may rationally preserve more documentation; a product in a shifting market may benefit from shorter learning cycles. The book's strongest caution is against copying rituals without their logic. A further caution is that method selection alone cannot resolve structural limits, such as unavailable users, conflicting incentives, or managers who retain all decision authority.

Teach teams from clear rules toward sound independent judgment

Learning has stages. The book uses Shuhari, a martial-arts model of learning, to describe three stages. In shu, a learner follows explicit rules. In ha, the learner begins to understand and adapt the principles behind them. In ri, the person can act fluently without being bound to a particular form. A coach should meet a team where it is: newcomers may need clear instructions for a Daily Scrum before they can understand self-organization.

Make mistakes teachable. Coaches explain why practices exist, notice when teams rename old habits instead of changing them, and help people work through discomfort. Allowing a team to encounter manageable failure can make a lesson memorable, but coaching also requires judgment about risk. Failure should reveal a useful lesson, not expose users, employees, or the business to avoidable harm.

Analysis

Shuhari offers a useful corrective to the idea that competent people can simply be told to change. Tacit skills often develop through practice before learners can explain the underlying principles. Coaching therefore involves both instruction and restraint: too much intervention blocks ownership, while too little can leave a team repeating a harmful pattern. The stages should not be treated as a rigid ladder. A veteran may be fluent in one practice and a beginner in another, and a team's willingness to learn depends heavily on whether mistakes are met with curiosity or punishment.

Analysis

The book's central argument is that agile is a social and technical operating system, not a set of ceremonies. Its examples repeatedly show the same failure pattern: a team adopts a visible practice while preserving the incentives and authority structures that made the old process ineffective. A standup becomes surveillance, user stories become tiny specifications, and automated tests become optional overhead. The result is incremental improvement without a new way of working.

The strongest contribution is the book's connection between feedback and design. Frequent demonstrations expose product misunderstandings; short planning cycles limit the cost of those misunderstandings; tests, integration, and refactoring reduce the technical cost of changing code. Lean and Kanban widen the lens further, showing that delay often lives between teams, approvals, and overloaded workflow stages rather than inside an individual worker's effort. Together these ideas form a coherent account of how teams learn and deliver.

The account is most persuasive when it treats organizational behavior as part of engineering. A team cannot sustain honest estimates or shared ownership if leadership punishes bad news, rewards heroics, or adds work without removing anything. Yet the adaptation should not become agile orthodoxy. Documentation, upfront design, and staged approval can be rational where safety, regulation, or stable interfaces demand them. Conversely, iteration is not valuable merely because it is frequent; the feedback must come from relevant users and change decisions.

A useful modern reading is to regard agile practices as instruments for making uncertainty, work, and accountability visible. That visibility can improve learning, but it can also become surveillance or metric gaming. The decisive question is not whether a team uses Scrum, XP, or Kanban, but whether the method gives the people closest to the work enough information and authority to improve the product without hiding costs or exhausting themselves.

Summary in 30 Seconds
Short delivery cycles expose product misunderstandings while there is still time to change direction. Automated tests, frequent integration, and regular refactoring make code safer to modify. Mapping the path to users can reveal that a 71-day delivery takes 35.5 days of waiting. Work-in-progress limits reduce queues, while measured experiments help teams improve flow. Practices work best when teams understand their purpose and can adapt them to the problem.
Contains spoilers

Last updated:

Report Issue

Review Summary

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

Learning Agile is praised as an excellent introduction to Agile methodologies, particularly for beginners. Readers appreciate its comprehensive coverage of Scrum, XP, Lean, and Kanban, along with practical examples and actionable advice. The book is commended for explaining the principles behind each methodology and emphasizing the importance of an Agile mindset. Many found it helpful in understanding the "why" of Agile practices. Some readers noted that experienced practitioners may find less new information, but overall, it's considered a valuable resource for those seeking to implement or improve Agile practices in their projects.

Your rating:
4.55
109 ratings
Want to read the full book?

Glossary

Agile Manifesto

Shared agile values

A statement of values and principles for software development created by practitioners seeking better ways to build software. Its four values favor people and interaction, working software, customer collaboration, and responding to change, while recognizing that processes, documentation, contracts, and plans can still have value. The book treats it as the common foundation beneath different agile approaches.

Fractured perspective

Disconnected team viewpoints

A condition in which people on a project understand a practice only through their own role. A developer may see a user story as a coding task, while a product owner sees it as customer value. Without conversations that connect these views, the team can misunderstand requirements and repeat familiar project problems despite adopting new tools.

Better-than-not-doing-it results

Improvement without transformation

The modest gains a team gets by adopting useful agile practices without changing how it thinks about work, communication, or ownership. A daily meeting may improve status awareness, for example, while remaining a command-and-control status meeting. The practice helps, but the team misses the broader benefits of collaboration, adaptation, and shared responsibility.

Collective commitment

Shared responsibility for value

A Scrum team's common responsibility for delivering the most valuable working software it can, rather than each member merely completing assigned tasks. The team helps shape the plan and adjusts how work is done as new information appears. This commitment depends on realistic expectations, open communication, and a Product Owner who can represent business priorities.

Visibility-inspection-adaptation cycle

Feedback-driven project adjustment

A recurring process of making work visible, examining its actual state, and changing plans or actions in response. In Scrum, daily collaboration and working-software reviews help reveal misunderstandings and obstacles early. The cycle replaces reliance on a supposedly complete plan with decisions informed by what the team and stakeholders can currently observe.

Incremental design

Design built in small steps

An XP approach in which a system's design develops as the team solves immediate problems and learns more about the software's use. Developers aim for small, independent units, test their behavior, and refactor as needed. By avoiding unnecessary early commitments and dependencies, the code remains easier to extend or change.

Seven Wastes of Software Development

Seven forms of non-value work

A Lean checklist for identifying work that consumes effort without directly helping deliver valuable software: partially done work, extra processes, extra features, task switching, waiting, motion, and defects. The categories help teams examine their entire delivery system. Work may still be required for another reason, such as regulation, even if it does not add value to the product itself.

WIP limit

Cap on active work

A Kanban policy that sets the maximum number of work items allowed in a particular workflow stage. When that stage reaches its limit, the team does not push in more items and instead addresses other work or the constraint. Limits help reveal overload, reduce queues, and encourage stakeholders to make priorities explicit.

Little's Law

Queue size predicts waiting time

A relationship from queueing theory that applies to a stable system: average work in the system equals the average arrival rate multiplied by average time in the system. Written as L = W × λ, it can be rearranged to estimate lead time as inventory divided by arrival rate. Kanban teams use it to reason about queues and delivery delays.

Options thinking

Preserve choices under uncertainty

A Lean way of distinguishing a firm commitment from a possible choice that remains open. Teams commit to meaningful outcomes while delaying detailed decisions until they have better information. They may investigate more than one solution before selecting one. The purpose is to preserve useful flexibility, not to avoid decisions or keep every possibility open indefinitely.

Shuhari

Three stages of learning

A martial-arts model used in the book to explain how people learn a method. Shu is following explicit rules, ha is understanding and adapting the principles behind them, and ri is fluent practice that is no longer tied to a prescribed form. Coaches can use the model to offer novices structure while helping experienced learners develop independent judgment.

About the Author

Andrew Stellman is a seasoned software developer, architect, and project manager with over two decades of professional experience. He has worked on large-scale real-time systems, managed international software teams, and held executive positions in major financial institutions. Stellman has consulted for various organizations, including Microsoft and Bank of America. He is known for his expertise in building better software and his ability to tackle complex technical challenges. Together with Jennifer Greene, Stellman has authored several books on software development and project management. Their collaborative work focuses on practical approaches to improving software engineering practices and principles.

Download PDF

To save this Learning Agile summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.30 MB     Pages: 16

Download EPUB

To read this Learning Agile 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.34 MB     Pages: 20
Want to read the full book?
Follow
Listen1 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...