Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 29 ยท Agile Basics

What Is Agile?

Learn what Agile means, why plan-driven projects struggle, how iterative and incremental delivery works, and how feedback loops cut the cost of change.

Agile is a way of building products, usually software, in small steps while staying open to change. Instead of writing a huge plan, building for a year and hoping the result is right, an Agile team delivers a small, working piece, shows it to real users, learns from their reaction and adjusts the plan. The word describes a mindset and a family of methods such as Scrum, Kanban and Extreme Programming (XP), not a single process you can install.

This lesson explains the problem Agile was created to solve, the two ideas at its core (iterative and incremental delivery), and why short feedback loops make change cheap. The rest of this tutorial builds on it: you will meet the Agile Manifesto, then Scrum, and finally Jira, the tool many teams use to run all of it. Nothing here needs special software. The runnable examples are small JavaScript models that you can change and re-run.

The problem: plans meet reality

Before Agile became common, many software projects followed a plan-driven (often called waterfall) approach. Work moves through phases in a fixed order: gather all requirements, design everything, build everything, test everything, release. Each phase finishes before the next begins, and the customer typically sees working software only near the end.

This feels safe, because everything is written down and approved early. It struggles for three reasons:

  • Requirements are guesses. People are bad at describing in advance what they will want. They recognize the right product when they use it, not when they read a 200-page document.
  • The world changes. In a year-long project, competitors, laws, technology and the customer's own priorities move. A plan that was right in January can be wrong by October.
  • Problems surface late. If the biggest misunderstanding is only discovered during final testing, fixing it means undoing months of work built on top of it.

The third point is the heart of the matter. The later you learn that something is wrong, the more work depends on it, and the more it costs to correct. Agile attacks this problem directly: find out early, while change is still cheap.

Plan-driven delivery

Plan first Requirements are fixed up front.
Build in phases Design, build, test, release in order.
One big reveal The customer sees it at the end.

Safe on paper, risky when requirements are uncertain.

1 / 2

Two core ideas: iterative and incremental

People often say "iterative and incremental" as one phrase, but the words mean different things.

Incremental means you build the product in slices that each add something usable. Imagine a shopping site. An incremental team might deliver product browsing first, then the cart, then checkout, then order history. After each slice, there is a real, working thing a customer could use.

Iterative means you revisit and improve what you already built. The first version of search might be crude. After watching people use it, you rework it into something better. You expect to go around the loop more than once.

Agile teams do both at the same time. They deliver a thin vertical slice (it works end to end: screen, logic, data), get feedback, and then either extend it (incremental) or refine it (iterative). The fixed-length cycle in which this happens is often called an iteration; in Scrum it is called a Sprint, typically one to four weeks.

A thin slice matters more than it may seem. Building all the databases first, then all the logic, then all the screens produces nothing a user can try until the very end. A slice that goes through every layer for one small feature can be shown to a user in days.

Feedback loops

A feedback loop is the time between doing something and learning how well it worked. Short loops are the engine of Agile. There are loops at several levels:

  • Minutes: the developer runs automated tests after each change.
  • Daily: the team inspects progress and spots blocked work.
  • Every iteration: stakeholders see and try the new increment, and the team reflects on how it worked together.
  • Every release: real users show, through behavior and data, whether the product solves their problem.
flowchart LR
  A["Plan a small piece"] --> B["Build it"]
  B --> C["Show it to users"]
  C --> D["Learn what to change"]
  D --> A

The Agile loop: every pass teaches the team something that shapes the next plan.

A long loop is expensive in two ways: the mistake itself costs more, and you also make more mistakes in the meantime because you keep building on the unverified assumption.

Seeing the cost of late change

Let us make this concrete with a model. A product has six requirements, and three of them were misunderstood at the start (we know this only because we are the narrator; the team does not). Each takes two weeks to build. A wrong requirement is only discovered when a customer sees it working. When it is found, the team must redo that requirement, and also half a requirement's worth of work for each requirement built since, because later work leaned on it.

The model compares customer feedback at the end of the project against feedback after every two weeks. The numbers are invented for illustration; real projects vary a lot. What matters is the shape of the result.

JS Late feedback costs more

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The earlier a mistake is seen, the closer its cost gets to the minimum, which is simply redoing the one piece. Try changing which requirements are wrong, or set the feedback interval to 4 weeks, and watch the total move. In real projects, the cost does not grow in such a tidy way: defects found after release can cost far more than this model shows, because of support, reputation and data clean-up.

Value arrives earlier

The second benefit is about value, not cost. In a plan-driven project, no value reaches users until the final release. If the budget is cut, a market shifts or the company changes direction halfway, the team may have nothing to show. With incremental delivery, the most valuable slices ship first, so every month already paid for itself a little.

JS Incremental delivery under a budget cut

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Both strategies end at the same total value, but the incremental one never holds zero value while it waits. Notice also that the later slices are worth less. Delivering in priority order lets a team stop when the remaining items are no longer worth their cost, which is a real business decision that plan-driven projects rarely get to make.

Agile compared with waterfall

Question Plan-driven (waterfall) Agile
When is the scope decided? Mostly before work starts Continuously, in priority order
When does the customer see software? Near the end After every iteration
How is change treated? A risk to be controlled An expected input
Where does testing happen? A phase after building During every iteration
How is progress measured? Percent of plan completed Working software delivered
Typical documents Large, detailed up front Lightweight, just enough, kept current

Waterfall is not "wrong". For work where requirements really are stable and mistakes are very costly to fix later (for example, building a bridge, or firmware shipped on a chip that cannot be updated), a plan-driven approach can be the sensible choice. Most software is different: it is easy to change, hard to specify perfectly, and the people who use it are full of surprises. That is where Agile pays off.

What Agile is not

Because "Agile" became fashionable, it collects misunderstandings:

  • Agile is not "no planning". Agile teams plan constantly, in smaller horizons. They plan the next iteration in detail and the further future roughly.
  • Agile is not "no documentation". It prefers just enough documentation that people will actually read and keep current.
  • Agile is not a tool. You can use Jira badly without being Agile, and be very Agile with sticky notes on a wall. Tools support the way of working; they do not create it.
  • Agile is not speed at any cost. Agile teams aim for a sustainable pace, because exhausted teams build poor software.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the main problem with finding mistakes late in a project?

    The later a misunderstanding surfaces, the more work depends on it. Short feedback loops find problems while the cost of change is still small.
  2. 2. Which description best matches incremental delivery?

    Incremental means building in slices that each work. Iterative means revisiting and improving what already exists. Agile teams do both.
  3. 3. Which statement about Agile is correct?

    Agile teams plan in short horizons and expect change. Tools such as Jira can support Agile but are not required, and documentation is kept lightweight, not banned.
  4. 4. In which situation might a plan-driven approach still be sensible?

    Stable requirements together with very expensive late changes (for example, hardware that cannot be updated) favor careful up-front planning.

Summary

  • Plan-driven projects fix scope early and reveal the product late, which makes mistakes expensive when they finally appear.
  • Agile delivers working software in short cycles and uses feedback to decide what to do next.
  • Incremental means building in usable slices; iterative means revisiting and improving; Agile teams do both.
  • Short feedback loops lower the cost of change and deliver value earlier.
  • Agile is a mindset supported by methods such as Scrum, Kanban and XP, not a tool or an excuse to skip planning.

Next, read the founding statement of the movement in The Agile Manifesto and Principles.