The transition from text based machine learning model(BERT, Transformer) to the practical application(Cursor, Copilot) tooks less than 4 years when ChatGPT launched November 30, 2022. Humanity has achieved the undeniable milestone in such a limited time(and under Covid 19 pandemic).
Same time, this rapid transition changes what artificial intelligence means to the most of the people(at least developers). When cursor launched, it was IDE integrated with code suggestion(next word token prediction), which the majority of developer recognizes as AI. Now the main idea about AI is either Claude Code or ChatGPT(or Codex).
The virtue of the framework is to reduce the conceptual load and focus on what the business matters. Meanwhile, the transition during AI boom feels unprecedented that middle layer is built on top of each other without the majority even bothering to get it.
Artificial Intelligence is without doubt capable of processing the specific task at the fraction of the human cost and the speed of light ahead. For example, making a simple blog post requires one prompt to generate the end to end npm project without even taking a single break or complaint. This is the significant advantage for anyone who can now bootstrap the simple website, which before 2022 was mainly done by the platform such as wix.com
Here is the catch: now the creating the website is at the fraction of cost compared to few years ago, coding itself looks this abstraction layer where the business application is built on top. Consequently, less and less focus is spared while the tick in the SP500 inflates faster than ever before.
The economy where the intelligence outsources to the non human being is probably the first time in our history and it is still questionable we are in the bubble of AI. What I can say certainly that we are extrapolating the intelligence which is beyond what we are capble of previously. In the end, it produces the economy where human intelligence is deflating while the metrics inflates.
Intelligence used to imply the existence of someone behind it. A decision came from a person who had memory of the problem, some interest in the outcome and at least a possibility of being responsible when it went wrong. The LLM separates these things. It can perform the appearance of intelligence without having a stake in what the performance produces. The answer can be useful, but the consequence belongs entirely to somebody else.
This separation is what makes the agent economically attractive. The company does not need the machine to care about the product, become tired of the work or disagree with the direction. It only needs the intelligence to be available at the moment of demand. The human relation behind cognitive work becomes an API call, and the cost which previously included time, education and negotiation is compressed into compute.
But the removed cost does not disappear equally. It moves. The agent produces the implementation cheaply, while the developer takes the uncertainty of whether the implementation should exist. The business receives more output, while the organization gradually loses the memory of how the output was formed. The model provider owns the infrastructure, while the user becomes dependent on an intelligence that can change without the user’s control.
Therefore the deflation of intelligence does not mean everything becomes cheaper. The ordinary answer becomes cheap, then the scarce things surrounding the answer become more expensive: trusted data, distribution, computing power, attention and the authority to decide which answer will be used. Intelligence spreads across the economy while ownership of its production can remain concentrated.
This is similar to the contradiction in the current market. If every company expects to remove the same labor cost using the same small number of models, the competitive advantage cannot belong to everyone. The productivity may be real at the level of a task while its profit is captured somewhere else. What looks like the democratization of intelligence for the developer may at the same time be the centralization of intelligence for the economy.
The bubble and the transformation can exist together. The valuation can assume too much, too early, from companies which will not survive. Yet even after the valuation is corrected, the price of producing the first draft of software will not return to where it was. Financial excess does not make the technical change imaginary. The difficult question is not whether AI is real, but who is able to convert its real capability into lasting ownership.
Developers are familiar with abstraction. We do not need to understand the movement of every electron to write software. A useful abstraction removes a solved problem and gives back a stable boundary. The abstraction of the agent is different because the problem being removed is not always solved. Sometimes it is only hidden behind a convincing response.
The harness can choose files, call tools, modify the application and verify its own work. Each layer reduces the number of details visible to the developer. This is productive until the developer also loses the ability to say why the result is correct. At that point the framework is no longer reducing conceptual load. It is replacing the concept before the human has formed it.
This creates an unusual position. The developer appears more powerful because the amount of software under their control increases, but the connection between intention and implementation becomes weaker. We become managers of results which we did not completely reason through. The application still carries our name, the failure still reaches our users, but much of the path between those points is borrowed.
It is easy to describe this as a temporary problem of model accuracy. Better models will make fewer mistakes, but accuracy alone does not restore the missing relation. Even a perfectly generated application can leave its owner without understanding. The alienation comes not only from incorrect output, but from correct output arriving without the experience that would allow the person to possess the knowledge behind it.
The same issue already existed with frameworks and platforms, only at a different scale. Wix allowed a website without web development. Cloud services allowed infrastructure without a server room. The agent extends the abstraction toward the decision itself: not only how to build the page, but what the page should contain, how it should look and what should be written on it.
There is no clear boundary where assistance becomes substitution. A developer can learn through the model, or avoid learning because of it. The same prompt can expand one person’s thought and replace another person’s thought. The difference is not visible in the generated code, which is why production metrics cannot detect it.
When production becomes abundant, producing more is no longer the obvious advantage. A repository can grow in an afternoon. A company can generate documentation faster than anyone reads it. The cost of creating an option approaches zero while the cost of living with the chosen option remains.
Attention becomes the first scarcity. Someone still has to remain with the problem long enough to recognize what is relevant. Judgment becomes another scarcity because alternatives can be generated much faster than their consequences can be understood. Responsibility is perhaps the final scarcity: the model can provide a reason, but it cannot be the subject that accepts what follows from the decision.
This changes the value of the developer. The exchange value of writing an ordinary piece of code may decline, but the use value of understanding the whole system can increase. These two movements look contradictory only when intelligence is measured by visible production. The person who writes fewer lines may hold more of the knowledge that keeps the application coherent.
The practical response is not to reject the agent or to preserve manual work for its own sake. It is to be careful about what we allow to become invisible. Repetition can disappear. Syntax can disappear. The first draft can disappear. The relation between the business intention and the technical decision should not disappear with them.
For the developer, this means the most important work moves before and after generation. Before it, the problem must be chosen precisely enough that acceleration has a direction. After it, the result must become understood well enough that it is no longer merely rented intelligence passing through the repository.
This blog itself is a small example. The website can be created with a prompt, and the cost of the implementation becomes almost irrelevant. What remains is the decision to write, the thought that should continue from one paragraph to the next and the willingness to put a name below it. The page is easy to generate. Having something that is worth preserving on the page is not.
The agent harness will continue to improve because the economic pressure behind it is too strong to reverse. The question for the developer is not how to stop the abstraction, but how to remain present inside it. If intelligence becomes inexpensive while intention is neglected, we will produce more than any previous generation and understand less of what we have made.
the catch of this blog post is that half of the section after within Paradox of intelligence is writen by GPT sol 5.6 MAX, of course with the delibarate prompting, is my intelligence exptraloated or outsourced?
]]>