The items below are lines from eleven blog posts Sean Goedecke wrote about engineering careers, shipping, system design and working with AI. — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.

Visual summary of operating lessons from Sean Goedecke.
Infographic for "Lessons from Sean Goedecke".

On Career Strategy & "Dangerous Advice"

  1. On Fake Career Advice: In “Dangerous advice for software engineers,” Goedecke wrote: "Most career advice is fake: written to avoid liability, or to impress people". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  2. On Dangerous Advice: In “Dangerous advice for software engineers,” Goedecke wrote: "Strong engineers crave dangerous advice, for the same reason they crave sharp tools". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  3. On Dangerous Advice as a Sharp Tool: In “Dangerous advice for software engineers,” Goedecke wrote: "Dangerous advice is dangerous because (like sharp tools) it takes competence and judgment to use well". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  4. On Doing What Is Obviously Helpful: In “Dangerous advice for software engineers,” Goedecke wrote: "If you’re serious about getting things done, you’ll end up doing some of these things because they’re obviously helpful". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  5. On Managers and Dangerous Advice: In “Dangerous advice for software engineers,” Goedecke wrote: "Managers will almost never give you dangerous advice, even if it’s what you need to hear". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  6. On Honest Peers: In “Dangerous advice for software engineers,” Goedecke wrote: "I really appreciated the few peers I had who were willing to get real with me". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  7. On High Risk and High Reward: In “Dangerous advice for software engineers,” Goedecke wrote: "It’s very high-risk, high-reward, and is thus disproportionately useful to strong engineers (and harmful to weaker ones)". — Sean Goedecke, “Dangerous advice for software engineers”, seangoedecke.com.
  8. On Crushing Tickets: In “Thinking clearly about software,” Goedecke wrote: "Crushing JIRA tickets is a party trick, not a path to impact". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.

On Office Politics & Power

  1. On Rule-Breaking Being Rewarded: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "In fact, rule-breaking is systematically rewarded at large tech companies, and for good reason". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  2. On Rewarded Rule-Breakers: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "At every large tech company, some engineers get rewarded for visibly breaking the rules". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  3. On Being Blamed: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "If the results are bad, you will be blamed — even if you weren’t really at fault". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  4. On Plausible Deniability: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "Don’t expect your manager to help you decide; plausible deniability is part of the system". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  5. On Estimating Consequences: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "You should therefore only break rules when you’re very confident about your ability to estimate the consequences". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  6. On When to Break Rules: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "Break rules when the risk is low, the payoff is high, and your judgment is solid". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  7. On Rules and Judgment: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "Rules exist to constrain engineers with bad judgment, not to bind the ones with good judgment". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  8. On What Managers Like: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "Managers like competent engineers who are willing to break the rules, because it lets them enjoy the upside of rule-breaking while removing liability". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.
  9. On Who Rules Are For: In “How strong engineers break the rules and get away with it,” Goedecke wrote: "are written for the engineers with the worst judgement, to prevent them doing obviously harmful things". — Sean Goedecke, “How strong engineers break the rules and get away with it”, seangoedecke.com.

