In the 2000s, after making the movie “An inconvenient truth”, Al Gore claimed the Arctic ice will be gone in a matter of months. As of today, the Arctic Ice is still here.

In 2019, Alexandria Ocasio-Cortez warned us that the “World Is Going to End in 12 Years”. Just 7 years after such a claim, I am pretty confident the world will still be around in 2031.

Fear sells everywhere - this is one of the greatest marketing technique (just think about the FOMO many experience on a regular basis), this is why salespeople or politicians use it everywhere to sell their product (be a security system, a miraculous medication or a revolutionary program that will lower your tax and get you more public services at the same time!).

And today, a new fear just landed in our societal landscape: AI, job displacement and more globally, search for meaning. You hear politicians and influencers claims that “data center will turn your water brown” or that “AI is going to take your job”, triggering anxiety among the working class and ultimately questioning our existence and meaning (what will we do if we have no job?).

Instead of fear, I prefer to choose hope and believe in ourselves.

We are resilient and every time we face serious issues, we were able to figure them out and overcome our problems. And instead of listening to uneducated salespeople pushing their own agenda, we’d rather think for ourselves and evaluate if a change is good or not for society.

When it comes to AI, there is a lot to figure out today but there is no question there is a big potential for us. Like with any technology, we will need to adapt but we will grow as a society and get better. Instead of rejecting technology without any good reason, we should wonder how we can use it for the greater good.

Subscribe now

Only a few select companies (bank, insurance) were able to afford and operate them.

About 20 years later, mainframes got replaced by the IBM Personal Computer (PC), which provided more resources for cheaper (my family spent ~$1000 on a 486SX25 in 1992). There was an abundance of computers, the vision was to put a computer on every desk at work or at home.

In 20 years, the space and cost of computing got slashed massively:

• the cost got divided by 50

• what took a full room was now fitting in a box under your desk

Over time, processing capacity keeps increasing and costs keep decreasing.

This story is repeating again today in the AI world.

Today, training and operating large models requires datacenters that cost millions billions to build and operate.

But in a decade or two, the same workload will run faster on a hardware that will cost 1/1000th of today’s cost.

In fact, not even 5 years after the AI boom started, we have solution to operate AI workload locally, like the DGX Spark that costs a few thousands. I can run local models on my M4 Macbook Air and some people are already replacing proprietary models by open-source models on their Mac Mini. The progress made in a few years is astonishing and there is no doubt they will get parity with state-of-the-art models in a few months.

In a few months or years at most, agents will run locally on a $500 device (phone or laptop) and use local data. Companies like OpenAI or Anthropic are likely to be the Netscape or pet.com of this decade. They will need to innovate or die1.

Local models will not only unlock more use-cases, it will open an era of AI abundance.

I believe this is the wrong take.

Writing code is the cheapest aspect of building software. The majority of building software costs are operation (on-call, bug fixes) and maintenance (e.g., adding features, fixing vulnerabilities, deploying in the latest cloud infrastructure). Whoever wants to build their own SaaS will need to take on the maintenance and operational burden.

No one is realistically going to re-implement Gmail, Office 365, or Slack to avoid paying $10 to $20 per month. Companies buy SaaS applications to focus on their core business instead of going on side quests and implementing and maintaining some random software. A food business or a hardware store working on a website does not want to re-implement Slack, build an AWS replica, or re-implement Twilio. And the last thing they want is to re-implement an internal copycat of Workday (with all its legal subtleties) to handle HR concerns.

The few adventurous who want to embark on such a re-implementation crusade will ultimately need to hire engineers to maintain their custom software and ensure compliance with all applicable laws. Unless the company operates at a massive scale, the maintenance expenses will be far bigger than buying the SaaS equivalent.

On the other hand, the impact of agentic coding will lower the barrier to entry to build competitors to existing SaaS products. It will lead to more competition and, ultimately, more options for the customers, which is a good thing. It will also put pressure on existing players to deliver more value and/or lower their prices (and potentially, their margin).

