Agile & Project Management
Agile Principles: The Manifesto, Its Values and What They Change
Beginner9 min readReviewed by Mariem Ouled on Updated
Agile is a set of values about how to organise work under uncertainty, not a process you install. This guide walks through the four values and twelve principles of the 2001 manifesto, explains the empirical thinking underneath them, corrects the misreadings that give agile a bad name, and is frank about the situations where the approach is a poor fit.
What you will learn
- State the four values of the Agile Manifesto and what each one trades against the other
- Explain the twelve principles in terms of concrete behaviour change rather than slogans
- Describe empirical process control and why iterative, incremental delivery reduces risk
- Recognise the common misreadings of agile, including the claims about documentation and planning
- Judge honestly when an adaptive approach fits a piece of work and when it does not
In February 2001, seventeen practitioners who had each been experimenting with lightweight development methods met and agreed on a single page of text. That page — the Manifesto for Agile Software Development — has four value statements and twelve supporting principles, and nothing else. It names no roles, no meetings, no artefacts and no certification. Everything that people now call agile, from Scrum boards to quarterly planning events to the entire scaling industry, was built on top of that page afterwards, and much of it contradicts the page.
That gap is why this guide starts with the text itself. If you understand what the values actually claim and what problem the authors were reacting against, you can evaluate any practice someone puts in front of you — including the ones your organisation already uses — on its merits rather than on whether it is labelled agile. This article stays at the level of values and principles; the Scrum framework guide covers the most widely used concrete implementation, and project management fundamentals covers the predictive tradition the manifesto was arguing with.
Why the manifesto was written
The dominant model in the 1990s came from engineering disciplines where the shape of the product was known before construction began. You gathered requirements, wrote a specification, designed the system, built it, tested it, and handed it over — each phase completed and signed off before the next started. The approach is usually called waterfall, after a 1970 paper that presented the sequential diagram as a flawed straw man and then proposed iterating; the industry adopted the diagram and ignored the caveat.
Sequential phases work when three conditions hold: the requirements are genuinely knowable in advance, they do not change while you build, and the cost of discovering a mistake at the end is bearable. Software rarely satisfies any of them. Users cannot describe what they want until they see something; markets move during an eighteen-month build; and the defects that matter most — a misunderstood workflow, an unusable screen, a performance ceiling in the architecture — only become visible when someone tries to use the thing. A project that discovers its central misunderstanding during acceptance testing has already spent its budget.
The lightweight methods of the late 1990s were independent reactions to that pattern. They differed in detail but shared a bet: if you cannot know the answer up front, shorten the loop between doing and learning until the cost of being wrong becomes small.
The four values
Each value is written as a comparison, and each ends with the same clarification: while there is value in the items on the right, the authors value the items on the left more. That phrasing matters. None of the four is an instruction to abandon the right-hand item.
Individuals and interactions over processes and tools. A defined process makes good people slightly more consistent; it does not make a poor team good. When something goes wrong, the first question in most organisations is which process step was missed. The manifesto's question is which conversation did not happen. In practice this means colocating or properly connecting the people who need to talk, keeping teams small and stable, and treating a tool as something that records a decision rather than something that makes one.
Working software over comprehensive documentation. The only honest measure of progress is a running system doing something a user recognises. A specification that is ninety per cent complete tells you nothing about how much of the product exists. This value is the most frequently abused, and the FAQ below deals with the abuse; the discipline it demands is that documents must have an identified reader and a reason to exist.
Customer collaboration over contract negotiation. Fixed-scope, fixed-price contracts create an adversarial relationship in which every discovery becomes a change request and a fight. The alternative is to fix the budget and the timeline and let the scope flex, with the customer present continuously to decide what fills the box. That requires a customer willing to engage weekly rather than at milestones, which is often the hardest part of an agile adoption to arrange.
Responding to change over following a plan. A plan is a forecast made at the moment of maximum ignorance. Treating deviation from it as failure creates strong pressure to hide bad news. Treating the plan as something to be revised as evidence arrives makes bad news cheap to report, which is the only way it arrives early enough to act on.
The twelve principles in practice
The principles are more concrete than the values, and they are where most of the practical content sits. Rather than list them as slogans, here is what each one asks a team to actually do differently.
| Principle | What changes in practice |
|---|---|
| Satisfy the customer through early, continuous delivery of valuable software | Ship something usable in weeks, not at the end; measure progress by released increments |
| Welcome changing requirements, even late | Keep the design and the test suite flexible enough that change is cheap, and stop charging emotionally for it |
| Deliver working software frequently, weeks rather than months | Shorten the release cycle deliberately until each release is boring |
| Business people and developers work together daily | Put a decision-maker inside the team's day, not at a monthly steering meeting |
| Build projects around motivated individuals, give them the environment and trust | Delegate the how; stop assigning tasks to named people from outside the team |
| Face-to-face conversation is the most efficient form of communication | Prefer a call or a whiteboard to a ticket thread for anything ambiguous |
| Working software is the primary measure of progress | Retire percentage-complete reporting on unfinished work |
| Sustainable pace, maintained indefinitely | No crunch; a velocity that collapses after a release was never real |
| Continuous attention to technical excellence and good design enhances agility | Fund refactoring, testing and automation as part of the work, not as a later project |
| Simplicity — maximising the work not done | Delete features nobody uses; solve the problem in front of you |
| The best architectures and designs emerge from self-organising teams | Architects work with teams rather than issuing designs to them |
| At regular intervals the team reflects and adjusts its behaviour | Run retrospectives that produce one change and actually make it |
Three of these are worth pausing on because they are routinely skipped. Principle nine ties agility to engineering quality: a codebase without tests cannot absorb changing requirements, so a team that adopts iterations without adopting test-driven development, continuous integration and refactoring will get slower each iteration until it stops. Principle eight rules out the sprint-then-collapse cycle that many teams mistake for high performance. And principle twelve is the engine: without a retrospective that changes something, the other eleven are static rules rather than a system that improves.
Empirical process control
Underneath all of this sits an idea borrowed from process engineering. A defined process is one you can specify completely in advance and then execute: given the same inputs, it produces the same outputs, so planning it once is rational. An empirical process is one where too many variables are unknown, so you control it by frequent inspection and adaptation instead — do a small amount, look at the result, adjust.
Empiricism needs three things to work: transparency, so everyone sees the same honest state of the work; inspection, at a frequency short enough that a wrong turn is cheap; and adaptation, meaning the authority and the willingness to change course based on what was seen. Remove any one and the loop breaks. A team that inspects weekly but has no authority to change anything is holding a status meeting, not running an empirical process.
Iterative and incremental are the two techniques that make inspection possible, and they are not synonyms. Incremental means building the product in slices that each add usable function — a login flow, then a search, then a checkout. Iterative means revisiting and improving what already exists as you learn. Real delivery needs both: slice thin enough to release, then expect to come back and rework the first slices once users touch them. A team that only works incrementally accumulates a product full of first drafts.
Common misreadings
- "Agile means no documentation." The value statement compares documentation to working software; it does not delete it. Regulated products, public APIs and systems that outlive their team all need durable written material.
- "Agile means no estimates or dates." Business decisions require forecasts. Agile changes how forecasts are produced and how often they are revised — see estimation and planning — not whether they exist.
- "Agile means no architecture." Emergent design is not absent design. It means deferring decisions until the last responsible moment and keeping the ones that are expensive to reverse under deliberate review.
- "We do two-week sprints, so we are agile." Iteration length is the easiest thing to copy and the least meaningful. A team that plans two weeks of assigned tasks, reports status daily and releases twice a year has changed its calendar and nothing else.
- "Self-organising means no management." Teams decide how to do the work. Someone still sets direction, funds the effort, hires and resolves problems the team cannot reach.
Where agile does not fit
Being honest about limits is what separates a practitioner from an evangelist.
Adaptive approaches assume that changing your mind late is affordable. Where it is not — civil engineering, a hardware production run, a satellite launch, a migration with a single irreversible cutover — heavy up-front analysis is the rational choice, and hybrid models that plan the immovable parts predictively while running the software inside them adaptively work better than pretending everything is flexible.
They also assume a customer who will engage. Where the buyer signs a fixed-scope contract and then disappears for six months, or where a public procurement rule requires the full specification before a supplier is chosen, the collaboration value has nowhere to live. And they assume a team small enough to talk. Coordination across many teams needs additional structure, which is what the scaling frameworks attempt to supply and why they are contentious.
Finally, agile at the team level cannot fix a delivery pipeline that takes three months to get a change into production. That is the constraint DevOps practices exist to remove, and without them a team can be perfectly agile up to the point where its work sits in a queue.
Key takeaways
- The manifesto is one page of four values and twelve principles; every framework, role and ceremony people associate with agile was added later and is optional.
- Each value is a comparison with an explicit acknowledgement that the right-hand item still has worth — none of them abolishes documentation, contracts or plans.
- Empirical process control — transparency, inspection, adaptation on a short cycle — is the mechanism; iterative and incremental delivery are how you create something to inspect.
- Technical excellence is not optional garnish: without tests, automation and refactoring, the ability to welcome change disappears within a few months.
- The approach fits knowledge work with uncertain requirements and reversible decisions, and fits badly where late change is genuinely catastrophic or the customer cannot participate.
- Copying the calendar — sprints, stand-ups, a board — without changing who decides, how often you release and how honestly you report is the most common failed adoption.
Sources and further reading
Frequently asked questions
- Does agile mean there is no documentation?
- No. The manifesto values working software over comprehensive documentation, and the sentence ends by saying that the item on the right still has value. What agile rejects is documentation produced to satisfy a process rather than a reader: five-hundred-page specifications nobody opens, or design documents written after the code. An architecture decision record, an API reference and a runbook all survive the test of having an audience.
- Is agile the opposite of planning?
- It is the opposite of planning once. Agile teams plan constantly — every iteration, every refinement session, every release forecast — but they treat the plan as a current best estimate rather than a contract. The manifesto phrase is responding to change over following a plan, which presumes a plan exists. A team that refuses to forecast anything is not being agile, it is being unhelpful.
- Can agile work outside software development?
- The values transfer wherever work is knowledge work with uncertain requirements and a short feedback loop is possible: marketing campaigns, hardware firmware, research, curriculum design. They transfer poorly where the cost of a change late in the process is enormous and irreversible, such as pouring concrete or manufacturing a physical mould, or where a regulator requires a full specification signed before work begins.
- Is agile still relevant twenty-five years after the manifesto?
- The values are, though much of the industry has moved past the manifesto's original framing. Continuous delivery, product thinking, platform engineering and modern testing practices all descend from it and go further. What has aged badly is the certification industry that grew around the word, and the assumption that any team problem can be solved by adopting a framework.