caseymarquis

Go ignores the needs of the developers in favor of the needs of the architect and technical managers.

I’ve always disliked it for that reason.

In roughly November of 2025, “software developer” stopped being a position that humans fill directly. We all became architects and technical managers. Even the most complex code is now pair programmed with an AI.

I’ve chosen go for all new backend work since January 2026.

Development is now about good architecture that optimizes for locality of reasoning, rock solid testing, and categorizing risk on modules to decide what needs human pair programming and detailed review, and what can be safely vibecoded and left to AI to manage.

Frontend dev is now vibecoded directly by PMs at my organization within very specific and heavily enforced architectural constraints. The quality of work went up substantially because the experienced devs now just focus on the rules and review for the fronted codebases, while the PMs focus entirely on UX.

It is a strange new world.

That's either a fun or terrible exercise depending on who is administering and how. However, if you said it's a Ruby role and the candidate is good enough to be picky, you may scare them off when they think your description of the role was a lie.

I recently used ChatGPT canvas to improve a friend's resume. I had managed him in the past, and he is great to work with. However, from his resume you would never know it. I did 3 hours worth of editing and improvement in 5 minutes. I gave rambling descriptions of what he had done when working for me and why it was impressive, and GPT translated this into resume speak almost instantly. I then gave some vague suggestions for improvement, made a couple minor edits to buff off the AI veneer, and viola, he had a professional resume that will help him do great work in his next position.

While LINQ does include a library of extension methods for functional programming with .NET collections (which is great), it also includes "Expression Classes". In a nutshell, this allows a user to pass a single expression lambda to a function, and the function implementor receives the abstract syntax tree for the lambda, not the lambda itself. You can then not only receive and analyze these trees, you can also manually build and compile them. This effectively allows a limited set of runtime macros within .NET.

I grew up working construction on the side with my father, became an appprentice lineman, moved to aftermarket electrical installations in CNC machines, then ended up writing software products for over a decade. I've worked on a wide variety of software: Embedded projects requiring 2000 line assembly ISRs for legacy RS232 protocols, reverse engineering binary network protocols, implementing network server protocols from specifications, writing my own actor and dependency injection frameworks in managed languages, web application backend work, frontend work with JavaScript/TypeScript and frameworks, and so on. I also do a lot of product management, support, customer management, and internal management. Much of my customer support involves teaching external developers from large corporations how to use HTTP and SDKs.

I'm usually one of the smarter people in the room when doing software development and spend a lot of time helping others. In construction, I'm the enthusiastic idiot as the skillset is different. Most tech workers underestimate how high skilled tradework and many other positions outside their experience are, especially management work.

Having said all that, I feel uniquely qualified to offer a rebuttal. The article is describing a clear pattern that I see at large companies that are not focused on software development or lack solid engineering leadership. Ironically, the problem gets worse the more a company tries to outsource IT as they face all the same challenges with less control. It is an organizational health issue however, not some universal truth. If tech workers lack anything, it's experience with organizational growth, change, and group dynamics, not construction experience. Organizations are like people, they grow, change, figure out who they are, have identity crises and need different things in different phases. Ask the highest level/most competent manager you have access to for book recommendations if you're interested in this.

Anyway, back on topic, software "gruntwork" typically implies a department lacks the agency to automate away said gruntwork or lacks the skills to do so. As an example, I work with many organizations using the JVM, but none of them use Scala, Kotlin, Clojure, or any other "nice" JVM language. They use Java. In some cases Java 8. If you're writing Java, there is absolutely stupid gruntwork. I've written example applications for some of these organizations and I had to create code generation tools to stay sane in this environment. In software, you eliminate stupid gruntwork with tools, not people.

We do need average enthusiasts in software development, but it's not the same as construction. In construction the less talented person fetches things and does setup work. In software development, the less talented workers spend most of their time using libraries, plugins, frameworks, compilers, interpreters, databases, and languages while the more talented workers write them.

