The AI wave is ongoing.

The next wave is robotics.

The next problem is how we bridge the physical and the digital world.

The space is new and there is still everything to invent. China is the leader in the robotics space (see unitree or domestic product like roborock) and the US is in desperate needs of a robotics ecosystem. Only a few actors are really pushing some products forward in the USA (Elon with Tesla being top of mind). There is space for thousands of new startups.

At a time where AI is entering the physical world with so-called “world models” (see massive investments in startups like AMI Labs), there is no question that the next big innovations will come from robotics startups and their interaction with sounds, picture or smell through these upcoming models.

The problem is expanding beyond AI providers: any company building an AI product has no idea how to price AI feature. For example, GitHub introduced the concept of “AI credits” where consumers pay (on top of their existing seat) for the tokens they use. The more token you use, the more you pay. But this model is non-sensical and reveals the fundamental flaw everybody falls into. Existing product prices do not depend on the amount of CPU or RAM it uses. Similarly, we should not bill a customer for the amount of GPU (e.g. tokens) used. But nobody know how to price AI products, and the industry decided to bill the amount of tokens used.

This is a trap: a billing model should be based on the value of the outcome, not on the implementation detail. The user does not care that a product is using GPT-5.6, Opus or Kimi. The user cares about the outcome, regardless of the implementation.

Anatomy of an AI Application

An AI-enabled application is composed of three layers:

• Hardware (blue on the picture below). there are very few players in the space: Nvidia or Google (with their TPUs) are the most famous and used in the US (Tesla also has its custom chip). The cost of entry is enormous and it takes years to enter this market.

• Model (green on the picture below): this is the model that gives an answer based on some inputs and some tools. Frontier labs are known for GPT-5.5, Opus and open-source models are available with Deepseek or Kimi.

• Application (red on the picture below): this is what many software companies (e.g. Facebook, Salesforce) are building. At the application layer, it’s aggregating data and context that is later sent to a model and hopefully provide some value to the end-user.

If you compare this to existing application, the model is the equivalent of what the operating system and libraries/frameworks provide. The hardware was CPU, now, it’s GPU. Note that in the early days of the internet, there was some hardware lock-ins (who remembers Sun Microsystems and they Sparc CPU architecture and their Solaris Operating System?) but this did not last long.

Note that only the application layer is visible to the end-user. The hardware or software does not matter at all to the end-user - this is an implementation details: as long as the user has a value, these details are irrelevant.

What frontier labs are selling you?

Today, frontier labs are selling you a model (green on the figure above) and some GPU time (blue on the model above).

Each time you make a request to OpenAI or Anthropic, they need to pay for the GPU time spent to serve this request (the blue part in the model). This means building giant datacenters, buying thousands of Nvidia GPUs and paying electricity.

On top of this, they need to pay for the development of their models (the green part), which means getting the data, building the training data set, building evals.

To make it simple, when you pay $10 for a few million tokens, some money goes to pay the GPUs used to serve your request (blue) and some money go towards developing new models or pay back the development cost of the model you use (green).

Frontier labs realized very quickly that this business model is very limited and not sustainable:

1. any other company will eventually build a new model and replace them. Or even worse: open-source models can completely replace them and users just need to pay the GPUs via their existing cloud providers.

2. the real value does not live in the model but in the application layer. In fact, the model layer will be commoditized, the very same way the operating system or the webserver was commoditized.

They quickly realized that the real value is not in the model itself (the blue or green) but in the application layer (the red part). After all, an AI application for a lawyer or software engineer will extract more dollar value than an AI-enabled dating application. That’s why Anthropic got into the Claude Code bandwagon and is releasing new products every other week - they are trying to capture the real value of AI. They no longer want to sell you token but sell you an outcome.

Frontier labs need to capture value to stay relevant

Once Frontier labs realized they need to capture the application-layer (red in the diagram above), they started to release new applications to see what stick with the user. New products are coming regularly: Claude Code, Claude CoWork, Claude Legal, Claude Design - the goal is to capture the AI-enabled space for every domain before someone else does. And traditional software companies (Salesforce, Microsoft) also keep releasing new features with a similar pricing model (e.g. pay by token usage).

However, the cost does not match the value. For example, a lawyer using ChatGPT or Claude can easily justify a high price, higher than a simple chat application. An agentic application that automates your work (e.g. summarizes your customer calls, manager your agenda) provides more value than a summary of a Word document. But both are still billed using the same method (tokens).

This is where it’s hard to see the value of AI and harder to justify AI budgets. After all, software companies spent millions of dollars on tokens and do not see a comparable increase of productivity. AI made me more productive but it did not increase my productivity by 10, it rather increases productivity by 10% to 30% at best.

The typical counter-argument says that GPU and inference cost (green and blue part of the diagram) will go down. However, if these prices go down, it means that billing per token will be irrelevant and the pricing model needs to change as well. It also means that traditional software companies can use open-source models, integrate AI features at a marginal cost and make frontier models irrelevant.

The future of AI application pricing

I believe that AI (call them AI-native, AI-enabled or agentic) applications pricing will change dramatically in the next 18 months.

1. open-source models will get more traction, match frontier models performance for most use-case and make them irrelevant

2. inference prices will go down thanks to software optimization and more performant hardware

The AI winner will not be the current model providers. It will be the existing applications that have enough data to feed context to the model. These companies will integrate open-source models into their application. Once they define the real value of the application, they will change their pricing based in the product value and customer outcome.

Subscribe now

This is the right playbook: it not only enables hundred of startups to build new products on top of these models but it enables a short feedback loop.

For the Chinese ecosystem, the specific winner does not matter - what matters is that the Chinese tech ecosystem wins. These AI models will help build the next BYD, Roborock or Bambu Labs). They optimize for innovation and velocity.

On the opposite, the US ecosystem is dominated by two players who are lobbying heavily to build regulations to (1) block any new entrant (including open-source models) and (2) decide what is an acceptable use of AI (remember when claude is telling you some questions are not acceptable ?). I saw many of their arguments to start regulation but none of them make sense. At the end of the day, these players want to act as gatekeepers of any new AI technology, which always go against innovation velocity and would create a major setback for the US tech sector.

Without US regulation, the current US actors may not stay in business much longer. The enterprise business will slowly move to local models, eating their only profitable revenue stream.

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.