-: Hey there, Eden here.
And this video is all about FOMO, the fear of missing out,
and in the ever-changing rapid-pace environment
that we live in.
And specifically I'm talking
about the AI development environment.
So there is this blog which Andrej Karpathy wrote
at the end of 2025, which really resonated
with a lot of people, including myself.
And I think it encompasses a lot of ideas
which I actually agree and believe in.
And this ex post is Andrej's sharing his feelings
on this environment that we live in.
So he says that, "I've never felt
this much behind as a programmer."
So this is very true and I can totally resonate with that.
And I feel it every day
because there are new things coming out every day
and it's really hard, sorry, it's impossible
to keep track on everything
that is happening with all of the AI development.
"The profession is being dramatically refactored
as the bits contributed
by the programmer are increasingly sparse and between.
I have a sense
that I could be 10X more powerful
if I just properly string together
what has become available over the last year,
and failure to claim the boost
feels decidedly like skill issue."
And here he is referring to the FOMO feeling
that we have all been living with,
because we see tons of announcements
and we really don't have the time
to go and dive into everything.
He says that there's a new programmable layer of abstraction
to master in addition to the usual layers below,
involving agents, sub-agents, their prompts,
context, memory, modes, permissions,
tools, plugins, skills, hooks, MCP, LSP,
slash commands, workflows, IDE integrations,
and the need to build an all-encompassing mental model
for strengths and pitfalls
of fundamentally stochastic, fallible, unintelligible
and changing entities suddenly intermingled
with what used to be good old-fashioned engineering.
And the TL;DR for this
is that the software stack has changed.
We no longer write code, we write prompts that write code.
We write prompts that execute
in agents or subagents which invoke tools,
and we get the artifact,
and we are becoming the orchestrators.
And the skill of software engineering
is transferring from being a good coder
of knowing the right syntax
and how to use the technologies,
but to have a more higher-layer orchestrator role.
So we now manage a team of agents
where each agent is doing something else.
And I really like the comparison
of a team lead which manages engineers.
So the team lead goes
and tells the engineers what to do.
The team leader reviews their work, gives them feedback,
and these loops goes on and on and on
until we get the final product.
And the same work
a team lead is doing with engineers, we do with our agents.
We give the agents tasks, we see how they're doing,
we sometimes give them the correct tools
and the correct skills to perform those tasks.
And the work shifted more to review
than to the actual writing and implementation.
And this is a fundamental shift
that we are experiencing right now.
Now, all of the tech stacks of agents,
subagents, MCP, LSP, slash command,
workflows, IDE integrations, this is all true,
and this is the new tech stack.
This is the new programming language of the future.
And I think we have great privilege
to experience this firsthand as everything rapidly evolves.
So we are actually witnessing a paradigm shift
and a new abstraction layer
that we are going to work in order to create software.
So if in the beginning of software,
people used to have punch cards,
which they give the machine
and this would run the code, then we had Assembly,
then we had C++, which abstracted Assembly,
then we had Python, which abstracted C++,
so now we're in an era
where programming languages are abstracted
and English now is the new abstraction.
And the real challenge is for us to orchestrate
how to work with those new abstractions
and to learn to work with their limitations
and to solve those limitations
and to continuously push the limits.
And it talks here about good old-fashioned engineering.
And I have to give you an example
from my personal experience.
So when I was a software engineer,
I hated writing regular expressions.
I hated it.
And there is this website,
I think it's called regex101.com,
and this was a website
that really made things easier
when writing regular expressions.
So we had in our thing, this guy,
he was really, really good in writing regexes.
And every time I needed to go and write one,
I would always go and ask him.
And it was really a skill,
and he was renowned to it in the entire company
that he knew how to write regex.
So everyone who needed to write a regex,
if it was something complicated and not trivial,
that guy was the address.
We always went and asked for this engineer's help.
And today, this skill is actually not useful.
It's like learning how to navigate in a map
in order to drive somewhere.
You have Google Maps, you have Waze,
and today, you can simply ask an LLM
or Cloud Code or Cursor
how to write the regular expression
for what you're looking for.
So, the good old-fashioned engineering is changing.
And there are a lot of skills and techniques
and practices that software engineers had
which are no longer relevant.
And I think being a good software engineer
is simply to be a good problem solver,
and simply being curious,
I think those are the most important skills.
And this is valid for the old software engineering era
and it's valid for the future software engineering era.
And I think curiosity today
is having much more impact on your skills.
Because curiosity, this is what driving the change.
This is what driving to push the limits
and to try things new
and to learn how to do things differently
and potentially better.
And Andrej continues, he said,
"Clearly some powerful alien tool was handed around,
except it comes with no manual
and everyone has to figure out how to hold it and operate it
while the resulting magnitude nine earthquake
is rocking the profession.
Roll up your sleeves to not fall behind."
And I think the key part here is,
"comes with no manual."
And here, actually I think the imagination is the limit,
because all the technology we're seeing of agents,
of coding agents,
of how impressive they get
is a building block on a building block
on a building block on a building block
that will stack up one after another,
each one using the abstraction below.
And it's really amazing to live and see this in action.
And I was lucky enough
to jump on this train when it began,
and I saw how everything evolved,
and I saw how one abstraction
got better and better and better,
and then there was another layer of abstraction
that was created on top of it, which gave us insane results.
And I think the best way to have a deep understanding
is to go back in time and see how things evolved.
Because when you see how things evolved in this space
and you see the iterations,
for example, estate agents,
it all started from a ReAct prompt.
Then this ReAct prompt evolved to function calling,
then with function calling, we got into agentic workflows.
And then after that,
we are in this deep agents era right now
and task delegation and subagents.
And when you're seeing this firsthand
and when you jump on the train
and you see how abstraction is solving problems
from the early abstraction,
you really get in-depth understanding.
And it really removes a bit this FOMO feeling,
because you know what problems exist today,
and when new tools come, you know what they solve.
Now, it says everyone has to figure out
how to hold it and operate it.
So the key thing here is that, of course,
the best practices are things that are in the making.
And we don't have manuals,
we don't have official documentations of imagination,
because it really boils down to imaginations
and to try things and to experiment.
So I think this area here
that we're living in, experimentation is key.
And getting our hands dirty,
as it says here,
is very important in order to do this experimentation.
And in my opinion,
this is the moral of the story of this tweet.
It's sort of assuring us and calming us,
saying that, "Hey, we live in this FOMO world,
and even Andrej Karpathy,
who is a renowned computer scientist,
even he feels the FOMO.
Even he feels not knowing enough and falling behind."
And the way to solve it is to get your hands dirty
and to start experimenting.
And in order to solve this FOMO
is to roll up your sleeves
and to start getting your hands dirty and experimenting.
Now, I have to tell you, the FOMO,
this is something here to stay.
You are always going to feel this FOMO.
I feel it myself.
And I think here focus is really, really important as well.
There are lots of tweets every day,
lots of new technologies, new products
planning to solve X and X and Y.
And I think the skill of distilling the noise
and focusing on what's important,
it's really, really important in this era,
because this is a rabbit hole.
If you go into Twitter, you start scrolling around,
then it's going to have tons of content.
And there is this infinite rabbit hole we can go into
if we don't focus.
And my two cents is that when I go through Twitter,
I see what's new.
I don't go through everything.
I don't dive in deep into everything.
If I found something that interests me,
that solves the problem
that I'm really interested in solving,
I go, I dive deep, and I get my hands dirty.
Cool, so that's it for this video.
And I think my main key point here
is that you are not alone with the FOMO.
everyone is experiencing, including myself,
including Andrej Karpathy.
And we need to accept this FOMO
and we need to keep living with it.