v1.1.139 standards · plain markdown · MIT

How your team builds software, written down once.

Opinionated conventions, architecture decisions, processes, and checklists — battle-tested and version-controlled. Every project reads it first. No reinventing the wheel, no tribal knowledge.

paste into your project's CLAUDE.md

or, at the start of any AI session

I.The Six Principles

Boring on purpose.

Everything in the playbook exists to protect these six rules. Get them right and the surprises stay in the product — not in the pipeline, not in the merge, not in onboarding.

  1. I

    Every change has an issue.

    No ad-hoc work. Track everything. The board is the single source of truth for what is in flight, why, and who owns it.

    process/issues.md

  2. II

    Every issue has a branch.

    Never push to main directly. Branch names carry the issue number, so six months from now the history still explains itself.

    process/branching.md

  3. III

    Every branch has a PR.

    Even solo. The pull request is your audit trail, your review surface, and the place where CI gets the final word.

    process/pull-requests.md

  4. IV

    CI passes before merge.

    No exceptions. Lint, test, build, scan — green or it does not ship. Tests are not optional, and red main is an incident.

    process/ci-cd.md

  5. V

    Commits stay atomic.

    One concern per commit. Conventional Commits make the changelog write itself and turn every revert into a one-liner.

    process/commits.md

  6. VI

    Simplicity over cleverness.

    Make it work, make it right, then make it fast — in that order. The next person to read this code is you, with less context.

    conventions/naming.md

“No ad-hoc work. No surprises in main.” — the two rules everything else protects.

II.Before / After

Same team. Different rules.

The scenario: a mid-size team ships the same feature, on the same deadline.

Without a playbook

Ad-hoc

Everyone means well, but nothing is written down…

  • Someone pushes straight to main on a Friday afternoon
  • The commit log reads “fix”, “fix2”, “actually fix this time”
  • No issue, no context — nobody remembers why it was built
  • The one person who understands it is on holiday
  • Onboarding a new dev takes three weeks of “ask around”

With the playbook

Disciplined

Same people, but the standards do the remembering…

  • Every change traces back to an issue and a pull request
  • Conventional commits — the changelog writes itself
  • CI gates the merge: lint, test, build, scan, every time
  • Decisions captured as ADRs, not lost in a Slack thread
  • New hires ship on day one from the onboarding checklist

Same people · same deadline · different discipline

III.The Numbers

The playbook, by the digits.

Every page is plain markdown. Read it in a sitting, adopt what fits, fork what you disagree with.

0
Conventions
naming · API · testing · a11y · i18n
0
Processes
branching · PR · CI/CD · incidents
0
Architecture
database · multi-tenancy · security
0
Checklists
setup · onboarding · release · audit
0
Templates
issue · PR · CLAUDE.md starter
0
Lock-in
MIT · plain markdown · fork it
V.Why Write It Down

Why not just a wiki page?

A wiki works fine until it goes stale and nobody trusts it. A playbook in Git wins on version control, PR-reviewed changes, AI-readable markdown, and living next to your code. It is unapologetically opinionated — that is the feature, not the bug. Disagree? Fork it and make it yours.

“Every new project reads this repo first and follows these standards. No reinventing the wheel.”

Read the introduction

One repo. Every standard.

BranchingCommitsPull RequestsCode ReviewCI/CDIncidentsTestingLoggingObservabilitySecurityDatabaseMulti-tenancyPerformanceAccessibilityi18nDockerBranchingCommitsPull RequestsCode ReviewCI/CDIncidentsTestingLoggingObservabilitySecurityDatabaseMulti-tenancyPerformanceAccessibilityi18nDocker

From the first branch to the post-mortem — the whole lifecycle, process/ and conventions/, in one place.

Start here.

Point your next project at the playbook. The standards do the remembering — you do the shipping.

paste into your project's CLAUDE.md

or, just clone it