Learning paths
The hub holds the practices. The Academy teaches you why each one is there.
Seven paths through effective software development, in the order the argument runs: connect the specialists, start from the user, let the tests drive the design, make the boundaries explicit, learn the pattern vocabulary, question every line — and only then hand work to a machine.
In preparation.The curriculum below is settled; the lessons are still being written, and there is nothing to enrol in yet. Every path links to the documentation that covers its ground today.
Told as stories
Development practice is taught badly as a list of definitions and well as a sequence of decisions someone had to live with. So the lessons carrying astorymark come with a short video in narrative form: a team with a problem, the option they took, what it bought them and what it cost. 18 of the38 lessons are planned that way — the rest are short enough to read.
The curriculum
- FoundationComing soon
Connected development
Effective development starts as a communication problem. The rituals that put end-users, UX designers, domain experts, developers, architects, quality engineers, product owners and operations in the same conversation — before the code exists.
- The handover is where requirements go to die Includes a storytelling video
- Three amigos: the smallest conversation that prevents rework
- Example mapping: turning a story into rules, examples and open questions Includes a storytelling video
- Event storming: finding the domain with the people who live in it
- Ubiquitous language — when the same word means two things Includes a storytelling video
Read today: Practices
- FoundationComing soon
User-first
Starting from the person who has to use the thing. What the journey is, what it costs them when it is wrong, and why that belongs upstream of the architecture rather than downstream of it.
- The user journey as the first artefact Includes a storytelling video
- Designing the interaction before designing the system
- Accessibility as a design constraint, not a late audit
- What a UX designer needs from a developer, and vice versa Includes a storytelling video
- Design systems as a contract: Figma tokens, Storybook stories
Read today: User-first
- CoreComing soon
Test-first
Writing the test first is not about testing. It is a design technique: the first caller of your code is the test, and if it is painful to write, that is the design telling you something.
- Red, green, refactor — and why the third step is the one people skip Includes a storytelling video
- BDD: specifying behaviour in the language of the business
- ATDD: the acceptance test as the definition of done
- All-in-one testing: one suite, many levels, no duplicated intent Includes a storytelling video
- Test doubles without lying: stubs, mocks, and what each one is for
- SRP and testability: why a painful test is a design report Includes a storytelling video
Read today: Test-first
- CoreComing soon
Contract-first
Making the boundary between two parts explicit enough that either side can change without asking permission — and checkable enough that a breach is a build failure rather than a discovery in production.
- Where does the boundary go? Contract-first as a design method Includes a storytelling video
- API-first: the interface is the deliverable Includes a storytelling video
- What belongs in a contract, and what is an implementation detail
- Consumer-driven contracts and the tests that come with them
- Versioning and deprecation without breaking the people downstream Includes a storytelling video
Read today: Contract-first
- AppliedComing soon
Patterns-oriented design
The pattern catalogue taught the way it is actually used: as a shared vocabulary for a problem you already have, not a shelf to shop from. Including when not to reach for one.
- GoF, thirty years on: which ones still earn their keep Includes a storytelling video
- Tactical DDD: value objects, entities and aggregates, and what each one is for
- Strategic DDD: subdomains, bounded contexts and the context map Includes a storytelling video
- Architecture patterns: layers, hexagons, and what the boundary is for
- Integration patterns and the fallacies of distributed computing
- Use case patterns: the shape of an application boundary
- Anti-patterns — the ones that look like patterns until year two Includes a storytelling video
Read today: Code design
- AppliedComing soon
Software craftsmanship
Questioning a line of code: its relevance, its purpose, its location, its testability, its durability. At scale, the same questions are what keep a design extensible and free of accumulated debt.
- Five questions to ask of any line of code Includes a storytelling video
- Naming, and why it is a design activity
- Refactoring in small safe steps, continuously
- Technical debt: the metaphor, its limits, and how to make it visible Includes a storytelling video
- Code review as a teaching practice rather than a gate
Read today: Code design
- AdvancedComing soon
Semi-automation and AI
Where the machine takes over: scaffolding, generation, retro-engineering, assisted design. AI is a booster for a practice that was already sound — it multiplies whatever discipline it finds.
- What to automate, and what to keep as a human conversation Includes a storytelling video
- Code scaffolding from patterns instead of from a blank file
- Assisted API design: the model drafts, the contract decides
- Retro-engineering an architecture model from a codebase Includes a storytelling video
- Reviewing generated code without rubber-stamping it
Read today: MCP
You do not have to wait
Every practice the first lessons will teach is already written down, and the fastest way to see how they fit together is to pick one team ritual and run it this week.