My experience isn't universal, and I'd be interested in hearing some dissenting opinions on this.

I thought it was more like 2^23 unique prototypes?

I think OP has solved some of those issues with this approach. Initially, this is a fun tool that provides value to individuals. The result at scale becomes extremely valuable. The biggest missing piece is verification of skillset. I'm not sure how to solve that. Current employers? Motivated to keep their top performers and little incentive to engage early on. Peers are easy to game and are susceptible to generative AI for automation. You would almost need to integrate some kind of in person meeting for verification. Establish known experts and have them review and verify, then feed that into employer feedback after hiring for a sort of credit system. Employers using the rating system would themselves need to be monitored and policed.

This is a very interesting idea. Given access to long form descriptions of what has been worked on, ideally with some kind of trusted verification, this approach seems like it would operate at scale quite well and could transform the way we network and hire. A technical expert could explain what is needed for a role, and with AI assistance candidates could be sorted through extremely effectively and matched to companies that are a good fit for their experience. Given, this doesn't account for junior developers who have yet to build up their skillset, but for experienced developers this could result in a much more efficient hiring process.

Men are applying and women are hiring. Half the candidates are lying on their resumes. Many candidates are spamming their resumes indiscriminately. If you've ever had to hire someone for a position that attracts hundreds of candidates (i.e. software engineer with decent pay), you'll encounter the same dynamic. I hate being in that role. I have to reject 199 people and accept 1. Often, there are dozens of qualified candidates. You interview half a dozen, and then you tell 5 out of 6 perfectly qualified people you interviewed they didn't get the job. You feel like a horrible person the whole time. I've discussed this with my wife (we met on Bumble) and she confirmed the scenarios are very similar.

It's often better to be in the hiring position than in the applying position. But it's awful for everyone involved.

The way to avoid this mess when applying for jobs is to build up a network and lean on it for new positions. I wonder if dating may have a similar alternative approach.

Comparing a JavaScript ORM to a C# ORM like Entity Framework feels like comparing C macros to Lisp macros.

You can't really have a reasonable conversation about ORMs without defining the feature set your ORM has. If an ORM doesn't apply type safety to SQL queries and translate typed code expressions to equivalent SQL expressions, it's not performing two of the key functions I associate with ORMs. If I didn't take these features for granted, I would probably question how useful ORMs are too!

I think the reason it's so hard to have a conversation about ORMs in general is that we're often lumping radically different systems together and then making a blanket judgement. Again, it's like working with C macros, getting annoyed with them, and then judging all macro systems to be bad.

Since the word agile has become so loaded, you can instead explain why a waterfall practice is linked to predictable problems and avoid buzzwords entirely:

It takes 6 months to act on customer feedback with our current release strategy, and a full year to fix the bugs related to that feedback. We should be rapidly iterating on feedback quickly to avoid churn. Let's try xyz...

That seems positive, honestly. It forces a focus on the developmental process over the finished product.

Please write a blog post about that when you get a chance to do it!

Interestingly, it might be easier to replace mid-skill artists than mid-skill developers (not to say both won't happen over time). The key difference is that when generating art, you can say "Make A in-the-style B.", get what you want, and move on.

Meanwhile, you have to live with the consequences of AI generated code.

Case in point: My wife was trying to build a system to generate POs per vendor from a series of workorders a couple weeks ago. She was using AirTable, which vastly simplifies the creation and use of relational databases. Given a lack of database experience, the structure that she made was misaligned with what she actually needed (and completely denormalized). Putting it into production would have caused major problems over time.

This made me realize that writing code is only one of the barriers to entry in software. Eliminating this barrier effectively gives everyone in the world access to a small team of incredibly junior developers who have no idea what they're doing.

Just like mismanaged DIY home projects create more work for professional contractors, I think AI might -oddly enough- create more positions for mid-tier and higher developers.