Index: flowtimer/RecurringPhaseSequence.py
===================================================================
--- flowtimer/RecurringPhaseSequence.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
+++ flowtimer/RecurringPhaseSequence.py	(revision d310de340da31123226ed1ce1fd7fa3ed2c48c53)
@@ -11,6 +11,6 @@
             if 'title' in d and 'initial_ticks' in d:
                 return Phase(d['title'], d['initial_ticks'])
-            if 'phase_list' in d and 'initial_repetitions' in d:
-                return RecurringPhaseSequence(d["title"], d['phase_list'], d['initial_repetitions'])
+            if 'phases' in d and 'initial_repetitions' in d:
+                return RecurringPhaseSequence(d["title"], d['phases'], d['initial_repetitions'])
             print("Wrong format")
             return d
@@ -20,7 +20,7 @@
     def default_json_string(cls):
         return json.dumps({"title": "default",
-                           "phase_list": [{"title": "Tasking", "initial_ticks": 5},
-                                          {"title": "Work", "initial_ticks": 45},
-                                          {"title": "Break", "initial_ticks": 15}],
+                           "phases": [{"title": "Tasking", "initial_ticks": 5},
+                                      {"title": "Work", "initial_ticks": 45},
+                                      {"title": "Break", "initial_ticks": 15}],
                            "initial_repetitions": 3})
 
@@ -29,11 +29,11 @@
         return cls.from_json(cls.default_json_string())
 
-    def __init__(self, title, phase_list, repetitions):
+    def __init__(self, title, phases, repetitions):
         assert repetitions > 0
-        assert phase_list is not []
+        assert phases is not []
         self._title = title
         self.state = "initial"
-        self.phase_list = phase_list
-        self.current_phase = phase_list[0]
+        self.phases = phases
+        self.current_phase = phases[0]
         self.initial_repetitions = repetitions
         self.passes_left = repetitions
@@ -53,5 +53,5 @@
 
     def current_phase_number(self):
-        return self.phase_list.index(self.current_phase)
+        return self.phases.index(self.current_phase)
 
     def phases_left_in_pass(self):
@@ -59,16 +59,16 @@
 
     def upcoming_phases_in_pass(self):
-        if self.current_phase_number() < len(self.phase_list) - 1:
-            return self.phase_list[self.current_phase_number()+1:]
+        if self.current_phase_number() < len(self.phases) - 1:
+            return self.phases[self.current_phase_number()+1:]
         return []
 
     @property
     def initial_ticks(self):
-        return sum([each.initial_ticks for each in self.phase_list])
+        return sum([each.initial_ticks for each in self.phases])
 
     @property
     def ticks_left(self):
         return (
-            (self.passes_left-1) * sum([each.initial_ticks for each in self.phase_list]) +
+            (self.passes_left-1) * sum([each.initial_ticks for each in self.phases]) +
             self.current_phase.ticks_left +
             sum([each.ticks_left for each in self.upcoming_phases_in_pass()]))
@@ -99,12 +99,12 @@
                 self.passes_left -= 1
                 self.current_phase.reset()
-                self.current_phase = self.phase_list[0]
+                self.current_phase = self.phases[0]
 
     def advance_to_next_phase(self):
         current_index = self.current_phase_number()
-        if current_index < len(self.phase_list) - 1:
+        if current_index < len(self.phases) - 1:
             # Move to the next phase in the sequence
             self.current_phase.reset()
-            self.current_phase = self.phase_list[current_index + 1]
+            self.current_phase = self.phases[current_index + 1]
         else:
             # Completed a full sequence; check if more repetitions are needed
@@ -114,5 +114,5 @@
             else:
                 self.current_phase.reset()
-                self.current_phase = self.phase_list[0]  # Reset to the first phase
+                self.current_phase = self.phases[0]  # Reset to the first phase
 
     def tick(self, ticks):
@@ -134,3 +134,3 @@
 
     def unrolled(self):
-        return [deepcopy(seq) for seq in [each for each in self.initial_repetitions * self.phase_list]]
+        return [deepcopy(seq) for seq in [each for each in self.initial_repetitions * self.phases]]
Index: flowtimer/Schedule.py
===================================================================
--- flowtimer/Schedule.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
+++ flowtimer/Schedule.py	(revision d310de340da31123226ed1ce1fd7fa3ed2c48c53)
@@ -79,5 +79,5 @@
                     "type": "Sequence",
                     "title": block.title,
-                    "sequence": [serialize_block(phase) for phase in block.phase_list],
+                    "sequence": [serialize_block(phase) for phase in block.phases],
                     "initial_repetitions": block.initial_repetitions
                 }
Index: tests/test_recurring_phase_sequence.py
===================================================================
--- tests/test_recurring_phase_sequence.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
+++ tests/test_recurring_phase_sequence.py	(revision d310de340da31123226ed1ce1fd7fa3ed2c48c53)
@@ -17,6 +17,6 @@
         assert isinstance(sequence, RecurringPhaseSequence)
         assert sequence.initial_repetitions == 3
-        assert len(sequence.phase_list) == 3
-        assert sequence.phase_list[0].title == "Tasking"
+        assert len(sequence.phases) == 3
+        assert sequence.phases[0].title == "Tasking"
 
     def test_to_json(self, recurring_phase_sequence):
@@ -26,5 +26,5 @@
         assert data['initial_repetitions'] == 3
         assert data['passes_left'] == 3
-        assert len(data['phase_list']) == 3
+        assert len(data['phases']) == 3
 
     def test_initial_state(self, recurring_phase_sequence):
@@ -49,5 +49,5 @@
 
     def test_ticks_left(self, recurring_phase_sequence):
-        total_ticks = (sum([phase.initial_ticks for phase in recurring_phase_sequence.phase_list]) *
+        total_ticks = (sum([phase.initial_ticks for phase in recurring_phase_sequence.phases]) *
                        recurring_phase_sequence.initial_repetitions)
 
@@ -59,5 +59,5 @@
         assert not recurring_phase_sequence.completed()
         for _ in range(3):
-            for phase in recurring_phase_sequence.phase_list:
+            for phase in recurring_phase_sequence.phases:
                 recurring_phase_sequence.tick(phase.initial_ticks)
         assert recurring_phase_sequence.completed()