ub-mode

Every time you are asked to make a change follow:

• First Make it Work.
• Then Make it Right.
• Follow Practice

First Make it Work

Laziness Protocol

• One decision lives in one place.
• Ship the smallest edit that solves the problem.

Foundational Thinking

• Get the data shape right before you write the logic.
• Do first whatever helps every later phase.
• If a concurrent writer would matter, do not share state.

TDD

• Write the failing test before you change the code.
• See it fail for the reason you expect.
• Make the smallest change that makes it pass.
• If an honest test is impractical, do not write a bad one.

Redesign From First Principles

• Do not bolt a new requirement onto the old design.
• Ask what you would have built if it had been there from the start, think that through, and deliver it in pieces.

Attack the Premise

• When two fixes that share one premise fail the same gate, write that premise in one sentence and count which actors hold the imbalance.
• Remove the assignment.
• Do not start another fix until you have done that.

Subtract Before You Add

• Take complexity out before you add anything.

Outcome-Oriented Execution

• Aim at the end state you can check.
• A break in the middle is allowed when you planned it and can undo it.

Build the Lever

• If the work is not obvious at a glance, build the tool that does it.
• Do one unit by hand, then make the tool match that unit.

Architecture

Model the Domain

• Put the domain in a structure that makes the illegal states impossible.
• Maintain a glossary of domain terms.
• If the code is already clear and local, leave it.

Boundary Discipline

• Check the data where it enters.
• Inside, trust it.
• Keep the business logic in a pure function.

Type System Discipline

• Make the illegal value impossible to write.
• Parse outside data once, where it comes in.
• Do not silence the compiler.

Make Operations Idempotent

• Running it twice, or running it after a crash halfway through, ends in the same state.

Separate Before Serializing Shared State

• If they do not need the same mutable thing, give each its own.
• If they do, allow one writer, and enforce that in the structure.

Then Make it Right

Fix Root Causes

• Reproduce it.
• Fix the cause.
• A guard that only hides the crash is not a fix.

Sequence work into verifiable units

• Finish one small unit and check it.
• Then start the next.

Test Behavior, Not Implementation

• The test calls the code the way its user does and checks the result that user would see.
• If the test would still pass when every function returned nothing, throw it out.

Crapper

• Use the crapper tool
• Reduce each function under CRAP 10 by splitting it, by testing it, or both.
• Consider whether case statements are worth reducing.

Dryer

• Use the dryer tool to eliminate duplication that rank 0.8 or above.

Mutator

• Use the mutator tool
• Cover the uncovered.
• Kill the survivors.
• Delete dead code.

Refactoring

• Pin what the code does.
• Change the structure.
• Prove the behavior did not change.

Practice

Keep a Log

• Keep a log of every action you take and the reason you took it.
• Report that log upon completion.

Guard the Context Window

• Keep the main thread small.
• Send the bulk elsewhere, and keep the summary.

Worktree Cleanup

• Find what is safe to remove, confirm nothing still in use needs it, then reclaim the disk.
• Uncommitted work waits for a decision.

Commit and Push

• Commit often, in small ordered commits.
• Each commit says why, what changed, and how you proved it.
• Push to the main line at the end.