The hard part is to leave while it’s still good, almost at the top, and avoid dragging a falling project or a dying relationship for months or years. Too often, people keep working on a project even when it degrades or gets bad, hoping greatness will come back or trying desperately to milk some last bits of success. This is a losing game: you will not only lose your time, but people will always remember these last painful moments.

You need to stop at the top, before quality erodes. Admit that the best happened and move on to your next venture. There is nothing worse than trying to constantly repair something dying or broken.

Move forward.

There is HuggingFace, but the user experience and overall interface cater more to ML engineers than software engineers and builders (hint: try to build something from HuggingFace, unless you have solid knowledge in the domain, you will not go far).

Platforms like lovable or v0 have community portals that showcase projects built by their users. Sharing projects instead of repositories may be the right approach. New platforms would allow users to copy and modify existing projects for their specific use-case.

We are still in the beginning of the AI revolution. I am not sure if existing platforms will stick around for long, but I am convinced there is a need for a new AI-native developer platform. I am not sure what it will look like, but it seems to be where the industry is going.

Made in America is the biography of Sam Walton, the founder of Walmart. The book goes into how Walton started and expanded Walmart from his first variety store into the retail juggernaut Walmart is today. There are a few striking points in the book about either entrepreneurship or the status of our society and country.

Innovator Traits

Walton understood early on (in the 1950s) that discount stores (defined mostly by small margins and high volume) would take over variety stores. He was customer-obsessed since day one and relentlessly tried to innovate. Walton was not afraid to copy his competitors. Walton always visited stores everywhere in the country and took notes on his legal pad or using his microphone. There was no ego involved and Walton does not hesitate to credit Sol Price (the creator of FedMart and Costco) for many ideas.

Many ideas we see in tech today (e.g., customer obsession at Amazon or scaling laws) were already in place at Walmart, and they directly influenced companies like Amazon.

Status did not matter

Walton bought some expensive houses once he became a billionaire but never tried to impress anybody with a lavish lifestyle. He stayed true to some core values and principles. Many associates tell stories where he often shared hotel rooms with his employees on business trips or sometimes skipped paying the hotel and slept directly at an associate house.

Walton also reflects on his life and admits his mistakes, either professionally (e.g., when he was too late to open a new warehouse or when he was not giving enough recognition to his employees) or personally (e.g., not recognizing enough women in the retail industry - his wife changed his mind on this topic).

Build Stuff People Want

Walton success thesis is simple: build something customers want. For the Walmart case, variety stores had high margins, had limited opening hours, and some did not treat the customer well. Walton reduced prices, opened stores every day, and made sure the customer was treated properly (have you seen the greeters at Walmart?).

These are extremely elementary principles, and yet, the competition did not understand them and failed to execute.

The same principles guide many startups today. Even YCombinator had the motto “Make something people want”. Walton did not invent this concept, but he applied startup principles of today back in 1940, and it worked extremely well.

Keep Operating

Walton always stays true to some simple business principles and keeps operating according to them. For example, a key principle was to always pass any savings to the customers. Another one was to always treat associates right (at least, during his tenure as CEO). He never lowered his standards. He changed them sometimes when it made sense but never compromised.

Even when Wall-Street and other analysts were calling him done, he kept operating according to his plan and refused to change because of some trend or financial analysts called Walmart as done.

Walton weathered many storms in his career, and every time, what saved him was to stay true his fundamentals: listen to the people who cared about him since the beginning, focus on bringing value to the customers, and grow organically.

The same applies in startups: we may see many ups and downs and trends. But in the end, what matters is to build something users love and deliver value.

Apple’s original core vision

The original core vision of Apple was to build the best products on earth. And they did it at the best price they could, but never at the cost of quality or user experience. And they fulfilled their mission: to this day, many Apple products are unmatched.

Through the first 30 years of existence, Apple defined key tenets for the brand:

• differentiated branding and marketing (people still mention the 1984 ad that the Apple board originally refused)

• premium design, either software (iOS, macOS) or hardware (Macbook, iPhone) — Apple ships the best product; they do not ship junk

• world-class user experience

