Kami PeoPLe
Published in

Kami PeoPLe

Agile Principles Explained

The principles behind this great framework.

The Agile Cycle

This article is written as a part of Individual Review competency for Software Projects course 2020 at Faculty of Computer Science, University of Indonesia.


Agile is one of the most popular, widely adapted framework that can be used to build software, from small to large-scaled ones. Before going deeper, we need to have a basic understanding on what “agile” in software development is about. No, it’s not about making a software as quickly as possible. Rather, the “agile” mentioned here is about how effective you and your team in facing changes. There is a saying that “change is the only constant”. It’s true, even in software project. That being said, change is one of the core focus of agile.

Being Agile

What does it mean by being “agile”? Some few things that can be considered as being “agile” in software development are as follow:

  • Effective response to changes.
  • Effective communication among the stakeholders involved in a software project.
  • Effective organization to a team involved in the project.
  • Rapid and incremental delivery of software.

I’m sure there are more things that can be considered as “agile”, but I’m only leaving what I think are the most important ones.

Some Well-Known Agile Implementations

I’d like to point out that Agile is only a specification and that there are software process models that implement Agile, examples being “Extreme programming”, “Scrum”, and “DSDM”. I will try to give a brief explanation for each process models.

  1. Extreme Programming (XP). Proposed by Kent Beck, it is the most widely used Agile process. This process utilizes Class Responsibility Collaboration (CRC) cards as user stories. One of the practices used in XP is pair programming, where two people (developers) work together directly on the same system when developing code, to promote better communication.
  2. Scrum. Conceived by Jeff Sutherland and his team in early 1900s (implemented throughout Software Project Course 2020), is a software development framework which every activity occurs in a time-boxed (from two weeks to a month) event called “sprint”. Each sprint consists of these activities: sprint planning, daily scrum meeting, sprint review, and sprint retrospective. Each sprint is done in order to achieve desired sprint goals, with each deliverable is termed as “increment”.
  3. Dynamic Systems Development Method (DSDM). This process model is based on an approach that “provides a framework for building and maintaining systems which meet tight time constraints through the use of incremental prototyping in a controlled project environment”. This process model has a philosophy that says “80 percent of an application can be delivered in 20 percent of the time it would take to deliver the complete (100 percent) application”.

The Agile Principles

In 2001, Kent Beck et al published a foundation to every Agile implementation, it’s called “Manifesto for Agile Software Development”. The manifesto itself is the basis of the well-known “12 Agile Principles”, which is the focus of this article.

Here are the 12 principles used in Agile methodology with some explanation for each principle:

  1. Customer satisfaction is the highest priority, achieved through early and continuous delivery of valuable software. By delivering software increments continuously, feedback can be given to the said increment. That is, each delivery should invoke meaningful feedback that we can use to improve the next delivery. It’s all done with the customer’s (client/stakeholder) satisfaction in mind.
  2. Embrace change, even late in development. This also related to the constant that is “change”. We should be aware of each change that can arise, even in the middle of development. With this in mind, we should adapt to the given change, so there would be no “It’s already late in development, we can’t afford to make changes”.
  3. Deliver working software frequently. Related to principle #1, software should be delivered as routine as possible, ranging from a couple of weeks to a couple of months, preferably the shorter timescale. This is done in order to invoke feedback from the customer/client. The more feedback, the better.
  4. Business people and developers must work together throughout the project. Without the client/stakeholder involvement, there would be a higher chance of “development bias” throughout the project. By involving stakeholders closely, the developer can gain more clarity on what product they are actually building.
  5. Build projects around motivated individuals. How can we expect to give our best if there are no single motivations. This is very important, as motivations are the things that keep us going. To achieve this, supports should be given and trusts must be made.
  6. Effective information through face-to-face communication. By communicating directly, we can gain more clarity. Unlike written communications, we can gain much faster responses. We can also use body language to our advantage, if that counts.
  7. Working software = progress. This is the goal that every Agile adopter should have in mind. By having this orientation, we can set aside all the unnecessary things that do not contribute much to the software. It’s the software that counts.
  8. Promote sustainable development by maintaining a constant pace. By having a constant pace throughout the development, we can have some consistency in working the software. This principle also applies to non-developers too.
  9. Continuous attention to technical excellence. This principle leans much on the developer side. The development team should pay attention as much as possible to their technical skills. Developers also need to follow the latest trend in software world, as it can lead to inspirations or better decision on working the software.
  10. Simplicity is essential. I know some of us can be perfectionists, but we need to understand that what’s important is what the customer wants. This is done for rapid delivery and customer satisfactions. If some of the things do not contribute much, then give them a chance for another time.
  11. Self-organizing teams produce the best architectures, requirements, and designs. No, we don’t really need to have a team of “super developer” to achieve this. What is needed mainly is self-organization and much teamwork. Without proper teamwork, no optimal work can be done, let alone architectures, requirements, and designs. This principle tells us why Agile can promote teamwork and self-organization.
  12. Reflection and adjustment are essentials. No one is perfect, that’s why we need to reflect and adjust ourselves regularly. This can be done at the end of every “phase” or “increment”. By doing this, the team can keep the things they are good at and fix what did not work, in order to make improvements.


By looking at the 12 principles above, we gain more understanding to the Agile itself. At its core, Agile promotes many good things: adaptation, teamwork, adjustment, communication, etc. It’s one of the reason why Agile is widely used.

Well, folks. This wraps the article up. Please leave a comment if you have suggestions, corrections, or anything else so that I can improve my future writings :)

See you next time!




Dari PeoPLe untuk Umat — Writings from PPL 2020 B5

Recommended from Medium

Creating a Twitter Bot to Bring my Analytics to the People

The Horrors of Scale

What are Alexa Routines and How to Use Them?

Efficient Parallel Prefix Sum in Metal for Apple M1

Grand Fantasy Integrates Chainlink Sports Data to Power March Madness Contests

A dive into Serverless Architecture with AWS…

MVI Pattern in Android without RxJava

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Farhan Azmi

Farhan Azmi

More from Medium

How to improve “Bug” workflow in agile world

Scrum Guild at Leaseweb

Agile Scrum 101 — Every detail covered in less than 5 minutes

Don’t Do Scrum Unless You Did This!