Do tech stack choices still matter in 2026?

00:00:00: How important are tech stack choices by

00:00:04: developers like you and me now in April

00:00:08: 2026 with all the things that happened in the AI

00:00:11: space and with all the advancements in the AI models, and even

00:00:15: more importantly, the AI agent harnesses, the AI

00:00:19: agent tools like Cloud Code and Codex and so on?

00:00:23: And I created videos about these tools.

00:00:25: I have some courses on these tools, in case you're interested, Cloud Code

00:00:29: courses, which are very popular. But the question today which I

00:00:33: wanna take a closer look at it and share my opinion on is, how

00:00:37: important are tech stack choices by

00:00:41: developers? Do they still matter, or should we let the

00:00:44: AI decide? Or,

00:00:47: maybe more relevant, should we make decisions

00:00:51: based on the fact that we're about to use AI?

00:00:54: And I'll let you know what I mean. Now, obviously, the- the

00:00:58: most basic form of not caring about the tech stack...

00:01:02: And by the way, I'll primarily focus on tech stack

00:01:06: choices from the lens of web developers because that is

00:01:10: my main thing, web development, but I guess it will

00:01:13: apply to all kinds of developers. But the- the easy

00:01:17: path you could take is, of course, that you may be using a

00:01:21: tool like, let's say, Cloud Code, doesn't matter, and you don't

00:01:25: really care about the tech stack that's being chosen.

00:01:28: Who cares if you're using TypeScript and

00:01:32: Next.js with React, or if you're using

00:01:36: vanilla JavaScript and, let's say,

00:01:40: TanStack Start, or maybe you're using Angular instead of

00:01:44: Who cares, right? Let the AI decide.

00:01:47: Now, you could do that, of course, but here, we enter the realm of

00:01:51: white coding, obviously, because we as developer

00:01:55: don't make any choices. And as soon as you stop

00:01:58: making choices and decisions, as soon as you stop

00:02:02: steering the AI and

00:02:04: caring about the code, you could say, "That is my definition of

00:02:08: white coding." But of course, there would be one way of saying

00:02:12: don't really matter anymore, and I'll get back to that question.

00:02:15: The- the other maybe more relevant aspect,

00:02:19: though,

00:02:20: is that you could argue

00:02:22: that yes, you as a developer kind of still

00:02:26: make a choice, but ultimately, it's influenced

00:02:30: by the fact that you're about to use AI to help with the

00:02:34: development process. And you will review the code.

00:02:38: You care about it. You're not white coding.

00:02:40: But still, because you're about to use AI a

00:02:44: lot, you use a tech stack you know AI is good at.

00:02:48: You use TypeScript, you use Next.js with React, for example,

00:02:52: because you know there's been a lot of training data on that, and

00:02:56: AI will do good at that. So, these are the two

00:03:01: main points here. We have the first

00:03:04: way of not caring, which is let AI choose, the white coding approach,

00:03:09: and we have the second, uh, aspect, which is that we let

00:03:12: AI influence the choice.

00:03:16: I would argue both approaches are

00:03:20: kind of wrong and a bit shortsighted.

00:03:24: I would argue, as a developer,

00:03:27: it's more important than ever, maybe, to have an

00:03:31: opinion on the tech stack you're going to work on, to make

00:03:35: smart decisions and choices, because, of course, the

00:03:39: way we developers work is shifting, is

00:03:43: changing. We are writing less code.

00:03:46: I definitely write less code. May be different for you.

00:03:50: Maybe it will forever be different for you.

00:03:52: But as a industry as a whole, it's clear to see

00:03:56: that there is a big shift going on to developers writing less

00:04:00: code and instead orchestrating and using these

00:04:03: AI agents and tools. And that, of course,

00:04:08: implies that it becomes even more important which

00:04:12: choices and decisions we make. If you go down the

00:04:15: white coding tunnel,

00:04:18: if you let AI make the- the choices, th-

00:04:21: decisions,

00:04:23: that may not be a great future as a developer, for obvious reasons,

00:04:27: because who needs you if all you do is

00:04:31: ask the AI without any opinions, without

00:04:35: any influence on the code it will produce?

00:04:38: Nobody needs a developer for that, right?

00:04:40: So, that will not lead anywhere. Now, that may be

00:04:44: a- a decent, a good approach for quickly building some

00:04:48: building some internal application that just needs to do

00:04:52: one thing well and you don't care about edge cases, niche cases, problem

00:04:56: security.

00:04:57: There are definitely use cases where this may

00:05:01: be a- a valid approach, where you may just white code

00:05:05: something. This also, of course, may be very useful.

00:05:08: White coding may be very useful for people that don't know how to

00:05:12: code but that can build some of the software they need for

00:05:16: themselves with ease. With all the disadvantages white coding

00:05:20: it has its-

00:05:22: its- its purpose, I would say. There are use cases where it may

00:05:26: be a decent decision. But of course, obviously,

00:05:30: case, and the people that do white code may not even know which

00:05:34: options exist out there. Now, when it comes to letting AI

00:05:38: influence the choice, I would argue, this may

00:05:42: have been a valid argument maybe, like, a year