• privacy-first: people pay for the product

Through the years, Apple managed to innovate and ship products that redefined our industry. Jobs said it better than anyone at the launch of the iPhone.

Every once in a while, a revolutionary product comes along that changes everything and Apple has been – well, first of all, one’s very fortunate if you get to work on just one of these in your career. Apple has been very fortunate. It’s been able to introduce a few of these into the world.

However, since 2007, Apple stopped innovating.

Instead of staying an innovation machine, Apple became an iteration machine. They no longer ship products that redefine an industry. They ship iterations or marginal improvements of existing products.

Search for Meaning

What’s next after the iPhone?

Tim Cook surfed the wave started by the iPhone tsunami. He squeezed every penny from it: Apple made some features extremely expensive and they forced developers to pay a 30% Apple tax on every sale within an iOS app. Anything Apple launched since the iPhone is not a breakthrough innovation; it’s a marginal improvement.

Tim Cook managed to make Apple a remarkable company from a financial standpoint, but he failed to keep the innovation flywheel going.

The issue for Apple is to find the next big thing.

For some time, people believed it was the Apple Car. But after years of development and refusing to buy Tesla in 2017, the project got canceled. Apple stopped iterating on this idea, even if they had billions in the bank to do so.

The recent flop of the Apple Vision Pro gives us a better peek at the change of culture at Apple. Despite the technological achievements, Apple needs to face the fact that nobody wants to spend $4500 to live with googles strapped on their face.

There is more evidence that Apple is lost and unable to ship anything significant. When we see major improvements in AI every day, Siri is still struggling.

What values?

Apple has been one of the best brands in terms of marketing. The brand positioned itself as a premium brand, and their advertisements were designed accordingly (see “Here’s to the crazy ones”). They communicated their values very well: innovative, great to use, and user-friendly.

But today, such values are gone, and Apple is lost.

Take the Apple commercial about the environmental footprint. The ad made the Apple CEO Tim Cook like a child being lectured by a morbidly obese “Mother Nature”. The ad is childish and makes the Apple CEO appear stupid and out of touch. Jobs would clearly never have approved this (he mentioned once that one of his biggest mistakes was to make a teleconference with Bill Gates where he appeared on top of him).

More recently, for (another iteration of) the iPad, Apple launched the commercial Crush!. And yet, it was another huge marketing miss where Apple suggests they are crushing creative people, the same population who want to “Think Different” and bought Apple for years. At a time when people are afraid that AI will take their jobs, it was the worst message to send.

What future for Apple?

There is no question that Apple will keep making profits from their products for the years to come. There is no iPhone replacement today. And attempts at shipping AI-based products (humane pin, rabbit R1) to replace it are failing.

But this will not continue indefinitely. The lack of innovation, coupled with the few disastrous commercials, shows that the company is searching for meaning and in need of changes.

Apple needs to reinvent itself, know who they are, and find what their next big thing is.

The early players are now irrelevant (who still talk about GitHub copilot?), and model providers are doing everything possible to go beyond the API and capture the value delivered at the application level. We are seeing this with coding tools (Anthropic with Claude Code, OpenAI with Codex, Google with Gemini CLI) and it starts to happen in other domains as well (see Claude for financial services or even the AI companions from Grok).

There is the workflow I use today for:

• search: any search is done with ChatGPT desktop. When alone/at home, I rely on voice mode and type when in the office. I rarely use Google anymore and when searching, use alternative search engines (brave or kagi)

• large coding tasks: I use Claude Code (at work) or Gemini (at home) for any coding tasks larger than 2 lines. Both Claude Code and Gemini have similar performance and write 90%+ of the code I ship today.

• refining code: I use whatever is integrated in my IDE to refine the generated code and complete a line. IDEs like JetBrains have internal inline completion that are pretty good and free. Users now expect IDEs to have a good inline completion out of the box.

I feel we are still not in the final stage of what AI-enabled development tools can do. We may abstract them more and instead of writing code in the command line, integrate them into projects management tools (e.g. Jira). Claude Code or Gemini CLI may be the cool kids today but I wouldn’t be surprised if new tools come in a few months with a better integration into the developer workflow.

