We provide reliable estimates:

  1. Estimate in terms of ideal engineering days (story points), not calendar time.
  2. Use velocity to determine how many storey points the team can finish in an iteration.
  3. Use iteration slack to smooth over surprises and deliver on time every iteration
  4. Use risk management to adjust for risks to the overall release plan

We know why our work is important and how we'll be successful.Create a Vision Statement:

  1. What the project should accomplish
  2. Why the project is valuable
  3. Define success criteria

We prevent mistakes by fixing our process

We are all tuned into the status of our project

We stop at predetermined, unchangeable time intervals and compare reality to plan

We plan for success. Release early, release often

We define requirements in parallel with other work, but we can work with upfront requirements

We inspire trust in the team's decisions

We inform the customer of our progress

We deliver stories every week without compromising design quality

We make and meet long term commitments

We continually improve our work habits

Refactoring

Every day, our code is slightly better than the day before

Reduce technical debt

Collective Code Ownership

We are all responsible for high-quality code

No Bugs

We confidently release without a dedicated testing phase

  1. Write fewer bugs through Pair Programming
  2. Eliminate bug breeding grounds by refactoring poorly designed code
  3. Fix bugs quickly through Test Driven Development
  4. Test your processes using exploratory testing
  5. Fix your process using Retrospectives and Root-Cause analysis 

Pair Programming

We help each other succeed:

  1. Pair on everything you'll need to maintain
  2. Allow pairs to form fluidly rather than assigning partners
  3. Switch partners when you need a fresh perspective
  4. Avoid pairing with the same person for more than a day at a time
  5. Sit comfortably, side by side
  6. Produce code through conversation. Collaborate, don't critique
  7. Switch driver and navigator roles frequently

Simple Design

Our design is easy to modify and maintain

Express every concept once (and only once)

Version Control

We keep all our project artifacts in a single, authoritative place

 "Done Done"

We're done when we're production-ready:
Tested, Coded, Designed, Integrated, Builds, Installs, Reviewed, Fixed,Accepted

Continuous Integration

We keep our code ready to ship

  1. Integrate your code every few hours
  2. Keep the release infrastructure up to date 
  3. Use a dedicated build machine   
  4. Agree to never break the build

Coding Standards

We embrace a joint aesthetic

Automated Build

We eliminate build and configuration hassles

Trust

We work together effectively and without fear

Sit together

We communicate rapidly and accurately

Ubiquitous Language

We understand each other

Programmers should speak the language of their domain experts, not the other way around.

Slack

We deliver on our iteration commitments:

  1. Schedule some useful, important work that isn't time critical
  2. Paying down technical debt
  3. Research

Spike Solutions

We perform small, isolated experiments when we need more information

Ten-Minute Build

We eliminate build and configuration hassles. Automate the build

Documentation

Exploratory Testing

We discover surprises and untested conditions

  1. Charters
  2. Observations
  3. Note taking
  4. Heuristics 

Test Types:

None, Some, All 
Goldilocks test: too big, too small, just right 
Position: Beginning, middle, end 
Count: one, zero, many 
CRUD: create, read, update, delete
Command Injection 
Data Type Attacks

Iteration Demo

We keep it real. After every iteration we ask:

  1. Is our work satisfactory?
  2. May we continue?

Real Customer Involvement

We understand the goals and frustrations of our customers and end-users

Test Driven Development

We produce well-designed, well-tested, and well-factored code in small, verifiable steps

  1. "Don't write any production code unless you have a failing test".
      Think of a test that will force you to add the next few lines of production code
  2. Write the test
  3. Write just enough production code to get the test to pass
  4. Refactor
  5. Repeat

Performance Optimisation

We optimise when there's a proven need

Customer Tests

We implement tricky domain concepts correctly