On Engineering & Shipping

  1. On the Job of Shipping: In “How to ship,” Goedecke wrote: "They ship because someone takes up the difficult and delicate job of shipping them". — Sean Goedecke, “How to ship”, seangoedecke.com.
  2. On Not Shipping in Spare Time: In “How to ship,” Goedecke wrote: "It is too hard a job to do in your spare time". — Sean Goedecke, “How to ship”, seangoedecke.com.
  3. On What Shipping Means: In “How to ship,” Goedecke wrote: "many engineers do not understand what shipping even is inside a large tech company". — Sean Goedecke, “How to ship”, seangoedecke.com.
  4. On Happy Leadership: In “How to ship,” Goedecke wrote: "If you ship something users hate and makes no money, but your leadership team is happy". — Sean Goedecke, “How to ship”, seangoedecke.com.
  5. On Failed Ships: In “How to ship,” Goedecke wrote: "Engineers who think shipping means delivering a spec or deploying code will repeatedly engineer their way into failed ships". — Sean Goedecke, “How to ship”, seangoedecke.com.
  6. On Celebrating Launches: In “How to ship,” Goedecke wrote: "an un-celebrated launch is not a ship". — Sean Goedecke, “How to ship”, seangoedecke.com.
  7. On UX Obsession: In “How to ship,” Goedecke wrote: "Obsessing over UX is praiseworthy behaviour when you are an engineer on the team, but a blunder if you are leading the project". — Sean Goedecke, “How to ship”, seangoedecke.com.
  8. On Trust From Leadership: In “How to ship,” Goedecke wrote: "You need your leadership team to trust you in order to ship". — Sean Goedecke, “How to ship”, seangoedecke.com.
  9. On Staying Light on Your Feet: In “How to ship,” Goedecke wrote: "You need to stay light on your feet so that when these issues come up you’re not neck-deep in other work". — Sean Goedecke, “How to ship”, seangoedecke.com.
  10. On Time Free From Implementation: In “How to ship,” Goedecke wrote: "Ideally you should have at least 20% of your time free from implementation in the early stages of the project, scaling up to 90-100% in the final days". — Sean Goedecke, “How to ship”, seangoedecke.com.
  11. On Deploying Early: In “How to ship,” Goedecke wrote: "you need to deploy as much as you can as early as possible, and you need to do the scariest changes as early as you can possibly do them". — Sean Goedecke, “How to ship”, seangoedecke.com.
  12. On Getting Eyes on It: In “How to ship,” Goedecke wrote: "The key thing is to get whatever you’re building in front of as many eyes as possible". — Sean Goedecke, “How to ship”, seangoedecke.com.
  13. On Fallback Plans: In “How to ship,” Goedecke wrote: "Nothing builds trust like having fallback plans, because in case of emergency fallback plans indicate control over the situation". — Sean Goedecke, “How to ship”, seangoedecke.com.

On System & API Design

  1. On Self-Effacing Design: In “Everything I know about good system design,” Goedecke wrote: "Paradoxically, good design is self-effacing: bad design is often more impressive than good". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  2. On Impressive-Looking Systems: In “Everything I know about good system design,” Goedecke wrote: "always suspicious of impressive-looking systems". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  3. On Boring Components: In “Everything I know about good system design,” Goedecke wrote: "good system design is not about clever tricks, it’s about knowing how to use boring, well-tested components in the right place". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  4. On State: In “Everything I know about good system design,” Goedecke wrote: "Since managing state is the most important part of system design, the most important component is usually where that state lives: the database". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  5. On Complex Systems: In “Everything I know about good system design,” Goedecke wrote: "A complex system usually reflects an absence of good design". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  6. On Good Design Feeling Easy: In “Everything I know about good system design,” Goedecke wrote: "You can tell that you’re in the presence of good design if you have thoughts like “huh, this ended up being easier than I expected”". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  7. On Failing Closed: In “Everything I know about good system design,” Goedecke wrote: "auth should (obviously) always fail closed: it’s better to deny a user access to their own data than to give a user access to some other user’s data". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  8. On Blind Retries: In “Everything I know about good system design,” Goedecke wrote: "You need to make sure you’re not putting extra load on other services by blindly retrying failed requests". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  9. On Direct Requests Between Services: In “Everything I know about good system design,” Goedecke wrote: "Much of the time it’s better to just have one service make an API request to another service: all the logs are in the same place, it’s easier to reason about, and you can immediately see what the other service responded with". — Sean Goedecke, “Everything I know about good system design”, seangoedecke.com.
  10. On Boring APIs: In “Everything I know about good API design,” Goedecke wrote: "Good APIs are boring". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  11. On a Sacred Duty: In “Everything I know about good API design,” Goedecke wrote: "you have something like a sacred duty to avoid harming your downstream consumers". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  12. On Great APIs and Unwanted Products: In “Everything I know about good API design,” Goedecke wrote: "A technically-great API can't save a product that nobody wants to use". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  13. On Changing APIs for Neatness: In “Everything I know about good API design,” Goedecke wrote: "You should never make a change to an API just because it'd be neater". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  14. On API Versioning: In “Everything I know about good API design,” Goedecke wrote: "you should only use API versioning as a last resort". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  15. On Valuable Products: In “Everything I know about good API design,” Goedecke wrote: "If your product is valuable enough, users will flock to even a terrible API". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.
  16. On Idempotency Keys: In “Everything I know about good API design,” Goedecke wrote: "Requests that take action (particularly high-stakes action like payments) should include some kind of idempotency key to make retries safe". — Sean Goedecke, “Everything I know about good API design”, seangoedecke.com.

