Chapter 02 · 8 principles

Delivery

Continuous flow replaces sprint ceremonies and batch releases.

Four task tiles on one track, ending in an arrow to a single green pill labelled Production.
Working in production is done.

No plan survives contact with development. The question isn't how to prevent change — it's how to absorb it without losing momentum.

Continuous Flow Over Sprints

Weekly billing creates the payment rhythm. Not sprints. This is Kanban: work flows continuously from a priority queue. It comes in, gets ranked, gets executed, gets deployed. No velocity tracking. No burn-down charts. No planning poker.

The only question that matters: what's most important right now?

For meaningful phases — major features, big rewrites — think in 6-week cycles. Long enough to ship something end-to-end valuable. Short enough to stay honest. But these aren't fixed time-boxes with commitments baked in at the start.

WIP Limit of 1

One task at a time. Finish it. Deploy it. Then move on.

Starting something new? Stop the current task first. This forces honest prioritization and kills context switching. It prevents the trap of being "90% done on five things" while nothing is actually working. The client sees consistent forward motion. The developer stays focused.

Production Is Done

Code review isn't done. QA passed isn't done. Merged isn't done. Working in production is done.

This changes how the developer thinks about deployment. If deploying is hard, it gets avoided. If it's easy, it happens constantly. Feature flags handle incomplete work — deploy behind the flag, keep building, flip it when it's ready. The main branch stays production-ready. Always.

Scout Rule

Leave code better than it was found. That's the entire refactoring strategy.

No scheduled debt sprints. No percentage allocation. Just improve what gets touched. With a solo developer and consistent patterns, technical debt stays manageable without ever making it a project.

Communication While Delivering

Regular updates go out after each work session — not at end of day, but when the work is actually done. Meetings happen only for decisions that genuinely need real-time discussion. Everything else is written.

This keeps calendars empty and focus time protected. Communication overhead stays near zero.

What's Ahead

Eight principles govern how delivery works in practice — from the overall flow of work, through the constraints that keep it honest, to how quality is maintained, how progress gets communicated, and the tools used to ship.

  1. Continuous Flow

    Start here
    Kanban over sprints — a priority queue, not fixed time boxes.
  2. WIP One

    One thing in progress at a time — finish it, deploy it, move on.
  3. Production Is Done

    Work is only done when it's live in production.
  4. Feature Flags

    Flags decouple deployment from release — ship safely, release when ready.
  5. Scout Rule

    The codebase gets better with every change — no separate refactoring projects.
  6. Async Updates

    Progress is communicated asynchronously, not in meetings.
  7. Quality Gates

    Safe to fail, fast to fix.
  8. Default Stack

    Deep expertise in familiar tools beats starting fresh each time.