27,688 karma · joined September 4, 2008
Now: HotelTonight / Airbnb
Web generalist with a product focus and wearer of many hats.
https://mubi.com/users/2
https://github.com/gtd
http://websaviour.com/
https://twitter.com/dasil003
[ my public key: https://keybase.io/gtd; my proof: https://keybase.io/gtd/sigs/LLH-bIciQfUgvlVI7-Xe0LaEIEZxOSA0zHYbjhCYiXU ]
Of course they aren’t liquid yet, but they’re still RSUs, and it’s much more common than OpenAIs profit shares structure
The uncomfortable truth is that "the right thing" depends a lot on the point of view and narrative at hand. In large organizations political capital is inherently limited, even in very senior positions. It's especially challenging in large scale software development because ground-level expertise really is needed to determine "the right thing", but human communication inherently has limits. I would say most people, and especially most software engineers, have strong opinions about how things "should" be, but if they were put in charge they would quickly realize that when they describe that a hundred person org they would get a hundred different interpretations. It's hard to grok the difficulty of alignment of smart, independent thinkers at scale. When goals and roles are clear (like Apollo), that's easy mode for organizational politics. When you're building arbitrary software for humans each with their own needs and perspective, it's infinitely harder. That's what leads to saccharine corporate comms, tone deaf leaders, and the "moral mazes" Robert Jackall described 30+ years ago.
(Obviously this advice can easily go horribly wrong in the hands of incompetent leadership, context matters, etc)
If you have a system that is big enough and has had enough change over time that it's structure is no longer well suited to the current or near future job-to-be-done, then it doesn't really matter how you got there, you need to explain to non-technical stakeholders that current business requests will take longer than it would intuitively take to build if you just look at the delta of the UX that exists today compared to what they want (ie. the "why can't you just..." conversation). This is a situation where the phrase "technical debt" is a useful metaphor that has crossed the chasm to non-technical business leaders, and can be useful (when used judiciously of course).
It actually undermines the usefulness of the metaphor if you try to pedantically uphold the distinction that tech debt is always intentional, because non-technical stakeholders will wonder why engineering would intentionally put us in this situation. I understand we all get to have our techie pet peeves (hacker != black hat), but this is really not a semantic battle I would fight if I'm dealing with anyone non-technical.
Of course Netflix is saying all the right things now to keep anti-trust off their backs, but at some which culture do you think is going to win out?
The reason I wrote what I wrote is because I came into the industry in the year 2000, and multiple times throughout my career experienced a rug pull of my own mental model of my value as a software engineer. It's very painful and something that I think ICs in deep-thinking professions like software are very vulnerable to.
All that said, to be charitable, I think what the author meant to express is that you don't want to make yourself a bottleneck as a manager, which is a common failure mode for newly converted IC to junior manager. Where he goes off the rails in the most tone-deaf way is describing that as "not doing useful work". As a manager your work is constantly observing what people are doing, staying the hell out of the way when things are working, and leaning in when things are not going well from a team and outcomes perspective. Doing that well is incredibly challenging and important work.
I will say though, that there is still a good amount of naivete in the reasoning presented. The bottom line is that these generalizations and rationalizations are based on a single vary large company and implicitly dependent on the viewpoint and priorities of a bunch of VPs and executives whose mental model may or may not align with how you see the world in the infra trenches. Now Google is an engineering-driven culture, so the author is probably not too far off, but it also represents a particular time and place. Google has enjoyed one of the strongest and most profitable market positions that was cemented years before he entered the work force, and so there's a level of comfort and sheltered existence that infra teams at most companies do not enjoy. Make hay during the good times, but always be aware leaderships attitudes and priorities can change very quickly due to market or investor pressure, and at that point you need to be ready to adapt and articulate your value in a new environment of greater scrutiny, or to a new company (in the case of layoffs).
Basically human junior engineers start by writing code in a very procedural and literal style with duplicate logic all over the place because that's the first step in adapting human intelligence to learning how to program. Then the programmer realizes this leads to things becoming unmaintainable and so they start to learn the abstraction techniques of functions, etc. An LLM doesn't have to learn any of that, because they already know all languages and mechanical technique in their corpus, so this beginning journey never applies.
But what the junior programmer has that the LLM doesn't, is an innate common sense understanding of human goals that are driving the creation of the code to begin with, and that serves them through their entire progression from junior to senior. As you point out, code can be "too DRY", but why? Senior engineers understand that DRYing up code is not a style issue, its more about maintainability and understanding what is likely to change, and what will be the apparent effects to human stakeholders who depend on the software. Basically do these things map to things that are conceptually the same for human users and are unlikely to diverge in the future. This is also a surprisingly deep question as perhaps every human stakeholder will swear up and down they are the same, but nevertheless 6 months from now a problem arises that requires them to diverge. At this point there is now a cognitive overhead and dissonance of explaining that divergence of the users who were heretofore perfectly satisfied with one domain concept.
Ultimately the value function for success of a specific code factoring style depends on a lot of implicit context and assumptions that are baked into the heads of various stakeholders for the specific use case and can change based on myriad outside factors that are not visible to an LLM. Senior engineers understand the map is not the territory, for LLMs there is no territory.
Diversity of tech companies is an important consideration for me, one that definitely outweighs one-time issues, especially in a field where credible competition is limited.
But here's the thing: the hard part of programming was never really syntax, it was about having the clarity of thought and conceptual precision to build a system that normal humans find useful despite the fact they will never have the patience to understand let alone debug failures. Modern AI tools are just the next step to abstracting away syntax as a gatekeeper function, but the need for precise systemic thinking is as glaringly necessary as ever.
I won't say AI will never get there—it already surpasses human programmers in many of the mechanical and rote knowledge of programing language arcana—but it it still is orders of magnitude away from being able to produce a useful system when specified by someone who does not think like a programmer. Perhaps it will get there. But I think the barrier at that point will be the age old human need to have a throat to choke when things go sideways. Those in power know how to control and manipulate humans through well-understood incentives, and this applies all the way to the highest levels of leadership. No matter how smart or competent AI is, you can't just drop it into those scenarios. Business leaders can't replace human accountability with an SLA from OpenAI, it just doesn't work. Never say never I suppose, but I'd be willing to bet the wheels come off modern civilization long before the skillset of senior software engineers becomes obsolete.
I agree looking at the quality of life of the poorest is a valuable barometer for the quality and success of a society to serve all its people. Similarly I think looking at the richest and what checks exist on their power also says a lot about the health of a civilization. It also makes perfect sense to me that we would look at wealth distributions as well. After all comparison and competition is core to the human experience, is entirely relative, and more visible than ever in the age of the internet and social media. These dynamics massively impact individual perceptions of success and political priorities, fairness being a deeply baked value in the human wetware (just ask any 5-year-old), so not sure why we wouldn't want to address them directly. Certainly there's more value than in the superficial tribalism and dog whistle culture that passes for political discourse today?