The Developer Hiring Market is Broken

I've been watching the software hiring process deteriorate for over a decade. I thank my lucky stars that I have a good network and reputation, so I don’t have to deal with the nonsense many candidates are facing today.

Don’t get me wrong, job searching sucked back in the day, too, but what was already broken has become genuinely dysfunctional. Companies struggle to identify talent, buried in a sea of AI spam resumes and fake candidates. Meanwhile, the lucky few who make it into interviews face what amounts to technical hazing rituals. (I’m looking at you, leetcode)

But that’s not the root cause. The root cause is that…

The traditional gatekeepers have failed us completely

The perceived value of college credentials has been dropping for years. In fact, a decade ago, Lazlo Bock of Google told a room of executives that there was no relationship between where employees went to school and how those people actually performed in their jobs. [1]

In my own experience, I’ve found it more likely that a college computer science graduate can’t write a for loop than that they ace an interview. Now we have HR departments and ATS systems that screen resumes for keywords while overlooking actual capabilities. We have recruiting firms extracting massive fees without adding any real value because, frankly, they struggle with the same intake and assessment issues everyone else has. They can’t evaluate the very thing they’re selling.

Now AI has made everything worse. Resume spam floods hiring pipelines with synthetic garbage. Interview tools that were already questionable become completely useless when candidates can have ChatGPT solve LeetCode problems in real time. The signal-to-noise ratio in technical hiring has collapsed.

Do we have hiring processes or Geneva violations?

The current system punishes everyone

Candidates hate the process for obvious reasons. Let’s see, we have excessive interview rounds that stretch for weeks or months. Then there’s the unpaid take-home coding tests. (Seriously, who the f- wants to do free coding tests for dozens of potential employers?) And then there's LeetCode, which is pure trivia masquerading as a technical assessment. Being able to optimize a binary search tree has zero correlation with shipping reliable software.

Imagine if juniors spent more time building skills with actual value instead of spending all their time “grinding leetcode”? The risk and cost of onboarding them would be much lower.

I was talking to an experienced developer the other day, and I pointed out that I rarely encounter a company that trains its engineers on how to conduct a proper interview. He couldn’t think of any either. That’s pretty messed up and will be the topic of a future post.

My first successful business was in the coding bootcamp space. I remember telling people at the time that “if colleges were doing their jobs well, my business wouldn’t exist.” The fact that I could train and mentor people for 12 weeks, and they outperformed new graduates, was a shock to my employer partners.

And then, the P/E firms came in and turned the bootcamp space into a cheap degree mill. But that’s a story for another day.

On the employer side, they waste expensive engineer time on ineffective interviews that loosely predict job performance. They're overwhelmed with the number of unqualified candidates applying, exacerbated by AI resume spam. Most importantly, they're missing out on the "hidden network" of talent, which consists of experienced developers who have secure jobs and strong networks and simply won't jump through these hoops.

In a way, we already have an informal guild system. Senior engineers at established companies recognize each other's work and vouch for quality. The referral networks that drive most real hiring decisions are proof that this approach works. But it's exclusive, opaque, and leaves too many people outside looking in.

If we had a viable credentialing system, most of these issues would disappear. So here's the BHAG (Big Hairy Audacious Goal): let's move to a proper guild system.

What a Guild System Could Look Like

It’s no coincidence that I called my first business The Software Craftsmanship Guild. As an entrepreneur, I’m used to my peers talking about disruption, but not really being disruptive. But we need to burn the whole thing down and replace it with something that actually works.

Imagine a professional guild for software developers, similar to what exists in medicine or law. Rigorous certification processes administered by practicing professionals. Clear pathways for advancement and specialization. Real accountability for the people doing the certifying.

Here are some things I’d want to build into the system:

A Tiered Certification Structure

One of the major problems with entry-level hiring is that existing credentials have little correlation with the ability to perform on the job. And, frankly, it’s nearly impossible to simulate an enterprise environment in the classroom. There are just too many tools, languages, and frameworks, both modern and legacy, that are often held together by the digital equivalent of duct tape.

This makes hiring juniors risky. It takes months, even for seasoned professionals, to hit their stride in a new environment. It only takes a few bad hires at the junior level before companies write them off and choose the strategy of poaching proven talent from their neighbors as their primary recruitment strategy.

