Agile software development

Agile software development is a set of methodologies for producing computer software. Agile software development is built on the values stated in The Agile Manifesto. These are face-to-face communication, producing working software in incremental iterations, collaborating with customers and being responsive to change.


The term “Agile Software Development” was first introduced in the Agile Manifesto, which was published in 2001. However, many of the concepts that are incorporated in what is today called agile software development were previously brought up in earlier software development or project management methods, such as Extreme Programming or Scrum.


There are many reported benefits with agile software development. Studies have shown that projects using agile software development produce software with increased quality and a higher productivity. A positive correlation with project success rate and the use of agile software development has also been found. Agile software development methods have further been reported to make the employees more satisfied and to improve communication and coordination.


There has been some concerns that agile software development projects tend to produce too little documentation. The lower emphasis on documentation could also lead to knowledge loss. Further, the incremental and iterative way of producing software could be very stressful to individual developers. There has also been concerns that agile methods don't allow for a proper software architecture development, and that they may lead to architectural problems.


There are a number of practices associated with agile software development. No definitive list of practices accepted as the industry standard exists, but some of the more widely recognized agile software development practices are listed below.


A backlog is a set of requirements or features that are to be completed in a project or in a specific iteration. The content of the backlog is prioritized into an order. During iteration planning, items from the project backlog are taken into the iteration backlog and are broken down into smaller parts, which are also prioritized.

Collective ownership

Collective ownership can have two meanings. It can mean that everyone working in an agile software development project, or a specific part of that project, is authorized to make changes to the software code as he or she sees fit. It can also mean that a specific work-task is never the sole responsibility of a single developer working in the project, but that the responsibility lies with the team as a group.

Continuous integration

Continuous integration is a way of putting different parts of a software product together. It should be done continuously (i.e. regularly throughout the development process, instead of putting all the parts together at the end). There are several continuous integration software systems available, but the practice of continuous integration doesn't really require a specific software.

Cross-functional team

A cross-functional team is a team of software developers that incorporates a wide selection of software development competences, such as system designers, feature developers and software testers. The idea is that the team together should be able to accomplish almost all the tasks required throughout the software development process, and that all team members should be able to at least take part in all of the steps along the way. This requires a very wide competence of all team-members.

Daily meetings

During an iteration, meetings are held daily (usually in the morning), to let everyone in the team know what everyone else has been doing since the last meeting, what they are planning to do next, and if there are any obstacles that needs to be taken care of. Meetings should be quick and effective, and are often held with the participants standing up so as to speed up the process. Daily meetings are sometimes called Daily Scrums (since they are a part of the Scrum project management method), or Daily Stand-ups (since the participants are standing up).


At the end of an iteration, a working example of the developed software should be demonstrated to stakeholders. These often include the customer or a customer representative, project management and developers from other teams within the same project, or developers from other projects who are stakeholders in the demoed project.

Frequent releases

Agile software development suggests that the software under development should be released to the customer frequently during it's development, instead of having just one large release at the end of the development project. How often a release is made varies greatly between different projects, but a sprint length of a few weeks and a release at the end of every sprint is a common practice.

Iteration planning meeting

Iteration planning meetings are held at the beginning of an iteration. Requirements or features in the software that are to be done during the iteration are broken down into smaller parts and the effort required to complete the smaller parts is estimated by the development team.

Iterative and incremental development

Agile software development should be done in iterations, and for every iteration some value-creating functionality should be added to the software. This is in contrast to more traditional software development, where the whole software is developed in one long time-frame, without creating lesser, working parts along the way.

On-site customer

Agile software development teams often have a customer or customer representative on-site to answer questions about requirements and help with prioritizing things to be done. The customer can also take part in the actual creation of program code.

Open office space

Open office space means that an agile software development team should be located together in an open area, so that they can see and talk to each other easily. There should preferably also be room for whiteboards and other equipment, and not just desks with computers.

Pair programming

Pair programming is when two computer programmers are working together working on one computer, using a single keyboard and mouse. The programmers take turns typing program code into the computer, and discusses solutions to any problems along the way. The programmer that isn't using the keyboard reviews the code as it is typed in.


During the course of a software development project, software developers should at regular intervals take time to review the program code that has been written previously, clean it up and restructure it to make it work better or better to work with. This is called refactoring, and it is especially necessary if the project is also using the Simple design practice.

Retrospective meetings

At the end of an iteration, the development team should have a meeting to discuss how things went. The purpose of the retrospective meeting is to continuously improve the way the team works together and to find the best solutions to common problems.

Sign-up for tasks

Sign-up for tasks means that the members of an agile software development team chooses for themselves, individually, which tasks they want to be working on during an iteration, instead of a manager telling them what to do. Tasks are selected from the backlog.

Simple design

Simple design means that a software developer, or an agile software development team, should chose the simplest possible software design for any task at hand. The idea is that the software functionality and design will change over time, and that putting time and effort into optimizing the design isn't worth it before the software has matured. Problems with the design that is created with this practice can be solved with refactoring.

Sustainable pace

An agile software development team should plan their work and effort in such a way that there is no need to put in extra hours at the end of a project. Instead, the team should keep a steady pace at all times.

Task board

A task board is a visual tool that is mainly used to display the progress of work items during an iteration. A simple example of a task board is a white board that has been divided into three consecutive parts: To be done, in progress and done. Tasks are represented by post-it notes and are moved along the board as they are fulfilled. Task boards are also known as Scrum boards, as this practice is included in Scrum.


QR Code
QR Code agile_software_development (generated for current page)