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.