We're in the context engineering stone age. You the engineer shouldn't be trying to curate context, you should be building context optimization/curation engines. You shouldn't be passing agents context like messages, they should share a single knowledge store with the parent, and the context optimizer should just optimally pack their context for the task description.
Unlike PG's half-baked founder mode essay, this article is more complete in describing what behaviors are successful during scaling. It also matches my experience when Netflix was scaling up the streaming business in the 2010-2016 era.
> how do good leaders stay in the detail and run great companies at scale?
It's a relevant question not just for founders but for leaders at every level.
IMO, one test for a "good leader" is whether they are capable of doing the work 1 to 2 levels down into their teams. The more familiarity they have, the more they are able to hire, fire, and evaluate those people. After all, it's pretty hard to evaluate work in an unfamiliar domain. Paradoxically, though, good leaders do not contribute to that work directly. So how do they maintain their skills if they don't do the work?
Consider the case of a front-line engineering manager with IC engineer reports. A good one will know their team's codebase, know where it could be easily extended and have good intuition for the time required for any given feature idea. They know the difference between good and bad code. But they NEVER submit PRs, mostly because the maker schedule/manager schedule problem [1] forces a choice of doing only one type of work well. (Every new manager I've seen who wants to "spend 10-30% of their time writing code" will either fail to support that code or fail to support their team as a manager, when in a fast growing team or company.)
The solution for eng. managers is to have the codebase on their machine, be able to build and run it, and occasionally implement their own experiments or POCs. These things NEVER go to production. It's meant purely to maintain the manager's familiarity with the codebase and staying current with their team's output. (Hat tip to CW).
Note that we still don't have good labels for these behaviors. "Hands on" and "hands off" confuses the issue-- is the example above "hands on" or "hands off?" It's both and neither, because those aren't useful labels.
There are other solutions for leaders higher up the org chart. The article mentions skip level 1:1s and niche area deep dives both with the purpose of evaluating leadership effectiveness. When I did these, I'd always start with setting the same context: I have two goals for this meeting and one non-goal. I want to hear about what you're working on, what's going well and where the challenges are. I also want to answer any questions you have about what's going on elsewhere in the company. My non-goal is giving you specific direction, since that's always between you and your manager. I'm just here to gather and share information.
The role of a leader is to set goals, share context and ensure the right team is in place, hiring and firing as needed. They need to know what's going on from top to bottom in the teams they lead, and in order to hire effectively, they need to be capable of doing the work 1-2 levels below them. But they never actually contribute 1-2 levels down, because that would severely undermine the people they've delegated to.
I think this is why so many had a knee-jerk reaction to in PG's founder mode essay, where he implied that founders have a special ability to bypass management layers and contribute directly (in the Steve Jobs example). I've seen it happen, and it failed 100% of the time. 100%. After establishing some amount of managerial structure -- wild guess would be after 50+ total employees -- contributing directly several layers down into your team is a recipe for disaster. The puzzle is how to lead effectively without making that mistake.
[1] maker schedule/manager schedule https://www.paulgraham.com/makersschedule.html
* Bonus behavior: good managers are sensitive to booking meetings with any of their team members who are on the maker schedule.
I’m not extremely productive, but I have 2 use-cases I’m excited about.
1. Having more screen real estate in my small home office. I often dive into spaghetti code, and seeing more of it helps me maintain context.
2. Working in my RV. I can’t take my extra screens with me (it’s a multi-use family RV, so I’m not mounting anything. Plus, there isn’t room.), and I’m so, so excited about having more screen real estate in there. We lived/worked in it for 3 months last summer, and it was really nice coming home to more screens at the end of the trip.
In a context where I'm working on a few languages regularly and among a larger set of languages that coworkers are in charge of, I can see how Ruby has solved a ton of problems that other languages are still struggling with.
- package management: bundler/rubygems has been a sa-holved problem for the longest time whereas npm/yarn is an unholy mess, python is only beginning to see the light after refusing for so long, go mod is kind of a step in the right direction but still falls short in others, cargo is an outright copy but tries too hard to also be rake, a distinct problem making it a kintchensink... Gemfiles being descriptive, one can generate lockfiles from their platform including information for a foreign one and it's going to resolve consistently, including corner cases like this gem has a transitive dependency on a ruby extension and this platform has a binary gem at that version but that platform can build from source at that other version so I'm going to pick the one that's consistent and respects the constraints that have been described, or bail out and yell at you. This makes using semver-like squiggly a breeze and a non-event.
- build tools: scons, cmake, ninja, doit & al. feel both incredibly complex and limited compared to rake. Every single time build files end up becoming obscure behemoths. When they don't they're incredibly focused on one thing but to make them to anything else they become a hodgepodge of additional external scripts and have to rely on so many tricks and hacks, which is why I used to stick to make. People seem to also have forgotten that rake can perfectly replace make as well, but rake can do so much more and still present a consistent interface and task implementation.
- testing: minitest/test, minitest/spec, spec are running circles around any other test framework. The composability of reusable contexts, nested cases, and shared examples allows one to cover a ton of behaviours with very little test code that is eminently descriptive. Just the other day I did a deep reflector of some part of the code, and I only had to change a bunch of helpers as to how things should operate, and the entirety of my functional test suite was literally a zero-line diff.
- talking to browsers: capybara is still my go-to to automate browsers, whether in tests or not, headless or not. It's just way too easy.
- linting: Rubocop has a metric ton of tunable checks to enforce your preferred style and optionally auto fixes a lot of violations, standardrb takes a tab from gofmt by giving you some sane community defaults for Rubocop and thus autoformats by default. Rubocop is easily extensible, either you pull things and can lint rakefiles, Rails, spec and whatnot, or if you have special cases you can write your own cops.
- typing and LSP: forget Sorbet, RBS+Steep is the way. RBS can generate typed skeletons either statically or dynamically using typeprof; ideally if you have good coverage you could run tests using typeprof and have automatic typing generation that can then be used entirely statically. Then the `rbs` command then allows you to statically ask a ton of questions about types but it's not a linter by itself, that's where Steep comes in. Steep comes with a LSP and it Just Works: autocompletion, inline type information, and so on. Type signatures can be packaged within gems, but if they're not there's rbs_collection, which also integrates with bundler.
So I'm not too sure what you're referring to as "tooling" that would be primitive when compared to other languages when in my mind it's the other languages that constantly play catch-up ;)
> You also get that intangible "separation" of your work life from your home life that your commute used to give you--hard to explain. A brief walk outside to and from the office allows me to reset into work-mode or home-mode.
A lifehack that I learned here on HN when I was working from home was to actually leave the door, then walk right back in and work. If I needed to do any housework, I would again leave through the door, and return "home".
This reduced all temptations to mix work and home life. It also made it clear to the other people in the house that daddy is now serious, and that even just a simple "hi, how are you" would require me to get up, leave, and return to answer. And then leave and return to go back to work. The social friction was important.
Likewise with chip software tooling; despite it being standard to outsource tooling to large EDA vendors, we got a lot of mileage out using our own custom tools, generally created or maintained by one person, e.g., while I was there, most simulator cycles were run on a custom simulator that was maintained by one person, which saved millions a year in simulator costs (standard pricing for a simulator at the time was a few thousand dollars per license per year and we had a farm of about a thousand simulation machines). You might think that, if a single person can create or maintain a tool that's worth millions of dollars a year to the company, our competitors would do the same thing, just like you might think that if you can ship faster and at a lower cost by hiring a person who knows how to crack a wafer open, our competitors would do that, but they mostly didn't.
"Do Thinks That Don't Scale" is probably the absolute heart of my (bootstrapped, two-founder) company. Off the top of my head, we:
* Manually create pre-configured accounts for potential customers, sometimes with up to an hour of entering in their existing data so things look familiar right from first login.
* Investigate problems and repair live data, usually just by logging in as a user and using the tools in the product. Can they do this themselves? Sure. Do they appreciate our doing it instead? Oh, hell yes.
* Have screen-sharing calls where we walk customers through the process of linking our product with third parties (e.g. OAuth pairing with Square so they can process payments).
* Call customers who are want help or advice with _other parts of their business_ that aren't related to our product, but about which we know something. Don't know what you should put in your vendor contracts or what % you should charge for sales commissions? Give us a call; we'll help you out.
...plus probably dozens more that aren't fresh on my mind. We work flat-out to onboard every single customer, no matter how small, because word-of-mouth is our only growth channel and delivering a surprisingly human onboarding/support experience is the best way I know to generate great referrals. It doesn't scale, but it's also probably our main growth driver.
It'll work until it doesn't, I guess, but so far doing things that don't scale is how we scale.
That’s my second favorite YouTube video. I love how it reveals some universal primitives are really complicated. The pattern in the video is as fundamental to the universe as circles are. Imagine how many other mind-boggling structures are ubiquitous but just outside our understanding.
From my perspective, as a relatively early adopter of Waymo (60+ rides). I have zero gripes with the driving itself. In fact I've seen Waymos do things that no human would be able to do*. Drop-offs and pickups I'd like to see improvements made like getting a bit closer to the curb. Occasionally the route selections make no sense at all.
* Waymo made a right turn up a steep hill. Two lanes each way. It then pulled a bit into the left lane abruptly and I didn't get why until a split second later a skateboarder was crouched down and went by on my right against traffic. There was zero chance a human would pull that off. Not enough time for a head check or mirror check. There wouldn't have been an accident but the Waymo clearly has insane reaction time and vision advantages - and uses them.
* Our go-to-market was contingency recruiting; we'd get paid for placements. Our CTF and HN calling cards easily got us added to the recruiting funnels of big tech companies (I'm assuming any of you could have done that too; I'm just saying, we never had to cold call). But it didn't change anything about how those companies qualified candidates, so to make that business successful we'd have had to do the same dialing-for-dollars matchmaking work any recruiter does, with comparable results.
* We took things very personally. You build relationships with your earliest users (candidates, in our case). Recruiting funnels at our clients had no such connection. The impedance mismatch was demoralizing; our lived experience was that every time a candidate we presented to a client got rejected, we had ourselves failed (I mean, really, we had!). Similarly, the idea that we were just another hoop that candidates had to hop through (but only the non-name-brand candidates who didn't know how to skip us to get an interview at a client) grated on us.
* A lot of second-system-syndrome on the implementation side; we'd done successful recruiting CTFs before, and set what was in retrospect a completely bizarre goal of outdoing ourselves at that job. That mistake is all me.
* Japan/Chicago remote founding team was very difficult, most especially for Patrick. There are teams that could handle that, but their members are more punctual about routine meetings than I am. Both the US and the Japan side felt checked out to each other. This didn't kill us; other things did, and we could have pushed through this problem. But it made things miserable for everyone. Again: this is all me.
* Erin & I were self-funding the company, which was expensive (just in terms of paying everybody's personal bills). Towards the end, it had become clear that we weren't going to drive 3 FTE worth of revenue on contingency placements in the next 12 months. We could have switched up the business model, driven user growth metrics, and gone out for seed funding, but none of us at that point were convicted enough of the business to stake our reputations on that. For all 3 of us, our time was worth too much. I think we made the right call.
It's been almost a decade since we did this, and those years haven't been especially kind to recruiting startups. There are knobs we could have turned to keep things chugging, and probably chugging comfortably, for many more years. But ultimately, I don't think there were any significant rewards to win by building a tech-company-specific recruiting firm. I think the company was ultimately fated to wind down sooner or later. If you're in that situation, sooner is always the better option! Life is short!
The underlying idea behind Starfighter, about the right way (or, at least, a right-er way) to hire people, has proven out repeatedly since then. We hired resume-blind and with work-sample challenges at Latacora, the next company me and Erin started, and we hire resume-blind and with work-sample challenges at Fly.io. Recruiting this way is a competitive advantage. The degree of advantage varies with the market; when the market is weak you can hire good people with terrible processes. But the advantage is never marginal, because bad hires are expensive, and there's so much hidden talent out there.
"Last Tuesday I got a call from a national magazine ... What he wasn't interested in is a list of science fiction predictions which just aren't going to happen. Except in rare moods, neither am I. ..."
You'll be building the right thing from the start. Selling will be easier too since confidence in the team is just as important as the product. Onboarding will be easier too. Support will be easier too. Heck, everything is easier.
Other advice:
*DO NOT HIRE A PROFESSIONAL PRODUCT MANAGER*
Instead, provide product management training to that customer you hired. You'll avoid playing the telphone game. Your devs will be closer to the customer this way.
The best RVing advice I was given was to not buy an RV and buy a pull trailer instead which somewhat correlates to the TFA's "bigger is not always better". RVs get horrible gas mileage, and are not easy to drive around. This is why you see a lot of RVs pulling trailers with a smaller car on it. The trailer route allows you to drop off the trailer and then use the pulling vehicle separately. I'm sure it's confirmation bias, but people I know that have RVs use them less than the people I know that have trailers.
This post basically argues you can be a successful feature factory if you’re driving feature prioritisation with data… but when you’re small, you can often get away with it because eg. You’re feature cloning a competitor.
It’s sad to see this seriously proposed, because it shows a deep lack of understanding.
Features are never the problem.
You can have a million features and be working on a million more and be perfectly ok, if those features do not impose constraints.
Constraints are the problem.
When you add a feature, well engineered or not, you probably add some constraints to your system.
As time passes, the effort to maintain all the existing constraints scales with the constraint count.
The difference between a feature factory and good engineering is that good engineering means when you implement a feature, you minimise the set of constraints it adds.
There is no amount of data and thoughtful prioritisation that can save you if you don’t put effort into understanding and maintaining your constraints, and if you don’t understand your constraints, you can’t thoughtfully discard some of them when you need to.
When you’re small, the set of constraints you have is small, so solving the N constraint problem is easy.
As you scale up, the problem becomes harder.
You can have a big product, but if you don’t understand the difference between features and constraints, you’re doomed to one of those “why aren’t we agile any more” conversations.
Feature factories aren’t bad because they’re fast. They aren’t bad because of a focus on shipping or iterating and pivoting… they’re bad because they slap on constraint after another onto a system until you can’t breathe without something breaking.
> It did make me very hesistant and perfectionist in future projects and took out a certain amount of faith that 'it will work out'.
But that's because you still cared about others. And maybe didn't read enough startup/entrepreneur books or know enough people who did that. Once you know what crap companies willingly release which go on to be successful, it will make you far less perfectionist.
I had the luck of having a few family members in computing in the 70s when I was born, so I heard early on about Allen debugging/fixing the basic interpreter he wrote on a PDP for a processor he didn't have access to at the time on the plane for one of the most important meetings of Microsoft at the time. The absolute and total garbage Oracle released for many years when they started. etc. And those are old stories, but this happens all the time; a lot of products that are launched by big or small companies are so full of bugs that I wonder sometimes if anyone bothered to try them.
I simply stopped caring about perfection as it drove me insane and no-one cares anyway. Even, in line with this article, even if I make something ONLY for myself, I rather just finish it and then change it over time then try to get it in a 'perfect state' from the start. It doesn't make me happy as perfection is not really something that's easy to define; especially in software, it is so incredibly hard to get to anything better than 'ok', that striving for perfection (Dijkstra like) will drive you completely bonkers and nothing ever gets released.
The 1985 edition "includes e.g. case studies (useful!), and an extended discussion of Jung's theories of intuition and how they should influence your designs (!!)"
"In most people's vocabularies, design means veneer. It's interior decorating. It's the fabric of the curtains of the sofa. But to me, nothing could be further from the meaning of design. Design is the fundamental soul of a human-made creation that ends up expressing itself in successive outer layers of the product or service."
Design is not just one thing or another. It happens at each layer. From deciding how many options you want to present to the user, to how they will be presented. Or deciding how to deal with errors in the backend, versus reporting them in the front end. Design decisions are made the whole way through.
I think this is visible with lots of Apple products because some people complain that they aren’t flexible enough. But reducing configurability is as much a design decision as the colour of the icons. (And sometimes more challenging)
When we got engaged I put the money I would have spent on a ring towards buying a farm (as someone said in a thread on news.yc "oh, you're The Farm Guy!").
My wife thanks me almost literally every day for the farm. I don't think she'd appreciate a diamond ring nearly as much.
When it came time to actually get married I dropped around $2 or $2.5k on gold casting grain, carving wax, a small burn out kiln, a crucible, etc., and made wax blanks for our rings on my Sherline lathe, then cast them in gold using the burn out kiln and my blacksmithing forge.
Meanwhile, she sewed her own dress from scratch.
After the small church ceremony we had everyone back to our house for BLTs and tomato soup, using home made bacon and home made bread, etc.
Our complete wedding cost maybe $3,000 or $3,500 and the cost was dominated by the burn out kiln and the gold.
The good news is that the kiln and accessories still get used: a few weeks ago she carved a belt buckle from wax and I cast it in bronze.
My advice: eschew consumerism. A DIY lifestyle is a lot more fun.
[ edit ]
here's a pix of my first practice rings in silver, and then one of the rough cast gold rings before cleanup.
https://goo.gl/photos/tdLEjxQipMS2ZtQh8
