Agile manifesto and principles
Open in the Padhaiko app2.1 Understanding the Agile Manifesto: History and the four core values
In February 2001, seventeen independent software practitioners and methodology authors—including Kent Beck, Ken Schwaber, Jeff Sutherland, Alistair Cockburn, Martin Fowler, Jim Highsmith, Ron Jeffries, and Robert C. Martin—met at Snowbird ski resort in Utah. They represented competing lightweight frameworks (Scrum, Extreme Programming, Crystal, DSDM, FDD, and Adaptive Software Development) that had grown in reaction to heavyweight, document-driven Waterfall processes. Together they coined the term Agile and published the Manifesto for Agile Software Development.
The Four Core Values of the Agile Manifesto
The Agile Manifesto states: "We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
That is, while there is value in the items on the right, we value the items on the left more."
2.1.1 Interpreting the Four Core Values Correctly
A common exam trap is assuming Agile rejects tools, documentation, contracts, or plans altogether. The closing sentence of the Manifesto explicitly rejects that extreme: the items on the right have real value, but whenever a conflict arises, the items on the left take priority.
| Core Value (Left over Right) | What It Means in Practice | Common Misconception (What It Does NOT Mean) |
|---|---|---|
| Individuals and interactions over processes and tools | Empowered, communicative people solve unexpected problems; tools and workflows exist to serve people, not control them. | "No processes, standards, or version control tools are needed." |
| Working software over comprehensive documentation | Real, tested software is the primary evidence of progress; write lean documentation that directly helps build, operate, or use the system. | "Never write architecture notes, API docs, or user guides." |
| Customer collaboration over contract negotiation | Engage customers continuously throughout delivery to discover true needs instead of treating the initial contract as an adversarial wall. | "Eliminate legal contracts, SLAs, or scope agreements." |
| Responding to change over following a plan | Update plans continuously as real feedback and market shifts emerge, rather than rigidly defending an outdated baseline. | "Do no planning and change requirements chaotically mid-sprint." |
2.2 The 12 Agile Principles: Customer satisfaction, quality, teamwork, and development
Supporting the four core values are 12 Agile Principles that translate the Agile mindset into day-to-day behaviors across customer value, teamwork, engineering quality, and development rhythm.
| No. | Principle Summary | Focus Pillar | Practical Implementation |
|---|---|---|---|
| 1 | Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. | Customer Satisfaction | Ship usable increments early rather than holding everything for a single end-of-project launch. |
| 2 | Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage. | Adaptability | Keep the Product Backlog prioritized and flexible so late insights improve market competitiveness. |
| 3 | Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale. | Development Rhythm | Use short 1–4 week sprints to tighten feedback loops and lower delivery risk. |
| 4 | Business people and developers must work together daily throughout the project. | Teamwork & Collaboration | Embed a Product Owner with the team for daily clarification rather than infrequent formal reviews. |
| 5 | Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done. | Teamwork & Trust | Replace micromanagement with clear goals, psychological safety, and obstacle removal. |
| 6 | The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. | Teamwork & Communication | Prefer high-bandwidth synchronous conversation (in person or video + whiteboard) over slow email chains. |
| 7 | Working software is the primary measure of progress. | Development & Transparency | Measure completion by tested, integrated features—not "80% coded" or completed design documents. |
| 8 | Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely. | Sustainable Development | Avoid chronic overtime and crunch, which cause burnout and spike defect rates. |
| 9 | Continuous attention to technical excellence and good design enhances agility. | Quality | Apply clean architecture, refactoring, TDD, and automated tests so the codebase remains easy to change. |
| 10 | Simplicity—the art of maximizing the amount of work not done—is essential. | Quality & Lean Focus | Avoid over-engineering and gold-plating; build only what delivers validated user value. |
| 11 | The best architectures, requirements, and designs emerge from self-organizing teams. | Teamwork & Autonomy | Let the people doing the work decide how to implement solutions rather than imposing top-down task micro-plans. |
| 12 | At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. | Continuous Improvement | Hold a Sprint Retrospective every iteration and act on concrete improvement experiments. |
2.2.1 Grouping the 12 Principles by Theme
For exam answers, organizing the 12 principles into four themes makes them easy to recall and explain:
- Customer Satisfaction & Value (Principles 1, 2, 3, 7): Frequent delivery of working software, embracing late changes, and measuring progress strictly by working functionality.
- Teamwork & Human Dynamics (Principles 4, 5, 6, 11): Daily business-developer alignment, trusting motivated individuals, high-bandwidth communication, and self-organizing teams.
- Technical Quality & Simplicity (Principles 9, 10): Technical excellence, clean design, and ruthless simplicity (maximizing work not done).
- Sustainable Development & Reflection (Principles 8, 12): Maintaining an indefinite sustainable pace and inspecting/adapting the team's own process regularly.
2.3 Changes as a Result of Agile Values: Shifts in attitudes toward workers and change
Adopting the Agile Manifesto fundamentally changes organizational culture—especially how leaders view workers and how teams respond to change.
2.3.1 Shift in Attitude Toward Workers (Theory X to Theory Y)
- Traditional Command-and-Control (Douglas McGregor's Theory X): Assumes workers dislike work, avoid responsibility, and must be tightly directed through top-down task assignments, time-tracking, and rigid process compliance. Managers plan what and how every task is done.
- Agile Empowerment and Trust (Theory Y): Assumes skilled professionals are intrinsically motivated when given purpose, autonomy, and mastery. Leadership shifts from command-and-control to servant leadership: setting clear product goals, clearing organizational impediments, and trusting cross-functional, self-organizing teams to determine the technical execution.
- From Individual Silos to Shared Ownership: Workers are no longer rewarded solely for individual utilization ("100% busy coding") or blaming other departments ("QA missed it"). The whole team shares accountability for the working increment.
2.3.2 Shift in Attitude Toward Change
- Traditional View of Change: Change is treated as a threat—called scope creep—that disrupts baselines, triggers formal Change Control Boards, and causes schedule blame. Teams try to freeze requirements early, even when the market moves.
- Agile View of Change: Change is treated as new learning and a competitive advantage. Because teams inspect working increments every 1–4 weeks and keep unbuilt work in a flexible, prioritized Product Backlog, reprioritizing upcoming sprints costs almost nothing compared to tearing up months of built code.
- Continuous Planning: Agile does not eliminate planning; it replaces one-time predictive planning with continuous adaptive planning across vision, roadmap, release, sprint, and daily horizons.
| Aspect | Traditional Organizational Attitudes | Agile Organizational Attitudes |
|---|---|---|
| View of Workers | Interchangeable resources managed via top-down task assignment and strict supervision. | Self-organizing, creative knowledge workers trusted to design and deliver solutions. |
| View of Change | Unwelcome disruption ("scope creep") resisted with change freeze gates. | Natural product discovery harnessed as competitive advantage via backlog adaptation. |
| View of Documentation | Exhaustive sign-off artifacts created before coding begins. | Lean, living documentation created just in time when it adds durable value. |
| View of Management | Directing tasks, tracking hours, enforcing process compliance. | Defining vision, removing impediments, fostering collaboration and quality. |
2.4 The Agile Litmus Test: Evaluating process and behavior
Many teams adopt Scrum vocabulary ("sprints", "stand-ups", "story points") while keeping traditional Waterfall behaviors underneath—a dysfunction often called "Water-Scrum-Fall" or "Agile Theater". The Agile Litmus Test is a practical diagnostic used to evaluate whether a team's actual process and behaviors align with the Agile Manifesto and principles.
The Agile Litmus Test
The Agile Litmus Test evaluates any proposed practice, workflow rule, or team behavior by asking whether it reinforces the four core values and 12 principles in daily reality—specifically checking empirical transparency, working increments, customer collaboration, self-organization, sustainable pace, and continuous adaptation.
2.4.1 Key Diagnostic Questions of the Agile Litmus Test
To audit process and behavior health, teams test observable realities against six core checks:
| Evaluation Dimension | Healthy Agile Signal (Pass) | Anti-Pattern / Warning Signal (Fail) |
|---|---|---|
| 1. Individuals & Self-Organization | Team members pull tasks, decide technical design together, and collaborate face-to-face daily. | A manager assigns every task to individuals; communication goes through ticket comments only. |
| 2. Working Software Cadence | Potentially shippable, tested software is demonstrated at the end of every short sprint (1–4 weeks). | Sprints end with "code complete, testing next month" or slide-deck status reports. |
| 3. Customer Collaboration | A Product Owner or customer representative clarifies requirements daily and gives feedback at every Sprint Review. | Customer disappears after kickoff and only sees the product at final UAT months later. |
| 4. Responsiveness to Change | Product Backlog is reprioritized after every Sprint Review based on empirical user feedback. | Scope is locked for 6 months; every tweak requires executive change-board sign-off. |
| 5. Sustainable Pace & Quality | Automated tests and Definition of Done hold steady; team works at a consistent, burnout-free pace. | Chronic weekend crunch before releases; unit tests skipped to hit arbitrary deadlines. |
| 6. Reflection & Adaptation | Retrospectives produce concrete action items that visibly improve the next sprint. | Retrospectives are skipped when busy, or the same complaints repeat with zero action. |
2.5 Platinum Principles: Resisting formality, acting as a team, and visualization
Beyond the 12 Manifesto principles, practical Agile project management (as emphasized in Mark C. Layton's framework) distills daily execution habits into three Platinum Principles that keep teams lean, cohesive, and transparent:
The Three Platinum Principles
- Resisting Formality: Keep processes, artifacts, ceremonies, and documentation as lightweight as possible ("just barely sufficient"). Adopt structure only where it directly helps delivery, and resist bureaucratic bloat.
- Acting as a Team: Operate as one unified, cross-functional unit sharing a single Definition of Done and common sprint goal—rather than isolated specialists handing work "over the wall."
- Visualization: Make work, priorities, progress, and blockers immediately visible to everyone through information radiators (task boards, Kanban boards, burndown charts, story maps).
2.5.1 Applying the Three Platinum Principles
- 1. Resisting Formality:
- In practice: Replace 40-page requirements documents with concise User Stories supported by face-to-face conversations (Three C's: Card, Conversation, Confirmation).
- Guardrail: Resisting formality means avoiding unnecessary ceremony, not abandoning engineering discipline. Coding standards, automated tests, and the Definition of Done remain strict.
- 2. Acting as a Team:
- In practice: Developers, testers, designers, and the Product Owner collaborate daily. If testing piles up near sprint end, developers help write automated checks or pair with testers to finish stories rather than starting new code.
- Result: Collective ownership eliminates finger-pointing ("I finished my coding, QA is behind") and builds mutual trust.
- 3. Visualization:
- In practice: Maintain a physical or digital task board (
To Do | In Progress | Verify | Done), a visible Sprint Burndown chart, and a flagged blockers column. - Result: Visualization enforces Empirical Transparency (Topic 1.3)—anyone walking past the board sees bottlenecks instantly without interrupting developers for status updates.
- In practice: Maintain a physical or digital task board (
2.1
An engineering department conducts an Agile Litmus Test across six criteria, scoring each criterion from 1 (strictly traditional/Waterfall) to 5 (mature Agile), giving a maximum total score of 30:
- Team Alpha: Self-organization = 5, Working increments each sprint = 2, Customer collaboration = 4, Responding to change = 5, Sustainable pace = 3, Retrospective adaptation = 5.
- Team Beta: Self-organization = 1, Working increments each sprint = 2, Customer collaboration = 1, Responding to change = 1, Sustainable pace = 2, Retrospective adaptation = 2.
Calculate each team's total score, percentage Agile health score, and mean criterion score, and diagnose each team's primary bottleneck.
Calculating Team Alpha's Litmus Test Score: Sum of scores = 5 + 2 + 4 + 5 + 3 + 5 = 24 out of 30.
- Percentage Agile health score = (24 / 30) x 100 = 80.0%.
- Mean criterion score = 24 / 6 = 4.00 out of 5.
- Diagnosis: Team Alpha shows strong collaboration, adaptability, and self-organization, but its score of 2 on "Working increments each sprint" and 3 on "Sustainable pace" indicates technical debt or late testing preventing clean sprint-end increments.
Calculating Team Beta's Litmus Test Score: Sum of scores = 1 + 2 + 1 + 1 + 2 + 2 = 9 out of 30.
- Percentage Agile health score = (9 / 30) x 100 = 30.0%.
- Mean criterion score = 9 / 6 = 1.50 out of 5.
- Diagnosis: Despite possibly holding stand-ups or sprints, Team Beta is practicing Agile Theater ("Water-Scrum-Fall")—scoring 1 on self-organization, customer collaboration, and change responsiveness.
- Team Alpha: Total = 24 / 30 (80.0%), Mean = 4.00 / 5 — healthy Agile foundation, needs stronger engineering/testing integration to ship clean increments every sprint at a sustainable pace.
- Team Beta: Total = 9 / 30 (30.0%), Mean = 1.50 / 5 — classic "Water-Scrum-Fall" needing structural autonomy, active Product Owner collaboration, and backlog flexibility.
2.2
Exam-Style Scenario Question: A company claims to follow the Agile Manifesto, yet requires developers to write a 60-page technical design specification for sign-off before coding starts, forbids direct contact between developers and clients, and penalizes teams whenever sprint plans change. Identify which Manifesto values and Platinum Principles are being violated and propose concrete remedies.
Mapping Violations to Manifesto Values:
- 60-page upfront sign-off violates Working software over comprehensive documentation (and Principle 10: Simplicity) as well as the Platinum Principle Resisting formality.
- Forbidding developer–client contact violates Individuals and interactions over processes and tools and Customer collaboration over contract negotiation (plus Principles 4 and 6).
- Penalizing plan changes violates Responding to change over following a plan (and Principle 2).
Concrete Agile Remedies:
- Replace the 60-page upfront document with lightweight architecture sketches, User Stories, and executable acceptance criteria (Resisting formality).
- Include the Product Owner and key stakeholders in Sprint Reviews and regular backlog refinement, allowing direct developer–user clarification (Acting as a team).
- Adopt a visible visual board and burndown chart (Visualization) and treat plan updates between sprints as normal empirical adaptation.
The company violates all four Manifesto values (especially Working Software, Customer Collaboration, and Responding to Change) along with the Platinum Principles of Resisting formality and Acting as a team. Remedies include lean just-in-time documentation, direct Product Owner collaboration, and visual boards supporting empirical backlog adaptation.
Exercises
Practice Exercises — Agile Manifesto and Principles
State the four core values of the 2001 Agile Manifesto exactly, and explain why the closing statement ("while there is value in the items on the right, we value the items on the left more") is essential for avoiding project chaos.
The Four Core Values (2001 Snowbird Manifesto):
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
Importance of the Closing Caveat: The right-hand items—tools, documentation, contracts, and plans—are still necessary for governance, legal clarity, onboarding, and coordination. The caveat clarifies that Agile is not undisciplined hacking; rather, when a trade-off occurs, teams prioritize human communication, working product increments, collaborative discovery, and adaptability over rigid artifacts.
The four values prioritize individuals/interactions, working software, customer collaboration, and responding to change. The closing clause prevents misinterpretation by confirming that processes, tools, documentation, contracts, and plans still hold supporting value rather than being discarded completely.
Explain how four specific Agile Principles (Principles 7, 8, 9, and 10) protect both product quality and developer sustainability over long multi-year product lifecycles.
Progress and Sustainable Pace (Principles 7 & 8):
- Principle 7 (Working software is the primary measure of progress): Prevents "phantom progress" where teams report 90% design completion while hiding integration failures.
- Principle 8 (Sustainable development): Requires maintaining a constant pace indefinitely, eliminating chronic crunch that causes fatigue, turnover, and human errors.
Technical Excellence and Simplicity (Principles 9 & 10):
- Principle 9 (Continuous attention to technical excellence and good design): Automated tests, refactoring, and clean modular design keep the cost of future changes low.
- Principle 10 (Simplicity—maximizing work not done): Avoids building speculative, unused features, keeping the codebase lean and easier to maintain.
Principle 7 ensures honest progress tracking via working software; Principle 8 prevents burnout via steady pace; Principle 9 preserves code maintainability through clean design; and Principle 10 eliminates unnecessary complexity by avoiding unused features.
Describe how adopting Agile values transforms an organization's attitude toward (a) workers and leadership, and (b) requirement changes during development.
Shift in Attitude Toward Workers and Leadership: Organizations move from Theory X command-and-control (managers micromanaging individual tasks and guarding departmental silos) to Theory Y servant leadership (trusting motivated, self-organizing cross-functional teams, supporting face-to-face communication, and sharing whole-team accountability).
Shift in Attitude Toward Change: Rather than viewing requirement changes as disruptive "scope creep" blocked by formal Change Control Boards, Agile teams treat change as empirical feedback that keeps the product competitive. Scope stays flexible in a prioritized backlog while sprint timeboxes remain stable.
Agile shifts worker management from top-down control to autonomous, self-organizing teams led through support and trust, and shifts change from a penalized disruption into a welcome source of competitive advantage managed via continuous backlog prioritization.
Define the Three Platinum Principles and explain how each one reinforces the Agile Manifesto in day-to-day team execution.
1. Resisting Formality: Avoid unnecessary templates, approval layers, and heavyweight documents; keep practices lean ("barely sufficient") so effort goes into working software rather than paperwork—reinforcing Working software over comprehensive documentation and Simplicity.
2. Acting as a Team & 3. Visualization:
- Acting as a team: Breaks down analyst/developer/tester silos into collective ownership of the sprint goal—reinforcing Individuals and interactions and Self-organizing teams.
- Visualization: Uses task boards, burndowns, and story maps so priorities and blockers are transparent to everyone immediately—reinforcing Transparency and Customer collaboration.
The Three Platinum Principles are: (1) Resisting formality (lightweight, value-focused workflow), (2) Acting as a team (cross-functional shared ownership), and (3) Visualization (open information radiators showing real-time work and blockers).
A department audits two projects using a 5-question Agile Litmus Test (each scored 1 to 5, max 25 points):
- Project X: [5, 4, 4, 3, 4] across [Self-Organization, Working Increments, Customer Collaboration, Sustainable Pace, Visualization].
- Project Y: [2, 2, 1, 2, 3] across the same five criteria.
Compute each project's total score and percentage score, identify the percentage-point gap between them, and name the single highest-priority weakness in Project Y.
Scoring Project X and Project Y:
- Project X total = 5 + 4 + 4 + 3 + 4 = 20 / 25 -> (20 / 25) x 100 = 80.0%.
- Project Y total = 2 + 2 + 1 + 2 + 3 = 10 / 25 -> (10 / 25) x 100 = 40.0%.
- Percentage-point gap = 80.0% - 40.0% = 40.0 percentage points.
Diagnosing Project Y's Top Weakness: Project Y's lowest score is 1 / 5 on Customer Collaboration, meaning the team is working in isolation from real stakeholder feedback—violating Manifesto Value 3 (Customer collaboration over contract negotiation).
- Project X: 20 / 25 (80.0%)
- Project Y: 10 / 25 (40.0%)
- Gap: 40.0 percentage points
- Project Y's Top Priority Fix: Re-establishing continuous Customer Collaboration (1 / 5) via an active Product Owner and regular Sprint Reviews.