---
title: "The Project Arc: Building a Program in Stages"
description: "Taking a project from a written aim to working software in stages: a thin version that runs end to end, then features added one at a time, each kept working. Refactoring is the step that keeps the cod"
canonical: https://lightmysky.com/learn/computing/the-project-arc-building-a-program-in-stages-mt_hACOaB3nA_
source: https://lightmysky.com/learn/computing/the-project-arc-building-a-program-in-stages-mt_hACOaB3nA_.md
retrieved: 2026-09-12
---

> **Agent view.** This is the Markdown twin of the page, for tools and assistants.
> When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md
> API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md
> Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt
> Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json
> Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`.

# The Project Arc: Building a Program in Stages

Taking a project from a written aim to working software in stages: a thin version that runs end to end, then features added one at a time, each kept working. Refactoring is the step that keeps the code liveable as it grows.

Subject: Computing · Area: Programming · Ages 17 to 18
Page: https://lightmysky.com/learn/computing/the-project-arc-building-a-program-in-stages-mt_hACOaB3nA_

## Ready when they can

- Break an aim into stages where every stage leaves a program that still runs
- Keep a small backlog and say what the next stage is and why it is next
- Refactor once the shape of the code has drifted, without changing what it does

## Lesson: Building big programs in small stages

Software engineering builds in a planned way instead of hacking until something works. You write a short plan naming the aim, the main parts, and how you will test each part. Skipping that thinking buys painful rewrites later.

**Example.** You start with a walking skeleton, the simplest end to end job, like a quiz asking one question and checking the answer. Then you add one slice per stage while the program keeps running. You hold remaining work as a small backlog, an ordered list whose top item is always the next stage.

You pick the next stage for a stated reason: it unlocks later work, cuts the biggest risk, or delivers the most value. Say the reason aloud, since a stage with no reason is usually the wrong stage. A light plan also exposes risk early, so you can reorder or shrink the aim in time.

**Tip.** You refactor once the code shape has drifted, while everything still works. Refactoring reshapes the code without changing what it does, so later stages land on a tidy base and stay fast.

**Recap.** Thin running start, one reasoned slice per stage, and tidy the shape as it drifts.

## Practice

8 questions on this page, each with its working shown.

## Needs first

- [Debugging as a Method: Reproduce, Isolate, Fix](https://lightmysky.com/learn/computing/debugging-as-a-method-reproduce-isolate-fix-mt_2JGE4ICRf6)
- [Designing with Objects: Deciding What Each Class Owns](https://lightmysky.com/learn/computing/designing-with-objects-deciding-what-each-class-owns-mt_De_gpvpOzg)
- [Decomposing a Problem into Subprograms](https://lightmysky.com/learn/computing/decomposing-a-problem-into-subprograms-mt_P293LckCnd)

## Opens up

- [Version Control as a Graph of Commits](https://lightmysky.com/learn/computing/version-control-as-a-graph-of-commits-mt_oKsDRKirMy)