alt Hacker NewsLessons from 14 years at Google
Comments
I first learned about the "innovation tokens" idea in "Novelty is a loan you repay in outages, hiring, and cognitive overhead" from this, still one of my favorite essays on software architecture: https://boringtechnology.club/
Likewise, "Abstractions don’t remove complexity. They move it to the day you’re on call." made me think of this 23 year old classic from Joel Spolsky, the Law of Leaky Abstractions: https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-a...
15 years in leadership worked at 3 jobs lead major transformations at retail where nearly 100B of revenue goes through what i built. Ran $55-$100M in a yearly budget… over 300 FTEs and 3x contractors under my or my budget,…largest retailer in google at that time…my work influenced GCP roadmap, Datastax roadmap, … much more all behind the scenes…. besides your capabilities and ability that had to be there to get you in those positions - but once you are in those positions - only that mattered is politics and asskissing. I know so many people smarter than me, always stayed lower b/c they didn’t know how to play politics. Only reason i never got higher was I didn’t know how to play politics and kiss ass any more or any better.
The top people are all who kissed each others ass and looked out only for their cohort (e.g. people who were in same positions as them in early 2013). So teach your kids to kiss ass and play poltiics.
> 4. Clarity is seniority. Cleverness is overhead.
Clarity is likely the most important aspect of making maintainable, extendable code. Of course, it’s easy to say that, it’s harder to explain what it looks like in practice.
I wrote a book that attempts to teach how to write clear code: https://elementsofcode.io
> 11. Abstractions don’t remove complexity. They move it to the day you’re on call.
This is true for bad abstractions.
> The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise. (Dijkstra)
If you think about abstraction in those terms, the utility becomes apparent. We abstract CPU instructions into programming languages so we can think about our problems in more precise terms, such as data structures and functions.
It is obviously useful to build abstractions to create even higher levels of precision on top of the language itself.
The problem isn’t abstraction, it is clarity of purpose. Too often we create complex behavioral models before actually understanding the behavior we are trying to model. It’s like a civil engineer trying to build a bridge in a warehouse without examining the terrain where it must be placed. When it doesn’t fit correctly, we don’t blame the concept of bridges.
This first 3 hit me very hard,
1. The best engineers are obsessed with solving user problems.
I think this problem is rooted in early education: students learn languages, frameworks, and tools first without understanding what problems they actually solve. Once engineers have experience building a few products for users, they begin to understand what matters to the user.
2. Being right is cheap. Getting to right together is the real work.
- Sadly most of the arguments are won by either someone in power or experience. Right decisions are made with consensus. You build consensus during creative process and leverage power and experience during crisis.
3. Bias towards action. Ship. You can edit a bad page, but you can’t edit a blank one.
- Every decision is a risk management. The smart people convert higher risk into lower risk. Most people struggle here to take the risk because of the fear of failing and just waste time arguing, debating and winning over each other.
I’d agree on most of these but the biggest value in such a list is for the writer to actually put it on paper. You have to reflect on multiple aspects in your career and synthesise those. Reading them is close to useless, like scanning a page full of news, it all just evaporates once you start your daily work routine.
The best suggestion would probably be to try and write such a list yourself IMO.
feels LLM assisted, at the very least.
> The skill isn’t being right. It’s entering discussions to align on the problem
> clarity isn’t a style preference - it’s operational risk reduction
> The punchline isn’t “never innovate.” It’s “innovate only where you’re uniquely paid to innovate
> This isn’t strictly about self-promotion. It’s about making the value chain legible to everyone
> The problem isn’t that engineers can’t write code or use AI to do so. It’s that we’re so good at writing it that we forget to ask whether we should.
> This isn’t passive acceptance but it is strategic focus
> This isn’t just about being generous with knowledge. It’s a selfish learning hack
"Addy Osmani is a Software Engineer at Google working on Chrome and AI."
ah, got it.
They are pretty insightful. Particularly this one:
> 3. Bias towards action. Ship. You can edit a bad page, but you can’t edit a blank one.
I have my own version of this where I tell people that no amount of good advice can help you make a blank page look better. You need to have some published work before you can benefit from any advice.
>The engineer who truly understands the problem often finds that the elegant solution is simpler than anyone expected
This one is golden, it should be framed and put in every engineer's office.
>Your network outlasts every job you’ll ever have.
Networking is the real human currency, period.
> At scale, even your bugs have users
Also known as ossification. It is a term most often heard in the context of network protocols, but it applies more generally to every system where users depend on unspecified behaviors and even bugs.
Reading about HTTP/3 and QUIC is interesting in that aspect. I first didn't understand the insistance on encryption. Turns out it is not just security and privacy, but by encrypting everything that is not strictly necessary for proper transport, you make it impossible for any "middlebox" to make assumptions they shouldn't make.
I think similar approaches can be used by APIs. Never expose more than what is specified, treat the ability to access internal state as a bug, not because it is secret, but because if users start relying on it, internal changes that shouldn't break anything will.
Read it carefully.
He's not saying that these are all common values or practices at Google.
He's saying he learned those lessons while working at Google.
Despite the metaphor of a "lesson", a "lessons learned" post is almost never about something the author was explicitly told. It was something that you had to learn from experience, or at best from informal advice. Where you had to swim against the flow of your circumstances.
I neither think Osmani means to say that Google is _against_ these lessons. Every organization as big as Google has a lot of accumulated wisdom that will help you. These are just the things which remain hard, and some of which are even harder in a large organization.
Not looking to dismiss the authors long tenure at a major tech company like Google, but the first point kind of stuck like a sore thumb. If the Google culture was at all obsessed about helping users, I wonder why Google UX always sucked so much and in particularly in the recent years seem to be getting even worse. Every single one of their services is a pain to use, with unnecessary steps, clicks - basically everything you are trying to do needs a click of sorts. Recently I was writing an e-mail and noticed I misspelled the e-mail address of the recipient, which I rarely do. So, I should just be able to click the address and edit it quickly, right? Wrong - now you have a popup menu and inside of it you have to search for "edit e-mail" option. Most of the rest of his lessons while valuable in their own right, are not something I would put under the headline of "after X years at <insert-major-tech-company>", as they do not quite seem to be that different from lessons you pick up at other companies ? I´d more interested to hear about how the culture was impacted when the bean-counters took over and started entshittifying the company for both the users and the employees too.
> Abstractions don’t remove complexity. They move it to the day you’re on call.
As someone who has been on call a lot, this is only true for bad or incomplete abstractions.
When you are on call (or developing) you can't possibly know everything about the system. You need abstractions to make sense of what is going on, how the system as a whole works, and know which parts to hone in on when things go wrong.
And it is extremely useful to have standard ways of changing configuration for things like timeouts, buffer sizes, etc. in a central place.
> 1. The best engineers are obsessed with solving user problems.
The author lost me right here.
Not because he’s wrong about this in general - he is not. But it seems to not be any kind of differentiator at Google. Maybe the opposite is true- make it as screwed up as physically possible, then make it a little worse, then release it - that seems a lot closer to the lesson Google engineers learn. As long as you are “first” and shipped it.
Then get promoted, move on and meanwhile your crap code eventually gets the axe a decade later.
Every engineer should read this. It's a wonderful collection of heuristics that might seem banal, but which are shimmeringly true.
The two that stand out are
> Novelty is a loan you repay in outages, hiring, and cognitive overhead.
and
> Abstractions don’t remove complexity. They move it to the day you’re on call.
as a warning against about being too, too clever.
Your code is a strategy memo to strangers who will maintain it at 2am during an outage. Optimize for their comprehension, not your elegance. The senior engineers I respect most have learned to trade cleverness for clarity, every time.
YES! And sometimes that stranger is you, 6 months down the line.
I am going to file this line
> If you win every debate, you’re probably accumulating silent resistance.
Nothing novel, but all true, well expressed, and worth repeating. This should be part of every CS curriculum.
#2 and #14 are tough pills to swallow. It's not enough to be right, or even have a long track record of being right. You usually have to convince others that it was their idea all along, but still advocate for yourself at performance review time.
Seems reasonable. Many points maybe more applicable Google/Google-like companies. With layoffs and overall job shortages a lot of workplaces are having a cake and eating it too. They demand fast delivery and taking shortcuts (calling it creative thinking) and once things blow up directly due to shortcuts put blame on developers / testers for taking shortcuts and compromising quality in the process.
I clicked through to the bio and am super confused. Third person, extremely long, lots of pictures with CEOs and smelling of LLM writing.
Here's a sample:
> His story isn’t just about writing code, but about inspiring a community to strive for a better web. And perhaps the most exciting chapter is still being written, as he helps shape how AI and the web will intersect in the coming decade. Few individuals have done as much to push the web forward while uplifting its developers, and that legacy will be felt for a long time to come.
> 15. When a measure becomes a target, it stops measuring.
This is Goodhart's law - "When a measure becomes a target, it ceases to be a good measure" [1].
> The engineer who truly understands the problem often finds that the elegant solution is simpler than anyone expected.
> The engineer who starts with a solution tends to build complexity in search of a justification.
I do agree this is a good point, I just find it funny that it comes from "staying 14 years at Google".
This is literally the reason why I left Google first, and Meta second. Finding simple solutions will get you absolutely nowhere in a place like those. You have to find complex solutions with a lot of stakeholders, alignment, discussions, escalations... Why ship one button if you can ship 100 and get you, your team and your manager promoted in the process?
> First do it, then do it right, then do it better. Get the ugly prototype in front of users.
Great, give users something that messy, horrible and not fully functional. Customer who spend big for production environments are exploited to "be the outsourced QA"
> In large organizations, decisions get made in meetings you’re not invited to, using summaries you didn’t write, by people who have five minutes and twelve priorities. If no one can articulate your impact when you’re not in the room, your impact is effectively optional.
Very true in large organisations. But... in a company whose stated mission is to "organize the world's information and make it universally accessible and useful" ... this feels like a failure.
When a truly data driven company manages to quantify impact by more than the volume of hot air emitted :) then it's going to eat the world.
Perhaps it's for the best that nobody does that?
The quote "Sorry this letter is so long, I didn't have the time to write a shorter one" (Mark Twain, Blaise Pascal, lots of debate) sticks with me over the years. I appreciated the several points from Addy supporting this idea: when writing code has never been easier and faster, it takes even more time to make sure that the code being written is truly useful and necessary.
> If you win every debate, you’re probably accumulating silent resistance.
This is very true in personal lives as well.
> "Writing forces clarity. The fastest way to learn something better is to try teaching it."
Something that seems lost on those using LLMs to augment their textual output.
>Your job isn’t forever, but your network is.
I'm very suspicious of this working in the modern technological age. Even in university I'm feeling this: it is hard to create a bond with real friends, but extremely easy to regress to anonymity and become a loner.
> Addy Osmani is a Software Engineer at Google working on Chrome and AI
Thanks for all the spyware in Chrome ig? And for many inane design decisions that favor usability over privacy and security?
> 13. The work that makes other work possible is priceless - and invisible.
> Glue work - documentation, onboarding, cross-team coordination, process improvement - is vital. ... The trap is doing it as “helpfulness” rather than treating it as deliberate, bounded, visible impact. Timebox it. Rotate it. Turn it into artifacts ... make it legible as impact, not as personality trait.
I see my own experience in this, but I don't think he's identified the problem correctly. Timeboxing, rotating, etc, is easy. Convincing management that it is as important as non-glue work and therefore worth allocating your time for it is the hard part. And if you can't do that, you end up stuck in the situation described.
The other option is to just let things fail of course, but then you have to convince both management AND the rest of your team to do this, otherwise someone else will just pick it up between the cracks too.
What skills compound after 10+ years? (Ask HN: Submission)
I've come to realize that not all skills can stand the test of time.
Some things were very useful initially but quickly plateaued. Some felt like they were moving at a slow speed, but were quietly compounded a year after.
I always return to a rough outline.
Quickly acquainted with tools, frameworks, and specific stacks.
Slow skills: judgment, problem framing, communication, taste.
The gradual changes are often unnoticed daily but become apparent over time.
Projects become unclear.
Pile up constraints.
Being right is less important than the trade-offs you make.
I’d be interested to know what you think.
Which skills were more useful than you anticipated?
What’s something you over-invested in early on that didn’t compound?
What would you choose to learn more slowly if you had a second chance? ~
Clarity is seniority. Cleverness is overhead. - On a consulting project where the client was building a 5000 user plus application. They had an amazing architect, know all the best frameworks and had implemented that on the project. Issue is, only he understood the framework (even though it's documented on github) and it costed the developers more time to understand the framework than if the code was a little "dumber". Then he left for a better role for his career as he should. Because of that, the devs and new architects abandoned the framework and built new things around it and now the old framework is "tech debt".
Lots of good stuff here. Literally none of it required working at Google to learn.
Usually there are nuggets of wisdom in lists shared like this but I feel like every lesson shared here has immense value.
> "remain skeptical of your own certainty" > "Model curiosity, and you get a team that actually learns."
These are two lessons that typically require battle scars to learn. For such big ideas to be summed into two sentences is pretty remarkable and puts to words lessons I wish I knew how to share. Amazing article, thanks for sharing!
> Bias towards action. Ship. …The quest for perfection is paralyzing.
Unfortunately for users this is more often used as an excuse to ship buggy / badly done software.
> Before you build, exhaust the question: “What would happen if we just… didn’t?”
Well said! So many times I have seen great products slide down. If they just froze the features and UI, and just fixed performance, compatibility and stability issues for years, things would be better. (this applies to any company). Many programs I use are years old. They are great programs and don't need constant change! Updates can only make it worse at that point (minus critical security issues, compatbility, performance regressions)
This resonates a lot. The shift from "was I right?" to "does this actually help people?" changes everything. I've found that the engineers who got promoted fastest weren't always the smartest problem solvers, they were the ones who genuinely cared about the end outcome.
The hardest part is that user focus is sometimes at odds with technical cleanliness. You can ship something inelegant but useful, or elegant but slightly off from what people need. Most orgs mess this up by choosing elegance.
These all jibe with my 25 years of experience (only one at google though). I'll add:
* Don't work "off the clock", no matter how strong the urge: There's nothing managers hate more than surprises. Even good ones! If you've got some idea to work on, discuss it and get buy-in early. If you're spending a lot of your own time on something, that means it's probably low-value and you subconsciously know it, or it's stepping on somebody else's toes, or it's something that you're the only one who cares about. Once you're done, all your manager is going to say is "why were you doing that instead of <other higher priority thing>", and if it creates a bug or user complaint or anything else, you'll be on the hook. Save your creativity for personal projects.
* Get fast feedback. This kind of relates to the above, but more generally, iterate quickly at every scale. If testing your changes takes more than one button click and a couple seconds, whether compile time, staging deployment time, etc., fix it. Find out how others are automating their dev flows. A tiny bit of improvement here cascades greatly. Get fast feedback on designs: don't spend a ton of time writing a long doc and waiting for approval; send out a 1-paragraph summary or whatever you think the minimum is, get signoff, get done and move on. Do document, but don't overdo it. Get fast feedback on ideas; don't wait until code review time to find out that the team was planning a different direction. Yes, this does kind of suck if you're naturally introverted and prefer just coding, but it's part of the job.
* Set an extremely low bar for each day, but meet it. We aren't all superstars all the time. There'll be times when you're burnt out or blocked by something you really don't want to deal with, and making progress can seem overwhelming, so "I'll just surf the web for a while" turns into all day, which can turn into all week or all month of excuses about how little progress you're making, and the anxiety and guilt becomes more overwhelming than even the work. Avoid this by setting an easily achievable goal: a couple lines of code, a quick chat with someone who might know how to unblock one thing, whatever. That way you're not letting the anxiety build, you're not waking up the next day in the same state that you were the previous day, you at least have something to talk about during standup, and it's one less thing to deal with. Oftentimes it creates some momentum, and turns into a fully productive day! But be okay if it doesn't: the goal is just to get that one thing done, and anything else is purely optional: sometimes it's good to have an off day to recharge, so long as you're not starting the next day in the exact same position.
My favorite is the first one, "The best engineers are obsessed with solving user problems." and what I hate about it is that it is super hard to judge someone's skills about it without really working with him/her for a very long time. It is super easier said than done. And it is super hard to prove and sell when everybody is looking for easily assessable skills.
#3 hit hard. You can edit a bad page, but you can't edit a blank one. I've wasted weeks overthinking architecture for things I'd never built. Shipping something ugly and learning from real feedback taught me more than any amount of planning. Also #6 is underrated. Early on I thought good work speaks for itself. It doesn't. Took me years to realize decisions happen in rooms I'm not in. If no one can explain your impact when you're gone, it doesn't exist.
Thanks for sharing this.
14 years? Wild. I remember when Addy came into the scene hot with a new jQuery tutorial (what seemed like) every few days. To be clear, that's not a knock despite how it may read in 2026.
These lessons should be learned by every junior engineer and shared with every other engineer. I agree with the point, “Your network outlasts every job you’ll ever have,” that you mentioned. I literally know developers who aren’t actually good at what they do, but they always manage to find another job.
Your post is absolutely golden and it doesn't apply only at Google. I can't remember seeing so many deeply true statements together in one post. I'm sure many here will start to contest some of them but with enough experience they will also realize that the points were true.
This and the other top story on HN right now ( I charged $18k for a Static HTML Page) [0] make it clear the the most important thing as a software developer is jumping through hoops and being agreeable. It does not matter if it makes sense to you. I’ve come to accept that I can’t always predict what is actually valuable for the business and should just go with the flow and take their money. The leetcode-style interview selects for this by presenting as an arbitrary hoop you have to jump through.
Number 14 really speaks towards the subtle difference between being domineering in conversation and genuinely a sme in an area with little overlap in other people's domain knowledge. I feel like being extremely transparent in explaining the rationale and to a degree teaching really reinforces that boundary.
If you get to a point of silent resentment 'debt' in spite of efforts to empathise, consider perspective, and provide clarity, then you have a collaboration problem on the other end. How you choose to address that is dependent on your political capital, and sometimes you need to accept it.
Young me naively believed people were like rational automatons who would speak up when appropriate, not take thinga personal, and aspire to the true north that I aspired to as a colleague, and that is no baseline for a healthy collaboration.
Aren't #2 and #14 mostly the same point? And they seem to indicate a rather unhealthy cultural dynamic. Amazon's "Disagree and commit" is a much healthier dynamic than "Pretend to agree and then silently sabotage."
I think there's a valid middle ground in finding a path that works well for everybody, but this does not seem to be the right way.
I wonder if this is a common thing at Google because I recall another interview (can't find now, I think in the context of WebRTC??) from many years ago where an engineer proudly described how he conspired against a major technical decision because it didn't align with his personal preferences. I was a bit shocked to see someone admit something like that so publicly.
I think part of the importance of being a senior engineer is not spreading hype through the industry. This appears to be the guy who just posted all over social media that they just got Claude and redid a year long project in a week, followed by tweets from his eng team clarifying its just “demo” grade.
Lesson 11 (Abstractions move complexity) and Lesson 20 (Time > Money) are two sides of the same coin. In engineering, we talk about "leaky abstractions" in our code. But the biggest leaky abstraction is often our own health. We treat our bodies as a "boring dependency" that will always work, but burnout and RSI (Repetitive Strain Injury) are essentially the ultimate system outages. Just as "Novelty is a loan" (Lesson 5), neglecting your physical "hardware" early in your career is a high-interest loan that you end up repaying in your 40s. Real seniority isn't just about navigating people and politics—it's about managing your personal energy so you actually have the health to enjoy the "compounding" (Lesson 21) that comes at the end.
There are many big bosses under the Google CEO that lead hordes of developers to specific targets-to-meet. Eventually they prioritise their bonuses and the individual goals deviate with every iteration. So the quality will diminish continuously.
> At scale, even your bugs have users.
First place I worked right out of college had a big training seminar for new hires. One day we were told the story of how they’d improved load times from around 5min to 30seconds, this improvement was in the mid 90s. The negative responses from clients were instant. The load time improvements had destroyed their company culture. Instead of everyone coming into the office, turning on their computers, and spending the next 10min chatting and drinking coffee the software was ready before they’d even stood up from their desk!
The moral of the story, and the quote, isn’t that you shouldn’t improve things. Instead it’s a reminder that the software you’re building doesn’t exist in a PRD or a test suite. It’s a system that people will interact with out there in the world. Habits with form, workarounds will be developed, bugs will be leaned for actual use cases.
This makes it critically important that you, the software engineer, understand the purpose and real world usage of your software. Your job isn’t to complete tickets that fulfill a list of asks from your product manager. Your job is to build software that solves users problems.