Video guide
26:53 · 22 August 2025
10 AI Concepts Every JavaScript Engineer Should Know
Chapters 7 sections
Key concepts in this video:
- 01
1. The Model Spec: Software as a Projection of Specs
The model spec idea, released by OpenAI: stop writing code, write specifications. You put your specs in markdown files — from high-level rules like 'assume best intentions' down to which library to use — and an agent generates the software from them. Software becomes a projection of the specs, the way the UI in React is a function of state and props.
Projection is a deterministic operation. A compiler transpiling JavaScript to machine code, React building the DOM, a vector projected onto a plane — same input, same output, no randomness. Civilization runs on deterministic systems: engines, CPUs, banking software. Nobody trusts an elevator that failed even once.
LLM code generation is not that. Whatever the agent or model, output is at best an interpretation of the context provided, and different models interpret the same specs differently. Randomness and hallucinations are not a bug of large language models — they are the main feature. That is the gap between the pitch and the practice.
model specdeterminismLLMcode generation - 02
2. Context Engineering
Prompt engineering died; context engineering replaced it. The claim: you get bad AI results because you feed it too little. So you feed it everything — specs, rule files like Cursor rules or Claude files, your indexed codebase, documentation sites, internal docs, existing tests — vectorize it all and pass it to the LLM.
It works better than a bare prompt, but calling it engineering is generous. It is context stuffing, made possible only because context windows exploded. And as the next concept shows, more context is not free.
context engineeringpromptingLLM - 03
3. Context Rot: Bigger Windows, Worse Answers
Context windows got huge. Gemini 1.5 Pro takes 2 million tokens. A token is roughly 3 to 4 characters — a debounce function is about 51 tokens, and 2 million tokens is four copies of Cracking the Coding Interview in a single prompt. Most companies have less written-down process than that.
So the window looks like a solved problem. It isn't. Model performance decreases as you add tokens, and it decreases exponentially — context rot. Accuracy is much better when the context is small.
Which puts you back at square one: it is easy to get an LLM to write code, and extremely hard to get one to build software.
context windowtokenscontext rot - 04
4. Retrieval Augmented Generation (RAG)
RAG solves a real problem: the model was trained on React 18, but you want React 19 answers, not class components. Instead of prompt-to-model directly, you build a context store — your company's docs, your product specs — and vectorize it.
When the user asks something, a secondary model embeds the prompt, runs semantic search to find similar content in the store, and stitches it into a bigger prompt. The LLM answers with knowledge it was never trained on.
This is a genuinely good technique, and likely the future of AI in the enterprise. The good news: building this kind of system requires knowing a lot of software development, not a lot of AI.
RAGembeddingssemantic searchvector store - 05
5. Agentic Coding: A Recursive LLM in a While Loop
Strip the hype and an agent is a recursive self-calling LLM. It makes a pseudo plan, extracts a success criteria from your prompt — that is the base case — and keeps querying itself, or a sub-agent, until it thinks the criteria is met. Pretty much a while loop around a model.
Look under the hood of Claude Code and you find prompts — literal English instructions like 'when you have completed a task, you must run the lint and type check commands.' Telling a statistical machine what to do in English means repeating clauses over and over, like teaching a child, with no guarantee it complies. It only works because a 200,000-token context window makes all that repetition affordable.
English as a programming language is not a new idea, and Dijkstra called it decades ago: machines programmed in native tongues would be as damn difficult to make as to use. High-level languages exist precisely because we wanted something English-like but precise and deterministic. Programming languages are an evolution of English, not the other way around.
agentsClaude CodepromptsLLM - 06
6. MCP: Model Context Protocol
MCP is Anthropic's open standard for connecting models to external services: an MCP client used by the model, and an MCP server wrapping your existing API. The model wants to query Google Maps on your behalf — it calls the client, which calls the server, and the answer comes back digested. Because it is a universal standard, OpenAI and the others comply too: swap models, keep the same servers.
Under the hood it is familiar: JSON-RPC — remote procedure calls, around since the 90s, the same idea as tRPC. It combines resource-style access with callable functions on one server, adds per-tool descriptions the model consumes, and supports native HTTP streaming for token traffic.
The honest take: we already had REST and GraphQL with description fields and the OpenAPI standard for defining what endpoints do. MCP is a glorified REST API with RPC bolted on — real standardization value, but technically underwhelming. Nobody cared at launch; Anthropic built the first ten or twenty servers themselves before it blew up.
MCPJSON-RPCRESTOpenAPI - 07
7. Chain of Thought
Reasoning models appear to break tasks down like humans: query one and it shows you steps before the answer. Chain of thought blew up when DeepSeek came out. But the AI companies themselves found the visible steps are a placeholder: inject specific solution steps into the prompt and they never appear in the displayed reasoning, even when they are part of the answer.
Under the hood the model is still doing token prediction. The visible steps are generated by a helper LLM and constructed for you, the human, to feel like the model is thinking sequentially. Ask GPT itself: it will tell you chain of thought is not a transcript of its internals.
Mental model: it is a fancy loading indicator.
chain of thoughtreasoning modelstoken prediction - 08
8. Test-Time Compute
Test-time compute: the model generates three to five candidate solutions, an internal reward model ranks them, and it iterates until it settles on the best-ranked output. Sold as a major breakthrough, and the term shows up in every AI talk.
Then DeepMind measured it. For easy questions — the colors of the US flag — accuracy improves. For hard problems like math, it is actually detrimental. Another technique that makes sense for certain problems with certain models, not a jet-engine leap.
test-time computereward modelDeepMind - 09
9. LCM: Large Concept Models
The LCM, from Meta, changes the unit of thought. Instead of parsing text into tokens, turning those into embeddings, and predicting the next token, the model represents the world in concepts.
It is early stage, but it is the most interesting item on this list: a step past the LLM toward machines that can break down concepts and actually help humans work. One to keep an eye on.
LCMMetatokensembeddings - 10
10. Model Distillation
Model distillation: a big teacher model trains a small student model. It is how many claim DeepSeek copied ChatGPT — ask DeepSeek who it is and it used to answer 'ChatGPT.'
The numbers make the case: a distilled Qwen 2.5 hits 85.6% accuracy; the full model buys you roughly 3 more points at ten times the size. Diminishing returns in accuracy mean you have to verify the output anyway — so run the model that is ten times cheaper. Smaller models are the future.
The plateau confirms it. GPT-5 landed disappointing: slightly better, nicer UI, web search and reasoning bolted on, but it feels like the models from a year or two ago. Like the combustion engine, the field had its burst of innovation, scaled vertically, and hit the flat part of the curve.
distillationteacher-studentsmall models
Transcript
talk about the 10 AI mental models every JavaScript developer should know. In start with number one, the model spec. The model spec was released by Open AI, and so basically the main idea behind the model spec is that software is a projection of the specs. It's not anymore about writing code, but rather writing specs, writing specifications. So basically, you write your specifications in markdown files and then you have your agent generating the software based on that.
So software is a projection of the specifications. The specifications look like this, they can be very high level, like respect the letter and speed of instructions, assume best intentions, but then you can go deeper and even specify things about the implementation, like what library to use. This idea comes from looking at higher level languages like JavaScript, where we have this higher order syntax, which looks like English, but then we transpile that or interpret that into machine code by an interpreter or in the case of compiled languages like Java, by a compiler.
It's the same pretty much with how React builds the UI, where we have state and props in any component definition and we take all that and we project that to a UI using React, which builds the fiber tree and the video. So you can say the UI it's a function of the state or, you know, the code it's the function of the specs. So this idea it's not old and it's been reused in the software world many times.
Now, before we go on, let me introduce myself, I'm Bogdan and five years ago together with my brother Josh, we started a senior dev where we hope developers go to the senior developer and beyond. Check out free training. in the description. And the reason I decided to make this video is because in one of our coaching calls, one of our mentees mentioned, hey, I'm really demotivated because I watch all these videos on YouTube and I feel like AI killed the software jobs and it's pointless to learn.
It's pointless to get better. But remember, you always feel things that you don't understand. And so And by the end of it, ideally if you're a developer, you'll have zero anxiety about your future, you know how to use the technology and you won't be afraid that you'll be replaced by some LLM tomorrow. And so let's go back to the main idea, which is that the software becomes a projection of the specs.
But what's a projection anyways? Well, going back to my mathematics class in my engineering degree, we used to project vectors on planes. And so basically you have a three-dimensional vector, which is a series of values in this case, because we are in a 3D plane, it's a 1 1 1. And then when you project that to the plane, it basically becomes a 1 1 0. This is pretty much what we do when we build maps from a 3D environment, but then you go on Google maps and it's all flat, right?
Basically, the space was projected on that 2D plane. It's a mathematical operation. Going back to projecting this vector on a plane, looking at code compilation in React, building the DOM. The question is, what do these three things have in common? And you guessed it, they are all deterministic. Well, a deterministic system in mathematics, it's a system where there's no randomness involved. And so basically, if you know the initial conditions of the system and the state transitions, you can guess the state it will find itself into.
Basically a deterministic model will produce the same output given the same starting input or the initial state. The most important part here is the no randomness involved part. Well, deterministic systems are very scalable and they are predictable and they are valuable. Civilization was built on top of deterministic systems, like the combustion engine or the jet engine, or any kind of precise concrete information systems.
Like the CPU, the von Neumann architecture, and pretty much all the internet before LLMs. And before we move on, remember that no one will trust an elevator that failed even once. Or a plane, a vaccine, any accounting software, supply chain software, banking or any kind of critical infrastructure. Those things cannot fail. They need to be concrete and they need to give predictable outputs. Going back to their idea, of software being a projection of the specs. What I found out working with cloud code is that there is nothing further from the truth. Whenever you prompt an agent, no matter the agent, no matter the module, you will get something that's pretty much all over the place. Sure, there will be parts of it that look very good and very legit, but there will be a ton of work to get from there to actually working software. And so what I've seen is that LLM code it's at their best and interpretation of the context provided. And different models might interpret your specs differently. And this is because randomness and hallucinations are not a bug, but rather the main feature of large language models. You know, you might ask yourself, okay, what about using gen AI for generating non-critical software like internal tools? Yesterday, Sebastian, the CEO of Klarna, one of the biggest financial unicorns in Europe and also in the US, mentioned that they'll basically replace Jira and Atlassian and Bitbucket with a vibe coded software that they did internally in two weeks. This is a real thing, people are starting to really reinvent everything and building their own tools. But why are we reinventing the wheel? I mean, what about the principles of buy or built or low code tools like Zappier and Rethll, or just dumb building it at all? Is that really the most important activity that you can do as a financial institution building your own internal ticketing system? I disagree. And I disagree because we don't buy software because of the code, we buy it because vendor, they organize the problem space and made all those decisions for us. So we don't need to go through that process, we by the way they model the problem space and the solution into this executable artifact. executable knowledge that is a software. And what we buy, it's a knowledge service embedded or delivered as a software, we don't just buy the code. Code by itself has no value. Yes, you can go ahead and build your own ticketing system, but there's a saying that engineers will build their own coffin, so you can be basically also redesign the tables or the chairs that you use or the keyboard and pretty much reinvent everything. Because you'll build it customized to yourself, and I'm sure you'll get so many productivity increase.
prices. Well, before we move on, let's remember software engineering is programming over time. Writing some code, writing a program, it's not that hard. Building software, it's hard. And so going back to this picture, a lot of people will tell me, well, maybe it's the prompt, maybe it's the specs. And the internet will say that you get bad results from AI because you don't know how to prompt it. That's the main idea, that there is a special way to prompt the AI that you don't know yet, that will actually give you the results, the magical results everybody talks about. I looked up prompt engineering. But then it turns out it's already dead and something better came along. Which leads me to the second concept, which is context engineering. Basically, context engineering means that you will not only fit the specs, but also style files like cursor files or cloud files generated by cloud code. And then you'll index your whole code base and maybe some documentation websites, maybe internal documentation from your company, maybe some existing tests. And you kind of vectorize that and you feed all that to the LLM and then you'll get better results. And that's what they call context engineering. I failed to see the engineering part in it, but let's go with it. The reason we can do that is because the context windows in models just went up. And so we saw AI companies basically competing to which one has a model with a bigger context window. And one of the biggest is Gemini 1.5 Pro where you have two million tokens. How much is it? Two million tokens? What does that mean? Well, you can basically tokenize text, and in general, as a rule of thumb, a token would be around three to four characters. So that implementation of the debounce function that we have right there, that would be around 51 tokens. 2 million tokens is basically four times cracking the code interview, the whole book in a single prompt. And let's be honest, a lot of the companies you probably work for have less business information or processes written down than four times this book. It really feels like we can just feed all that to the AI, like the context window, it's not a limitation anymore. But what we actually finding out is that there is context to it.
problems of decreases as you increase the number of tokens you provide with it. And it does so exponentially. So you actually get much better accuracy if your context it's very small. Which means we are back to square one. And so it's easy to get LLMs to write code, but it's extremely hard to get them to build software. Now if you are a JavaScript developer and you do want to get better at building software, we will help you become irreplaceable, develop senior level thinking and thrive despite AI and layoffs.
Check the link to the training in the description. How do we handle the fact that we want our LLMs not only to write code, but write code with the latest versions of the libraries we use. Like for example, you wanted to use React 19, you don't want suggestions or examples or components that use class components or React 16. Well, that's where our fourth concept comes into place, which is retrieval augmentation generation.
And this one is really interesting because normally you would have the users send a prompt to the LLM and get an answer. But with Rag, we basically have a context store. That means we take information from your company or the specifications of your product, and you kind of vectorize that and provide it as a context store. And so whenever a user asks something, a secondary model will embed that prompt and identify semantically similar content in your context store and put it together and stitch it together in a bigger prompt.
And so you are passing much more context to the LLM. So even if, let's say the LLM was trained on React 18, you can actually get answers from React 19 by giving it in the prompt using semantic search. This is a very good technique and I believe this is actually the future of AI in the enterprise. The techniques are to build this kind of system, you just need to know a lot of software dev. Moving on to concept number five, Agentic coding, this term has been thrown around so much, but it's basically about recursive LLMs.
So you've probably seen on YouTube everybody, it's amazed by cloud code. I over spent too much money on it. I bought the max plan. It was money not well spent. I do recommend you to try it out. get most of the value in the in the lightweight mode, or get your company to maybe pay for it. If not, you could use query code, which is very similar in performance. Agents are being hyped a lot, but in reality, it's a recursive self-calling large line which model.
Basically, it makes a pseudo plan, then it defines the success criteria that it extracts from the prompt, which is your base case, and then it keeps iterating onto yourself or a sub agent until that prompt is basically achieved. So, pretty much like a wide loop, but you keep playing the LLM until you get the satisfactory results or until the LLM thinks it got a satisfactory result. Now a lot of people think this is kind of a jet engine level of technology and it's mind-blowing and it will replace human workers, but then you go under the hood and you look at cloud code and this is what you find.
This is the actual code, it's literally just prompts the staff at Anthropic wrote and they're being sent as you use the agent. A lot of things got my attention here, but you see this very important clause where it says, when you have completed the task, you must run the length and type check commands. with bash if they were provided to ensure the code is correct. Basically, they are telling the machine what to do by using prompts, and there are a lot of problems with using English as a language for coding.
The number one is, remember, LLMs are statistical. So, if you really want to make sure that the LLM ends up actually executing something you ask it, you probably have to repeat that that clause again and again. It's basically like teaching a child. You will just repeat and repeat and maybe, if you're lucky enough, they will end up doing what you say, but again, there's no guarantee. The only way they actually guarantee a good output is by having all those clauses repeated all over and then stitching them together and passing them into their models.
Cloud context window, it's around 200,000 tokens, so they can afford to do that, basically, taking your code, indexing it, adding all the stuff around it and then querying the LLM recursively until they get a great result. I do not think the software of the future will look like that. And I'm not the only one, as Edra, a leading computer scientist of very long time ago, I suspect that machines to be programmed in our native tongues, be it English, Dutch, Jamaican, are as damn difficult to make as they would be to use. And so using English as a programming language is not a new idea. And the reason why we have high level languages
is because we did wanted something that looks like English, but it's also precise and deterministic. And so, programming languages are an evolution of the English language, not the other way around. Now, I highly recommend that you read the article, I will link it up in the description, because it will really give you a non-hype first principle thinking version of programming in natural language. And by the way, if you do want to know where your skills are as a JavaScript developer, check our free technical assessment. It's ajentic, by the way, because supposedly that sells these days.
It's actually not, okay. It's very deterministic. It will basically help you figure out where you are in the seniority scale, what are your technical gaps, and what are the next thing you should focus on to get to the next level. Okay, let's say you managed to vibe code your front end, and now you want to integrate it with the back end. That's where MCP comes in. And you probably heard about it because it has been all over the web.
I mean, MCP really sounds like the next big thing, and it's the most important thing in tech right now. At least, that's what you'll find if you just look for it on YouTube. It's a protocol, an open standard that enables the developers to build secure two-way connections between their data sources and AI power tools according to antropic, the company behind it. Basically, if you want to build agentic LLMs, you'd have to use a qlang the LLM, and then maybe the LLM would end up making calls to external services.
But all models will cut code their own logic. There was no standardization. And so antropic released MCP, which basically has two parts: a client part that will be used by the model and a server part. That is basically like a wrapper around existing API. And so when the model wants to do something on behalf of the user, let's say they want to call Google Maps, find a place, then they'll call the MCP client of Google Maps, and that ends up calling the MCP server, make a maps query, figure out where a place is or if it's open.
And then the model will come back to you, it will digest that information and come back with the answer you needed. So it basically gives models the ability to call all these APIs without having to reinvent the wheel, just by standardizing everything. Because MCP, it's a universal standard, so Open AI and all the other companies also compliant with it, so you could switch even your model, but still use the same MCP clients and the same MCP servers.
There's different things inside MCP, like tools, resources, prompts. And the funny thing is when it came out, nobody really cared. But then three months later, it just blew up. The first MCP servers were actually maintained by Anthropic. They literally build like 10, 20 of them. Because nobody really cared when they released it and it felt like it's not relevant. So one of the best way to add relevance is by building those those servers into it.
The way it looks under the hood is very familiar. You have JSON RPC, that stands for remote procedure calls, which are basically a way for the front end to run functions on the backend. Uh you probably used TRPC, which is done with TypeScript, but remote procedure calls have been around ever since the 90s. You would have them in Java, but then the world moved towards HTTP and rest APIs. And now they are coming back.
Now, my biggest question is, okay, why why don't we just use open API? If you just want to provide context to endpoints, you already have open API standards. where you can literally define what each endpoint does. And we have rest and those things are very mature, very easy to use technology and a lot of people know it. MCP is kind of combining prompting and APIs. Um they claim it's for standardization.
I do believe it definitely standardizes certain things, but again, we did have rest APIs between graph crawl, very established protocols for data communication. They also claim it's all about context. because it allows you to kind of write a description for every tool and then the LLM kind of consumes that and knows what to do with a specific tool. But again, we had description fields both in GraphQL and in TRPC and we have that in rest APIs too.
So again, kind of redundant functionality here. They do do this novel thing, a novel thing is that you can use tools and resources together, which is basically combining rest APIs with remote procedure calls on the same server. Again, nothing new. With remote procedure calls, you could tell the LLM to go and schedule a meeting for you in your Google calendar. It's it's actually a function that you can execute on the server, it's not just calling rest endpoints to consume resources.
And the last thing they added to it, it's kind of native HTTP streaming because a lot of communication in those LLMs happens by streaming tokens to a certain endpoint or from a certain endpoint. Now, to be very honest with you, I believe NCP is just a glorified rest API with remote procedure calls combined in an effort that this model developer companies like Open AI and Anthropic are making to give some technical substance to the AI coding movement.
So they really need to argue that this is a great technology and I really feel like this is sort of a made up protocol. They are combining it with HTTP, but it has nothing to do. It's not even as disruptive as graphQL was back in the days. So I do believe that at least from technical perspective, it's highly underwhelming. Moving on to chain of thought, when Dipsy came out, this was a big thing, probably in January.
But it turns out LLMs can actually break down tasks just like humans do. Whenever you query one of those reasoning models, they will kind of break down your task. of thought, even if they were part of the solution. And that's when they started wondering if chain of thought is actually what the model is doing. Even if you ask GPT what chain of thought is, it will tell you that it's not the transcript of the internal neurons, it's not the internal thinking of the model.
It's under the hood, the model is still doing just token prediction. The visible steps are actually generated with a helper LLM and constructed. So, it's helpful for you as a human to feel like this LLM is thinking, but that's not the exact steps the LLM is following. Basically, it's just a fancy loading indicator. The LLM is really literally giving you the impression that it's thinking and doing the task in a sequential way.
But that might have nothing to do with how it's doing it under the hood. Okay, now we're getting close to an end. But how can LLMs handle that much context? We've seen some LLMs handling 2 million tokens. Now, a concept named the rate, it's time to test compute, also very popular. And in this one, you have the model coming up with three or five solutions and then they's a reward model internally that chooses which is the best solution.
And then it keeps iterating and doing that until it ranks uh the final output and finally gives you a answer. Again, when this game out, uh it was sold as such an improvement. You'll see this term thrown around just like all the others in all the AI talks. But in reality, what Deep Mind found out is that for hard questions, this is actually detrimental. It only works for very easy questions like if you ask the model, what are the colors in the flag of the US?
Then yes, you'll get like a better accuracy, but if you're going into math problems, it's actually works against you. So it's again one of those experimental things that was sold as an amazing breakthrough, but it turns out it's just another technique that can make sense for certain problems with certain models. Finally, there's the LCM, the language concept model, this is coming from meta where rather than parsing text into tokens and then into embeddings and having an LLM predicting the next token, We model the world in concepts.
And to be honest, I'm quite excited about this one because I do feel like LLMs can be very useful into breaking down concepts and helping us human work. And I think it's a step to moving past the LLM and keep advancing into smarter machine intelligence. It's in the early stages, but I'll say I'll keep an eye on it. Finally, model distillation, you probably heard about this one, but basically, you have a teacher model, that's a very big model that you can use to develop a smaller student model.
A lot of people are claiming that's how Deep Sick copied chat GPT. If you ask Deep Sick who are you, it usually answers with chat GPT, or at least it used to. The reason I'm excited about this is because a distal model can be 10 times smaller, but you still get very good performance. So, as you see in the picture, a distal version of Queen 2.5 mat will give you 85.6% accuracy, whereas the full version will give you 3% more accuracy, but it's 10 times bigger.
And so smaller models are the future because you get a diminishing return in accuracy. Which means you'd have to verify the output anyhow, but it's a lot cheaper to run. And this is confirmed by the release of GPT-5, which you probably seen was very disappointing. We are reaching a plateau. This probably happened already last year where open AI is out, the models are not getting better. That's why they took so long to release GPT-5.
Now, I've been using GPT-5 in the last month, and to be honest, I don't really feel any difference with the models from three years ago or even one year ago. I mean, yes, it's slightly better, the UI got better. It has the the whole web search and the reasoning, but overall, it kind of feels the same. Chat GPT. Now you probably heard that AI engineers are making a lot of money. You've saw Facebook trying to post people from Open AI, then Open AI offering uh bonuses when GPT-5 came out.
And so it looks like there's a talent fight and like being an AI engineer is the next thing. You should be thinking that you should become an LLM engineer. Take into count, it's a different career path in itself. There's a lot of mathematics, a different ecosystem, and a different line of work than traditional software development. And it's very niche. So, it's just like cloud computing back in the days, there's a few companies that will build it, they're building this AI infrastructure layer. And a lot of companies that are just integrating the models. So a lot of the money is done into that final mile, that final implementation. And that's where a lot of work it's for software developers. There will be a couple of companies building models, but it's not that many. So it's a very small market and there's a higher barrier of entry. You need a masters or a PhD, usually a couple of post doctorate studies to really get in at that level. And there's huge competition because most of computer science students are moving towards graduating in ML and AI. And also there's an negligible salary increase over the long term. So, yes, there's a few people making tremendous salaries like in any sector. But if you take out the average, if you get to staff engineer and you stay there for a while in normal software engineering in the US, you will probably average out almost more cash at the end of the day. And again, you have more flexibility, the market is a lot bigger. So don't rush into this niche markets because yes, they sometimes have bigger compensations, but there's few positions, it takes longer to get one. Uh there's not so many employers, you lose flexibility. Uh be really careful, don't just look at the number itself. And so meanwhile, people are freaking out about AI and telling you should become an AI engineer or a prompt engineer or whatever that is. I get messages like this from our mentees, he just secured a senior front end position with a great salary, a salary that's even bigger than what people were getting two or three years ago, a 61% pay increase, building traditional SaaS and it's over six figures in Australia. But we have a lot of cases in the US. And so beware that it's a cost of opportunity.
If you're already good at software, you'll make a lot more, if you stick to it, sell yourself well. Now what you want to avoid at all cost is coasting, especially if you're employed, you put your head in the sand, you just survive. A lot of people are doing their job with AI, just copy pasting, asking GPT everything. The next layoff round will catch you off guard and you risk taking, you know, six months to one year to find a new position.
Uh if you're rusty or settling for a job that will pay you a lot less. What we see people getting rehired after layoffs are they get a much lower salary. So don't coast, use your time well. Get better at the craft, we'll see a lot of the shiny objects in the um people get into learning Python, sometimes their own companies pushing them to learn Python, even if they are a JavaScript software engineer with TypeScript React Node.js.
People go to build their own models or get some prompt engineering, set up some agents. It doesn't really help because as you've seen, a lot of those things are hyped and sometimes there's no fundamentals, so you waste a lot of time on loose ends. Other people are just ignoring AI, but you can't do that. You need to learn the vocabulary, learn the main technologies, maybe even build an MCP server yourself.
And add AI assisted coding skills to your resume, companies are buying it and so you want to use their FOMO if you're missing out to your advantage and really use it to stand out. Other people are quitting software engineering, then do that creates are a long-term bet. If you constantly work and get better over a long period of time, you'll be an unstoppable force. When things get tough, you're more sure you got to have the job.
I truly believe LLMs are a great tool. I think it's another step towards more intelligent machines or at least machines that will make our work more fun. But right now we are in the point in the market where the market is very far away from the truth. They are racing not towards intelligence, but rather towards raising money. And they're trying to sell certain products to their enterprise customers.
That is the motivation of all those vendors, including Microsoft with Open AI and Anthropic. And that's okay. It's not that ideal. evil. That's just the incentives they have. But as engineers, we want to take a step back and always apply first principles thinking and break those technologies apart to really see what are they selling to us. And what you'll see in the AI world is that the technical depth of the field did not increase exponentially in the last five years.
We actually had a linear growth. Some hardware improvements and then the models were scaled vertically where they got much bigger. But now we realize that there's a plateau there. And just like the combustion engine reached a plateau back in the days. So technologies usually follow this trend where there's a lot of innovation and then you reach a plateau and then you need to move on and innovate again.
Now, if you're a Java script developer, remember we can help you become irreplaceable, develop senior level thinking, using mental models and thrive despite AI and layoffs. So check out the links in the description and I'll see you in the next one.