The ATM around the corner is likely running Windows XP.

Windows 3.1, was still used in France ten years ago, 23 years after its release in 1992.

The San Francisco Municipal Transportation Agency (SMFTA) the closest city to the heart of Silicon Valley, paid $212M in 2024 to get off floppy disks.

There are many other examples: your bank or insurance likely relies on COBOL, military systems rely on old versions of the Ada programming language, and many satellites still operate on old CPUs as powerful as a 1980 Gameboy.

I am in awe when I see how far users can go to make an existing system last. Despite a product being declared obsolete, users still try to do everything possible to use it. This is a testimony of how much users love the product and how robust it is.

In a world where software is becoming disposable and a JavaScript package may no longer be viable 6 months after its release, I admire engineers who put in the effort to design a system that can last decades. I equally admire those who hack to make obsolete systems still usable today and push them to their last limits.

Building any piece of software is becoming easier every day. Even with the help of coding agents, building great software that lasts is still hard.

General Design Choices

Aider is developed in Python, which is the language of choice when it comes to write ML applications. Where opencode uses the Vercel AI SDK, aider relies on the Python litellm to stay platform agnostic. Like opencode, it can interface with many models, either remote or local (if you use ollama).

A good entry point is the base_coder.py file that contains the main iteration loop. The file models.py contains the code that initialize the models (along with the tools).

Multiple Modes, Multiple Agents

Aider provides multiple modes, each of them has its own prompts and set of tools. For each mode, there is a new agent, built around a new prompt.

• code

• ask (prompts)

• architect (prompts)

These agents have the same capacity (e.g. tools), the main difference is the initial prompt passed to them.

Code Indexing

Coding agents index your code incrementally. When you open a repository for the first time, the agent indexes the entire codebase and updates the index incrementally upon code changes. Aider supports all languages supported by the tree-sitter-language-pack, a collection of well-maintained tree-sitter grammars.

Aider indexes the code through a Repository Map, where it extracts symbols (also known as tags) definition (class or function/method definition) and reference (e.g. there the symbols are being used). This is implemented through tree-sitter queries that run queries (example of queries for Java) against each file. It qualifies the type of tag based on the name associated with the query.

This information is then saved in a SQLite database to make it available at the next execution and easily query it. The SQLite database is abstracted by the diskcache library.

Prompt Building

The prompt itself is built using some base strings (as shown in ask_prompts.py or architect_prompts.py). Then, the prompt is augmented with the code structure, which comes from the code index (aka repomap in the aider terminology). The enrichment logic resides in the repomap.py file and it attempts to pack the most information in the number of tokens available by ranking the data.

The code index sent to the prompt contains the class and function definition signatures. It’s enough to understand the structure of the code but it does not contains any information about the implementation of the function itself.

Comparing opencode and aider

The goal is not to compare the performance of the tools but the commonalities in the architecture. This gives you trends about what to use to build a coding agent and what may make a difference.

Common Patterns

• Both use a high-level library (AI SDK or litellm) to stay LLM provider-agnostic

• Both specialize their prompt for a particular task

Differences

• opencode augment the LLM calls with tools to understand the codebase better. aider relies on its repository map to feed the architecture of the software to the LLM

• opencode does not need explicit files, it finds what artifacts matters using tools (like grep)

• opencode keeps a tool that manages the todo list to keep track of what to do to accomplish a task. Other tools like Claude Code or Gemini follows a similar approach.

Opencode is an open-source coding agent. It’s similar to aider, another coding agent that I will review in another post. Note that there are different flavors/forks of opencode, I will use the sst repository to explain the code.

What is an agent?

With all the hype around AI and LLM, everyone has their own definition of what an agent is. From a technical perspective, an agent is a program that keeps calling an tool-augmented LLM until a condition is met. By “tool-augmented LLM”, I refer to a call to the LLM paired with some tools1 (edit a file, read a file, fetch some documents online, send a text, etc) to augment its capabilities.

