I think the tech world has a problem

A bold take these days, I know.

I recently graduated with a computer science degree, and the state of the job market is starting to get under my skin. Let me vent for a second.

Every week brings a new LLM, coding model, or agent system promising to relieve us lethargic meatbags of our hobbies and careers. The benchmarks go up, the context windows get bigger, and another chunk of the software development process gets handed over to an increasingly capable autocomplete box. At least, that seems to be what all the companies think.

Look, I'm not anti-AI. I certainly use these tools, and sometimes they're startlingly useful. Pretending they aren't changing software development would be stupid. Still, the timing sure stings. Software is getting cheaper to produce while getting paid to produce it seems harder. Naturally, this happened right after I finished my degree :)

Five years and tens of thousands of dollars later, the advice for breaking into the field increasingly seems to boil down to doing more software development for free.

Conventional employment no longer feels like the safe, boring alternative. Constant layoffs, hiring freezes, and return-to-office mandates have made the usual career path look much less certain than it did when I started university. Increasingly, it feels like the exciting alternative is to just go build something yourself and hope you can hit it big.

Find a problem, start a company, ship a product, raise some money. Maybe you'll become one of those suspiciously productive people on Twitter who announces a new company on Monday and somehow has 100k users by the end of the week.

Simple.

Well, except for the fact that starting a company requires having something worth building, the time to build it, and enough runway to survive while you figure out whether anyone actually wants it. None of those things are particularly easy to come by.

To be clear, I know that breaking through as a tech startup was never easy. Now, however, an enormous amount of software already exists, and a thoughtful new product has to compete with a flood of wrappers, clones, generated landing pages, and AI-generated slop.

You don't just have to build something good, you have to build something good enough for somebody to notice. That's always involved luck, and probably more than we'd like to admit.

Tech seems like one of those fields where a huge part of succeeding is simply working as hard as you reasonably can to increase your surface area for luck: build things, publish them, write about them, meet people, contribute somewhere, send the application, make the stupid little tool you wish existed, and hope one of those things eventually collides with the right person at the right time. The trouble is that increasing your surface area for luck takes time.

This brings me to open source.

I'm not going to say that "only rich people can accomplish anything in open source." That just isn't really true. However, there's one problem I do think we have to acknowledge:

Open source makes software free. It does not make the labour required to produce software free.

I think people often gloss over that distinction. The romantic picture of open source is a group of hackers scratching their own itches and building software no company would have planned or invested the time into. That still happens; Git, Linux, FFmpeg, Neovim, and countless other weird little tools prove the idea is not bullshit.

Still, there's an uncomfortable economic prerequisite hiding underneath it: Someone has to be able to afford the time.

Six unpaid months may be a rational bet if you have tons of savings, sponsorship, a job that pays you to work on open source, or an audience that turns the project into content.

But if you're in my shoes, or the shoes of thousands like me, as a nearly broke new grad trying to land a first SWE job, those same six months are six months without any income.

I have to acknowledge that in the grand scheme of things I do not have it that bad. I'm fortunate to have a family who will always support me, and to live in the greatest country on earth with little to worry about day to day. Still, I'd rather not spend the next five years mowing fields while waiting for someone to decide I'm finally qualified enough to centre a div.

There is a nasty feedback loop here. People with money, a reputation, industry connections, or an audience can afford to make those ambitious projects. Think of the Mitchell Hashimotos, DHHs, and Primeagens of the world.

I'm not here to hate on them. I enjoy their work to varying degrees, and will fully acknowledge that they largely built their own success. But building ambitious things is a feedback loop that gives them even more reputation, connections, investment opportunities, and money, which makes the next ambitious thing even easier to build.

Nearly every tech influencer today had a stable career for a while before branching off to do their own thing. They accumulated experience, money, connections, credibility, or an audience first. In other words, they had already given luck many chances to find them.

Meanwhile, someone trying to acquire those same safety nets in the first place gets told something like: "just contribute to open source! Build something cool! People will notice and the success will follow from there!"

