skill · foundations
Developer foundations
A six-week, ten-step path. By the end of it you have shipped a story behind a flag, paired through trunk-based discipline, reviewed PRs that taught, and watched your code through its first 48 hours. You are not a senior Developer. You are a Developer whose first cycle produced code the next reader can recognise.
How a skill works in this corpus
A skill is not a reading list. It is read → practice → check → reflect, anchored to your real cycle. Bring a real story from your sprint.
Mastery looks like
When you finish this path, you can:
- Sketch a story end-to-end in 30 minutes before typing code.
- Keep a branch alive less than a day, protected by a feature flag.
- Choose the right test level for the bug class you're protecting against.
- Leave at least one teaching comment on every PR you review.
- Read your own code at 2am during an incident and act on it.
Self-rating before you start
| 1 — Never | 3 — Sometimes | 5 — Default | |
|---|---|---|---|
| I sketch a story before I type code | |||
| My branches live less than a day | |||
| Each test names the level it's catching | |||
| Domain language survives from brief to code | |||
| I refuse stories I can't sketch in 30 minutes |
Step 1 — Orient in the chain
Read: As We Build · Domain Language in Code · As We Build · Trunk-Based Development · The Map.
Practice prompt: in three sentences, explain why the brief's names should survive into your code.
Step 2 — Read the codebase for domain language
Read: As We Build · Domain Language in Code.
Practice prompt: find one place in the codebase where the original brief's name has decayed. Write down what the brief called it and what it's called now.
Mini-check: can a new developer trace a production string back to the brief? If not, the gap you found is real.
Step 3 — Pair on a story
Read: What We Shape · Story Writing.
Practice prompt: take the next available story. Pair with an experienced developer end-to-end — amigos, sketch, code, test, review, merge.
Output: merged PR with a co-author, plus a one-page note on the team's trunk-based discipline.
Step 4 — Sketch before code
Practice prompt: take the next story alone. Spend the first 30 minutes sketching — sequence diagram, data flow, the test you'll write first. Do not type code in that 30 minutes.
Mini-check: if the sketch is bigger than one page, the story is too big. Push back at amigos.
Step 5 — Trunk-based discipline
Read: As We Build · Trunk-Based Development · As We Build · Feature Flags.
Practice prompt: ship your story behind a flag. Keep the branch alive less than a day. If you can't, split.
Pair task: ask another developer: would you have split this differently?
Step 6 — Hold amigos as one third
Read: What We Shape · Amigos & Gherkin.
Practice prompt: hold amigos for one of your stories. Bring at least one technical risk the brief doesn't yet acknowledge. Seed at least one Gherkin scenario from your risk.
Step 7 — Test at the right level
Read: As We Build · Testing Layers.
Practice prompt: for your story, write one unit test, one integration test, one e2e test (if warranted). Each test's name says what level it catches.
Mini-check: kill any test that is green for the wrong reason. A test that passes when the implementation is broken is a worse test than no test.
Step 8 — Review three PRs honestly
Practice prompt: review three PRs from the team. Comments say why this convention, not just change it. At least one comment should teach.
Pair task: ask the PR author: did my review help you understand the code differently?
Step 9 — Watch your code in production
Read: After We Build · The First 48 Hours.
Practice prompt: when your flag enables, watch the dashboards (not the support tickets) for at least one hour. Take notes; do not act on first-hour noise.
Output: a one-page note on what you saw. If you found an observability gap, write the follow-up PR.
Step 10 — Teach back, contribute back
Practice prompt: write a one-page guide for the next new Developer joining your team. What I wish I'd known before my first cycle. One page.
Authoring contribution: open a PR — sharpen one thing in the corpus about the developer's chain duties.
Self-rating after: rate yourself again. Bring the gap to your next cycle.
After this path
- Developer · Practitioner (coming) — multiple cycles, mentoring on review, leading a small feature end-to-end.
- Developer · Advanced (coming) — domain modelling, refactor leadership, platform contribution.
Stuck?
| If you got stuck at | Read |
|---|---|
| Step 4 — couldn't sketch in 30 minutes | The story is too big. Push back at amigos. |
| Step 5 — branch lived three days | Trunk-Based Development — the discipline holds even under deadline |
| Step 7 — bugs kept escaping the wrong test layer | Testing Layers |
| Step 9 — first-hour noise looked like a fire | Read the first 48 hours — note, don't act |