Junior certification should focus on fundamentals that don't change: debugging logic, abstraction, testing, design principles, and maintainable code practices. These skills transfer whether you're working in Python, Go, or whatever front-end framework the JavaScript developers move to next year.

From there, more experienced professionals could upskill into areas of specialization in specific languages, tools, and more advanced topics, such as infrastructure, performance, security, and architecture.

Panel-Based Examinations

There are so many problems with assessment. As an industry, we’ve been forced to overcorrect on the interview process because of the failure of the gatekeepers. Candidates spend excessive amounts of time and resources preparing for interviews. Imagine if, instead of spending 6-12 months mastering LeetCode to the point where medium and hard problems are consistently solvable in a stressful interview situation, candidates were able to… I don’t know… learn things they will actually use on the job?

The technical interview process is painful. It’s inconsistent because each company has its own standards. Additionally, most engineers who serve as interviewers have not received proper training in conducting effective interviews. It also unfairly punishes people who can do the work but fail the ATS check. And what about people who have test anxiety? It’s difficult enough to get interviews, and when they have such high stakes, you end up with what we have today: resume padding, AI-assisted interview tools, and fake degrees and job history.

Imagine credentials that have meaning. Imagine if someone had a Java Spring Boot developer certification, and it meant they could do the work. Companies would be free to interview for fit.

It’s possible. What it takes is a trusted assessment body. Guild systems did this for hundreds of years. Yes, it would be expensive and time-consuming. But once granted, a credential would be good for years. Set up in-person assessment sites, schedule a few certified evaluators to observe the candidate doing real-world tasks, and eliminate millions of hours of janky assessments that neither employers nor candidates want to participate in.

Professional Accountability

To be clear, I’m not proposing a union that protects people who are bad actors. If someone gets certified and then burns through three teams in two years with the same complaints following them, that's a signal, not noise. The guild needs mechanisms to revoke credentials for both technical and professional failures.

It makes me think of my Grandfather. He was married five times, and it was always her fault. Sure, Gramps, sure.

Structured Apprenticeship

Right now, senior engineers mentor junior developers as an unpaid side duty. Quality is all over the board. Again, few seniors have ever been trained in pedagogy. Others are forced to do it when they don’t enjoy it. In a guild system, mentorship becomes a distinct professional track with its own standards and accountability. Companies could sponsor these apprenticeships, effectively offloading training to a quality-first organization rather than attempting to handle it internally.

The Economic Benefits are Massive

Companies already spend absurd amounts on technical recruiting. I've seen organizations spend $50,000+ per senior hire, including recruiter fees, interview time, and the inevitable mis-hires that wash out within six months. Sure, you will always have bad hires due to poor fit or other circumstances, but I bet employers would gladly pay for access to Guild-certified candidates if it meant they could skip the technical screening circus entirely.

On the recruiting side, it would also mean that recruiters would have to shift to become more like agents. The "spray and pray" approach to recruiting would eventually die out over time. Connecting the right candidates with employers would become a relationship game, which would improve the experience for everyone. And, if they don’t want to play ball, a Guild system could cut them out entirely.

Reskilling pathways could also be provided, fixing another piece of the broken system. I’ve seen many developers with great fundamentals struggle to find work, not because they couldn’t adapt, but because there was no structured way to demonstrate their new capabilities. If a tech worker didn’t want to work on legacy systems anymore, they could upskill into a trusted credential and get on with their career, instead of the current environment where employers don’t want to bear the risk of hiring a worker with no professional experience in a modern stack, regardless of whether they could pick it up quickly.

A Guild Checks all the Boxes

Let’s recap:

• For tech workers, advancement pathways without doing the technical interview obstacle course. Credentials become trusted, and they travel between companies. It also provides much-needed opportunities to reskill when technologies shift.
• Employers benefit from predictable hiring costs and quality guarantees. They eliminate technical screening overhead and end up with a broader talent pool that they can trust.
• The industry in general would benefit from improved code quality. When professional reputations are tied to the performance of people you’ve certified and trained, you start caring a lot more about best practices and knowledge transfer.

The tech community has the expertise to make this work. We understand what skills actually matter. We are the best positioned to evaluate technical competency. We've been informally mentoring and vouching for each other for years.

What we need is organization and commitment.

I've been thinking about this problem for years, watching talented people get filtered out by broken processes while companies struggle to find the skilled workers they need. The current system serves nobody except the failed gatekeepers who continue to profit without providing sufficient value.

It’s time for something new. All we need is the will to build it!