Chapter 13: Lean team culture
A failed order-routing fix shows how knowledge silos can stop delivery and why respect for people is a practical requirement for Lean improvement.
After this chapter you will be able to
- Knowledge Silos as Failure Points. Explain how the order-routing incident shows that knowledge held by one person can halt the value stream, and why AI could not reliably recover the unstated business rule.
- Respect as Engineering Practice. Explain why the introduction treats respect for people as a condition for Lean techniques to work, rather than as a motivational slogan.
- Respect as a system property. Explain why continuous improvement does not stick without respect for people, and describe respect as giving those closest to the work the authority, information, and psychological safety to improve it.
- Responses to raised problems. Explain how the response to a developer who raises a problem affects whether people speak up again and whether problems are corrected or remain hidden.
- Respectful code artifacts. Explain how code can respect its future maintainers by making its behavior and business rules understandable, even when less readable code passes the same tests.
- Human ownership of AI code. Explain why human review is an accountability gate for AI-generated code and why passing CI is not enough to merge it.
- Review culture feedback loops. Explain how constructive and hostile PR reviews affect developers’ willingness to propose improvements, and distinguish useful review comments from personal preferences.
- Psychological safety and response. Explain why people must feel safe raising problems and see a meaningful response for a team to learn and improve.
- Practices that make honesty worthwhile. Describe the four practices the section gives for showing that honesty leads to better outcomes: blameless reviews, visible follow-through, leader vulnerability, and low-cost experiments.
- Order Taking and AI Waste. Explain how dismissing a developer's judgment can turn them into an order taker, and why adding AI can accelerate the resulting waste.
- Autonomy Over Prescribed Solutions. Distinguish a user problem that leaves room for developer judgment from a prescribed solution, and explain how that difference shapes AI use.
- Ownership through human understanding. Explain why code ownership in an AI-augmented team depends on someone being able to explain the code’s behavior, assumptions, and likely failure points, rather than merely identifying who wrote or generated it.
- AI fix loop knowledge loss. Trace how repeatedly sending broken AI-generated code back to AI for fixes can produce code that no human understands.
- AI and integration knowledge. Explain why AI can quickly build a useful picture of isolated code yet miss the implicit contracts that determine whether a cross-system change is safe. Describe how human system-level knowledge complements AI’s code-level understanding.
- Silo ownership tradeoff. Explain why a silo can improve one developer’s throughput while harming team throughput when that developer is unavailable. Contrast AI’s reduced recovery cost with the coordination cost and risk reduction of collective ownership.
- AI-enabled collective ownership. Explain why AI lowers the barrier to working across the stack without eliminating the need for human expertise in each area.
- Shared quality and defect distance. Explain why quality is a property of the whole team's work and why finding defects later increases cost and lead time.
- Jidoka and collective accountability. Describe what jidoka means for developers working with collective code ownership, including developers who merge AI-generated code.
- Embedded collective quality safeguards. Describe how pre-commit hooks, CI tests, and feature flags support quality when developers contribute across components.
- Onboarding as a value stream. Explain how value stream mapping makes onboarding waste visible and why time to first production deployment is the improvement target.
- First-day shipping tasks. Explain why a small, real production-bound change is more useful on day one than reading documentation or shadowing.
- AI pairing and dual value. Explain how AI-assisted pairing resembles developer pairing and why it can benefit both the code and the developer.
- Team persona as interactive guidance. Describe how a team persona makes an AI assistant useful for pairing, using Tom's architectural task as an example.
- Persona limits and human review. Distinguish the principles a persona can convey from the experience it cannot, and explain why human review remains necessary.
- Judgment before writing code. Explain why technical skill alone is not judgment, and state the questions a developer with judgment asks before coding.
- AI and human mentoring roles. Distinguish the skills-based pairing AI can provide from the judgment-building conversations that require human mentoring, including the section's standardized-work analogy.
- Processes that create order takers. Explain how over-specified tickets, repeatedly deprioritized suggestions, and approval-heavy processes discourage developers from exercising judgment and initiative.
- Teamwide problem identification capacity. Explain why a team’s improvement rate is constrained when only managers and leads identify problems, and how it changes when every developer does so.
- Systems That Shape Initiative. Explain why changing team practices, rather than simply urging developers to be more motivated, changes whether they take initiative.
- Problem-Framed Ticket Boundaries. Describe how a problem-framed ticket divides responsibility for the problem, business context, success criteria, and technical solution.
- Protected Measurable Improvement Time. Describe how dedicated improvement time gives developers permission and accountability to improve the system.
- Contextual Decision Authority. Explain where technical decision authority should sit and what boundaries should remain in place.
- Visible Impact Feedback. Explain how showing developers the measured outcomes of their work encourages further problem solving.
- Limits of Small Team Osmosis. Explain why a problem-solving habit that works informally on a small co-located team can falter as teams grow and become distributed.
- Explicit Distributed Improvement Structure. Describe how the section replaces informal improvement with retrospectives, bounded sub-teams, visible WIP limits, and lightweight cross-team alignment.
- Inclusive Visible Problem Solving. Explain how recognizing different forms of initiative and making improvements visible helps problem solving spread beyond leadership.
- Honest individual culture scores. Describe how team members individually score six dimensions of Lean culture from 1 to 5 using observed behavior rather than aspirations, then compare their scores to expose blind spots.
- Lowest dimension as constraint. Explain why the team selects its lowest-scoring dimension as the constraint to improve first.
- One measured culture improvement. Describe how the team turns its lowest-scoring dimension into one concrete action for the next sprint, recorded with a baseline, proposed change, target measurement, and owner. Explain that the assessment is a map for improvement, not a grade.
What it builds on
- What Kaizen actually means (chapter 10) · Introduces continuous improvement as a Lean practice.
- Andon for production systems (chapter 12) · Introduces andon for production systems.
- Pulling the cord (chapter 12) · The andon cord as a way to call attention to a problem.
- Post-incident reviews as kaizen triggers (chapter 12) · Post-incident reviews as opportunities for improvement.
- User value (chapter 2) · The idea of value for users.
- The code review (chapter 4) · Code review as part of coding work.
- Understanding flow, from idea to production (chapter 6) · Viewing work as a value stream from start to delivery.
- Tracking decisions (chapter 11) · The decision log referenced as a source for architectural decision records.
Section by section
Introduction
A failed order-routing fix shows how knowledge silos can stop delivery and why respect for people is a practical requirement for Lean improvement.
- Knowledge Silos as Failure Points: Explain how the order-routing incident shows that knowledge held by one person can halt the value stream, and why AI could not reliably recover the unstated business rule.
Why it matters: A team cannot keep work flowing if a departed colleague is the only source of a critical rule. - Respect as Engineering Practice: Explain why the introduction treats respect for people as a condition for Lean techniques to work, rather than as a motivational slogan.
Why it matters: Process techniques cannot drive improvement when the team's working conditions prevent people from sharing what they know or raising problems.
Key terms: knowledge silos, single points of failure, value stream, intent, respect for people, knowledge, improvement
13.1 Respect for people as engineering practice
This section explains why respect for people must be built into engineering systems so developers can surface problems and improve the work.
- Respect as a system property: Explain why continuous improvement does not stick without respect for people, and describe respect as giving those closest to the work the authority, information, and psychological safety to improve it.
Why it matters: Improvement practices cannot work reliably when the people doing the work cannot safely act on what they see. - Software andon moments: Describe how a developer raising a serious risk in a review or retrospective parallels a production worker pulling the andon cord, and why stopping to address a defect can be worth its immediate cost.
Why it matters: Recognizing a developer's warning as an andon moment makes it harder to dismiss an early signal of costly trouble. - Responses to raised problems: Explain how the response to a developer who raises a problem affects whether people speak up again and whether problems are corrected or remain hidden.
Why it matters: A team's reaction to one warning helps determine whether the next problem is surfaced early or stays hidden.
Key terms: respect for people, continuous improvement, system property, psychological safety, gemba, andon cord, defect, design review, code review, retrospective
13.1.1 What respect looks like in code
This section shows how readable code and accountable review express respect for future maintainers, including people and AI assistants.
- Respectful code artifacts: Explain how code can respect its future maintainers by making its behavior and business rules understandable, even when less readable code passes the same tests.
Why it matters: The next person may need to change the code during an incident, not merely run it. - Human ownership of AI code: Explain why human review is an accountability gate for AI-generated code and why passing CI is not enough to merge it.
Why it matters: Review makes someone responsible for code that the team will have to understand and change later. - AI as future code reader: Describe how code structure helps AI coding assistants navigate an unfamiliar codebase and give accurate guidance.
Why it matters: Legible code helps both human maintainers and the tools they use to explore it.
Key terms: clear naming, explicit error handling, business rules, magic numbers, implicit state, accountability chain, human review, ownership, shared understanding, CI
13.2 Respect in process: Building the conditions for honesty
This section shows how respectful reviews and visible responses to concerns make honesty and continuous improvement possible on a software team.
- Review culture feedback loops: Explain how constructive and hostile PR reviews affect developers’ willingness to propose improvements, and distinguish useful review comments from personal preferences.
Why it matters: Review comments shape not just one PR but whether people offer the next improvement. - Psychological safety and response: Explain why people must feel safe raising problems and see a meaningful response for a team to learn and improve.
Why it matters: Problems cannot drive improvement when people expect punishment or futility from reporting them. - Practices that make honesty worthwhile: Describe the four practices the section gives for showing that honesty leads to better outcomes: blameless reviews, visible follow-through, leader vulnerability, and low-cost experiments.
Why it matters: These practices give people concrete reasons to believe speaking up is safe and useful.
Key terms: PR reviews, constructive reviews, hostile reviews, virtuous cycle, vicious cycle, psychological safety, honesty, andon cord, blameless post-incident reviews, visible follow-through
13.3 Autonomy, mastery, and purpose
The section explains how autonomy, mastery, and purpose keep developers engaged as problem solvers rather than turning them and their AI tools into order takers.
- Order Taking and AI Waste: Explain how dismissing a developer's judgment can turn them into an order taker, and why adding AI can accelerate the resulting waste.
Why it matters: Faster delivery is not an improvement if the team stops asking whether it is delivering the right thing. - Autonomy Over Prescribed Solutions: Distinguish a user problem that leaves room for developer judgment from a prescribed solution, and explain how that difference shapes AI use.
Why it matters: Giving developers the problem preserves their ability to find a solution that serves users. - Mastery Beyond Routine AI Work: Explain why delegating routine coding to AI without scrutiny does not develop mastery, and identify the higher-order skills the section emphasizes.
Why it matters: AI frees time for harder judgment only if developers keep exercising and developing that judgment. - Purpose Through Customer Impact: Explain how connecting a task to its customer outcome changes a developer's decisions about AI output and proposed solutions.
Why it matters: Knowing whom the work helps gives developers a reason to look beyond a technically completed task.
Key terms: order taker, AI coding assistant, waste, Kaizen, autonomy, problem statement, specification, mastery, higher-order skills, tradeoff analysis
13.4 Code ownership models
This section defines code ownership by human understanding and warns that repeated AI-generated fixes can leave fresh code that nobody understands.
- Ownership through human understanding: Explain why code ownership in an AI-augmented team depends on someone being able to explain the code’s behavior, assumptions, and likely failure points, rather than merely identifying who wrote or generated it.
Why it matters: An identifiable author or generator does not ensure that the team can maintain the code. - AI fix loop knowledge loss: Trace how repeatedly sending broken AI-generated code back to AI for fixes can produce code that no human understands.
Why it matters: Repeated fixes can resolve immediate errors while eroding the understanding needed to maintain the code.
Key terms: code ownership, AI-augmented team, silo, AI-fix-AI-fix, legacy code
13.4.1 The silo trap
The section explains why AI can speed up understanding a departed developer’s code but cannot recover the cross-system knowledge lost in a team silo.
- AI and integration knowledge: Explain why AI can quickly build a useful picture of isolated code yet miss the implicit contracts that determine whether a cross-system change is safe. Describe how human system-level knowledge complements AI’s code-level understanding.
Why it matters: A convincing account of the code is not necessarily enough to make a safe change. - Silo ownership tradeoff: Explain why a silo can improve one developer’s throughput while harming team throughput when that developer is unavailable. Contrast AI’s reduced recovery cost with the coordination cost and risk reduction of collective ownership.
Why it matters: The fastest arrangement for one developer can leave the whole team unable to change a component safely.
Key terms: code-level understanding, cross-boundary dependencies, implicit contracts, system-level context, silo model, local optimization, team throughput, collective ownership
13.4.2 Moving toward collective ownership
The section explains how AI can make collective code ownership more practical while human expertise, cross review, component rotation, and tests keep it safe and sustainable.
- AI-enabled collective ownership: Explain why AI lowers the barrier to working across the stack without eliminating the need for human expertise in each area.
Why it matters: Shared ownership reduces dependence on one specialist without treating AI-generated work as automatically safe. - Expert cross review: Describe how mandatory cross review both checks changes to critical components and spreads knowledge.
Why it matters: An informed review is both a safety net for unfamiliar changes and a way to spread maintenance knowledge. - Rotation through components: Explain how short assignments in unfamiliar components reduce dependence on individual developers.
Why it matters: Rotation turns knowledge held by one person into capability the team can retain. - Business-rule tests as documentation: Explain how tests with explicit business-rule names and assertions help new contributors and AI assistants work within system constraints.
Why it matters: Clear tests make important rules available to both new teammates and the AI tools assisting them.
Key terms: collective ownership, siloed ownership, key person risk, AI-assisted breadth, human depth, mandatory cross review, domain expertise, critical component, rotation through components, cross-training
13.4.3 Quality as a team responsibility
The section explains why quality must be built into collectively owned code through shared accountability and early defect detection, rather than delegated to a later QA phase.
- Shared quality and defect distance: Explain why quality is a property of the whole team's work and why finding defects later increases cost and lead time.
Why it matters: Catching a defect while the work is fresh avoids a later handoff and costly rework. - Jidoka and collective accountability: Describe what jidoka means for developers working with collective code ownership, including developers who merge AI-generated code.
Why it matters: Shared permission to change code only works when responsibility for its quality is shared too. - Embedded collective quality safeguards: Describe how pre-commit hooks, CI tests, and feature flags support quality when developers contribute across components.
Why it matters: These checks let developers contribute beyond familiar components while finding problems quickly and limiting their impact.
Key terms: quality, handoff, lead time, cost of defect distance, jidoka, collective ownership, quality ownership, AI-generated code, pre-commit hooks, CI pipelines
13.5 Lean onboarding
The section treats onboarding as a value stream and shows how to shorten the time from a new hire’s first day to their first production deployment.
- Onboarding as a value stream: Explain how value stream mapping makes onboarding waste visible and why time to first production deployment is the improvement target.
Why it matters: It turns a seemingly unavoidable wait into a measurable process the team can improve. - Automated development environment setup: Describe how a script or container can remove setup delays and how the team should treat a failure of that setup.
Why it matters: Fixing setup once prevents the same delay for every subsequent hire. - First-day shipping tasks: Explain why a small, real production-bound change is more useful on day one than reading documentation or shadowing.
Why it matters: Even a trivial change can teach the delivery process while producing real shipped work. - Rotating onboarding buddies: Explain why the section recommends rotating several buddies rather than depending on one assigned buddy.
Why it matters: New hires need timely help without placing all the support work on one teammate. - Living onboarding documentation: Describe what replaces the stale wiki and how those materials serve as usable standard work.
Why it matters: Guidance that a new hire can actually follow exposes gaps in the team’s standard way of working.
Key terms: value stream mapping, activity ratio, first production deployment, automated environment setup, setup script, onboarding process, first day shipping tasks, code, review, merge, deploy, buddy rotation, bottleneck
13.6 AI as a pairing partner
The section shows how an AI assistant guided by a team persona can act as a pairing partner, helping a developer learn and produce code aligned with team standards while still requiring human mentoring and review.
- AI pairing and dual value: Explain how AI-assisted pairing resembles developer pairing and why it can benefit both the code and the developer.
Why it matters: Pairing is valuable here not just because it helps finish a task, but because it helps a developer grow. - Team persona as interactive guidance: Describe how a team persona makes an AI assistant useful for pairing, using Tom's architectural task as an example.
Why it matters: A persona can make a senior developer's architectural judgment available to teammates when that developer is unavailable. - Persona limits and human review: Distinguish the principles a persona can convey from the experience it cannot, and explain why human review remains necessary.
Why it matters: Knowing the persona's blind spot prevents a plausible design from being mistaken for a fully reviewed one.
Key terms: pair programming, AI coding assistant, dual value, persona, bounded contexts, domain events, codified knowledge, human mentoring, architect review
13.6.1 What AI pairing does not replace
This section explains why AI can accelerate technical learning but human mentoring remains essential for developing judgment and improving how a team works.
- Judgment before writing code: Explain why technical skill alone is not judgment, and state the questions a developer with judgment asks before coding.
Why it matters: AI can help you build something well without telling you whether it is worth building. - AI and human mentoring roles: Distinguish the skills-based pairing AI can provide from the judgment-building conversations that require human mentoring, including the section's standardized-work analogy.
Why it matters: The blend frees mentors to focus on decisions and growth rather than every routine technical question.
Key terms: judgment, Lean thinking, skills-based pairing, human mentoring, standardized work
13.7 Building problem solvers, not order takers
This section explains how organizational processes turn developers into order takers and why involving every developer in identifying problems increases a team’s capacity to improve.
- Processes that create order takers: Explain how over-specified tickets, repeatedly deprioritized suggestions, and approval-heavy processes discourage developers from exercising judgment and initiative.
Why it matters: A team can get reliable implementation while losing the initiative that might produce a better solution. - Teamwide problem identification capacity: Explain why a team’s improvement rate is constrained when only managers and leads identify problems, and how it changes when every developer does so.
Why it matters: Drawing on developers’ observations removes a limit imposed by relying on a few leaders to spot problems.
Key terms: order takers, over-specified tickets, deprioritized improvements, approval-heavy processes, throughput constraint, improvement rate
13.7.1 Reversing the pattern
This section explains five structural changes that help a team develop problem solvers rather than order takers.
- Systems That Shape Initiative: Explain why changing team practices, rather than simply urging developers to be more motivated, changes whether they take initiative.
Why it matters: It shifts attention from judging individuals to changing the conditions in which they work. - Problem-Framed Ticket Boundaries: Describe how a problem-framed ticket divides responsibility for the problem, business context, success criteria, and technical solution.
Why it matters: Clear outcomes leave room for the person closest to the code to choose an effective approach. - Protected Measurable Improvement Time: Describe how dedicated improvement time gives developers permission and accountability to improve the system.
Why it matters: Protected time makes improvement a real responsibility rather than an optional activity displaced by urgent work. - Contextual Decision Authority: Explain where technical decision authority should sit and what boundaries should remain in place.
Why it matters: Developers can use their firsthand knowledge without losing shared engineering safeguards. - Visible Impact Feedback: Explain how showing developers the measured outcomes of their work encourages further problem solving.
Why it matters: People are more likely to suggest another improvement when they can see that their last one made a difference. - Cross-Team Improvement Visibility: Describe why teams should share what they improved, measured, and learned across the organization.
Why it matters: An improvement can benefit more than one team when its result and lessons are visible.
Key terms: problem solvers, order takers, Motivation follows structure, problem-framed tickets, success criteria, WHAT, WHY, HOW, improvement time with teeth, developer-proposed improvements
13.7.2 Sustaining and scaling the problem-solving habit
This section explains how to keep problem solving fast, inclusive, and visible as a small co-located team grows into distributed teams.
- Limits of Small Team Osmosis: Explain why a problem-solving habit that works informally on a small co-located team can falter as teams grow and become distributed.
Why it matters: Recognizing what breaks during growth helps a team preserve its improvement habit deliberately. - Explicit Distributed Improvement Structure: Describe how the section replaces informal improvement with retrospectives, bounded sub-teams, visible WIP limits, and lightweight cross-team alignment.
Why it matters: Explicit local routines keep improvement possible without requiring everyone to share a schedule or attend every meeting. - Cross Team Rotation and AI: Describe how rotation and AI assistance can help distributed sub-teams share context and reduce time-zone delays.
Why it matters: These practices help shared understanding and review feedback move across team and time-zone boundaries. - Inclusive Visible Problem Solving: Explain how recognizing different forms of initiative and making improvements visible helps problem solving spread beyond leadership.
Why it matters: When more people can contribute and see successful fixes, improvement can spread without waiting for leaders to drive each change.
Key terms: osmosis, feedback loops, problem-solving culture, retrospective cadence, async retro formats, sub-teams, kaizen cycle, WIP limits, shared standards, rotation
13.8 Exercise: Assess your team's Lean maturity
This exercise uses an honest team assessment to find a constraint in Lean culture and test one focused improvement.
- Honest individual culture scores: Describe how team members individually score six dimensions of Lean culture from 1 to 5 using observed behavior rather than aspirations, then compare their scores to expose blind spots.
Why it matters: A team can miss a real cultural problem if it relies on optimistic ratings or an average. - Lowest dimension as constraint: Explain why the team selects its lowest-scoring dimension as the constraint to improve first.
Why it matters: Focusing on the constraint keeps improvement effort from being spent where it will have limited effect. - One measured culture improvement: Describe how the team turns its lowest-scoring dimension into one concrete action for the next sprint, recorded with a baseline, proposed change, target measurement, and owner. Explain that the assessment is a map for improvement, not a grade.
Why it matters: A small, owned, measurable change turns assessment into improvement rather than a scorekeeping exercise.
Key terms: Lean culture, behavioral descriptions, psychological safety, blind spots, lowest-scoring dimension, constraint, bottleneck, kaizen card, baseline measurement, target measurement
13.9 Summary
Where this is used later
- Building a culture of continuous learning (chapter 15) · Building continuous learning depends on making it safe and worthwhile to surface mistakes and ideas.
- Learning loops and skill development (chapter 14) · Skill development builds on the need to grow beyond routine implementation.
- Scaling improvements across teams (chapter 15) · Provides the team-scale problem behind spreading improvements across teams.
- Exercise: Plan your first team Kaizen event (chapter 15) · Provides an honest starting point for a team Kaizen event.
Concepts explained in this chapter
- pair programmingA collaborative software-development practice in which two people work together on the same task, typically sharing one computer.
- psychological safetyPsychological safety is a shared belief that people can raise concerns, ask questions, and propose changes without being punished or humiliated.
- collective ownershipA team practice in which responsibility for maintaining and changing software is shared across team members rather than assigned to isolated specialists.
- code reviewThe practice of examining proposed source-code changes for correctness, design, and maintainability.
- executable documentationDocumentation expressed in executable or automatically checked artifacts so it can be verified against the system.
- continuous improvementA feedback loop is a process in which information about outcomes is returned to influence subsequent decisions or actions.
- onboardingOnboarding is the process of helping a new team member become able to perform and deliver work within an organization.
- respect for peopleA system property in which people closest to the work have the authority, information, and psychological safety to improve it.
- bounded contextA clearly defined boundary within which a domain model and its terminology have a consistent meaning.
- domain eventA record of a significant occurrence in a business domain that other parts of a system can respond to.
- personaA structured brief that shapes an AI assistant's responses toward specified characteristics, principles, or standards.
- autonomyControl over how one works and the ability to exercise judgment in defining and solving problems.
- intrinsic motivationMotivation that arises from internal drivers rather than external rewards or pressure.
- masteryThe development of skill and capability through progressively challenging work.
- purposeA connection between one's work and a meaningful goal beyond the immediate task.
- component rotationA practice of assigning developers to work on components outside their usual areas of responsibility for a limited period.
- cross reviewA review practice in which someone other than the change's primary author examines the proposed change.
- activity ratioThe proportion of elapsed work time spent on productive activity rather than waiting or other non-progressing periods.
- standard workA single prescribed method applied across teams regardless of differences in their work contexts.
- bugA fault in software that can cause incorrect, unreliable, or unintended behavior.
- jidokaA Lean production approach that builds quality into processes by stopping when abnormalities occur and preventing defects from proceeding.
- precommit hookA pre-commit hook is an automated check that runs before a version-control commit is created.
- qualityThe degree to which software satisfies its requirements and is free from defects.
- AI-generated codeSource code produced by an artificial-intelligence system from supplied inputs or instructions.
- ai coding assistantA software tool that uses artificial intelligence to help generate, transform, explain, or review code.
- contractAn application programming interface is a defined set of operations and rules through which software components interact.
- A3 reportA structured Lean problem-solving approach that documents an issue, its analysis, and proposed countermeasures in a concise report.
- Five WhysA root-cause analysis technique that repeatedly asks why a problem occurred, using each answer to guide the next question.
- cause analysisA systematic process for identifying the underlying causes of a problem or failure rather than addressing only its symptoms.
- fishbone diagramA cause-analysis diagram that places a problem at the head of a central spine and branches potential causes into categories.
- kaizen cardA record of a proposed process improvement that specifies its baseline, change, owner, and target outcome.
- postincident analysisA post-incident review is a structured examination of an operational incident and the conditions that allowed it to occur.
- wip limitA rule that caps the number of work items that may be in progress at once.
- retrospectiveA team meeting for reflecting on recent work and identifying improvements.
- throughputThe rate at which completed work passes through a production or delivery system.
- legacy codeLegacy code is existing software that a team inherits and must understand or change, regardless of whether it is still useful and operational.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