On "Legibility" & Organizational Theory

  1. On Illegible Work: In “Seeing like a software company,” Goedecke wrote: "dependent on a huge amount of “illegible” work: work that cannot be tracked or planned for, but is nonetheless essential". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  2. On Making Work Legible: In “Seeing like a software company,” Goedecke wrote: "Quarterly planning, OKRs, and Jira all exist to make work legible". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  3. On Explaining Large Companies: In “Seeing like a software company,” Goedecke wrote: "Thinking in terms of legibility and illegibility explains so many of the things that are confusing about large software companies". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  4. On Pressure to Be Legible: In “Seeing like a software company,” Goedecke wrote: "This puts real pressure on growing tech companies to become more legible, even if it hurts their ability to deliver software". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  5. On Fit and Productivity: In “Seeing like a software company,” Goedecke wrote: "Engineers have different skillsets and interests, and will work much more productively on projects that are a good fit for them". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  6. On Estimating in Parts: In “Seeing like a software company,” Goedecke wrote: "breaking down a project into parts and estimating each part often delivers a less accurate estimate, because it makes it harder for engineers to align with the overall ship date". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  7. On Rehearsed Questions: In “Seeing like a software company,” Goedecke wrote: "Often when a question is asked formally in a public space, it’s already been rehearsed and workshopped privately with the person who’s answering the question". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  8. On Reputation and Backchannels: In “Seeing like a software company,” Goedecke wrote: "If you’re a well-liked engineer, your ability to pull on these backchannels is significantly greater than if you’re brand-new or have a bad reputation". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  9. On the Value of Legibility: In “Seeing like a software company,” Goedecke wrote: "People who are invested in legibility have real value to any tech company". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.
  10. On the Illusion of Legibility: In “Seeing like a software company,” Goedecke wrote: "most legibility “improvements” are not actually increasing legibility, but are only creating the illusion of legibility". — Sean Goedecke, “Seeing like a software company”, seangoedecke.com.

General Wisdom

  1. On Expertise as Invariants: In “Thinking clearly about software,” Goedecke wrote: "expertise in software is the mastery of invariants: beliefs about how software works that are true 99.99% of the time". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  2. On Frantic Trial and Error: In “Thinking clearly about software,” Goedecke wrote: "The opposite of thinking clearly is frantically trying different things until the problem goes away". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  3. On Predicting Before Acting: In “Thinking clearly about software,” Goedecke wrote: "you should never take an action (e.g. running a test or interacting with your program) without predicting what will happen and why". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  4. On Specific Predictions: In “Thinking clearly about software,” Goedecke wrote: "Don’t predict “I should get an error here”, predict the specific type of error". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  1. On Buggy Programs: In “Thinking clearly about software,” Goedecke wrote: "a buggy program always reflects a lack of understanding, and a lack of understanding always causes failed predictions about how the software should behave". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  2. On Sitting in Uncertainty: In “Thinking clearly about software,” Goedecke wrote: "My suggestion is to try and work with people who are happy to sit in uncertainty for a while". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  3. On Learning Systematically: In “Thinking clearly about software,” Goedecke wrote: "If you can, it’s better to learn systematically". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  4. On Clear Thinking and Learning: In “Thinking clearly about software,” Goedecke wrote: "Thinking clearly increases the rate at which you can learn". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.
  5. On Writing Down Clear Thoughts: In “Thinking clearly about software,” Goedecke wrote: "There are few higher-leverage things you can do in an organization than writing down clear thoughts about your work". — Sean Goedecke, “Thinking clearly about software”, seangoedecke.com.

