Developer tooling
Project Starter Kit
project-base
Nineteen mistakes, written down once, so they cost you once.
A ready-made starting point for new software, which arrives with nineteen past mistakes already written down and blocked, so nobody on the team makes them a second time.
Where it runsNowhere, on purpose. It is the folder a new project is started from. Its checks run on the developer's machine, and again automatically before new code is accepted.
Who is this for?
Teams that rediscover the same bug in a new project every year, and the client who paid for it three times.
What the numbers mean
Each one cost somebody a week once. It costs the next project nothing.
Who does what is decided before the work starts, not argued about during it.
The handover is written before there is anything to hand over.
How it actually works
Every new project starts empty and relearns the same lessons in the same order, and each lesson costs about a week.
This one starts with them already inside it. Nineteen defects that really happened are written down, each as what broke, why it broke, and the check that now stops it.
The checks are the important half. A rule written in a document is a rule nobody follows by month three. So every lesson here is wired to something that runs on its own and fails loudly: a check that fires the moment code is saved, and another that turns the whole project red before it can be shipped.
Twenty eight of its fifty two files are writing rather than code, and that ratio is deliberate. What makes a project survive its second engineer is almost never the code.
Before you have written a line, the empty base has to pass its own checks. If the foundation does not verify, nothing built on top of it can claim to.
It is why the second, third and fourth project cost less than the first instead of costing the same.
We build things like this. Tell us what you are stuck on.
What it is built with
- Python
- Make
- pre-commit
- GitHub Actions