Framework
Build to Become
A repeatable loop for turning an interest into real capability — and, over time, into a sense of who a young person is becoming. What kids build changes who they become; this is the shape of that change.
Definition
Build to Become is a six-stage cycle — Choose, Frame, Build, Test, Explain, Improve — that a young person moves through to make something real. It's a loop, not a line: each pass through it produces both a better artifact and a more capable maker.
The problem it addresses
A lot of “making” stops at Build. A kid produces something once, gets a reaction, and moves on. The stages that turn a one-off project into durable skill — testing against reality, explaining decisions, improving — get skipped. This model names all six stages so none of them quietly disappear.
The loop
- Choose
Pick something that matters to you.
- Frame
Decide what problem you're really solving.
- Build
Make a first real version.
- Test
Put it in front of reality and watch what breaks.
- Explain
Say why you made the choices you did.
- Improve
Change it based on what you learned — then loop.
Improveback to Choose — the loop repeats
The identity-level outcomes
Each stage builds more than a skill; it builds a belief a young person holds about themselves. Those beliefs are what carry over to the next project — and the next part of life. In order:
- I can choose.
- I can begin.
- I can learn what I need.
- I can recover when something fails.
- I can explain my decisions.
- I can improve my work.
- I can make something useful for another person.
A worked example
A 10-year-old wants to build an app to help walk dogs in their neighborhood. Through the loop:
Choose: they pick dog-walking because they love dogs and neighbors keep asking.
Frame: the real problem isn't “an app” — it's “neighbors can't tell when I'm free.” So the app needs a simple schedule.
Build: they make a first version with a list of time slots and a request button.
Test: a neighbor tries it and gets confused — two people booked the same slot.
Explain: the kid explains they assumed one request per slot, and sees why that assumption failed.
Improve: they add a “taken” state to each slot — then loop back to Choose the next feature.
By the end they didn't just make an app. They chose, began, learned what they needed, recovered from a failure, explained a decision, improved the work, and made something a real person used. That's every outcome on the list.
Common misuse
- Skipping Test and Explain. These are the stages that convert effort into understanding. Jumping from Build to Improve without them loses most of the value.
- Treating it as strictly linear. Real projects loop back constantly. The stages are a checklist of what should happen, not a one-way schedule.
- Making it the adult's loop. If a grown-up (or an AI) does the choosing, framing, and explaining, the kid never earns the outcomes. Keep the decisions with the learner.
How to use it
For parents
Use the stage names as gentle prompts. “What are you testing?” or “can you explain why you chose that?” keeps a project moving without taking it over.
For educators
Structure project work around the six stages and assess the full loop — especially Test, Explain, and Improve — so a single polished artifact isn't the whole grade.
For product design
Design tools that support every stage, not just Build. This loop is the intended backbone of SayMake, an experiment — see also high-agency learning.