On AI & The Future of Coding

  1. On Expertise With LLMs: In “LLMs reward expertise,” Goedecke wrote: "you can say “no, I think it could be simpler here”, or “but don’t we already do X?”, or “can we express this problem in these familiar terms?”". — Sean Goedecke, “LLMs reward expertise”, seangoedecke.com.
  2. On Communicating to the Model: In “LLMs reward expertise,” Goedecke wrote: "the difficult part is in communicating to the model exactly what kind of solution the human wants". — Sean Goedecke, “LLMs reward expertise”, seangoedecke.com.
  3. On Working Memory: In “Elegance and intelligence are anticorrelated,” Goedecke wrote: "For software engineers, the most important kind of raw intelligence is often the size of your working memory: how many moving pieces you can hold in your head at a given time". — Sean Goedecke, “Elegance and intelligence are anticorrelated”, seangoedecke.com.
  4. On Brute-Forcing Problems: In “Elegance and intelligence are anticorrelated,” Goedecke wrote: "Intelligent people sometimes produce inelegant solutions because they’re capable of rapidly brute-forcing problems". — Sean Goedecke, “Elegance and intelligence are anticorrelated”, seangoedecke.com.
  5. On Relative Stupidity: In “Elegance and intelligence are anticorrelated,” Goedecke wrote: "it’s interesting to consider that our relative stupidity might be one of them". — Sean Goedecke, “Elegance and intelligence are anticorrelated”, seangoedecke.com.
  6. On Requirements You Don’t Have: In “What requirements don’t you have?,” Goedecke wrote: "When designing software, the requirements you don’t have are as important as the requirements you do". — Sean Goedecke, “What requirements don’t you have?”, seangoedecke.com.
  7. On Coding Agents and Requirements: In “What requirements don’t you have?,” Goedecke wrote: "Knowing what requirements you don’t have becomes far more important when working with coding agents". — Sean Goedecke, “What requirements don’t you have?”, seangoedecke.com.

Specific Technical Opinions

  1. On I/O and Language Speed: In “Software is slow because of bad design, not slow languages,” Goedecke wrote: "Software performance is usually dominated by I/O, not the speed of the language". — Sean Goedecke, “Software is slow because of bad design, not slow languages”, seangoedecke.com.
  2. On Slower Than Necessary: In “Software is slow because of bad design, not slow languages,” Goedecke wrote: "most software is far slower than it could be". — Sean Goedecke, “Software is slow because of bad design, not slow languages”, seangoedecke.com.
  3. On Natural Fast Designs: In “Software is slow because of bad design, not slow languages,” Goedecke wrote: "in some languages, fast designs are more natural than slow designs". — Sean Goedecke, “Software is slow because of bad design, not slow languages”, seangoedecke.com.
  4. On Compromise: In “What requirements don’t you have?,” Goedecke wrote: "Identifying what you can compromise on — what can be slow, or stale, or inflexible — is usually the key to an elegant design". — Sean Goedecke, “What requirements don’t you have?”, seangoedecke.com.
  5. On Empirical Questions: In “Software is slow because of bad design, not slow languages,” Goedecke wrote: "This is an empirical question, and my position on it comes from my experience staring at thousands of Ruby flamegraphs". — Sean Goedecke, “Software is slow because of bad design, not slow languages”, seangoedecke.com.