Core Principles of Agile Software Development, Explained

UPI Study › Courses › Software Engineering › Free lessons › Lesson 5.1 Free with a free account

Core Principles of Agile Software Development

Software Engineering · Chapter 5: Agile Methodology in PracticeSection 5.1 · lesson 31 of 1037 min · free with a free account

← Getting Started with Agile ThinkingNext lesson: The Agile Lifecycle: From Planning to Delivery →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

The Agile Manifesto: 4 values and 12 principles.

  • State a formal definition of agile
  • Explain each of the 4 values, and what "over" means
  • Describe the 12 principles, grouped by theme
  • Relate this shared foundation to the methods built on it

Transcript

Everything said in the video, section by section (897 words). Read along, or search it.

Agile Methodology in Practice

Core Principles of Agile Software Development

Agile's philosophy, with its focus on flexibility, customer collaboration, and fast feedback, has a specific written source. This section looks at that source, the Agile Manifesto. It covers what its four values say, what its twelve principles say, and how together they define what agile formally means.

A Written Source

From Philosophy to a Declaration

In two thousand one, a group of experienced software practitioners met to compare notes. They were frustrated with heavyweight, documentation-driven approaches that often failed to deliver what customers actually needed. So they tried to write down what their most successful projects had in common. What they produced was short. A declaration of four values, and twelve supporting principles. It was not a method, with specific steps. It was a shared foundation, which many later, more specific methods would build on.

Definition

What "Agile" Formally Means

Formally, then, agile refers to a family of software development approaches that share a common foundation. That foundation is the declaration from two thousand one, now known as the Agile Manifesto, with its four values and twelve principles. The Manifesto itself does not prescribe specific practices, roles, or ceremonies. It states what successful, adaptive projects had in common, at a level general enough that many different methods could each implement it in their own way.

The 4 Values

This, Over That

The four values are usually summarized as four short statements. Individuals and interactions, over processes and tools. Working software, over comprehensive documentation. Customer collaboration, over contract negotiation. And responding to change, over following a plan. Notice the word over. These are preferences, not rejections. Each value names two things that both matter, and says which one takes priority when a real project forces a choice.

Table 5.1

The Tension Each Value Resolves

Each value resolves a particular tension. People and how they work together come first, because it is people, not the process describing them, who actually solve problems and adapt. A system that genuinely works comes before exhaustive documentation, because running software demonstrates real progress in a way a document cannot. Ongoing customer involvement comes before a fixed contract, because a rigid agreement struggles to absorb what the team learns once work is underway. And adapting to change comes before sticking to the plan. A plan is written before the project starts. That is when the team has the least real understanding it will ever have.

Figure 5.1B

12 Principles, 5 Themes

Beneath the four values, the Manifesto lists twelve more specific principles. Treated as twelve unrelated rules, they are hard to remember. Grouped by the theme each one serves, the pattern is much easier to hold onto. Three principles are about delivering value, and three are about people and collaboration. Then two each cover measuring progress, quality and simplicity, and the team and its reflection.

Themes 1 and 2

Value, and the People Who Create It

The first theme is delivering value. Get real, working value into the customer's hands early and often. Welcome a change in requirements, even a late one, rather than resist it. And deliver in short, frequent cycles, rather than one long one. The second theme is people and collaboration. Business people and developers work together daily, not just at milestones. Projects are built around individuals who are trusted and supported, rather than tightly controlled. And face-to-face conversation is treated as the most effective way to convey information.

Themes 3 to 5

Progress, Quality, and the Team

The third theme redefines what counts as progress. Progress is working software itself, not a status report describing it. And the work should move at a pace the team can sustain indefinitely. The fourth theme ties agility to technical discipline. Continuous attention to technical excellence and good design is what keeps a team moving quickly. And maximizing the unnecessary work left undone keeps effort focused. The fifth theme is about the team itself. The best designs tend to emerge from teams that organize their own work. And a team that regularly reflects, and adjusts, keeps improving.

Think About It

Break 1 Principle

Here is a question to think about. Imagine a team where business people and developers only speak once a month. What problems would you expect? Developers would likely fill gaps in their understanding with guesses. Misunderstandings would surface weeks later, as rework. And the business's priorities could shift without the team knowing, so the product slowly drifts away from what is actually needed.

Foundation and Methods

1 Foundation, Many Methods

So how does this foundation relate to the specific agile methods? Each method puts the same foundation into action, through its own concrete practices, roles, and routines. The practices differ from method to method. The four values and twelve principles stay constant across all of them.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Agile is a family of software development approaches, sharing a common foundation of four values and twelve principles. The Agile Manifesto is the two thousand one declaration that states those values and principles. A value, in the Manifesto, is a stated preference for one priority over another, without rejecting the lower priority entirely. And a principle is one of twelve more specific statements, built on the values, describing what successful agile projects tend to share.

Key Takeaways

What to Carry Forward

To pull this together. Agile formally refers to a shared foundation, the Manifesto's four values and twelve principles, rather than one specific method. Each value states a preference, not a rejection. Both sides matter, but one wins when a real project forces a choice. The twelve principles cluster around five themes. Delivering value, people and collaboration, measuring progress, quality and simplicity, and team reflection. Working software, at a sustainable pace, is what counts as real progress. And while specific methods differ in their practices, the foundation stays the same.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About Core Principles of Agile Software Development

What is the Agile Manifesto?
The Agile Manifesto is a short declaration written in 2001 by a group of experienced software practitioners frustrated with heavyweight, documentation-driven approaches. It states four values and twelve supporting principles describing what successful adaptive projects had in common. It does not prescribe specific practices, roles, or ceremonies, so many different agile methods implement it in their own ways.
What are the four values of the Agile Manifesto?
The four values are individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. Each value names two things that both matter and states which one takes priority when a real project forces a choice.
Does the Agile Manifesto mean agile teams do not write documentation?
No. The word over in the Manifesto's values expresses a preference, not a rejection. Working software is valued over comprehensive documentation because running software demonstrates real progress in a way a document cannot, but documentation still matters. The same reading applies to processes, contracts, and plans, which keep their value while ranking lower when a choice is forced.
How are the 12 agile principles organized?
The twelve principles can be grouped into five themes. Three cover delivering value early and often, welcoming change, and short cycles. Three cover people and collaboration, such as daily work between business people and developers. Two each cover measuring progress through working software at a sustainable pace, technical excellence and simplicity, and self-organizing teams that regularly reflect and adjust.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →