Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Code & Curiosity by Maximilian Schwarzmüller

Code & Curiosity by Maximilian Schwarzmüller artwork

Do tech stack choices still matter in 2026?

Apr 13, 202617 minAudio
  • Apple Podcasts
ShareXLinkedInFacebookWhatsAppEmail

We're not discussing JavaScript frameworks anymore. But do tech stack choices still matter? Or should we let the AI decide (or influence our decisions)?

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

How important are tech stack choices by developers like you and me now in April 2026 with all the things that happened in the AI space and with all the advancements in the AI models, and even more importantly, the AI agent harnesses, the AI agent tools like Cloud Code and Codex and so on? And I created videos about these tools. I have some courses on these tools, in case you're interested, Cloud Code courses, which are very popular. But the question today which I

wanna take a closer look at it and share my opinion on is, how important are tech stack choices by developers? Do they still matter, or should we let the AI decide? Or, maybe more relevant, should we make decisions based on the fact that we're about to use AI? And I'll let you know what I mean. Now, obviously, the- the most basic form of not caring about the tech stack... And by the way, I'll primarily focus on tech stack

choices from the lens of web developers because that is my main thing, web development, but I guess it will apply to all kinds of developers. But the- the easy path you could take is, of course, that you may be using a tool like, let's say, Cloud Code, doesn't matter, and you don't really care about the tech stack that's being chosen. Who cares if you're using TypeScript and Next.js with React, or if you're using

vanilla JavaScript and, let's say, TanStack Start, or maybe you're using Angular instead of Who cares, right? Let the AI decide. Now, you could do that, of course, but here, we enter the realm of white coding, obviously, because we as developer don't make any choices. And as soon as you stop making choices and decisions, as soon as you stop steering the AI and caring about the code, you could say, "That is my definition of

white coding." But of course, there would be one way of saying don't really matter anymore, and I'll get back to that question. The- the other maybe more relevant aspect, though, is that you could argue that yes, you as a developer kind of still make a choice, but ultimately, it's influenced by the fact that you're about to use AI to help with the development process. And you will review the code. You care about it. You're not white coding.

But still, because you're about to use AI a lot, you use a tech stack you know AI is good at. You use TypeScript, you use Next.js with React, for example, because you know there's been a lot of training data on that, and AI will do good at that. So, these are the two main points here. We have the first way of not caring, which is let AI choose, the white coding approach, and we have the second, uh, aspect, which is that we let

AI influence the choice. I would argue both approaches are kind of wrong and a bit shortsighted. I would argue, as a developer, it's more important than ever, maybe, to have an opinion on the tech stack you're going to work on, to make smart decisions and choices, because, of course, the way we developers work is shifting, is

changing. We are writing less code. I definitely write less code. May be different for you. Maybe it will forever be different for you. But as a industry as a whole, it's clear to see that there is a big shift going on to developers writing less code and instead orchestrating and using these AI agents and tools. And that, of course, implies that it becomes even more important which choices and decisions we make. If you go down the

white coding tunnel, if you let AI make the- the choices, th- decisions, that may not be a great future as a developer, for obvious reasons, because who needs you if all you do is ask the AI without any opinions, without any influence on the code it will produce? Nobody needs a developer for that, right? So, that will not lead anywhere. Now, that may be a- a decent, a good approach for quickly building some

building some internal application that just needs to do one thing well and you don't care about edge cases, niche cases, problem security. There are definitely use cases where this may be a- a valid approach, where you may just white code something. This also, of course, may be very useful. White coding may be very useful for people that don't know how to code but that can build some of the software they need for themselves with ease. With all the disadvantages white coding

it has its- its- its purpose, I would say. There are use cases where it may be a decent decision. But of course, obviously, case, and the people that do white code may not even know which options exist out there. Now, when it comes to letting AI influence the choice, I would argue, this may have been a valid argument maybe, like, a year ago, may- maybe not even back then, but definitely not anymore today,

you why. Obviously, AI has a favorite stack. I've said that before in other videos. If you let AI run, if you go down the white coding path, chances are pretty high, if we're talking about web development, that you will get a TypeScript, React, Next.js, Tailwind, uh, uh...... project, right? That's the favorite stack of AI, and there are reasons for that. Obviously, there have been a lot of React, Next.js, Tailwind projects in the training data,

depending on how we look at the training data, if we include code from the 2010s, the early 2010 years, obviously there will not be any Tailwind in there. There will be far fewer TypeScript projects or no TypeScript projects in there, um, no Next.js projects. So, obviously, there would have been a lot of vanilla jQuery projects in that training data too, and there definitely were. But the reason for that not being the favorite tech stack of AI, of course, is not just the amount

of training data it saw, which matters, but it's not the only thing. But it's also that these AI models, as we use them, no matter by which provider, they go through different stages. There is the pre-training str- stage. There is the fine-tuning, the reinforcement learning stages. There are all these stages where the model provider kind of shapes these models and their behavior. And then there are system prompts. If you're using a tool like Claude Code, there is an invisible system prompt, more or less invisible, that

instructs the AI model to act in certain ways. And we already know, we saw that, um, that these models have definitely been influenced to prefer certain technologies like TypeScript and React. And why is that? That is because, especially TypeScript, for example, is a language that works pretty well for AI, because it is able to validate the code it produced by checking for type errors.

Obviously, that's not the only way of validating. A type-error-free code base is not necessarily a good code base and (laughs) not necessarily a code base that works the way you want it to work, but it's a indicator. It tends to be better than vanilla JavaScript as far as I know. So, these are reasons why AI has the favorite tech stack and why you may come to the conclusion a good idea to go with that favorite tech stack or something closely related.

For example, you may decide that using vanilla JavaScript is not something you wanna do because you heard, by me for example, that AI benefits from using type-safe languages like TypeScript. And there may be some truth to that. But in... At this point in time, in April 2026, it has been proven over and over again, and it has been my experience too, that AI and these AI agents like Claude Code are really good at picking up whichever tech stack you

throw at them. It used to be the case that it is kind of annoying to, for example, work with libraries or frameworks that are pretty new and where there hasn't been a lot of data in the training data or maybe no data at all, anymore. As a developer using AI, you can obviously go to the docs of any library you wanna use. Let's say you wanna use the latest version of Nuxt.js or you wanna use Svelte 5 or whatever it is,

uh, TanStack Start, for example, which is relatively new. You can go to the docs of these projects, and you can pick the relevant articles and just throw them into the context of your current chat session so that the AI is aware of this documentation. And it will be able to pick up on the code examples and the explanation it sees there and apply that to your code base. So you can absolutely use very new libraries that may not have been

in the, in the training data in your project typically don't even have to go to the docs and choose them manually. Instead, if you just have a specific enough prompt where you tell it that you wanna use a library, let's say TanStack Start, and you tell the AI that it should go lo- look at the docs, and you maybe gave it a c- uh, an MCP like the Context-7 MCP or the AI agents like Claude Code and so on, they also have web search, you trust that it does a web search and finds the relevant

documentation. And you can, of course, influence that by using skills, Uh, for example, I have a, a code research skill where I tell the AI that for certain prompts I may be using, it should take a look at that skill, and in that skill, how it should look up docs. So you may have stuff like that. And if you do have that, you typically don't have to include documentation yourself. Uh, instead, the AI can look for it on its own and include it and pull in the relevant documentation as

it needs to. And, shocking, of course, as a developer you can also still write code. And it, it turns out that if you have a project, AI tends to kind of replicate what's already in there regarding code style, for example. So if you have a project, maybe you already created some functions in there, some routes already, anything like that where you may be using Nuxt.js or TanStack Start or whatever it is, the AI will

pick up on that. And it will not suddenly start using Next.js syntax and features in that TanStack Start project typically. So all these things combined, existing code, uh..Pulling in the right context, nudging the AI at, uh, to- towards looking up documentation and including that, all these things together make it really easy these days, um, to work with libraries or a tech stack in general that is not the default

and that may include certain technologies that are not well-known by AI. That has been my experience. I read a lot on X by other people where the experience has been kind of similar, so that definitely works today. Maybe that was different a year ago, but it's absolutely viable today. And that kind of brings me back to my original question: Does the tech stack choice still matter? Because, of course, it's great that you can make a choice, that you are not forced to take one of these two routes, right?

That is great. But does it matter? And I would argue, yes, it matters a lot. As I said initially, that is one of the things that sets a developer apart from non-developers. Not the only thing, but a thing. Different projects benefit from different tech stack choices. And yes, theoretically, you can build anything with any tech stack or with most tech stacks, and often it may not matter, but it can matter. If you are working on some project where performance is key, and I don't mean the performance

for your 10 users, I mean for, uh, bigger projects where performance really will matter, you may prefer to go for a backend language like Go, for example, because you want better performance, a better memory footprint than you maybe with, let's say, TypeScript. That being said, just to also have that in there, there is no reason to over-optimize if you're just building something and you don't even know how many users you'll have. If you ever reach the point where your application chokes under

the load, you can always rewrite it. That also is easier than ever now with AI. But yeah, those choices obviously still matter. It also matters what you, as a developer, know. If you are really good in Angular, let's say, there's no reason to build a React application. Because, as a developer, you still wanna understand and review the code and get in there and write some code hi- here and there to, again, get AI to move into the right

direction. We don't wanna become white coders. Instead, we wanna leverage our knowledge enhance it or leverage it, yeah, with AI. So obviously, if you know something really well, that reason to go with that technological choice, with library, programming language, whatever it is. And therefore, yes, tech stack choices do matter, and different languages, different frameworks, libraries, they have pur- purposes.

They have a reason to exist. Now, you could definitely make the argument that there are some changes going on there because maybe, like, five or six years ago, a new JavaScript library may have appeared. You know, back then, we had new JavaScript libraries almost every week, it felt like. Uh, a new library may have come up because it provided better developer ergonomics. That may not be as relevant today anymore.

Today, you could argue, uh, a new library could come up because it's easier to use by agents, because it does something that makes it particularly easy to be used by agents while still being readable and understandable by humans too, of course. But yeah, I definitely could see a sh- a shift like this happening. And some reasons for why you might have chosen a certain library or framework or programming language in the past may not matter anymore because you are writing less code.

Still, for me personally, at least, and I have the luxury of being able to make a lot of tech stack choices for my own projects, obviously, so for me, aesthetics still matter, for example. I still wanna work with a tech stack, I enjoy looking at the code because I'm, I'm looking at a lot of code. I'm reviewing a lot of code, so I want to look at something I- I- I like seeing, right? So yeah, tech stack choices, in my opinion, still

matter. The reasons may have changed a bit and, the, the impact of choosing certain uh, but it's an important choice, in my opinion. And of course, as always, I am also interested in hearing your that.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. We will have to accept AI-generated content

    Oct 15, 202612 minAudio

    I think we'll have to get used to (and accept) AI generated content. Not to slop though.

    • Apple Podcasts

    Credit the people on this episode

  2. Is software dead?

    Oct 13, 202612 minAudio

    There's a lot of talk about software being dead. Unsurprisingly, it's complicated.

    • Apple Podcasts

    Credit the people on this episode

  3. GPT 6 Astra - Good Beyond 3D?

    Sep 9, 20268 minAudio

    GPT 6 Astra was released. It's a good model, I have to say. Especially for 3D work it seems to be a real game changer. But due to all the hype, you may be disappointed...

    • Apple Podcasts

    Credit the people on this episode

  4. You may ignore Omarchy but not its impact

    Aug 26, 20268 minAudio

    Omarchy got a lot of hype and visibility recently. But even if you don't care or don't use it, you shouldn't ignore it.

    • Apple Podcasts

    Credit the people on this episode

  5. SvelteKit 3, Solid 2 - Do they matter anymore?

    Aug 18, 202614 minAudio

    We're not going back to the JS framework wars. BUT new frameworks and framework versions are important. For a different reason now!

    • Apple Podcasts

    Credit the people on this episode