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.
the mindset
- 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.
the craft
- 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.
the team
- 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.
the business
- 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.
the guardrails
- 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.