00:05:46: ago,

00:05:47: may- maybe not even back then, but definitely not anymore today,

00:05:51: you why.

00:05:53: Obviously, AI has a favorite stack.

00:05:56: I've said that before in other videos.

00:05:58: If you let AI run, if you go down the white coding

00:06:02: path, chances are pretty high, if we're talking about web development,

00:06:06: that you will get a TypeScript, React, Next.js,

00:06:10: Tailwind, uh, uh...... project, right?

00:06:13: That's the favorite stack of AI, and there are

00:06:17: reasons for that. Obviously, there have been a lot of React,

00:06:21: Next.js, Tailwind projects in the training data,

00:06:25: depending on how we look at the training data, if we include code

00:06:29: from the 2010s, the early 2010 years,

00:06:33: obviously there will not be any Tailwind in there.

00:06:35: There will be far fewer TypeScript projects or no TypeScript

00:06:39: projects in there, um, no Next.js projects.

00:06:43: So, obviously, there would have been a lot of vanilla

00:06:47: jQuery projects in that training data too, and there definitely

00:06:50: were. But the reason for that not being the

00:06:54: favorite tech stack of AI, of course, is not just the amount

00:06:58: of training data it saw, which matters, but it's not the only thing.

00:07:01: But it's also that these AI models, as we use them, no

00:07:05: matter by which provider, they go through different stages.

00:07:09: There is the pre-training str- stage.

00:07:11: There is the fine-tuning, the reinforcement learning stages.

00:07:14: There are all these stages where the model provider kind of

00:07:18: shapes these models and their behavior.

00:07:20: And then there are system prompts.

00:07:22: If you're using a tool like Claude Code, there is an

00:07:26: invisible system prompt, more or less invisible, that

00:07:29: instructs the AI model to act in

00:07:33: certain ways. And we already know, we saw that, um,

00:07:37: that these models have definitely been

00:07:41: influenced to prefer certain technologies like TypeScript and

00:07:45: React. And why is that? That is because, especially TypeScript,

00:07:49: for example, is a language that works pretty well for AI,

00:07:52: because it is able to validate the

00:07:56: code it produced by checking for type errors.

00:08:00: Obviously, that's not the only way of validating.

00:08:02: A type-error-free code base is not necessarily a good code

00:08:06: base and (laughs) not necessarily a code base that works the way you want it to

00:08:09: work, but it's a indicator.

00:08:12: It tends to be better than vanilla JavaScript as far

00:08:16: as I know. So, these are reasons why AI has the

00:08:20: favorite tech stack and why you may come to the conclusion

00:08:24: a good idea to go with that favorite tech stack

00:08:28: or something closely related.

00:08:31: For example, you may decide that using vanilla JavaScript is not

00:08:35: something you wanna do because you heard, by me for example, that

00:08:39: AI benefits from using type-safe languages like

00:08:43: TypeScript.

00:08:44: And there may be some truth to that. But in...

00:08:48: At this point in time, in April 2026,

00:08:52: it has been proven over and over again, and it has been my experience too,

00:08:56: that AI and these AI agents like Claude Code are

00:08:59: really good at picking up whichever tech stack you

00:09:03: throw at them. It used to be the case that it is kind of annoying

00:09:07: to, for example, work with libraries or frameworks that are pretty

00:09:11: new and where there hasn't been a lot of data

00:09:15: in the training data or maybe no data at all,

00:09:19: anymore. As a developer using AI, you can obviously go

00:09:23: to the docs of any library you wanna use.

00:09:26: Let's say you wanna use the latest version of Nuxt.js

00:09:29: or you wanna use Svelte 5 or whatever it is,

00:09:34: uh, TanStack Start, for example, which is relatively new.

00:09:38: You can go to the docs of these projects, and you can

00:09:42: pick the relevant articles and just throw them into the

00:09:46: context of your current chat session so that the AI is aware of

00:09:50: this documentation. And it will be able to pick up on the code

00:09:54: examples and the explanation it sees there and apply that to

00:09:58: your code base. So you can absolutely

00:10:01: use very new libraries that may not have been

00:10:05: in the, in the training data in your project

00:10:09: typically don't even have to go to the docs and

00:10:12: choose them manually. Instead, if you just have a specific enough

00:10:16: prompt where you tell it that you wanna use

00:10:19: a library, let's say TanStack Start, and you tell the AI that it should go

00:10:23: lo- look at the docs, and you maybe gave it a c- uh, an

00:10:27: MCP like the Context-7 MCP or the

00:10:31: AI agents like Claude Code and so on, they also have web search, you

00:10:34: trust that it does a web search and finds the relevant

00:10:38: documentation. And you can, of course, influence that by using skills,

00:10:43: Uh, for example, I have a, a code research skill where I

00:10:47: tell the AI that for certain prompts I may be

00:10:51: using, it should take a look at that skill, and in that skill,

00:10:55: how it should look up docs. So you may have stuff like that.

00:10:58: And if you do have that, you typically don't have to include

00:11:02: documentation yourself. Uh, instead, the AI can look

00:11:05: for it on its own and include it and pull in the relevant documentation as

