Rough Work

Hard-won perspective on senior software engineering.

introduction

1.
Who wrote this? Why?
I have no CS degree. I learned by shipping software, not memorizing algorithms. This is an attempt to validate the messy way most of us actually work.

1.
When You Don't Know the Answer
How to navigate ambiguity without waiting for certainty.
2.
When Best Practices Fail
The most important skill isn't solving the problem. It's recognizing which kind of problem you have.
3.
Fear Complexity
Why the best engineers choose boring on purpose.
4.
Chesterton's Fence
Why you should never delete 'ugly' code until you understand why it's there.
5.
Deliberate Ignorance
Why being a specialist means being comfortably ignorant of most things.
6.
The Feynman Method
The ultimate test of whether you actually understand your code.
7.
The OODA Loop
Why speed of decision making is your best defense against chaos.
8.
The Rules of Debugging
Finding your way out of the 'this shouldn't be happening' panic.

1.
Software is a Liability
Why more code doesn't always mean more value.
2.
Cohesion vs. Coupling
The two forces that shape every codebase.
3.
Destructive Decoupling
When loosely coupled code becomes incoherent code.
4.
Naming Things
Why names are the most important architecture decisions you'll make.
5.
Clarity at the Point of Use
Designing code that's meant to be read, not just written.
6.
Clarity Over Brevity
Why smart one-liners are actually technical debt.
7.
The Trap of the Wrong Abstraction
Why duplication is often cheaper than a hasty extraction.
8.
Wait for the Pattern
Why patience is the most underrated refactoring tool.
9.
The Customer Illusion
Why one model for everything usually means a model for nothing.
10.
The Active Record Bargain
Speed now, complexity later.
11.
The Application is the Center
Why the database is just a plugin, not the foundation.
12.
The Repository Pattern
Decoupling your business logic from your storage details.
13.
Wrappers Are Design Tools
Protecting your domain logic from external jargon.

1.
The Manager of One
Why the most valuable skill you can have is not needing a boss.
2.
The Trust Battery
The invisible currency that powers every team.
3.
Writing Solidifies, Chat Dissolves
Why deep work requires a move away from the 'instant' message.
4.
The Myth of the 10x Engineer
Why the most valuable engineers are often the ones writing the least code.
5.
You Are "The Glue"
Why senior engineering is about enabling others to ship.
6.
Hiring Multipliers
What to look for when you're building a team, not filling a seat.
7.
Which Archetype Are You?
Choosing your path post-senior.
8.
Burnout is Not a Badge of Honor
Why the 'grind' culture is a fast track to mediocrity.

1.
The Job to Be Done
Why building faster isn't the same as building better.
2.
Outcomes, Not Syntax
Why business value is the only language that matters for your career.
3.
Hyrum's Law
Why your private implementation is never actually private.
4.
Bets, Not Backlogs
Why the graveyard of 'future ideas' is killing your productivity.
5.
The Hill Chart
Recognizing the difference between 'figuring it out' and 'getting it done'.
6.
The Only Scalable Fix is Migration
Why piecemeal refactoring never actually pays off the debt.

1.
The Test Pyramid
Why expensive tests keep you from shipping.
2.
Arrange, Act, Assert
Turning your tests into a clear story.
3.
The Third User
Why testing implementation details is a trap.
4.
Don't Mock What You Don't Own
A simple rule for more resilient tests.
5.
Mocking at the Boundaries
Finding the balance between speed and reality.
6.
Test Against the Real Thing
Why your test database and production database should be the same one.
7.
The Expand and Contract Pattern
How to change a database without stopping the world.
8.
Escape Output, Don't Sanitize Input
The right way to handle untrusted data.
9.
Blameless Post-Mortems
Why you can't fire your way to a reliable system.