Great, sounds good. But... with what fucking time?

I wake up at 4:30 to cut grass, try to keep a few hobbies alive, and grind on personal projects in the few hours left over. Personal growth is nice, for whatever it's worth, but it can feel like the effort returns nothing concrete. Maybe this is just what it means to grow up?

Either way, that's where I think the usual advice to new grads starts to feel a little absurd, or at least outdated. Open source was never supposed to be an unpaid internship programme for an industry that stopped wanting to train its own juniors.

The current junior software market has an uglier contradiction:

The industry increasingly expects beginners to demonstrate the output of experienced engineers, before giving them the opportunity to become experienced engineers.

Companies used to turn inexperienced programmers into experienced ones by hiring them. Sometimes they even hired juniors just to keep them away from a competitor, whether or not those juniors were even competent.

A CS degree isn't enough anymore, so you need to build side projects.
Side projects aren't enough on their own, they need real users.
Oh, but good luck getting users when you don't already have a platform to reach them.
While you're at it, teach yourself all the essential things that your school didn't: distributed systems, cloud infrastructure, CI/CD, containers, security, databases, frontend design, and AI tooling.
Then, contribute to somebody else's software for free so you can prove that you know how to work on "real" software, too.

All of that for the privilege of being considered for a Junior Software Engineer position.

That's the part that bothers me more than any LLM benchmark. AI might change how many programmers the industry needs, and it will almost certainly change what those programmers spend their time doing. Nobody really knows where that settles yet. Right now, though, companies seem reluctant to absorb the cost of turning juniors into experienced seniors, especially since the mentorship part is debatably less important these days. Things are moving too fast for that, so instead the juniors are paying that cost themselves. Get the degree, learn the tools, build the portfolio, find users, contribute to open source, and somehow cover rent while doing it.

Open source starts looking less like a community and more like an entrance fee, and the fee is a lot of your time. Time that only gets more precious once you start losing out on all the perks of being eligible for the reserved "new grad" positions. Good luck kid, now you're in the same pool as everyone else who actually knows what they're doing.

Reality check: is that really true, though?

Meaningful open-source work certainly doesn't require building the next Docker or eventually turning it into a YC-backed company (even though this is basically a requirement if you ever want to be "successful"). One person building a genuinely useful 4k-line CLI can make a real impact. So can someone fixing an irritating compiler bug, maintaining a Neovim plugin used by thousands of people, writing an unusually-good library, or contributing consistently to one established project.

Small-scale open source is probably where the original premise still works best, if you ask me. You don't need capital to build a good terminal utility. You do need it to turn that utility into a company that scales and employs a dozen engineers.

Those two things get conflated because tech culture mostly celebrates projects once they become full-fledged businesses. Someone quietly maintaining an excellent library used by 40k developers doesn't usually get their own TechCrunch write-up. Someone raises $18 million to put an AI chatbot in front of PostgreSQL, and suddenly they're a visionary founder.

That selection effect makes open source look far more plutocratic than the ecosystem actually is (or at least should be).

Plenty of important maintainers are not wealthy, which creates the opposite failure. Critical infrastructure depends on one exhausted person after work, fielding GitHub issues from billion-dollar corporations asking when they'll fix a bug. That is the contradiction at the centre of this.

Open source is supposed to democratize access to software. Anyone can use it, anyone can study it, anyone can change it, anyone can contribute. But serious contributions require access to the one resource that open source can't democratize:

Free time.

The same constraint applies to nearly every alternative we're told exists when the normal career path isn't working.

Can't find a job? Build out a better portfolio. Portfolio isn't enough? Contribute to open source. Open source isn't getting you noticed? Build your own product. Product isn't getting traction? Start a company. That company isn't getting traction? Build another, surely the new one will.

Every step gives luck another chance. The problem is that it also demands more time from the people who usually have the least of it to spare.

The software is free. The developer's rent is not.

That's enough yapping. Redox is going through a large rewrite. I will write another devlog when it is done. It has, once again, been too long since the last one.