From a programming perspective, an agent is a while loop that keeps calling the LLM until a final condition is satisfied (for example, passing a text, getting the answer “yes” by voice or just getting an answer from the model). The LLM is augmented with tools to make progress on a task, be it reading a file, editing a file, getting semantic information or doing websearch. To give a concrete example, when ChatGPT searches the internet for you, it uses a web search tool to find information on the internet for you. Coding agents use tools that read files, grep the codebase or call LSP-related features (find a symbol definition, list the functions with a specific name, etc).

The mental model to keep in mind is something like the snipper below. The callLLM() function is where the tools are added to the LLM call.

while (true) {
  result = callLLM(message)
  if (isFinalConditionMet(result)) {
    exit()
  }
  message = updateMessage()
}

Coding Agent in a Nutshell

Your coding agent is simply iterating on messages sent to an LLM until your condition is met. The agent sends in its message the list of tools available and the argument of the tools. The LLM returns either some text or requests the agent to invoke some tools. You can see a very simplistic message sequence of how this would work for a very simple function creation.

OpenAI has some good documentation about tools, the important part is that all tools are executed locally.

Model Interoperability

There are many model providers today (OpenAI, Anthropic, xAI, Mistral, etc) and each provider has its own way to call a model and handle tools, making it hard to switch models. Opencode uses the AI SDK from Vercel, which abstract model providers and lets developers write provider-agnostic AI agents.

The core of the model orchestration is done in session/index.ts through the function streamText(). Initializing the models along with the tools is done in provider/provider.ts.

The beauty of using such a framework is simple: you can focus on building the core of your application without having to worry about what platform or AI framework you can use. Any developer building an AI application should rely on such a library (AI SDK for TypeScript, Langchain for Python) to avoid any platform dependence.

Prompt quality matters a lot

The prompt size is no longer a major constraint but the quality of the prompt is really what matters. Editing or analyzing a monorepo with 1000 files and trying to update only 2 files is like finding a needle in a haystack. And to make your LLM finding the needle, you better give it really good instructions.

This is why the quality of your prompt matters. A lot.

The prompt for opencode is quite long and gives a ton of examples of what to follow. There are some general guidelines to follow for a good prompt:

• be extremely explicit about what you want. If something matters, use CAPITAL LETTERS TO INDICATE YOU CARE ABOUT A PARTICULAR INSTRUCTION.

• keep using Markdown to write your prompt. Hierarchical information with titles using the # character and very important information using ***BOLD***

• use special tokens to specify examples, like <example>

Once you have a good basic prompt, you need to be able to augment it with tools that provides the necessary features to find the needle in the haystack.

Augment LLM with tools

Tools are the real coding agent "magic sauce". An LLM without tools is like Bruce Wayne. With the tools, it becomes Batman and can save developers from hours of debugging.

Common tools for coding agents are: grep, read file or write a file. All tools for opencode are located in packages/opencode/src/tool and added to the LLM in provider/provider.ts. All coding agents (including Cursor, Claude Code, etc) rely only on two things:

• the quality of the prompt

• the quality and accuracy of the tools

The important part of the tool is to correctly specify what the tool does through a clear description (like this one) and parameters (like those ones). These tools are then called to the LLM and the program loops with the tool results until the LLM is finished.

I insist that the quality of the tools contributes significantly to the quality of your coding agent. This is why all popular coding agent (Cursor) index your codebase: they index symbols to easily feed accurate data to the model. Similar to the tool to get a line of code (many LLM struggle to find a line of code accurately) or edit files: small tweaks can have major effects on the overall tool quality. This is why having good evals help you quickly iterate on the quality of your product.

Ask the Agent to Plan

Opencode has an interesting approach: it provides a TODO list tool to the agent. The initial prompt explains how the TODO list works and the tools available to read and write the TODO list.

The agent constantly uses this todo list tool to keep track of what to do and in what order.

Why coding agents cost so much to operate?

Since the release of Claude Code, users complained about the cost.

The team behind Claude Code even discussed this in the Latent Space podcast, explaining that some users at Anthropic can spend thousands of dollars a day. While this is probably an extreme case, this shows this is a valid concern. Cursor probably did not have this problem yet because usage was heavily subsidized by VC money.

Coding agents are expensive because of how they are implemented: we pass a ton of token in the prompt and context. When your typical ChatGPT request contains a few hundred tokens at most, a coding agent will consumer ten of thousands of tokens per request. If you constantly vibe code as the cool kids do today, it will very quickly be extremely expensive.

I believe this is not a real problem and we have seen that story before. VC subsidized Uber for years until users were hooked on the platform and were ready to pay the real cost of a ride. Amazon subsidized many products to establish dominance and eventually reach economies of scale. There is no doubt that coding agents are here to stay ; the current economic model may have to evolve.

What is coming next?

I can see mostly two major improvements in the coming months:

1. Running locally: projects like ollama make it really easy to run LLM locally. As LLM are getting optimized and CPU/GPU are getting more powerful, there is no question that coding agents will run locally in just a few months.

2. More accurate tools: today, most tools are just grep’ing the codebase, similar to what you would do when you start working on a new codebase. I can see coding agents having more tools to analyze the codebase and giving better information to the prompt.

The web as we know it will slowly lose traction as we switch to other interaction paradigms. We will no longer go to a webpage to search for the best lawnmower, we will just ask using voice and videos of product reviews will instantaneously play on our augmented-reality glasses. We will not order McDonald’s from the UberEats App: we will ask our AI companion to get a Big Mac delivered in 30 minutes.

Developers have to adapt today and embrace new paradigms, be working on smart glasses, an electronic pin or any other wearable that will fit our lifestyle and product use cases. With the ongoing AI wave, the dominance of any major player is being threatened. They will have to innovate, adapt or accept becoming irrelevant.

Male or female, rich or poor, fat or skinny: we all have to make this choice.

When happy, no matter the issue at hand, you see the light at the end of the tunnel.

When sad, the light has faded, the room stays dark and there is no end in sight.

What will matter is what we have built, the connections we made and how we made others feel. Knowing we established strong friendships or raised kids who strive in their lives: this is what will bring a sense of meaning and accomplishment when our last breath will come.

I made many mistakes in my life, valuing my professional life way more than I should have. And under-invest in my private life, to the point of breaking relations I should not have. These are facts acted and there is no way I can go back to fix it. But I can act on the future, and in the few years that I have left on this planet, I want to explore joys I never had the opportunity to.

To the few people reading this: I hope you love what you do and embrace the daily struggle to master a skill. Do it, but not at the expense of your personal life. Take risks, make sure they are calculated, and that you do not reach a point of no return.

This meme illustrates how many engineers, designers, or also product managers see themselves:

• no experience: embrace simple and easy solutions because you do not know any better. At this stage, you find engineers building frontend and backend with JavaScript/TypeScript and designers reusing React templates.

• some experience: continually try to show off the few skills you acquired in a niche domain and nitpick useless details. Usual suspects: engineers using Zig or Rust to implement a backend for 10 users (that includes their mom and dog).

• a lot of experience: you understand that simple solutions are what work best. Either design (simple and clear design are better) or programming (simple code is easier to maintain and operate). We find here engineers with 10+ years of experience who build backend and frontend with JavaScript/TypeScript (or maybe Go).

You should always aim for simple solutions, either in design or software implementation. Users want simple and clear designs (think Blackberry vs. iPhone). Too often, we add layers of complex and useless features that nobody uses and end up in bloated products (almost every Microsoft product). Focus on simple solutions used by a large user base.

Occasionally, simple solutions are complex and hard to execute. This was especially true in the past, when implementing a simple search box (Google) required thousands of machines to set up and designing new algorithms. And today, most of the complexity is abstracted away by cloud providers. You should avoid execution risks and only embark on a difficult journey if this is justified by the potential business outcomes.

With the never-ending progress of AI, the cost of building software will approach $0 in a not-so-near future. And more generally, the cost of immaterial products (software, copywriting, image edition) will follow a similar trend.

Value creation may then come from material products: stuff we can touch, feel, see or taste.

Your iPhone will still cost $1,000+ in five years but will provide way more value thanks to all the new software that will be developed on top. AI will accelerate the development of physical connected products, from housemaid robots to fighter drones. The complexity of robotics will be facilitated by AI-driven software development.

It’s legitimate to believe that we will see more hardware projects take off. Innovation in hardware products will accelerate significantly, and we may finally see the future we have been promised.

The best engineers of the years to come won't be those with the cleanest and most maintainable code. It will be those who know how to deliver the best product fast, even if the underlying code is not perfect.

First, we had the punched cards.

Then, we had the desktop computer followed by the laptop.

The last evolution of the computing platform is the smartphone.

Every iteration of the computing platform reduced friction. Every new version of the computing platform is more integrated into our lives. The laptop is easier to move and use anywhere. The smartphone put a computer in everyone’s pocket.

The question is what is the next iteration of the computing platform. A few people tried, like humane.ai with the AI Pin or Rabbit with the R1. No one succeeded. Even Apple with its Apple Vision Pro or Google and its Google glasses. They all failed.

Still, the next iteration of the computing platform is yet to be invented. And with the advanced in AI, there is probably a place for a computer with no screen and a direct immersion in our lives. A computer that mimics our senses (vision, hearing, maybe touch?) and our thinking. A computer that can not only help us with our everyday tasks but can also be a companion.

This next computing platform is yet to be invented. It is unlikely that the majors players (Apple, Google) will be the one to invent it — the only potential large company that could pull it off may be Meta. Similar to the iPhone, this new platform is unlikely to be an incremental improvement: it will be a leapfrog innovation.

I can’t stop thinking about how AI will redefine the world as we know it. Education, medicine or even transportation: all sectors will be impacted.

One key question is what happens to us as humans.

Are we staying relevant in this new world?

It seems just a matter of years before we clone ourselves1. Our style, our thought process, or even our voice. All of what makes us “unique” (or what we thought so) will be replicated in a few GB or TB of data. A multi-modal model will be able to mimic your personality and let us live in the cyberspace. Your clone will interact with others through audio, video, or text. Similar to the episode Be Right Back of Black Mirror, virtually talking to loved ones who die will be possible. As technology progresses, the difference between reality and virtual will keep decreasing to a point where you cannot distinguish what is real from what is generated from models.

Imagine a world where you could stay forever with the person you love? Or speaking to your parents, even after they pass away? Sure, many people will want this and our society is so lonely that the vast majority would love to have more company, real or fake virtual. There are already a few startups who are making $100k+ ARR with AI girlfriends, and it’s just a matter of time before it gets to the millions.

When Copilot started, I thought it was a very nice coding assistant autocomplete to complement the IDE.

When ChatGPT came, I thought this will be helpful but will unlikely be a disruption.

I believed AI was a bubble ready to pop as blockchain or crypto.

I was an AI hater/skeptic.

I was just stupid and wrong.

Actual assistant like ChatGPT desktop or Anthropic are already replacing search: I barely use Google today and ask questions directly to my phone.

Products like lovable, cursor or v0 are first steps in redefining software development. I no longer use Stackoverflow and my coding questions and code refactors are done by ChatGPT.

We are just scratching the surface: AI will impact every aspect of the world as we know it: from talking to your bank to making appointments with your electrician or plumber. I am convinced it will not replace workers, it will make them more efficient.

This new wave just started and is about to go on for years. It will likely reshuffle the cards in big tech. Some products and companies will be killed, while new winners will appear.

Today, existing companies add an AI layer on top of their product (for example, Strava adding “Intelligence” to tell me that my run was faster than my average). This is a losing strategy: 90+% of the time, these AI features offer no value to the customer. They make me think of Clippy: good intention, bad product.

The new winners from the AI era won’t add an AI layer on top of existing products. They will seamlessly integrate AI into existing products, making it invisible but, still, amplifying the product's core value proposition. What matters is not if you use AI, but how you use it to deliver better value to your customer.