00:11:09: it needs to. And, shocking, of course, as a developer you can also still

00:11:13: write code. And it, it turns out that if you

00:11:18: have a project,

00:11:20: AI tends to kind of

00:11:23: replicate what's already in there regarding code

00:11:27: style, for example. So if you have a project,

00:11:31: maybe you already created some functions in there, some routes

00:11:35: already, anything like that where you may be using

00:11:38: Nuxt.js or TanStack Start or whatever it is, the AI will

00:11:42: pick up on that. And it will not suddenly start using

00:11:46: Next.js syntax and features in that

00:11:49: TanStack Start project typically.

00:11:51: So all these things combined, existing code,

00:11:55: uh..Pulling in the right context,

00:11:58: nudging the AI at, uh, to- towards looking up

00:12:02: documentation and including that, all these things together make it

00:12:05: really easy these days, um, to work with libraries

00:12:09: or a tech stack in general that is not the default

00:12:13: and that may include certain technologies that are not well-known by

00:12:17: AI. That has been my experience. I read a lot on X by other

00:12:21: people where the experience has been kind of similar, so that

00:12:24: definitely works today. Maybe that was different a year ago, but

00:12:28: it's absolutely viable today. And that kind of brings me back to

00:12:32: my original question: Does the tech stack choice

00:12:36: still matter? Because, of course, it's great that you can make a choice,

00:12:40: that you are not forced to take one of these two routes, right?

00:12:44: That is great. But does it matter? And I would argue, yes, it matters a

00:12:48: lot. As I said initially, that is one of the things that

00:12:52: sets a developer apart from non-developers.

00:12:55: Not the only thing, but a thing.

00:12:58: Different projects benefit from different tech stack

00:13:02: choices. And yes, theoretically, you can build anything

00:13:06: with any tech stack or with most tech stacks, and often it may

00:13:09: not matter, but it can matter. If you are working on

00:13:13: some project where performance is key, and I don't mean the performance

00:13:17: for your 10 users, I mean for, uh, bigger projects where performance

00:13:21: really will matter, you may prefer to go for a

00:13:25: backend language like Go, for example, because you

00:13:29: want better performance, a better memory footprint than you maybe

00:13:33: with, let's say, TypeScript. That being said, just to

00:13:37: also have that in there,

00:13:39: there is no reason to over-optimize if you're just building something and you

00:13:43: don't even know how many users you'll have.

00:13:45: If you ever reach the point where your application chokes under

00:13:49: the load, you can always rewrite it.

00:13:52: That also is easier than ever now with AI.

00:13:55: But yeah, those choices obviously still matter.

00:13:59: It also matters what you, as a developer, know.

00:14:02: If you are really good in Angular, let's say, there's no

00:14:06: reason to build a React application.

00:14:09: Because, as a developer, you still wanna understand and

00:14:13: review the code and get in there and write some code hi- here and there

00:14:16: to, again, get AI to move into the right

00:14:19: direction. We don't wanna become white coders.

00:14:22: Instead, we wanna leverage our knowledge

00:14:26: enhance it or leverage it, yeah, with AI.

00:14:30: So obviously, if you know something really well, that

00:14:34: reason to go with that technological choice, with

00:14:38: library, programming language, whatever it

00:14:40: is. And therefore, yes, tech stack

00:14:44: choices do matter, and different languages, different

00:14:48: frameworks, libraries, they have pur- purposes.

00:14:51: They have a reason to exist. Now, you could definitely make the

00:14:55: argument that

00:14:58: there are some changes going on there because maybe, like,

00:15:01: five or six years ago, a new JavaScript

00:15:05: library may have appeared. You know, back then, we had new

00:15:09: JavaScript libraries almost every week, it felt like.

00:15:13: Uh, a new library may have come up because

00:15:16: it provided better developer ergonomics.

00:15:20: That may not be as relevant today anymore.

00:15:23: Today, you could argue, uh, a new library could come up

00:15:26: because it's easier to use by agents, because

00:15:30: it does something that makes it particularly

00:15:34: easy to be used by agents while still being readable and

00:15:38: understandable by humans too, of course.

00:15:40: But yeah, I definitely could see a sh- a shift like this happening.

00:15:44: And some reasons for why you might have chosen a certain

00:15:48: library or framework or programming language in the past may

00:15:52: not matter anymore because you are writing less code.

00:15:56: Still, for me personally, at least, and I have the luxury of

00:16:00: being able to make a lot of tech stack choices for my own projects, obviously,

00:16:04: so for me, aesthetics still matter, for

00:16:07: example. I still wanna work with a tech stack,

00:16:12: I enjoy looking at the code because I'm, I'm looking at a lot of code.

00:16:16: I'm reviewing a lot of code, so I want to look at

00:16:19: something I- I- I like seeing, right?

00:16:23: So yeah, tech stack choices, in my opinion, still

00:16:27: matter. The reasons may have changed a bit and,

00:16:31: the, the impact of choosing certain

00:16:34: uh, but it's an important choice, in my opinion.

00:16:38: And of course, as always, I am also interested in hearing your

00:16:42: that.