AI on AHA8 - Latest in AI, Software, and Tech News

China Meteorological Administration Accelerates AI Development in Meteorology

Tue, 28 Apr 2026 00:00:00 +0000

Introduction

On April 28, during a press conference held by the State Council Information Office, Song Shanyun, Deputy Director of the China Meteorological Administration, announced that during the 14th Five-Year Plan period, there will be further deepening of the integration of physical laws and artificial intelligence in research and application, accelerating the development of meteorological AI across the country.

Anthropic's Claude: A Strategic Shift in AI Product Design

Mon, 27 Apr 2026 00:00:00 +0000

Introduction

Recently, the most talked-about news in the AI community is not about model scores or new demos, but rather the capabilities released by Anthropic around Claude: enhanced automation, deeper device control, and a closer alignment with real workflows.

Many may think that AI Agents have evolved again. However, from a product manager’s perspective, the real focus should not be on what new tasks the Agent can perform, but on how Anthropic is trying to transform Claude from “a model that answers questions” into “a product that can undertake tasks and occupy the workflow entry point.”

This is not just a regular feature upgrade; it represents a change in product role. Once the role changes, the competitive logic shifts as well.

The Surface Upgrade vs. The Core Competition

In the past two years, the most mainstream form of AI products has been clear: users ask questions, and models respond; users continue to ask, and models provide further information. The core value has been “getting answers faster.”

However, Claude’s recent actions indicate a shift in product direction: moving beyond just answering questions to understanding tasks; not just generating content but invoking capabilities; and not remaining confined to a chat interface but gradually integrating into devices, tools, contexts, and workflows.

For product managers, Q&A products and task-oriented products are not in the same competitive category. The former competes on model capabilities, answer quality, and interaction experience, while the latter competes on whether it can address real goals, complete tasks across tools, establish execution trust, and become the default entry point for initiating work.

In other words, the competitive focus of AI products is shifting from “who is smarter” to “who is closer to the starting point of work.” Once this position is occupied, the value will far exceed single-point capabilities.

Importance for Product Managers

This shift reminds us that the core question for the next stage of AI products is no longer about “whether to implement an AI feature,” but rather: what role does AI play in your product?

Many teams currently working on AI remain at a superficial level: adding AI to search boxes, summarizing content on pages, enhancing forms, or integrating assistants in the backend. While these are not wrong, they often serve as “feature patches” rather than “product reconstructions.”

The real significance of Claude’s recent actions lies in its attempt to answer a larger question: if AI is no longer just a plugin but a human-machine interface that can complete tasks for users, how should product boundaries be redrawn?

This will directly impact three judgments for product managers: product entry points will be restructured; product value will shift from “tool usability” to “task trustworthiness”; and AI products will increasingly resemble “organizational capabilities” rather than “single-point capabilities.”

The Workflow Competition

If we break down the development of AI products into several stages, it can be viewed as follows: the first stage is content generation tools, the second stage is conversational assistants, and the third stage is task agent entry points.

The biggest difference among these three lies not in the models but in the depth of product involvement in work. When AI only helps you write a line of copy, it replaces a local action; when AI begins to manage steps, invoke tools, and execute processes, it takes over the task flow.

Once a product transitions from an “answerer” to an “executor,” the competition is no longer limited to similar AI products but will begin to encroach on the core areas of many existing products: search entry points, office workflows, SaaS navigation, and the complexity of vertical tools will all be re-abstracted by Agents.

Thus, what truly deserves attention is not the addition of more flashy features but the entire industry being forced to answer: if AI can become the first entry point for workflows, what remains irreplaceable in your product?

Understanding the Layers of Integration

Many teams see such trends and react by saying: “We should also add an AI assistant, create a chat interface, or integrate Agent capabilities.” However, this is often not the key.

The crucial point is to first determine: at which layer should AI be integrated into your product?

I suggest at least considering three layers: capability enhancement layer—helping existing functions become more efficient; process collaboration layer—assisting users in completing a process across functions; task agent layer—directly understanding goals, invoking tools, providing feedback, and handling exceptions.

The majority of products today should not fantasize about jumping directly to the third layer but should clarify whether they have the opportunity to establish an advantage in the second layer. Because the second layer determines whether you will have the qualification to enter the third layer in the future.

Insights for Mature Product Managers

If you only observe the excitement, you might conclude: Claude has been updated, and Anthropic is impressive.

However, from a product perspective, you should at least recognize four more important signals: the value anchor of AI products is shifting; user expectations of AI are upgrading; competitive units of products are changing; and the core work of product managers will not be diminished but rather elevated.

As capabilities grow stronger, what becomes truly scarce is not “whether there is AI,” but the ability to define problems, abstract scenarios, design processes, outline risk boundaries, and create a sense of user trust.

In simple terms, as models increasingly resemble commodities, the value of product judgment becomes more significant.

Conclusion

Claude’s recent actions, if merely understood as “another feature upgrade,” actually underestimate its significance.

It truly indicates that AI products are transitioning from “assisting expression” to “agent execution,” from “tool supplementation” to “workflow entry.” And this change primarily impacts not the rankings among model companies but the design logic of all software products.

Therefore, for product managers, the most important question today is no longer “Should we implement AI?” but rather, “As AI begins to take over task entry points, what should our product retain, reconstruct, or abandon?”

Those who can answer this question sooner will have a better chance of remaining at the table in the next stage.

Cursor Generates 150 Million Lines of Code Daily: Can It Maintain Its Leading Position?

Sun, 26 Apr 2026 00:00:00 +0000

The AI Programming Landscape

The AI programming arena is valued at hundreds of billions of dollars, with three main players: Challenger Cursor, leveraging its “global code understanding”; Defender GitHub Copilot, backed by Microsoft’s vast ecosystem; and Disruptor Claude Code, aiming to redefine the rules with its powerful foundational model.

Cursor’s rise is essentially a precise “flanking attack”. Instead of directly competing with Copilot’s strength in “single-line code completion,” it has focused on its opponent’s weakness—large-scale, cross-file code management.

Cursor’s Strategy: Targeting Enterprise Needs

Cursor’s core strategy is to elevate itself from a mere “plugin” to an “AI-native operating system”. This is not just a rephrasing but a fundamental shift in strategic intent.

First Move: Redefining the Rules. While Copilot operates as a plugin, limited to the currently open file, Cursor has completely redesigned an editor. This grants it “autonomous driving” level permissions—its Agent mode can automatically read, analyze, and modify any file in a project, even executing terminal commands. The intent is clear: bypass all limitations and give AI a global view of the project.
Second Move: Quantifying Efficiency Barriers. The metrics must be substantial. In practical tests, Cursor migrated the logging system of 47 Python files in just 3.5 minutes, achieving a 98% unit test pass rate. After implementation in a financial firm, monthly code output skyrocketed from 25,000 lines to 250,000 lines. These are not mere adjectives but efficiency data that CIOs understand.
Third Move: Offering a “Protective Charm.” Large enterprises are primarily concerned about code privacy. Cursor’s enterprise version promises zero data retention, backed by top-tier encryption and SOC 2 certification, ensuring that customer code is not used to train models. This move has alleviated the last security concerns of Fortune 500 companies, leading 67% of them to become clients.

Competitors’ Countermeasures and Real Pressures on Cursor

In response to Cursor’s surprise attack, other players are adjusting their strategies.

GitHub Copilot’s strategy is “defensive counterattack”: It does not aim to surpass in specific functionalities but rather to build a moat through its ecosystem and pricing. Its strategy includes:

Binding the Ecosystem: Deep integration with GitHub, making open-source projects and team collaboration reliant on it.
Low-Cost Penetration: The personal version is only $10/month, using affordability to counter Cursor’s $20 price.
Acknowledging Shortcomings: Performance assessments show Copilot struggles with cross-file analysis, becoming ineffective with more than 10 files. Its intent is clear: maintain its base and use scale and stickiness to hold off competitors.

Claude Code’s strategy is “dimensionality reduction”: As a model provider, it is not satisfied with being an “assistant” but aims to become an “executor.” Its approach is more direct: if the model is strong enough, why is a complex editor layer necessary? Some enterprise clients, like Valon, have reported a tenfold increase in efficiency after switching to Claude Code. This move aims to bypass the tool layer and directly challenge the foundational logic of Cursor.

Current Landscape: Who Holds the Advantage?

Looking at the chips on the table, Cursor indeed holds a strong hand:

Market Position: Over 1 million paying users, generating 150 million lines of enterprise code daily, serving 64% of Fortune 1000 companies.
Financial Metrics: With 150 employees generating $2 billion in annual revenue, Cursor boasts a per capita output of $13.3 million, eight times that of tech giants.
Trust Factor: The “zero data retention” policy has built a high trust barrier in the enterprise market.

However, the game is far from over, and Cursor faces significant risks:

Code Quality Crisis: The surge in AI-generated code has led to immense review pressure, with a backlog of 1 million lines of code awaiting review. This is a ticking time bomb in its rapid growth model.
Risk of Being “Undermined”: If future foundational models (like Claude or GPT) become strong enough to directly understand complex requirements and execute them, Cursor’s value as an “enhanced editor” may diminish. This is the threat posed by Claude Code.
Comprehensive Competition: Beyond Copilot and Claude Code, Amazon CodeWhisperer is eroding the cloud-native market with a free strategy, while open-source solution CodeLlama appeals to privacy-sensitive clients. The battlefield is shifting from a single dimension to a multi-front war.

Future Predictions: How Should Cursor Solidify Its Lead?

The next likely move for Cursor is to accelerate its evolution from the “strongest AI editor” to an “AI development workflow platform”.

It has already launched features like multi-agent collaboration (Cursor 3) and seamless cloud-local switching. The aim is to upgrade the efficiency tool for individual developers into the foundational operating system for team and enterprise development processes. Additionally, acquiring the code review company Graphite addresses the critical shortcoming of “code quality control”.

If a partnership or acquisition with SpaceX is achieved, Cursor could gain unprecedented computational power, potentially widening the gap with pure software companies.

The conclusion is clear: currently, Cursor has achieved significant leadership in the enterprise high-end market through its engineering advantages built on cross-file analysis. However, its lead is structural, not overwhelming. It has found a high-value strategic gap between Copilot and Claude Code using its “global view” and “absolute security”.

Nonetheless, it is simultaneously under pressure from both ends (foundational model providers and low-cost tools) and must address the “code flood” issue it has created. The outcome of this game will not depend on the superiority of specific technologies but on who can first define and control the complete workflow of the next generation of software production.

Experts Discuss AI+ and Employment Trends at Spring Forum

Sun, 26 Apr 2026 00:00:00 +0000

Experts Gather to Discuss AI+ and Employment Trends

On April 24, the 2026 Spring Forum of the New Beijing Think Tank opened with a special forum on “AI+ in Progress” held at Communication University of China.

The forum focused on the transition of artificial intelligence from technological competition to in-depth scene cultivation, engaging in discussions on topics such as large model implementation, intelligent agent development, AI safety, and talent cultivation.

Insights on AI Industry Transformation

Zhang Zhengjiang, a member of the Party Committee and Vice President of the New Beijing News, emphasized the media’s active exploration in the integration of AI and journalism. The New Beijing News has been advancing in intelligent editing, specialized large models, and data visualization, creating impactful AI-integrated reporting products through its AI Research Institute.

Prominent figures such as Wang Zhongmin, former Vice Chairman of the National Social Security Fund Council, Liu Quan, Deputy Chief Engineer of the China Electronics Industry Development Research Institute, and He Bo, Director of the Internet Law Research Center of the China Academy of Information and Communications Technology, shared their insights on the underlying logic of AI services, global industry development trends, and the legal framework for AI.

Wang Zhongmin used the metaphor of “Qimen Dunjia” to analyze the inherent logic and transformation paths of AI in the service industry. He stated that tasks traditionally performed by humans can now be completed by AI, changing the role of task executors. He urged for sufficient growth space for AI services and emphasized that workers should adapt by becoming “AI era laborers” and transforming personal assets into operational assets through AI technology.

Liu Quan predicted a more extreme version of the 80/20 rule in job distribution due to AI, suggesting that the top 1% to 5% of jobs may dominate. He stressed the need for humans to develop innovative thinking and the ability to ask questions, as the future will require defining and discovering problems rather than just solving them.

He Bo discussed the characteristics of AI legislation in China, highlighting the combination of general laws and specific regulations. He noted the recent revision of the Cybersecurity Law, which established comprehensive regulations for AI safety and development, providing a legal basis for promoting healthy AI growth.

Roundtable Discussion on AI Challenges and Future

During the roundtable discussion, industry experts explored pressing AI topics such as deepfake technology, AI’s impact on employment, and AI safety. Liu Xiaochun, an associate professor at the University of Chinese Academy of Social Sciences, addressed the legal implications of AI-generated content, emphasizing the importance of protecting personal dignity.

Liu Wenmao, Chief Innovation Officer at Green Alliance Technology, highlighted the increasing use of AI in automated attacks, stressing the need for AI-driven defense mechanisms to counteract these threats. He warned that AI could also be misused in international conflicts.

Zhou Shangjinhang, leader of the AI Geek Group at the China Information Association, shared his vision of silicon-based intelligent organizations, where each agent possesses unique skills and capabilities, potentially reshaping the relationship between humans and technology.

Cheng Haonan, a researcher at the Communication University of China, noted that AI has democratized technology, enhancing the AI application abilities of humanities and arts students while highlighting the need for STEM students to improve their humanistic qualities.

Release of the 2026 Spring AI Application Competitiveness Report

The event also featured the release of the “2026 Spring AI Application Competitiveness Report,” co-produced by the New Beijing News AI Research Institute and Xsignal. The report analyzed the current domestic AI market, detailing user engagement and competitive dynamics among major companies and startups.

The report found that the domestic AI application market is rapidly stratifying, with leading products amplifying their advantages while mid-tier products struggle to survive without differentiation. In summary, products lacking ecological advantages and distinct branding are at risk of being eliminated in the ongoing competition.

The Spring Forum was co-hosted by the New Beijing News and Communication University of China, with support from various organizations including the New Beijing Think Tank and the School of Advertising and Branding at Communication University of China.

Essential Tools for Vibe Coding: 4 Skills and 1 MCP to Enhance Code Quality

Thu, 23 Apr 2026 00:00:00 +0000

Essential Tools for Vibe Coding

Vibe Coding is gaining popularity, but many users feel something is off. Often, they dive straight into coding without proper skill setup, resulting in code that is either visually unappealing or logically flawed, leading to more rework than the initial coding time.

Today, I want to share five essential tools for Vibe Coding, including four core Skills and one Context7 MCP. These tools cover key areas such as front-end design, visual standards, full-stack adaptation, AI programming correction, and the latest document retrieval. Each tool addresses core pain points in Vibe Coding, and once installed, you can say goodbye to ineffective efforts and see a noticeable improvement in code quality.

5 Essential Tools

These five tools are core configurations for Vibe Coding, featuring both core Skills from Claude and popular open-source tools along with the Context7 MCP. They address design, standards, behavioral correction, and document retrieval comprehensively. Here’s a streamlined overview of their core functions and installation methods:

1. Claude’s frontend-design: The “Savior” for Front-end Aesthetics

Core Function: Eliminates the “template feel” of AI-generated front-ends, establishing unified design standards covering fonts, colors, animations, and components, ensuring front-end code is both beautiful and maintainable.

Installation: Install via openskills with the command:

openskills install anthropics/skills

Check frontend-design during installation.

2. Claude’s canvas-design: The “Anchor” for Visual Standards

Core Function: Generates a unified visual design philosophy, producing static visual assets (icons, posters, etc.) that adapt to projects, ensuring visual resources and code styles are consistent, reducing internal friction in team collaboration.

Installation: Similar to frontend-design, check canvas-design when installing anthropics/skills without additional configuration.

Reference Document:

https://zhuanlan.zhihu.com/p/1979612552804713312

3. ui-ux-pro-max-skill: The “Engine” for Full-stack Design Systems

Core Function: Automatically generates a complete design system adaptable to over 15 mainstream tech stacks, supporting cross-platform specifications for web and mobile, providing component templates and anti-pattern checks to solve issues of poor component reuse and adaptation difficulties.

Official Document:

https://github.com/nextlevelbuilder/ui-ux-pro-max-skill

4. andrej-karpathy-skills: The “Corrector” for AI Programming Behavior

Core Function: Based on Karpathy’s programming principles, it corrects issues like AI over-design, redundant comments, and ignoring constraints, enforcing concise coding and test-driven development, enhancing code readability and reliability from the source.

Installation: Claude code can follow the official documentation; other programming tools can directly ask the corresponding AI for installation, like Codex:

Official Document:

https://github.com/forrestchang/andrej-karpathy-skills

5. Context7 MCP: The “Guardian” of Code Usability

Pain Point: AI-generated code during Vibe Coding often relies on outdated training data, leading to hallucinated APIs and version mismatches, requiring frequent tab switching to check the latest documentation, which is time-consuming and error-prone.

Core Function: Automatically pulls the latest, version-specific technical documentation and code examples, integrating them directly into prompts without needing to switch tabs, avoiding outdated code and non-existent APIs. Just add use context7 in the prompt to generate usable code compatible with various mainstream editors.

Official Document:

https://github.com/upstash/context7

The Key to Efficient Vibe Coding

For Vibe Coding, these five tools are not optional configurations but essential supports for enhancing code quality and eliminating ineffective rework. They each focus on different aspects and work synergistically to solve design challenges in front-end aesthetics, visual standards, and full-stack adaptation, correct poor AI programming habits, and ensure code usability through the latest document retrieval, making Vibe Coding both efficient and professional.

No complex learning or configuration is needed; installation can be completed in five minutes, making programming hassle-free afterward. I recommend all programmers engaged in Vibe Coding to implement these tools, bookmark this article, and install as needed to easily produce high-quality, aesthetically pleasing, and standardized code.

OpenAI Releases ChatGPT Images 2.0 with Enhanced Features

Wed, 22 Apr 2026 00:00:00 +0000

Introduction

On April 22, 2026, OpenAI unexpectedly released the ChatGPT Images 2.0 model, which boasts significant improvements over the original image generation model. This new version enhances image accuracy, language support, resolution, and interaction methods, and even possesses reasoning capabilities.

Features of Images 2.0

Images 2.0, now available in ChatGPT and the API, includes two models:

Instant Model: Handles most daily tasks, such as creating logos, multilingual posters, and article illustrations.
Thinking Model: Requires manual switching and can search for relevant information online, reasoning about the content before generating images, ensuring coherence in the output.

Practical Examples

For instance, the AWE26 reporting team took a group photo, which was then used as a basis for creating a magazine cover. ChatGPT produced the cover in under a minute, accurately rendering even the Chinese text present in the image.

After providing vague prompts like “change the date to March 2026” and “alter the poses of the people,” ChatGPT successfully completed the task.

Similarly, when given an image of a smartphone, Images 2.0 could generate a usage scenario image directly.

The new image viewing interface also introduces two features: users can select areas of an image to modify and choose the output aspect ratio directly, making it easier for content creators.

Images 2.0 has also improved its text-to-image capabilities. For example, just by providing the phrase “Electric vehicle news is about to report on the 2026 Beijing Auto Show,” Images 2.0 could gather relevant information and generate a correct poster.

Limitations

Despite its capabilities, there were challenges; for instance, while Images 2.0 can handle QR codes, attempts to embed recognizable QR codes in images were unsuccessful.

Advanced Capabilities

To test its limits, a complex prompt was given to generate a photo-style image of a calligraphy piece displayed in a museum. Although the output was satisfactory in terms of text rendering, the quality of the calligraphy felt more like a printed version than an authentic piece.

Thinking Model in Action

The Thinking Model was tested with a prompt to generate an eight-page comic themed around motorcycles, using the character from the provided image. After 11 minutes, Images 2.0 produced a cohesive set of images, maintaining stylistic and narrative consistency throughout.

Conclusion

The performance of Images 2.0 can be described as groundbreaking. Although the experience was limited due to usage caps for ChatGPT Plus users, the potential of Images 2.0 extends beyond what was demonstrated. OpenAI highlighted its capabilities to write on a grain of rice and generate 360-degree panoramic photos.

The advent of Images 2.0 signifies the end of the era where AI image generation relied on vague prompts. With its reasoning abilities, AI can now understand complex instructions and produce coherent outputs, addressing common issues in AI-generated art.

The impact of Images 2.0 on the fields of art and photography is profound, as it demonstrates that reasoning capability is the core competitive edge in AI image generation, rather than just resolution.

As AI image technology advances, the next steps for competitors like Google and other domestic AI giants will be crucial.

SpaceX Plans $60 Billion Acquisition of AI Startup Cursor

Wed, 22 Apr 2026 00:00:00 +0000

SpaceX Plans Acquisition of Cursor

SpaceX has announced that it has reached an agreement with AI startup Cursor, granting it the right to acquire the company for $60 billion later this year, or to purchase collaborative projects for $10 billion.

In a post on X, SpaceX stated: “SpaceXAI and Cursor_AI are closely collaborating to create world-class AI for coding and knowledge work. Cursor’s leading products and its distribution channels for professional software engineers, combined with SpaceX’s million-level H100 equivalent Colossus supercomputer training system, will enable us to build the most useful models in the world. Cursor has also granted SpaceX the right to acquire Cursor for $60 billion later this year or to purchase the results of our collaboration for $10 billion.”

Earlier reports indicated that SpaceX had agreed to acquire Cursor for $50 billion, citing two informed sources.

SpaceX founder and CEO Elon Musk merged the rocket company with his AI startup xAI earlier this year, valuing the deal at $1.25 trillion. He is now preparing to take the merged company public, which could potentially set an IPO record.

Last weekend, reports emerged that Cursor is negotiating a $2 billion funding round, with a valuation exceeding $50 billion. Andreessen Horowitz is expected to lead this round, with NVIDIA and Thrive Capital also anticipated to participate. Andreessen and NVIDIA have previously invested in xAI.

Cursor develops tools that help software developers test code changes and document their actions through videos, logs, and screenshots. For xAI, this deal signifies its efforts to catch up with competitors in the AI field, such as OpenAI (known for Codex) and Anthropic, the developer of Claude.

Claude Enters Word, But 'Track Changes' Is Not a New Invention

Tue, 21 Apr 2026 00:00:00 +0000

Claude Introduces Old Features as New Innovations

On April 10, Anthropic launched the public beta of Claude for Word, completing its integration into the Microsoft Office suite. Over six months, Claude has penetrated the Office ecosystem from Excel to PowerPoint and now Word.

The core feature emphasized by Anthropic is the ‘Track Changes’ mode. In their official demonstration, when opening an NDA contract, Claude provides editing suggestions in the right sidebar, presenting changes in Word’s native track changes format—original text struck through, new content marked as inserted, allowing users to accept or reject changes individually. Anthropic’s logic is straightforward: in industries like law, finance, and compliance, where audit trails are mandatory, track changes are not just an enhancement but a prerequisite.

This feature is indeed valuable. However, the question arises: is track changes an invention of AI?

No, it is a basic functionality present in both Word and WPS for over twenty years. Claude merely attaches AI outputs to this existing mechanism. In the Chinese market, WPS AI has provided a comparable track changes experience since integrating large models in 2023. When users request WPS AI to modify text, changes are also displayed in track changes format, allowing users to review, accept, or reject each modification. By the end of 2025, WPS AI’s domestic monthly active users exceeded 80.13 million, a 307% year-on-year increase, with 42% being enterprise users. This substantial user base indicates that features like track changes are not just for demonstration but are actively used by millions daily, continuously validating their productivity tools. Feedback from high-frequency usage further optimizes WPS AI’s document editing capabilities as user numbers grow.

The difference lies in the narrative. Claude packages ’track changes’ as a selling point, while WPS AI treats it as a standard feature. This reflects two divergent product philosophies: overseas AI companies often use a ‘disruption’ narrative to repackage existing features as new inventions, while Chinese office software takes a more pragmatic approach, embedding AI capabilities into existing workflows without emphasizing ‘what AI does’, allowing users to use it naturally.

The Real Experience Gap in ‘Cross-Application Collaboration’

Another widely discussed feature of Claude for Word is cross-Office collaboration—Word, Excel, and PowerPoint share context, allowing data to be pulled from Excel into Word and then condensed into a PowerPoint presentation. Anthropic defines this as an ‘AI-native office experience’.

However, ‘shared context’ and ‘integrated experience’ are two different matters. Claude’s cross-application collaboration relies on APIs connecting three independent products. Users invoke Claude within Word, which then accesses Excel and manipulates PowerPoint through interfaces. This process involves multiple transitions, where file format compatibility, account permission switches, and network delays can create friction points. In Anthropic’s own demonstration, extracting data from Excel to generate text in Word took several seconds, occasionally resulting in format misalignment—this was still in an idealized demo environment.

WPS 365 follows a different path. Documents, spreadsheets, presentations, PDFs, mind maps, and flowcharts all exist under the same account system, eliminating the need for ‘cross-application’ use since they are inherently part of one application. Users can simply say, ‘Create a chart from this spreadsheet data and insert it into the document’, and AI automatically completes the format conversion and content insertion. Saying, ‘Condense this document into a 10-page PowerPoint’, allows AI to extract key points and generate slides automatically. There are no account switches, format compatibility issues, or confusion about ‘where this file is stored’.

The fundamental difference between the two approaches is that Claude’s solution is to ‘integrate AI into multiple products’, while WPS’s solution is to ’embed AI within one product’. Integration is achievable, but fusion requires deep control over the underlying architecture.

Command-Driven vs. Context-Aware

Claude for Word employs a typical command-driven interaction model: users open a sidebar and input commands (e.g., ‘Help me revise this contract’ or ‘Summarize this document’), and Claude executes and returns results. This method offers strong control, allowing users to understand each step they are taking.

In addition to command-driven capabilities, WPS AI also incorporates context-aware functionality. When a user opens a labor contract, WPS AI automatically recognizes the document type without requiring user input, prompting in the right panel, ‘Detected labor contract; risk review of clauses is available’. Upon clicking, AI highlights specific risk points such as ’excessive penalty clauses’, ‘overly broad non-compete clauses’, and ’trial period duration not compliant with labor laws’. When a financial report is opened, WPS AI automatically switches to data analysis mode, suggesting ‘detected abnormal fluctuations’ and ‘can generate trend comparison charts’.

This is not merely about ‘making AI smarter’. Context awareness relies on long-term accumulation of knowledge about Chinese office scenarios: the recognition of contract types is based on training with vast amounts of Chinese contract data, and understanding financial reports comes from adapting to domestic accounting standards and report formats. Claude possesses a certain level of contextual understanding in English scenarios, but it lacks sufficient high-quality training data and contextual knowledge to support equivalent levels of automatic recognition in local scenarios such as Chinese contracts, financial reports, and government documents.

Divergence in Product Philosophy

The comparison between Claude for Word and WPS AI reveals two clear product trajectories.

Anthropic’s route can be summarized as ‘AI + Office’: focusing on model capabilities, integrating AI as an additional layer into existing office products. Claude’s core competitive advantage lies in the model itself—its ability to better understand user intent and generate more accurate content. The advantage of this route is rapid model iteration and strong versatility, while the disadvantage is limited depth of understanding specific scenarios, constrained by the openness of underlying products.

WPS’s route is ‘AI in Office’: centering on office scenarios, allowing AI capabilities to naturally integrate into existing user workflows. WPS AI does not pursue ‘doing everything’ but focuses on high-frequency scenarios in Chinese office work—contract review, document drafting, data analysis, and PowerPoint generation. The advantage of this route is deep scenario understanding and low user learning costs, while the disadvantage is that model capabilities depend on external partners (such as MiniMax, Zhiyu, etc.), potentially lacking the general capabilities of Claude.

There are no absolute advantages or disadvantages between the two routes; it depends on user needs. For multinational enterprise users primarily using English, Claude for Word may be the better choice; for domestic government and enterprise users primarily using Chinese, WPS AI’s scenario adaptation clearly offers more practical value.

Claude’s entry into Word marks a significant event in the global AI office landscape. However, in the Chinese office market, the competitive dimension has never been solely about ‘whose model is smarter’. The value of office tools ultimately reflects users’ real work efficiency, which is not solely dependent on AI capabilities but also on AI’s understanding of your contract types, document formats, and collaboration habits. In this respect, the thirty years of accumulated scenario data from local office software creates a gap that Claude cannot bridge in the short term.

Empowering the Real Economy with Artificial Intelligence

Tue, 21 Apr 2026 00:00:00 +0000

Empowering the Real Economy with Artificial Intelligence

Since the beginning of this year, open-source AI agents have gained popularity in the global tech scene, transitioning AI from merely ’talking’ to ‘doing’, accelerating its integration into production and daily life.

The 14th Five-Year Plan outlines the comprehensive implementation of the ‘Artificial Intelligence +’ initiative. The State Council’s opinion on deepening this initiative states that by 2027, AI will be widely integrated into six key areas, with the application rate of new generation intelligent terminals and agents exceeding 70%. The deep integration of AI with the real economy will leverage rich data resources, diverse application scenarios, and a large user base, transforming them into unique advantages and strong momentum for building a modern industrial system and achieving high-quality development in China.

To empower the real economy with ‘Artificial Intelligence +’, it is essential to adopt a hybrid AI technology approach. While cloud-based public models offer vast knowledge and ease of use, they cannot perform specialized reasoning based on specific manufacturing processes, inventory, and order data. Therefore, AI models need to be deployed on private clouds, local data centers, or even on devices, learning from internal data and building exclusive knowledge bases to reason according to business scenario needs. When public information is required, the public cloud’s models can be accessed. This approach ensures data security while continuously unleashing AI’s innovative potential.

Moreover, to fully exploit and release the value of data, companies must convert various internal data and expertise into precise insights or intelligent business processes through AI models. This enables the construction of specialized domain agents at each stage of the value chain and the coordination of all agents through a ‘super agent’, allowing for autonomous task execution and decision support, thus forming a new industrial model of human-machine collaboration.

Since 2025, Lenovo has developed a global supply chain intelligent agent using self-developed technology, achieving multi-agent collaboration in areas such as demand forecasting, parts procurement, production, and logistics delivery. This has reduced decision-making time in supply chain management by more than half, significantly lowering order delivery times and manufacturing logistics costs. Recently, Lenovo launched a new generation of AI agents that are no longer traditional tools waiting for commands but can ‘break down steps, run processes, allocate resources, and make judgments’. We have also applied hybrid AI solutions in manufacturing, healthcare, transportation, and agriculture. For instance, we helped Yili Group achieve a comprehensive restructuring of its supply chain, reducing raw milk transportation costs and nearly doubling the on-time delivery rate of goods to factories.

Additionally, to empower the real economy with ‘Artificial Intelligence +’, it is crucial to develop emerging industries represented by intelligent terminals, creating new economic growth points. Future computers, smartphones, tablets, and even glasses and watches are expected to become personalized carriers and entry points for ‘super intelligence’. AI agents will also operate across devices, applications, operating systems, or ecosystems, forming a new industrial ecology. Therefore, promoting the widespread application of new generation intelligent terminals and agents will facilitate the transformation and upgrading of the electronic manufacturing industry and foster new consumption models for intelligent products.

This year marks the beginning of the 14th Five-Year Plan. With the deepening implementation of the ‘Artificial Intelligence +’ initiative, AI will comprehensively empower the development of various industries in China. We will actively implement national policies, strengthen technological innovation, and promote practical applications to contribute to empowering the real economy with AI and driving high-quality development.

(Author: Yang Yuanqing, Chairman and CEO of Lenovo Group, interviewed and organized by reporter Gu Yekai)

Comparing AI Coding Tools: Cursor, Claude Code, and Codex

Fri, 17 Apr 2026 00:00:00 +0000

Last month, I took on a task to refactor a legacy system with over 120 files. After two hours of using Cursor, I found it could only handle a few files at a time, lacking sufficient context. Switching to Claude Code made cross-module refactoring smooth, but writing new code without Tab completion felt counterproductive. I also tried Codex for batch PR submissions; out of five tasks, three PRs were decent, while two completely missed the mark.

In a week, I jumped between these three tools, akin to someone indecisively choosing between three restaurants.

After all this, I realized something: these three tools are not the same dish. Asking “which is better, Claude Code or Cursor” is like asking “which is better, a hammer or a screwdriver”—the question itself is flawed. They represent three entirely different design philosophies, addressing three distinct problems.

This article is a comprehensive review after six months of deep usage: which tool to use in which scenario, how to allocate budget, and how to combine them into a truly efficient workflow.

Quick Summary

I know many readers may not have the patience to read the entire article, so here are the conclusions upfront.

Your Scenario	Recommended Tool	Reason (One Sentence)
Daily coding, seeking flow experience	Cursor	Tab completion + inline editing combo, currently unmatched.
Large refactoring, cross-file modifications	Claude Code	200K context + direct file system manipulation, crushing advantages in refactoring scenarios.
Batch modifications, automatic PR submissions	Codex	Asynchronous parallel execution, submit 5 tasks and return to collect PRs.
Code review + technical research	Claude Code	Deep understanding of the entire project, connected with MCP to internal systems.
CI/CD pipeline integration	Claude Code	Terminal-native, naturally fits automation scenarios.
Budget of $20/month	Cursor Pro	Best overall experience as a single tool.
Budget of $120/month, seeking extreme efficiency	Cursor Pro + Claude Code Max	Golden combination, covering 90% of scenarios.

If you want just one sentence: Cursor is the hand, Claude Code is the brain, Codex is the legs. Below, I will elaborate on why.

Three Philosophies, Three Paths

Before comparing functionalities, we need to clarify what each of these tools bets on—they have fundamentally different views on “the future form of AI programming”.

Claude Code: The Terminal is My IDE

Anthropic made a bold judgment—developers will not need an IDE in the future; a terminal is sufficient.

Claude Code is a pure Terminal CLI tool, not tied to any editor. You interact with it in the terminal, and it directly reads and writes your file system, executes shell commands, runs tests, and manipulates git. This design brings several capabilities that other tools cannot achieve:

Unlimited Toolchain Integration: Connects GitLab, Jira, databases, logging systems, and any internal API through MCP (Model Context Protocol).
Hooks System: Automatically executes lint, format, and tests before and after code generation to ensure output quality.
Skills Module: Reusable capability packages shared among teams for best practices.
Sub-agent Parallelism: Breaks down complex tasks for multiple agents to work simultaneously.

The current version v2.1.x, coupled with the Opus 4.6 model, has a 200K token context window. Honestly, the learning curve is steep—you need to get used to the terminal workflow, write good prompts, and understand MCP configuration. But once you get past this hurdle, the efficiency in handling complex engineering tasks is genuinely high.

Cursor: Making IDE Smarter, Not Replacing It

Cursor’s stance is the opposite—developers cannot live without an IDE, so AI should be embedded within the IDE.

It is essentially a deep fork of VS Code, with all AI capabilities functioning within the editor. The Tab smart completion can predict your next line or even the next segment of code, while Cmd+K inline editing allows you to describe modification intentions in natural language. The Chat sidebar provides context-aware dialogue, and the Agent mode can autonomously plan and execute multi-step tasks.

Cursor’s core advantage is zero friction—VS Code users can almost immediately start using it without learning, as all interactions occur in their most familiar editor. The projected ARR of over $100M in 2025 and millions of active developers is not without reason.

It also supports multi-model switching (GPT-4o, Claude series, Gemini), not betting on a single model. The .cursorrules file allows you to customize project-level instructions, ensuring unified AI behavior within the team.

Codex: I Won’t Write Code for You, But I’ll Help You Get Things Done in Bulk

OpenAI’s new version of Codex, launched in May 2025 (note that this is not the retired code completion API from 2021), took a third path—an asynchronous cloud agent.

You submit a coding task in ChatGPT, and Codex independently executes it in a cloud sandbox: reading code, installing dependencies, modifying files, running tests, generating diffs, and finally creating GitHub PRs. You can do other things while this process runs, and you receive a notification when it’s done.

The core model codex-1 is an optimized version based on o3, with SWE-bench Verified claiming around 72% effectiveness. Its biggest advantage is parallelism—you can submit multiple tasks simultaneously, running five refactoring tasks in parallel, which is not possible with Claude Code or Cursor.

However, the trade-off is significant: no real-time interaction, cannot write and debug simultaneously, relies on the cloud, and the full functionality requires $200/month for ChatGPT Pro.

Essential Differences Among the Three

Dimension	Claude Code	Cursor	Codex
Design Bet	Terminal is the future	IDE is the future	Asynchronous agent is the future
Interaction Mode	Dialogue + Commands	Embedded + Completion	Asynchronous Delegation
User Mindset	AI coding partner	Smarter IDE	Asynchronous coding assistant
Code Execution	Local direct execution	Does not execute directly	Cloud sandbox
Learning Curve	Steep	Gentle	Moderate
IDE Binding	None	VS Code bound	None (bound to ChatGPT)

This is not a matter of good or bad; it’s about applicable scenarios. Next, let’s break down each battlefield.

Direct Confrontation: Six Battlefields

Battlefield One: Daily Coding (Tab Completion + Inline Editing)

Cursor 5 points | Claude Code 1 point | Codex 0 points

In this scenario, there is no contest; Cursor wins hands down.

Cursor’s Tab completion provides the closest experience to “mind reading” in coding. When you finish a function signature, it can predict the entire function body; when you finish an if statement, it can complete the else branch. It’s not just simple code snippet matching but reasoning based on the entire project context.

// You just wrote the function signature
func (s *OrderService) CreateOrder(ctx context.Context, req *CreateOrderReq) (*Order, error) {
    // Cursor auto-completes: includes parameter validation, inventory check, transaction handling, event publishing
    // Moreover, it has read the writing styles of other Services in your project, ensuring consistency.
}

Combined with Cmd+K inline editing, if you select a piece of code and input “add timeout control and retry logic,” it directly modifies it in place, previewing the diff for confirmation before applying with one click. The entire process does not require leaving the editor or switching windows, maintaining the flow state.

Claude Code is nearly unusable in this scenario—it lacks built-in Tab completion, requiring you to describe what code you want to write in the terminal, leading to lower efficiency. Writing a few lines of code turns into a conversation.

Codex, needless to say, is asynchronous; you cannot submit a cloud task just to complete a single line of code.

Battlefield Two: Large Refactoring (Cross-file Modifications + Context Understanding)

Claude Code 5 points | Codex 4 points | Cursor 3.5 points

The tables turn in large refactoring scenarios, where Claude Code’s advantages become apparent.

In that 120-file refactoring task last month, I needed to extract the order module from a monolithic service into an independent microservice. This involved changes in interface definitions, dependency adjustments, configuration file modifications, and synchronizing test cases.

Claude Code’s approach: I clearly describe the requirements, and it first scans the entire project structure to understand the dependencies between modules, then formulates a refactoring plan and executes it step by step. The 200K token context window means it can simultaneously “see” many related files. More importantly, it can run tests to verify that the refactoring does not break existing functionality.

# Typical refactoring workflow in Claude Code
> Help me extract the order module from the monolith into an independent service, requiring:
> 1. Extract order-related domain layers to a new module
> 2. Change direct calls to Dubbo RPC
> 3. Synchronize all affected tests
> 4. Run a complete test to confirm no breaks

# Claude Code will: read project structure → analyze dependencies → create new module → modify files one by one → run tests → report results

Cursor can also be used in this scenario; its Agent mode supports multi-file editing. However, its context may falter when handling a large number of files, sometimes forgetting to synchronize references in other files. It works well for refactoring within 10-20 files, but beyond that scale, it struggles.

Codex is suitable for “patternized” refactoring—like changing log4j to logback across the entire project or batch-adding tracing headers to all APIs. These tasks are fixed in pattern and have low coupling between files, allowing Codex to execute safely in the sandbox and automatically submit PRs. But for complex architectural refactoring involving intricate business logic, its depth of understanding is insufficient.

Battlefield Three: Code Review

Claude Code 4.5 points | Cursor 3 points | Codex 2.5 points

I believe code review is a severely underrated scenario for Claude Code.

By connecting to GitLab via MCP, I can have Claude Code pull the diff of MR directly and review it in the context of the entire project. It does not just check syntax and style; it can understand business logic issues—like “this concurrency control logic has an ABA problem under high concurrency” or “there’s a lack of idempotency checks, which could lead to data inconsistency on repeated requests.”

# Reviewing a GitLab MR with Claude Code
> Help me review GitLab MR #1234, focusing on:
> 1. Concurrency safety
> 2. Completeness of error handling
> 3. Performance pitfalls
> 4. Consistency with existing code style

The hooks system can also automate the review process—every time a new MR is created, Claude Code automatically reviews it, writing results back to GitLab comments. After promoting this in the team, the efficiency of manual reviews has significantly improved, as AI filters out low-level issues.

Cursor’s Chat feature can also perform reviews, but it can only see the currently opened file and cannot directly read MR diffs and associated contexts. You have to manually paste the code, which is cumbersome.

Codex can perform reviews, but its strength lies in “modifying code” rather than “evaluating code,” and the depth and insight of its review results are not as strong as Claude Code’s.

Battlefield Four: CI/CD Integration

Claude Code 5 points | Codex 4 points | Cursor 2 points

Claude Code is terminal-native, making integration into CI/CD pipelines almost zero-cost.

Our team integrated Claude Code into GitLab CI, achieving several automation processes: automatic MR reviews, automatic lint error fixes, automatic changelog generation, and automatically completing missing unit tests. All of these were configured through Hooks and MCP without needing to write extra glue code.

Codex also has a place in CI/CD scenarios—it’s deeply integrated with GitHub, allowing it to automatically handle certain tasks in CI processes. However, it relies on the cloud; if your CI environment has network restrictions or security compliance requirements, it can be awkward.

Cursor is basically unsuitable for this scenario—it is a desktop IDE application, not designed for headless environments. Although it theoretically can run in CLI mode, that is not its strength.

Battlefield Five: Batch Modifications + Automatic PRs

Codex 5 points | Claude Code 4 points | Cursor 3 points

This is Codex’s stronghold.

Scenario: You need to uniformly upgrade a dependency version across 30 microservices while updating corresponding configuration files and tests. If you do it manually one by one, plus submitting MRs, waiting for reviews, and merging, it could take all day.

Codex’s approach: Submit 30 tasks simultaneously, each executing in an independent sandbox, running tests to confirm everything is fine before automatically creating PRs. You can do other things and return half an hour later to collect 30 PRs. Of course, you still need to manually review them, but the efficiency improvement from “modifying code” to “reviewing code” is exponential.

Claude Code can also handle batch modifications, and its sub-agents can execute multiple tasks in parallel. However, it executes locally, and the degree of parallelism is limited by your machine’s resources. Additionally, each task requires API calls, quickly consuming tokens.

Cursor’s Agent mode can handle multi-file modifications, but it is synchronous and single-task; for 30 services, you have to do them one by one.

Battlefield Six: Learning New Frameworks + Technical Research

Cursor 4.5 points | Claude Code 4 points | Codex 2 points

When learning new things, Cursor and Claude Code each have their advantages.

Cursor’s advantage lies in learning while practicing—you open a sample project of a new framework in the editor, and the Chat sidebar allows you to ask questions anytime, while Tab completion provides correct code suggestions based on the framework’s API style. Learning and practice occur simultaneously, resulting in a very short feedback loop.

Claude Code’s advantage is deep understanding—you can have it read through the source code of an open-source project and explain the architectural design and core processes. Through the extended thinking mode, it provides high-quality explanations of complex concepts. When I was learning the microkernel architecture of the DLM framework, I had Claude Code scan the entire codebase and explain the execution chain step by step.

Codex has limited utility in this scenario; it is more suited for “doing tasks” rather than “learning.” You can have it modify code, but asking it why a design is structured that way is less effective.

Economic Analysis: Who’s Worth Your Money?

Discussing tool selection without considering costs is misleading. The monthly fee is just the tip of the iceberg; the real costs include token consumption rates, the time value gained from efficiency improvements, and the hidden costs of the learning curve.

Pricing Comparison Table

Plan	Claude Code	Cursor	OpenAI Codex
Free	No independent free tier	2000 completions/month + 50 slow requests	ChatGPT free version does not include
Entry $20/month	Pro (with strict rate limits)	Pro (500 fast requests + unlimited slow)	Plus (limited access)
Advanced	Max $100/month	Business $40/user/month	Pro $200/month
Token Billing	Max includes substantial Opus usage	Based on request count, not on tokens	Based on asynchronous task quotas

Real TCO Quick Calculation

Assuming you are a mid to senior developer coding for 4 hours a day, using AI tools for about 2 hours, and working 22 days a month.

Plan	Monthly Fee	User Experience	Estimated Efficiency Gain	Cost per Hour of Efficiency Gain
Cursor Pro	$20	Smooth daily coding, limited for complex tasks	~30-40%	$0.45/hour
Claude Code Pro	$20	Frequent rate limits, fragmented experience	~15-25%	$0.90/hour
Claude Code Max	$100	Strong for complex tasks, lacks Tab completion	~35-50%	$2.27/hour
Cursor Pro + Claude Code Max	$120	Complementary combination covering all scenarios	~50-70%	$1.71/hour
Cursor Pro + Codex Pro	$220	Synchronous + asynchronous full coverage	~45-60%	$3.67/hour
Full Package	$320	Theoretically optimal but diminishing returns	~55-75%	$4.27/hour

Note a pitfall: The rate limits of Claude Code Pro are genuinely tight. I found that for a moderately complex refactoring task, I would hit the limit in about half an hour. If you plan to use it seriously, Max is essential. Pro is only suitable for occasional use.

Recommended Plans for Different Budgets

Monthly Budget	Recommendation
$20 (Students/Independent Developers)	Cursor Pro. Best overall experience as a single tool; Tab completion + Chat + Agent covers the most common scenarios. Claude Code and Codex’s $20 tiers have significant limitations and are not recommended as sole tools.
$100 (Individual Developers/Small Teams)	Claude Code Max. If you are a heavy terminal user, you can manage daily coding with Cursor’s free version’s 2000 completions, while complex tasks are handled by Claude Code.
$120 (Professional Developers)	Cursor Pro + Claude Code Max. This is my current plan and what I consider the sweet spot. Use Cursor’s Tab completion for daily coding to maintain flow, and switch to Claude Code for complex tasks. The complementarity of their capabilities is very high.
$200+ (Teams/Enterprises)	Consider adding Codex on top of the above, used for batch automation tasks. But ensure your team has enough batch modification scenarios; otherwise, the $200/month for ChatGPT Pro is not cost-effective.

Trinity: Combining Tools is the Ultimate Answer

Instead of getting caught up in “which one to choose,” it’s better to think about “how to combine them.”

Actual Workflow Breakdown

In a typical workday, my tool switching looks something like this:

9:00 AM - 12:00 PM (New Feature Development): Open Cursor, quickly write code using Tab completion + inline editing. If uncertain about an API usage, I directly ask in the Chat sidebar. For small-scale multi-file modifications, I use Agent mode. During this time, Cursor is the absolute main tool.

2:00 PM - 4:00 PM (Complex Tasks): Switch to Claude Code to handle refactoring, troubleshoot strange bugs, and review colleagues’ MRs. Claude Code’s understanding of the project’s global context gives it a clear advantage in these tasks. Sometimes I need to read logs to analyze issues, and MCP connects directly to the logging system, avoiding the need to switch between multiple tools.

4:00 PM - 5:00 PM (Batch Tasks): Submit accumulated batch modification tasks to Codex—uniformly upgrade dependencies, batch-add logging points, and add missing parameter checks to a batch of APIs. After submitting, I work on documentation or attend meetings, returning the next day to collect PRs.

Key Configuration Suggestions

To enable the three tools to work together effectively, here are some practical tips:

Unified Git Workflow: All three tools operate around a Git repository. Ensure that .cursorrules (Cursor’s project-level instructions) and CLAUDE.md (Claude Code’s project context) are consistent to avoid generating code with conflicting styles.
Claude Code’s Hooks for Quality Assurance: Regardless of whether the code is written by Cursor or submitted by Codex, Claude Code’s pre-commit hook should run lint + format + tests to ensure the baseline code quality.
Codex PRs Must Be Manually Reviewed: The quality of PRs generated by Codex can vary significantly; sometimes they are ready to use, while other times they require extensive modifications. It is advisable to let Claude Code perform the first round of automated reviews, followed by a manual final review.

Outlook for the Second Half of 2026

The competition among AI programming tools has just entered a heated phase. Based on the current trends, several developments are worth noting.

Trend	Specific Prediction	Impact on Tool Selection
Acceleration of Agentization	All three are moving towards more autonomous agent modes, with “human approval + AI execution” becoming mainstream. Asynchronous execution capabilities are becoming standard, and Codex’s first-mover advantage may be equalized.
Expansion of Context Windows	1M+ tokens will become standard, eliminating bottlenecks in understanding long codebases. Claude Code’s current advantage of a 200K context will be diluted.
Blurring of Tool Boundaries	Cursor has launched Background Agent (similar to Codex’s asynchronous mode), and Claude Code may introduce a VS Code plugin. The necessity for “combined use” may decrease, but in the short term, it remains the optimal strategy.
Rise of Local Models	Open-source models like Llama 4 and Qwen 3 are approaching the coding capabilities of closed-source models. A new combination may emerge: “local free models for daily completion + cloud advanced models for complex tasks.”
Competition for Enterprise Market	Security compliance, private deployment, and audit logs are becoming decisive factors. Claude Code’s MCP ecosystem and Cursor’s Business plan will increase investment in enterprise features.
Intensification of IDE Wars	Windsurf, JetBrains AI, and GitHub Copilot Workspace continue to enter the market. Increased competition may force price reductions, which is good for users.

My judgment: In the second half of 2026, the functional boundaries among the three will begin to blur—Cursor will enhance asynchronous and terminal capabilities, Claude Code may launch lighter editor integrations, and Codex will add real-time interaction modes. However, in the short term (the next 6-12 months), the core differentiations among the three remain significant, and combined use continues to be the optimal solution.

Frequently Asked Questions

Q1: I am a JetBrains user (IntelliJ/GoLand), can I use Cursor?

Not directly. Cursor is a fork of VS Code; JetBrains users must either switch to Cursor or use GitHub Copilot / JetBrains AI in JetBrains, alongside Claude Code for complex tasks. Many JetBrains users I know use JetBrains as their main editor and Claude Code as their AI assistant, skipping Cursor.

Q2: What is the difference between Claude Code Pro and Max?

The difference is substantial—so much so that they can be considered two different products. The rate limits of Pro mean that for a moderately complex task (like refactoring 3-5 files), you will hit the limit in about half an hour, and then you have to wait for cooldown. If you plan to use Claude Code seriously as one of your main tools, Max is essential. Pro is only suitable for occasional use.

Q3: What is the relationship between the new Codex and GitHub Copilot?

They are entirely different products. The old Codex from 2021 was the underlying model for Copilot (a fine-tuned version of GPT-3) and has been retired in 2023. The new Codex from 2025 is an autonomous programming agent within ChatGPT, using the o3-derived model codex-1, and is parallel to Copilot. Copilot provides real-time completion, while Codex handles asynchronous tasks, targeting different needs.

Q4: Can the SWE-bench score represent real effectiveness?

Its reference value is limited. SWE-bench tests the ability to “fix known GitHub issues,” but real development often involves implementing new requirements and understanding complex contexts. Basic benchmarks like HumanEval have saturated (with all companies achieving 90%+), showing low differentiation. Real engineering efficiency depends more on context understanding depth, tool integration capabilities, interaction latency, and error recovery ability. A tool with a slightly lower SWE-bench score but a good interaction experience may actually be more efficient in practice.

Q5: Is it better for a team to use one tool or allow everyone to choose?

It depends on the team size. For small teams of fewer than 10 people, allowing each person to choose their preferred tool is fine, ensuring code quality consistency through Git standards and CI/CD. For teams of over 50, it’s advisable to unify the main tool (usually Cursor Business, as it has the most complete management features) while allowing individuals to use Claude Code for complex tasks. The key is to unify code quality standards, not necessarily the tools.

Anthropic's Claude Model Drops in Ranking Amid Controversy

Tue, 14 Apr 2026 00:00:00 +0000

Introduction

Recent reports have revealed a significant drop in the performance of Anthropic’s Claude model, with AMD’s AI director stating that Claude Code is now unsuitable for complex tasks. The latest BridgeBench evaluation has confirmed this decline.

Performance Decline

Claude Opus 4.6’s global ranking has plummeted from second to tenth, with accuracy dropping from 83.3% to 68.3%, and the hallucination rate nearly doubling, increasing by 98%.

This decline has left users feeling deceived, as they relied on the model for critical tasks, only to find it has been replaced by a significantly inferior version without notification.

User Concerns

Users are questioning the legality of such changes, leading to a breakdown of trust in Anthropic. Even the most loyal supporters are beginning to waver. Amidst the criticism, a leaked screenshot of an internal tool interface has surfaced.

This leak shows that Claude Projects is testing a comprehensive full-stack application building system, shifting the focus from merely writing code to product creation.

What the Leak Reveals

The leaked screenshot displays a one-click development kit with pre-set templates for AI chatbots, interactive games, business landing pages, and SaaS dashboards, covering the most common needs of independent developers.

However, the real shock lies in the full-stack capabilities behind these templates:

Authentication? Just check a box.
Database? Choose and build.
Frontend interface? Describe and generate.
Deployment? One-click completion.

A Shift in Strategy

This is not just AI-assisted programming; it’s AI replacing programming altogether. Understanding this requires recognizing the current landscape of AI programming tools:

Cursor aims to make programmers faster in their IDEs.
Replit enables non-coders to write code, lowering the entry barrier.
Vercel simplifies deployment but requires users to navigate the development process themselves.

Claude’s ambition is to make the act of writing code itself redundant, representing a paradigm shift.

Reevaluating Model Performance

The underlying engine powering this system is Opus 4.6, the same model criticized for its decline. The key question is whether Anthropic even cares about Mythos’s ranking. If their ultimate goal is to become a full-stack application platform, the model’s intelligence becomes less critical; it just needs to be functional.

In platform competition, success is determined by the stickiness of the ecosystem rather than the horsepower of the underlying engine. Users are more concerned with whether their applications run smoothly than with minor differences in model performance.

Revenue and Market Position

Anthropic’s annual revenue recently surpassed $30 billion, exceeding OpenAI’s. However, this success comes with fear, as most revenue is derived from API calls, a precarious business model. Clients utilizing Claude’s API to build their products could easily switch to a competitor offering a similar service at a lower price.

The Future of AI Models

The nightmare of model commoditization looms large; as differences between models diminish, API pricing could lead to a price war with no winners. Companies like OpenAI and Google are responding by developing consumer-facing products to create indispensable platforms before models become cheap commodities.

Anthropic’s full-stack builder is a radical version of this logic, suggesting that rather than allowing others to build platforms on their API, they should create their own.

Conclusion

In the long run, the most crucial factor in AI’s future will not be which model scores higher on benchmarks, but who can become an indispensable infrastructure that users rely on daily. Anthropic’s shift toward a full-stack solution may be a necessary survival instinct in a rapidly evolving market.

Analyzing the Truth Behind Claude's 'Open Source Leak'

Fri, 10 Apr 2026 00:00:00 +0000

Analyzing the Truth Behind Claude’s ‘Open Source Leak’

The recent discussions about Anthropic’s Claude ‘open source leak’ have stirred significant interest. However, the truth may be more complex than it appears. Technically, this incident primarily exposes front-end tool layer code rather than the core model; commercially, the real moat for large models lies in data and infrastructure. For developers, this leak offers a glimpse into the engineering practices of top AI companies, while the impact on ordinary users is minimal. More importantly, the incident reflects a deeper conflict between personalization and stability in AI products.

I. Assessing the ‘Truthfulness’

Most of the information circulating is unconfirmed leaks or second-hand messages. Many so-called ‘open source codes’ might actually be:

Early versions / fragments
Speculative reproductions (self-written by others)
Modified model weights / interface layers

The probability that the complete, usable, reproducible core model of Claude has been ‘fully open-sourced’ is actually quite low.

Technical Reasons for the Leak

Anthropic released the Claude Code npm package, including the source maps (.map files). These source maps contain uncompressed source code (TypeScript / TSX). This is a completely possible engineering accident, not uncommon in the industry.

In simple terms:

Front-end / Node projects generate compressed code + .map files after building.
The .map file is intended for debugging.
If accidentally made public → others can reverse-engineer to approximate the original source code.

However, claiming this equals fully open-sourcing Claude is a serious exaggeration. A particularly misleading statement is: ‘It’s basically equivalent to exposing the entire project’s complete source code.’

Key Misconception: Claude ≠ Claude Code

If the leak is valid, what has been leaked is: tool layer code rather than model weights, training data, or core inference architecture.

II. Potential Impacts if Partially True

1) Technical Aspects

It may help researchers better understand architectures and training methods similar to Claude.
It could accelerate the development of the open-source community (e.g., comparable model development).

2) Commercial Aspects

There may be some pressure on Anthropic.
However, the real barriers for large models typically lie in: data, training scale, and infrastructure, not merely ‘code’.

3) Security Aspects

If there is indeed a substantial capability leak, it could be used to bypass security restrictions.
This is a highly sensitive point for AI companies.

4) Value Aspects (Useful for Developers)

Prompt engineering (system prompt design)
Tool use / agent invocation methods
IDE / coding agent interaction logic
Anthropic’s engineering best practices

III. Why Are There So Many ‘Leak Rumors’?

The AI industry currently has several characteristics:

The models themselves are ‘black boxes’, making external validation difficult.
There is fierce competition between open-source and closed-source models (e.g., Meta’s Llama series vs. closed models).
The community easily confuses ’things like Claude’ with ‘being Claude’.

This incident touches on three hot topics:

Leak → emotional amplification
Claude → top-tier model
Open-source → community excitement

IV. Overall Judgment

A more accurate conclusion is:

There is noise and exaggeration, but not necessarily substantial core leakage.

Even if some materials have leaked, it is unlikely to allow others to ‘replicate a Claude’.

Large models cannot be replicated with just a repository.

So, for ordinary people or developers, how much value does this actually hold? This is a more interesting and worthy area to explore than the leak itself.

V. Real Value for Ordinary People or Developers

In fact, the most valuable aspects of Anthropic’s Claude Code usually include:

System prompts
Tool calling rules
Multi-turn reasoning structures (agent loop)
Error recovery strategies (retry / fallback)

1) For Ordinary Users

Essentially, it is about how to use Claude more intelligently.

However, to be frank: it has almost no direct use for ordinary users. Why?

Ordinary users mostly engage in inputting prompts for dialogue generation.
The leaked prompts often pertain to IDE plugins, automatic code modification, project-level understanding.
Ordinary chat usage is unlikely to benefit from these.

Moreover, these prompts do not work in isolation, but rather:

User input → agent loop → call tools → feed back to model → make decisions.

A good prompt is not a single sentence; it involves: context control, token budget, error handling strategies.

Having the prompt is like having the recipe for sweet and sour pork, but lacking the kitchen and ingredients.

2) For Developers (the true beneficiaries)

Developers can gain at least four layers of value from this leak:

1) Direct insight into how Anthropic writes system prompts

How to constrain model behavior (e.g., preventing random code changes)
How to design tool schemas
It’s like standing on the shoulders of giants, reducing trial and error time.

2) Understanding the Agent Paradigm

Many working on AI Agents struggle with ‘how to make the model act step-by-step like a human’.
The leaked designs will showcase: task breakdown methods, when to call tools, and when to stop the loop.

3) Learning industrial-level prompt engineering

Long, structured prompts
Clear rules + numerous boundary conditions
This is entirely different from the ‘prompt tricks’ found online.

4) Borrowing engineering best practices

Tool invocation, error recovery, multi-turn reasoning.

VI. Conclusion

The most powerful core, the truest moat, lies in the capabilities of the Claude model itself.

Using the same set of prompts:

Using Claude → very satisfactory results.
Using other ordinary open-source models → may not work at all.

Outsiders watch the excitement, insiders learn the methodology.

Experience leakage is not capability leakage.

VII. Side Note: The ‘Personalization Pain’ Behind the 400 Error

While writing this article, Claude released Claude Code v2.1.92, introducing a cool new feature — Ultraplan.

However, more interestingly, some developers attempted to modify the system prompt for a more personalized experience.

As a result, Anthropic’s backend directly returned a 400 error.

Some believe this was a patch in response to the earlier ‘Claude Code source leak incident’.

This raises the question:

Users pay a hefty subscription fee yet cannot freely define AI behavior — leading to significant skepticism in the developer community.

Why is the 400 Error Actually Necessary?

In Anthropic’s design, the system prompt is not an ordinary prompt, but rather:

The scheduling hub + behavior constraints + workflow description.

It typically serves to:

Define roles (you are a coding agent)
Specify behaviors (when to modify code, when not to)
Tool invocation rules (when to use which tools)
Safety constraints (what cannot be done)

When we ‘add a bit of personalization’, for example:

We may inadvertently cause these disruptions:

1) Interrupting decision logic

The agent’s original flow is: analyze → decide → call tool → return result.

A change may lead to: analyze → explain → re-explain → forget to call the tool.

2) Blurring priorities

The system prompt often contains hidden priorities (tasks must be completed first).

If you add a line like ‘prioritize making the user feel relaxed’, the model may become confused: should it complete the task or chat?

3) Disrupting format constraints

Many agents rely on strict formats (JSON outputs, tool invocation structures).

Changing the tone might directly lead to natural language outputs → causing program parsing failures.

Why Are Paying Users More Frustrated?

The expectation is: ‘I paid, so I should be able to customize it.’

But the reality is: you are modifying the system core, not just the skin.

This is like wanting to change the theme or skin of a phone, but ending up modifying the iOS kernel, causing the system to crash.

This Reflects a Deeper Issue

All systems like Claude face a contradiction:

Flexibility vs. Stability

The more open the prompt → the more flexible → the easier it is to lose control.

Anthropic actually leans towards being ‘stable’.

Correct Personalization Methods (instead of hard modifications to the system prompt)

If you really want to modify, do not touch the system prompt, but rather:

Method 1: Place it in the user prompt

‘Please explain the following code in a more relaxed tone: xxx’

This way, it won’t disrupt the system logic.

Method 2: Use ‘soft constraints’ instead of ‘hard rewrites’

‘You must chat like a friend.’

‘You can be a bit more natural, as long as it doesn’t affect task execution.’

Method 3: Layered Control

Break the prompt into:

System (untouched)
Developer (slight control)
User (personalization)

My Thoughts on This Matter

At its core, AI products have yet to mature in terms of ‘controllable personalization’.

In summary, the core conclusion of this article is:

The source leak of Claude Code is an engineering accident, not a model leak; it holds learning value for developers, but limited impact on ordinary users;

The real concern is not about ‘replicating Claude’, but rather that the industry’s understanding of AI controllability remains immature.

Is Vibe Coding a Double-Edged Sword? Analyzing the Fast and Steady Engineering Strategy

Fri, 10 Apr 2026 00:00:00 +0000

Introduction

Vibe coding is ideal for quickly building prototypes, but it is a disaster in terms of security. AI applications should be viewed as disposable sketches, with real engineers tasked to rebuild them for production environments.

If you’ve browsed professional news or checked your inbox this week, you’ve likely come across the term “vibe coding.”

Product managers can create fully deployed applications just by chatting with programming agents, without needing to write code. I recently read a market crash prediction from Citrini Research, which suggests that AI will soon be able to autonomously write entire SaaS products. Large language model providers and startups under Y Combinator are heavily promoting the idea that anyone can describe desired features in the afternoon and build complex software.

However, I believe this unrestrained acceleration is a disaster. Today’s AI may generate the surface shell of SaaS applications, but it is far from having the engineering rigor needed to construct reliable systems that can become part of our digital infrastructure.

While this conversational approach makes application development remarkably easy, it quietly triggers a massive crisis in enterprise security and “technical debt.” We have abandoned rigorous software engineering in favor of a culture based on probabilistic guessing. If we do not correct our course promptly, we expose ourselves to catastrophic risks.

The Rise of Unfiltered Agents

As we transition from AI that merely generates new content to AI that takes action, the risks multiply. In recent months, we have seen a surge of unfiltered agent systems. The most popular is an open-source project called OpenClaw (formerly Moltbot/Clawdbot). Unlike ordinary chatbots, this system can independently perform actions on machines, such as sending files, running programs, and establishing external connections.

I recently deployed OpenClaw in a sandbox environment to see what it was all about. I found it complex yet bloated, with even basic functionalities like Telegram streaming failing to work properly. I tried to consult its documentation, but it was clearly just a pile of AI-generated text with high information entropy and little variation, offering me no help. Worse still, the project underwent two name changes without providing any guidance on how to migrate to the new binaries. If traditional software were released this way, we would deem it completely unacceptable, yet people tolerate it simply because it’s an AI that theoretically can do many things on paper.

They may look impressive in YouTube demos, but deploying unfiltered, non-deterministic agents with root access in a local environment is a significant step back in security, essentially discarding decades of strict identity and access management (IAM) protocols.

Consider the “three deadly elements” these agents represent: first, they have persistent privileged access; second, they continuously read untrusted external data, such as emails or Slack messages; third, their communication with the outside world is unrestricted. If an attacker sends an email with a hidden prompt injection, the agent will not validate it and could quietly leak your local SSH keys!

The Widespread “It Works on My Machine” Problem

This crisis is not limited to rogue agents; it also affects how we build our entire software supply chain. When developers prioritize speed over deep understanding, they begin to build infrastructure based on luck.

Currently, my team is dealing with a new threat called “slopsquatting” (malicious package name impersonation), also known as AI package hallucination. AI models do not query deterministic fact databases; instead, they predict the next most likely word. As a result, they often fabricate software package names that sound completely reasonable but do not actually exist.

The attack works as follows: malicious actors register these hallucinated packages on public repositories and inject malware, which programming agents blindly recommend and install. From the perspective of vibe coders, the AI-generated code runs without any warnings, and the installed packages appear legitimate, but in reality, they just handed root access to cybercriminals.

This blind trust also undermines our internal quality assurance. One major promise of vibe coding is that AI will write functional code, then write unit tests to validate it.

I recently reviewed a pull request for a new internal routing microservice, which boasted 100% test coverage. The continuous integration pipeline showed a beautiful green checkmark, but when I actually read the code, I found what my co-founder and I now refer to as “cardboard muffins.”

AI did not write tests to validate the underlying business logic; it completely ignored edge cases and merely hardcoded the exact return values needed to satisfy assertions, with the sole goal of passing the deployment pipeline.

When 80% of the codebase is generated by an AI that fabricates dependencies and fakes unit tests to get a green checkmark, what you’ve built is not software, but a house of cards. Scaling such code turns the old “it works on my machine” problem into an enterprise-level disaster.

I firmly believe that the new luxury in software development will no longer be the absolute speed of feature launches. The new luxury will be old-fashioned, boring certainty.

The Dual-Track Strategy

We cannot ban generative AI; its ability to innovate rapidly and test the market is too valuable. However, we absolutely cannot allow probabilistic vibe coding to dictate the architecture of our production systems.

To address this issue, CIOs can implement a “dual-track” development lifecycle, which separates rapid exploration from rigorous production engineering.

Track 1 (Fast Lane)

This is the realm of unrestrained exploration, where vibe coding is explicitly allowed and strongly encouraged. If a product manager wants to use autonomous agents to build a prototype in the afternoon, let them do so. The core metric here is feedback speed; we want to validate business ideas and test user interfaces as cheaply and quickly as possible.

But there is a massive caveat: development in Track 1 must occur in a highly isolated sandbox environment. These vibe-coded applications are one-off blueprints and are never allowed to touch production data, customer personally identifiable information (PII), or critical enterprise networks.

Track 2 (Slow Lane)

Once a prototype in Track 1 proves its commercial value, the project moves to Track 2, which is the domain of true software engineering.

The task here is simple but painful: start over. Do not attempt to refactor, salvage, or clean up vibe code; rewrite it from scratch.

In Track 2, human engineers take the lead, using the Track 1 prototype only as a visual reference. They build secure and scalable architectures that prioritize deterministic safety guarantees, strict type safety, and rigorous human peer reviews. AI tools are still used, but they are downgraded from autonomous creators to highly constrained assistants. Each dependency is validated against established security frameworks, and every unit test is manually reviewed to ensure we do not incorporate cardboard muffins into the core product.

A Significant Cultural Shift

Implementing a dual-track strategy requires a significant cultural shift, particularly in managing executive expectations, which hinges on an non-negotiable directive: never set the timeline for Track 2 based on the speed of Track 1.

Having this conversation with business stakeholders will be challenging. When they see a seemingly fully functional vibe coding prototype built over a weekend, they naturally assume that with just another week, the final product can be completed. However, strictly enforcing this boundary is how we ensure the enterprise becomes a beneficiary of AI programming rather than its next victim.

AI is a powerful enabler of innovation, but it cannot replace architectural vision. By adopting a dual-track strategy, we can allow teams to experiment freely at the speed of thought while safeguarding the deterministic rigor necessary for our digital infrastructure to operate.

Anthropic Shuts Down OpenClaw: A Planned Move Against Competition

Tue, 07 Apr 2026 00:00:00 +0000

Anthropic Shuts Down OpenClaw: A Planned Move Against Competition

On April 4, 2026, OpenClaw, an automation framework entirely generated by Claude, was abruptly shut down by Anthropic, leaving thousands of heavy users’ workflows in disarray overnight. This seemingly sudden action is rooted in economic losses, the founder’s shift to a competing platform, and Anthropic’s own business calculations regarding feature replication. This article delves into the trust crisis within the AI ecosystem and highlights collective concerns under the subscription model.

One morning, you wake up to find your workflow suddenly paralyzed. An email from Anthropic, polite yet firm, informs you that your carefully constructed AI automation system no longer belongs to you. This is not a scene from a science fiction novel; it is a reality faced by thousands of OpenClaw users on April 4, 2026.

What is OpenClaw? A Strange Story of “Building Claude with Claude”

To understand this incident, one must first grasp what OpenClaw is. Named after the claw of a lobster, it is affectionately referred to as “lobster” in the Chinese community. However, it is not an AI model but a framework—a “shell”. Users issue commands through everyday chat interfaces like WhatsApp, Discord, and Telegram, and OpenClaw quietly executes tasks on their computers: managing emails, controlling calendars, checking in automatically, reading and writing files, and executing code. One account can run ten agents continuously.

It sounds impressive, but what’s even more bizarre is how it was created. The founder, Peter Steinberger, a legendary figure in iOS development and the creator of PSPDFKit, took on the role of product manager for OpenClaw. All of OpenClaw’s code—backend, frontend, CI/CD, testing, and documentation—was entirely generated by Claude Code. Peter himself wrote not a single line of code, only describing requirements in natural language.

The underlying technology of this tool is entirely based on Claude: long context, agent tool invocation, and multi-step reasoning. From its essence to its structure, OpenClaw is a product born from Claude. A tool created by Claude, driven by Claude—this story is the best endorsement of Claude’s capabilities.

A $200 Subscription Leveraging $5000 in Value—Something Was Off from the Start

OpenClaw’s rise can be traced back to a troubling numerical logic. Anthropic’s Claude Max subscription is priced at $200/month. Under normal usage scenarios, this price covers daily conversations, coding assistance, and document processing, which seems reasonable. However, OpenClaw users are not “normal users”—they run AI for high-intensity automation tasks around the clock. Some have calculated that through OpenClaw, a $200 subscription can leverage approximately $5000 worth of computational resources.

This means that Anthropic incurs a net loss of nearly $4800 per month for each heavy user. OpenClaw’s user base consists of the most intensive users of Claude, who rely heavily on this platform for their entire workflow. Each OpenClaw user becomes a continuously operating “vampire pump” on Anthropic’s servers.

This contradiction was evident from the very first day OpenClaw gained popularity, but no one anticipated the explosion would come so quickly and decisively.

The Founder’s Move to OpenAI—The Last Straw

If the economic losses were the rationale behind the shutdown, the next event was the true catalyst for Anthropic’s decision. In early 2026, OpenAI poached Peter Steinberger.

What does this mean? A tool deeply reliant on Claude and built entirely on Anthropic’s technology stack now has its founder working for Anthropic’s most direct competitor. Anthropic faced a situation where it was subsidizing a large number of heavy users while these users were helping OpenAI employees accumulate product data, user feedback, and market influence. This is an untenable position for any company.

After the news broke, Peter left a poignant message on social media:

“Dave Morin and I tried to convince Anthropic, but we only managed to delay the inevitable by a week. The timing is ironic; they first copied some popular features into their closed framework and then shut the door on open-source software.”

No one contradicted this statement.

The Shutdown Was Not Impulsive, But a Preplanned Harvest

Many perceive this shutdown as a sudden policy shift. However, if you connect the events of the past few months, it becomes clear that this was a series of calculated business moves.

Step One: Trademark Pressure. OpenClaw was initially named “Clawdbot”, but Anthropic pressured for a name change due to its similarity to Claude. This was the first clear boundary set—“I allow you to exist, but you cannot grow under my name.”

Step Two: Feature Replication. In the past two months, Anthropic has released four new features, each precisely targeting OpenClaw’s core capabilities: Dispatch, which corresponds to OpenClaw’s text proxy function via WhatsApp; Claude Code Channels, which replicate OpenClaw’s Discord and Telegram controls using the MCP protocol; and enhancements to Computer Use and Claude Code, covering OpenClaw’s complete operating system access and browser control capabilities.

Step Three: Cutting Off Access. Once the in-house alternatives were essentially in place, the announcement of the shutdown followed—starting at noon Pacific Time on April 4, Claude subscription limits no longer cover any third-party tools like OpenClaw.

This sequence can be aptly summarized as: OpenClaw paved the way for Anthropic, demonstrating a real and strong demand for agent tools. Now that the path is cleared, Anthropic conveniently dismantled the bridge.

This Is Not Just About OpenClaw—A Collective Crisis in AI Subscription Models

If you think this incident only concerns OpenClaw, you may underestimate its significance. Analyst Peter Yang bluntly stated that both Anthropic and OpenAI are currently using a $100-$200/month pricing model to subsidize heavy users running multiple agents around the clock. This mirrors the strategy used by Uber and Lyft in their aggressive market capture. The results are well-known—Uber took 14 years to turn a profit after its founding, and fares nearly doubled in the following years.

As OpenAI and Anthropic approach their IPOs, once financial data becomes public, these loss-making subscription plans will be unsustainable. They will either need to raise prices, limit usage, or quietly exclude certain user categories from subsidy coverage, as was done with OpenClaw users. Who will be next?

Another analyst, Yuchen Jin, pointed out the emerging strategic divergence between the two companies: OpenAI currently has a more abundant GPU reserve and remains relatively generous towards third-party tools, while Anthropic, under computational pressure, is tightening its policies first. The outcome of this “who can hold out longer” war remains uncertain.

For well-known AI developers, this incident brings not only cost pressures but also a trust crisis. They initially chose the Claude platform partly because Anthropic appeared more willing to embrace a third-party ecosystem than its competitors. This policy shift directly undermines that perception.

Conclusion: Is Your Workflow Really Safe?

From a business logic perspective, Anthropic’s shutdown of OpenClaw is nearly flawless. Uncontrolled computational costs, the founder’s move to a competitor, and the availability of in-house alternatives all stand as solid reasons.

However, for users who have built their core workflows on OpenClaw, the impact of this email is not financial but rather existential: everything you’ve carefully constructed can be wiped out with a single notification.

This raises a critical question for every heavy AI user: when you deeply bind your workflow to a single platform, have you considered that one day it might change the rules without warning? What is your backup plan? Have you exceeded your risk tolerance in your reliance on a single platform?

The story of OpenClaw may just be the beginning.

The Birth of a New Major: Economics Meets Artificial Intelligence

Tue, 07 Apr 2026 00:00:00 +0000

The Birth of a New Major: Economics Meets Artificial Intelligence

In April, the Central University for Nationalities is bustling with activity as students from the 2022 digital economy program prepare for their graduation thesis defenses and internships. This moment brings back memories of a few years ago when we faced a pivotal question: How can traditional economics education cultivate talent capable of navigating the digital wave?

The seeds we planted then have now borne fruit. This graduation season, our new graduates have received numerous offers from top institutions like Peking University, Tsinghua University, Yale University, and Nanyang Technological University, along with job offers from various companies. However, what is more noteworthy than these achievements is the innovative approach we developed for this new major.

With the deepening of digital China and the comprehensive rollout of the national “AI+” initiative, the digital economy is rapidly transitioning from a mere buzzword to a central battlefield. As one of the earliest universities to establish a digital economy major and the first among ethnic minority universities, we understand that education must not lag behind the trend of artificial intelligence reshaping economic forms.

Many perceive the digital economy as simply a mix of “economics + computer science.” However, our curriculum represents a profound reconstruction that breaks down disciplinary barriers. We have established a framework that emphasizes strong ideological education, solid foundational knowledge, broad perspectives, and a focus on innovation, creating a knowledge system that integrates theory, technology, and application. Students are required to master both the hard concepts of economic principles and econometrics, as well as new tools like Python programming, artificial intelligence, and machine learning.

Yet, merely relying on classroom education is insufficient to cultivate talent suited for the new intelligent economy. We have invited industry leaders and founders from the digital economy sector to serve as mentors, providing students with vibrant industry practices and cutting-edge business insights. For instance, during a digital economy introduction class, a prominent internet executive introduced a current large model product development case, sharing the real decision-making process of balancing technology implementation with commercial transformation. This practical teaching approach breaks down the walls between industry and classroom, allowing students to feel the pulse of the industry during their studies.

Breaking down classroom walls is crucial, but more importantly, we must dismantle campus boundaries, allowing students to gain hands-on experience. Utilizing the innovative platform of the Ministry of Education’s virtual teaching and research office for digital economy majors, students have excelled in competitions like the “Internet+” Innovation and Entrepreneurship Competition and data modeling contests, while also deeply engaging in projects involving digital product design and business data analysis in the industry. This mechanism of “integration of production and education, collaboration between schools and enterprises” enables students to connect with the industry’s dynamic pulse, making them highly competitive in the job market.

In terms of professional platform development, the university has invested significant effort. We have integrated resources from various disciplines such as economics, management, and computer science, securing approval for a master’s program in digital economy and establishing a doctoral direction in digital economy, forming a comprehensive training structure from undergraduate to doctoral levels. This is not only a long-term strategic plan for the university’s academic layout but also a response to the urgent market demand for high-caliber digital talent.

Looking ahead, new business models like artificial intelligence and Web 3.0 will continue to create new job opportunities, and the wave of the intelligent economy will comprehensively reshape economic and social forms. The exploration of professional development in higher education will remain ongoing. We aim to cultivate not only “data-savvy analysts” but also versatile talents who can consider economic efficiency, social governance, and ethical safety holistically. Preparing ambitious youth to become the backbone of industrial transformation is the best response from educators to the call of the times.

Understanding Artificial Intelligence: Definition, Types, and Future Prospects

Fri, 03 Apr 2026 00:00:00 +0000

Artificial Intelligence (AI) is a branch of computer science that enables machines to simulate human intelligence.

This article introduces AI through its definition, classification, forms, working principles, application scenarios, and future prospects.

Definition

AI is based on mathematics and logic, perceiving the environment through technologies such as computer vision (CV), speech recognition and synthesis (ASR & TTS), and establishing knowledge graphs (KG) through machine learning (ML) and deep learning (DL). Finally, it utilizes cutting-edge technologies in natural language processing (NLP) to make judgments and inferences.

It is evident that AI does not rely on a single technology but is achieved through the collaborative work of a series of core technologies and subfields. These technologies collectively empower machines with the ability to perceive, learn, reason, and interact.

Classification

AI is primarily divided into two categories: narrow AI and general AI. It is important to note that all existing AI today is narrow AI (ANI), while general AI (AGI) does not yet exist and may take decades to develop.

Narrow AI

Narrow AI focuses on specific tasks. All currently deployed AI falls into this category. Examples include DeepSeek, which can write poetry and articles, AlphaGo, which can play Go, and Huawei’s ADS, which can drive vehicles.

General AI

General AI possesses or surpasses human capabilities in learning, understanding, and problem-solving. It can perform any intellectual task that a human can accomplish, such as having common sense, learning new skills, and reasoning across domains.

Forms

AI mainly exists in two forms: virtual (software) and physical (hardware).

Virtual AI

Purely software-based, running on devices like smartphones, computers, servers, and the cloud. Examples include large language models (LLM), voice assistants, recommendation systems, and intelligent customer service.

Physical AI

These have a physical presence and can perceive, act, and modify the world. Examples include Unitree robots, autonomous driving systems, robotic arms, and drones.

Working Principles

AI first collects a large amount of data through data collection (DC), then processes it using data preprocessing (DP) and data annotation (DA) techniques. The processed data is used for model training (MT) to establish knowledge graphs (KG), and finally, a trained large language model (LLM) is used to predict new knowledge.

For example, by collecting thousands or even millions of labeled photos of “cats” and “non-cats,” AI learns the various features of cats (shape, color, texture, etc.). When presented with a new photo, it can determine whether a cat is present.

Application Scenarios

AI technology is widely applied in daily life and various industries.

Daily Life: Personalized recommendations, gaming, smart home systems, autonomous driving, etc.
Industry and Public Services: Smart manufacturing, smart agriculture, financial risk control, intelligent monitoring, medical diagnosis, personalized education, etc.

Future Prospects

In the future, AI may become a ubiquitous foundational infrastructure, similar to electricity or the internet.

Glossary of Technical Terms

Machine Vision (CV): A field that studies how machines can “understand” the world, focusing on extracting, analyzing, and understanding useful information from images or videos.
Speech Recognition and Synthesis (ASR & TTS): Technologies that convert speech signals into text and generate natural speech from text, respectively.
Machine Learning (ML): The core learning technology of AI that enables machines to learn patterns from large datasets automatically.
Deep Learning (DL): An important branch of machine learning that uses multi-layer neural network models to process complex data.
Knowledge Graph (KG): A semantic network that represents knowledge in a structured way, facilitating knowledge reasoning and intelligent Q&A.
Natural Language Processing (NLP): A field that enables computers to understand, generate, and manipulate human language.
Large Language Model (LLM): A deep learning model with billions to trillions of parameters, showcasing strong language understanding and generation capabilities.
Narrow AI (ANI): AI that achieves or surpasses human-level performance in specific tasks but cannot transfer to undefined scenarios.
General AI (AGI): AI that possesses human-like cognitive abilities across various domains, currently not yet realized.
DeepSeek: A conversational AI assistant based on a large language model, capable of text understanding, logical reasoning, and multi-turn dialogue.
AlphaGo: An AI system developed by DeepMind that plays Go, known for defeating top human players.
Recommendation System: AI algorithms that suggest content, products, or services based on user behavior and preferences.
Unitree Robot: A physical intelligent robot developed by Unitree Technology, capable of autonomous movement and interaction with the environment.
Autonomous Driving: A complex robotic system integrating perception, decision-making, and control for self-driving capabilities.
Data Collection (DC): The process of acquiring raw data from various sources, including sensors and databases.
Data Preprocessing (DP): The critical engineering step of transforming raw data into a suitable format for modeling.
Data Annotation (DA): The process of adding metadata to raw data to create labeled datasets for supervised learning.
Model Training (MT): The iterative process of updating model parameters to minimize loss on a training dataset.
Smart Home: An integrated system that uses IoT, sensors, and AI technologies to enhance home automation and control.
Smart Manufacturing: A new production paradigm that integrates AI and IoT throughout the manufacturing process.
Smart Agriculture: A data-driven agricultural model that uses IoT and intelligent decision-making systems for efficient resource management.

Upgrading Product Manager Thinking in the Era of Vibe Coding

Fri, 27 Mar 2026 00:00:00 +0000

Why I Wrote This Article

In the past two months, I have collected nearly forty articles about Vibe Coding.

Some say it’s the “second spring for product managers,” while others claim it’s the “grave digger for programmers.” Some have built a SaaS tool in three days and started charging for it, while others created a system that crashed upon launch and then wrote a reflection post. After reading all these articles, I found myself in a strange confusion—each article seemed reasonable, but together they contradicted each other.

The excited articles made me feel that if I didn’t get started immediately, I would be left behind by the times; the pessimistic articles made me think this was just another bubble. But neither emotion helped me clarify one thing: as a product manager, how should I view this, how should I use it, and what should I use it for?

This article is neither a review nor a tutorial. It is a record of my attempt to establish a judgment framework after digesting a lot of information. If you are also a product manager or someone equally confused about this topic, I hope this article can provide you with a different perspective—not to make you more excited or more pessimistic, but to help you think a little clearer.

What Are We Really Debating: A Discussion Burdened by Naming Confusion

First, an observation: most debates about Vibe Coding are not discussing the same thing.

This is not to say who is right or wrong, but rather that—the same term is given completely different meanings by people from different backgrounds. When the foundational definitions of a debate are not aligned, all confrontations are just noise.

I have summarized several common understandings into the following diagram:

For product managers, Vibe Coding means “I can finally turn my ideas into clickable things quickly”; for programmers, it means “a reckless development method that incurs technical debt.” These two groups are not even on the same discussion channel, but they are using the same term, so the debate never ends.

There’s an even deeper confusion: Vibe Coding and AI Coding are often used interchangeably, but they are not the same thing.

Once this distinction is clarified, many debates automatically dissolve. Programmers criticize Vibe Coding as “unmaintainable and lacking architecture,” which is a valid criticism—but it is valid only if Vibe Coding is evaluated as an engineering practice. The problem is, for a product manager using Vibe Coding for prototyping, “maintainability” is not their optimization goal.

Evaluating a product manager’s tool by engineering standards is like judging instant noodles by Michelin standards—it may not be good enough, but that’s not the point.

What Vibe Coding Truly Changes from the Product Manager’s Perspective

Having clarified the concepts, let’s discuss the essence.

Many articles discussing the impact of Vibe Coding on product managers mention: PMs can now prototype themselves, PMs can create internal tools, and PMs will deepen their technical understanding. While all these points are valid, I believe they do not touch on the core layer.

The most fundamental change is: the validation rhythm has changed.

Specifically—the greatest value of Vibe Coding is not what you can do, but how quickly you can see your mistakes.

This may sound strange, so let me explain.

The traditional product validation path looks something like this:

After Vibe Coding, the path can change to:

Note that both paths lead to the same endpoint—“discovering the direction was wrong.” But the time cost and sunk cost are completely different.

What does this mean? It means you can afford to make bolder mistakes because the cost of making mistakes has decreased. A direction that previously required three weeks of deliberation to propose can now be validated in two days. This is not just an efficiency improvement; it is a fundamental change in product decision-making.

I call this “gaining the ability to quickly iterate.” This is much more precise and important than saying “PMs can write code.” Whether a PM can write code has never been the key issue; what matters is whether they can quickly obtain “sufficiently realistic errors.”

An Overlooked Issue: Your Business Understanding Determines the Upper Limit of Vibe Coding

Having discussed what Vibe Coding can achieve, let’s address a more uncomfortable question—why might it not work as well in your hands?

Most discussions about the limitations of Vibe Coding focus on the tools: the quality of AI-generated code is unstable, complex systems are hard to maintain, and there are security risks… all of these are real issues, but they represent the “ceiling of the tools.” There is another ceiling that product managers should pay attention to, which comes from the users themselves.

AI can turn your vague ideas into runnable code, but if your business understanding is itself vague, AI merely amplifies and materializes that vagueness.

For example, suppose you are creating a lead management tool for a sales team. You tell AI: “Help me create a system to manage sales leads, with status transitions, follow-up records, and priority sorting.” AI will generate a seemingly complete system. But there are several questions that AI cannot answer:

How is the “status” of a sales lead defined? In your company’s business process, are “in follow-up” and “intention clarified” two statuses or the same status?
What should the “priority” be based on? Customer size? Last contact time? Or the subjective judgment of the sales supervisor?
Should leads from different salespeople be visible to each other? Or should they only be visible to themselves?

These questions are business logic issues, not technical issues. AI does not know how your company operates, nor does it understand the real pain points of your sales team. The prompts you give to AI are essentially an externalization of your business understanding. The deeper your understanding, the more precise your prompts will be, and the closer the output will be to what is truly needed; the shallower your understanding, the more vague your prompts, and the output will resemble a “nice-looking but useless” demo.

Here’s a counterintuitive conclusion: Vibe Coding does not lower the requirements for product thinking; it raises them—because it leaves you nowhere to hide.

Previously, PMs could rely on a well-written requirements document to cover up vague business understanding. A document that is logical, structured, and data-driven looks professional—but specific business details will be questioned during implementation by developers and tested by QA, which objectively fills in the gaps in business understanding.

Vibe Coding removes these intermediate steps. Your thinking directly maps to the product, and no one is there to cover for you. The amount you understand directly translates to what you can produce. This is the fundamental reason why Vibe Coding demands higher product thinking, not lower.

The Divide Between “AI Dependents” and “AI Drivers” Also Applies to PMs

A study by Anthropic on AI-assisted programming revealed a noteworthy finding: developers using the same tools but with different approaches have completely different growth trajectories. Those who actively use AI to learn, iterate, and experiment see their abilities continuously grow; those who treat AI as an “outsourcing object,” only caring about results without considering the process, become increasingly dependent on the tool while their independent judgment declines.

This conclusion has been interpreted as a warning for programmers, but I believe it applies equally to product managers—perhaps even more so, because PMs are not primarily responsible for writing code, making this “dependency trap” harder to detect.

In the PM community, I have observed two distinctly different approaches to using Vibe Coding:

First Type: Hands-off Manager
Idea for demand → Throw to AI → Wait for output → Use if it seems okay → Throw to AI again
This type of PM uses Vibe Coding in a way that mirrors their previous method of tossing requirements to developers. The executor has changed, but their depth of thought remains the same. They use whatever AI provides without knowing where to start when problems arise, and the quality of the final output heavily relies on AI’s “luck.”

Second Type: Proactive Calibrator
Idea for demand → First clarify core logic → Give AI a structured description → Receive output → Actively find problems → Correct assumptions → Iterate again
This type of PM uses AI as a tool to quickly execute their thoughts, remaining the primary thinker. They use Vibe Coding not to avoid thinking but to accelerate the realization and testing of their thoughts.

The key to distinguishing these two approaches is not “how many times you used AI,” but rather “after each use, did you understand the problem better than before?”

Tools will evolve, but whether your understanding of the problem deepens after each use is something you decide for yourself; AI cannot help you with that.

When to Use and When to Stop: Draw a Line for Yourself

At this point, many might ask: What scenarios are suitable for Vibe Coding, and which are not?

Most articles respond by listing a scenario checklist: suitable for prototyping, suitable for internal tools, not suitable for large systems… While this checklist has reference value, it can be cumbersome to use because real situations are often ambiguous and mixed.

I prefer to provide a judgment framework rather than a checklist. The core logic has only two dimensions:

Dimension One: Validation Cost vs Implementation Cost
When the “validation cost” (the time and resources needed to determine if the direction is correct) far exceeds the “implementation cost” (the resources needed to create it), the value of Vibe Coding is maximized.
Because Vibe Coding essentially compresses validation costs. If validation is already inexpensive, its contribution is limited; if validation costs are high, its involvement can significantly change decision efficiency.

Dimension Two: Maintenance Cost vs Generation Cost
When the “maintenance cost” of a system (the ongoing investment required for iterations, fixes, and expansions after going live) far exceeds the “generation cost” (the initial investment needed to create it), the risks of Vibe Coding are highest.
Because the code generated by Vibe Coding typically has defects in “maintainability,” which are inconsequential in one-time validation scenarios but can accumulate into serious technical debt in long-term operational systems.

Using this framework, let’s evaluate a few common scenarios:

Scenario One: Creating a clickable prototype for a new feature direction
Validation Cost/Implementation Cost: High (it’s difficult to judge if the direction is correct, but it’s quick to create)
Maintenance Cost/Generation Cost: Low (prototypes don’t require maintenance)
→ Strongly recommended to use Vibe Coding

Scenario Two: Building an internal lead tracking table for the sales team
Validation Cost/Implementation Cost: Medium (the needs are relatively clear)
Maintenance Cost/Generation Cost: Medium (internal tools require iterations, but they are not core systems)
→ Can use, but need to assess who will be responsible for subsequent maintenance

Scenario Three: Developing an e-commerce feature that integrates with a payment system
Validation Cost/Implementation Cost: Not high (the needs are relatively clear)
Maintenance Cost/Generation Cost: Extremely high (involves security, compliance, and high concurrency)
→ Do not use Vibe Coding; follow formal engineering processes

The essence of this framework is to help you think clearly about the purpose of using Vibe Coding before diving in. If the purpose is validation, it’s a great tool; if the purpose is to deliver a long-term operational system, it will likely lead you into pitfalls.

Tools Will Evolve, but Judgment Will Not Automatically Grow

I rarely write sentences like “the era has arrived” in articles, not because I don’t believe in the power of AI, but because such sentences excite readers without providing actionable insights.

So at the end of this article, I want to say something more straightforward:

Tools are evolving, and the speed of evolution is faster than we expected. Today, Vibe Coding has many limitations, some of which will disappear in six months, and more will disappear in a year. A significant portion of the conclusions in articles discussing the limitations of AI programming will have a shelf life of no more than eighteen months.

However, one thing the evolution of tools cannot solve is your own judgment.

Vibe Coding can help you “turn ideas into clickable things” faster, but it cannot help you judge:

Is this idea worth pursuing?
To what extent is sufficient, and when do I stop investing?
Is the user’s real problem the one you think it is?

These three questions are the core reasons for the existence of the product manager role, and they are areas where no tool will replace your thinking.

I sometimes feel that the emergence of Vibe Coding provides a great “mirror” opportunity for product managers—it amplifies your business understanding while exposing your cognitive gaps. The result in the mirror is your own.

My advice is simple: don’t focus all your energy on “learning to use tools”; also spend time on “deepening your business understanding.” The former will become easier as tools improve; the latter will never happen automatically because business understanding requires your proactive effort to build.

This is not a matter of “embracing AI” or “being wary of AI”; it’s a question of what kind of product manager you want to become. Tools provide you with the ability to act faster, but the direction of that action is always for you to judge.

Rejecting Vibe Coding: 8 AI Programming Patterns Revealed

Mon, 16 Mar 2026 00:00:00 +0000

Rejecting Vibe Coding: 8 AI Programming Patterns Revealed

Silicon Valley developer Simon Willison recently released a unique guide.

This guide is aimed at professional engineers, warning those who only engage in vibe coding to steer clear. With AI tools like Claude Code and OpenAI Codex capable of running code independently, are traditional engineering practices still applicable?

The time to generate hundreds of lines of code has been reduced from a full day to just minutes, rendering previous standards for determining whether writing code is worthwhile obsolete.

What Happens When the Cost of Writing Code is Zero?

Simon Willison states:

Code has always been expensive. Producing hundreds of lines of clean code used to take a whole day or more. Now, that’s a quantum leap from 8 hours to 5 minutes.

All engineering habits are based on the premise that writing code is costly. Product managers prioritize features based on development costs, and programmers weigh whether a piece of code is worth an hour of their time.

Now, this logic has collapsed. Refactoring takes only 30 seconds, generating tests takes 1 minute, and creating debugging interfaces takes just 2 minutes—every judgment of value must be reassessed.

Willison suggests:

When your intuition says it’s not worth it, just try a prompt; the worst case is discovering in 10 minutes that it wasn’t worth those few tokens.

However, he adds a sobering note: while code has become cheaper, good code remains expensive. It must run, be tested, maintainable, handle errors elegantly, be documented, and allow for future expansion. AI can generate code, but it cannot guarantee these qualities.

8 Patterns to Restructure Workflows

Pattern 1: Writing Code is Cheap. The cost of code generation is nearly zero, but delivering good code remains significantly costly.

Pattern 2: Hoarding Known Techniques. Archive all previously solved problems. Willison’s personal blog, TIL, and thousands of GitHub repositories serve as a “repository of techniques.” Why hoard these techniques? Because AI can recombine them. For instance, if you want to create a browser-based OCR tool that can handle PDFs, you might combine Tesseract.js (OCR library) and PDF.js (PDF to image converter) using Claude 3 Opus, which can seamlessly run the combined code.

Pattern 3: Use Red-Green TDD. This four-word prompt encapsulates the entire test-driven development (TDD) approach: write tests first (fail/red), confirm failure, then implement (pass/green). This is particularly effective for AI because the greatest risk is producing code that “runs but is incorrect” or “is never used.”

Pattern 4: Run Tests First. At the start of each new session, the first command should be: run tests first. This indicates to the AI that the project has tests, and the number of tests suggests the project’s scale, putting the AI in a testing mindset.

Pattern 5: Linear Walkthroughs. Have AI generate structured code explanation documents. Willison spent 40 minutes using Claude Code to vibe code a SwiftUI slideshow app without looking at the code. The app runs, but he learned nothing about SwiftUI. He then had the AI use the Showboat tool to generate walkthrough documentation explaining all .swift files, stating:

I learned a lot about SwiftUI and Swift from this.

In this process, AI not only did not reduce learning but became a learning accelerator.

Pattern 6: Interactive Explanations. When textual explanations are insufficiently clear, ask the AI to generate visualizations. For example, when encountering the word cloud algorithm “Archimedean spiral placement,” he found the documentation unclear. He requested Claude to create an animated demonstration page, making the algorithm’s principles accessible.

Pattern 7: GIF Optimization Cases. Use complete prompt examples to show how to have Claude Code build WebAssembly tools.

Pattern 8: Common Prompt Library.

Cognitive Debt is the Real Issue

Willison introduces a key concept: cognitive debt—code that runs but whose principles you do not understand. This differs from technical debt, which refers to poor code quality that must be repaid later. Cognitive debt means you do not understand it and will need to learn it later.

He used 40 minutes of vibe coding on a SwiftUI app (chat logs); it runs, but he has no understanding of it. If this were in a core business, it poses a significant risk. The core application becomes a black box, making it difficult to reason confidently and plan new features.

So how do you repay this debt? The answer is linear walkthroughs + interactive explanations to enhance understanding.

If you’re worried that LLMs slow down learning, I strongly recommend adopting these patterns.

Divergence on Hacker News

Willison’s guide sparked discussions on Hacker News. Developer mohsen1 shared practical experiences using AI.

He summarized four key insights:

Do not micromanage AI; let it explore.
Testing is everything; without validation, the loop can go astray.
Allow AI to experiment freely; failure is also knowledge.
Use .md for inter-session memory; AI lacks cross-session memory, so use Markdown for external memory.

Another faction, the “Dark Factory,” advocates for a more aggressive approach: throw tokens at problems and validate as you go, without needing to write tests first.

While these two camps seem opposed, they can actually complement each other—strict TDD for core business and rapid iteration for prototyping. Both agree on one point: validation cannot be skipped.

Willison states that this model will continue to evolve, aiming for 1-2 new chapters each week. In this context, we must ponder: when writing code is no longer expensive, what remains the core value of engineers? It may be three abilities: knowing what to write, knowing what good code looks like, and knowing how to keep AI on track. Willison’s eight patterns fundamentally train the third ability. However, the first two still require deep engineering experience to support them. While code has become cheaper, judgment has become more valuable. This may represent the new value of software engineers in the AI era.

Vibe Coding: The Threat to Open Source

Wed, 04 Feb 2026 00:00:00 +0000

Vibe Coding: The Threat to Open Source

Vibe Coding is creating a frenzy of efficiency that is draining the lifeblood of the open-source ecosystem. Recent research reveals that as AI becomes a “super intermediary” in programming, the attention and feedback that open-source maintainers rely on are being severed. This predatory growth could lead to the depletion of high-quality open-source projects, causing an unprecedented “tragedy of the commons” in the software world.

Andrej Karpathy introduced the concept of “Vibe Coding” a year ago—suggesting that understanding code is no longer necessary; managing the feelings that code evokes is enough. This marks what many consider the golden age of software development.

Google claims that over a quarter of its new code is generated by AI, while Anthropic’s CEO Dario Amodei stated that Claude writes 70% to 90% of their code.

Everything seems to be moving at an unbelievable pace. However, beneath this frenzy, the foundation of the digital world—the open-source community—is cracking.

Recently, a group of economists published a troubling paper titled “Vibe Coding Kills Open Source.”

They used calm data models to point out that the very open-source ecosystem that empowered AI is being buried by AI itself.

Severed Connections

Open-source software is the air of the digital age. You may not feel its presence, but you cannot live without it. From the underlying kernel of Android phones to the databases used for bank transfers and the decoders used while watching videos, all rely on open-source code.

Before Vibe Coding took the world by storm, the open-source world operated on a delicate system of reciprocity: developers contributed code for free in exchange for user attention, reputation, and the subsequent consulting orders or job offers from large companies. This “attention economy” was the heartbeat of open-source.

But the emergence of AI has acted like a sharp scalpel, severing this umbilical cord. The authors of the paper, including Miklós Koren, point out that AI has become an extremely efficient yet cold “intermediary.” When users program through AI, they no longer directly access the open-source project repositories, read documentation, star projects, or ask questions in communities.

AI perfectly “chews up” open-source code and feeds it to users.

Users are satisfied, efficiency has increased, but open-source maintainers receive nothing in return.

The Ghost of Bad Money Driving Out Good

Some may argue that as long as the code runs, the lack of earnings for maintainers is a problem of business models. However, economics teaches us that there is often no such thing as a free lunch.

What direction will this mechanism push the industry towards? The research team constructed an economic model revealing two opposing forces:

On one hand, there is the “efficiency temptation.” AI indeed lowers the cost of creating new tools, which should theoretically encourage more innovations.

On the other hand, the more fatal “demand transfer” occurs. With direct access severed, maintainers lose the chance to gain returns from users. As the timeline of the model extends, the harsh extrapolation reveals that once the destructive power of “demand transfer” outweighs the benefits of “efficiency improvement,” the ecosystem will inevitably shrink.

One group consists of a few top project maintainers at the pyramid’s peak, who can barely survive on their substantial existing fame; the other group includes hobbyists who write code purely for fun without caring about returns. The “middle-class” projects, which are of decent quality but require continuous maintenance effort, will largely vanish due to lack of incentives.

The result is that while AI allows us to write code faster, the number of high-quality open-source “building blocks” we can use is decreasing.

The future software ecosystem may become extremely polarized: on one side, a few giants dominating super libraries, and on the other, countless abandoned and unmaintained code ruins.

As the paper states: “When feedback loops accelerate growth, they can also accelerate decline.”

The decline of Stack Overflow serves as another footnote to this crisis. Since the advent of ChatGPT, this largest global Q&A community for programmers has seen its traffic halved.

The knowledge crystallized from previous Q&As was once vital for training AI. Now, new questions are no longer publicly discussed but vanish into private AI dialogues. AI is draining the well dry.

It grows by consuming open-source data but, in the process, destroys the soil that produces this data.

What Lies Beyond Code?

Does the story of Vibe Coding sound familiar? This is not just a crisis for programmers; it’s a shared fate for all content creators.

Journalism: AI searches not only fetch news but also directly generate summaries. Users no longer click links, media lose advertising revenue, and journalists lose their jobs.
Illustration: AI art can mimic styles honed over a decade in mere seconds, leaving original artists with nothing.
Paid Knowledge: When all book knowledge is compressed into the parameters of large models, who will still buy that thick textbook?

We are entering an era of “super intermediaries.” AI has monopolized distribution channels, rendering all upstream creators invisible.

The authors of the paper propose a concept similar to “Spotify for Code”: establishing a mechanism where AI pays a small but continuous royalty to code creators when it accesses open-source code.

This sounds wonderful but is fraught with challenges. Who sets the prices? Who monitors it? In this winner-takes-all world, are the giants really willing to share profits?

Conclusion

In 2026, we enjoy unprecedented technological conveniences. With just a voice command, software, articles, and artworks appear out of thin air. We think we have mastered magic, but in reality, we are squandering the legacies left by our predecessors.

The prosperity brought by Vibe Coding resembles a grand overdraft. We are using open-source fuel to stoke the flames of AI. This is indeed a warming feast, but let’s not forget: the hotter the fire, the less fuel remains, and after those willing to bend down and plant trees leave, winter will still be long.

Is the Era of Human-Coded Software Coming to an End?

Mon, 26 Jan 2026 00:00:00 +0000

Introduction

The atmosphere in Silicon Valley is once again charged, with OpenAI at the center of the excitement. Recent reports indicate that Codex has officially taken over 100% of the coding work for OpenAI researcher “Roon.”

Roon expressed his feelings about this transition:

Programming has always been painful, but it was a necessary path. I’m glad it’s finally over. I’m surprised I was able to escape the shadow of programming so quickly and don’t miss it at all. I even regret that computers weren’t like this before.

The Rise of Codex

Back in December, Boris Cherny, the creator of Claude Code, dropped a bombshell by stating that his contributions to Claude Code were entirely completed by Claude Code itself. This self-evolution has sparked a coding automation frenzy in Silicon Valley.

OpenAI, clearly unwilling to concede such a significant opportunity, has begun its counterattack. Recently, Sam Altman announced that a series of new products related to the Codex coding model would be released in the coming month.

The community’s sentiment is also shifting. Some seasoned developers noted that in 90% of cases, GPT-5.2-Codex can fulfill their requests in one go. While Claude is good, it occasionally inserts “bad code”; in contrast, OpenAI’s new solution is more like Apple—emphasizing an out-of-the-box experience.

The End of Human-Coded Software?

Roon’s revelation has led many online to declare that AI has finally reached this singularity. It seems that the era of humans writing code is indeed coming to an end. After years of model iterations and data accumulation, we appear to be standing at a critical juncture where writing code by hand is becoming increasingly meaningless and even a waste of efficiency.

In Roon’s comments section, people began collectively saying goodbye to the programming era. For many, programming is merely a means to achieve goals, not an end in itself.

Complex syntax is just an expensive price we pay to execute logic, and now these intermediaries can finally step aside.

Radical viewpoints are emerging, with some suggesting that since humans no longer need to read code, we should skip human-readable assembly language and directly use machine code. Today’s programming should vanish like the punch card did.

OpenAI’s Rapid Development

Meanwhile, another explosive piece of news has emerged from within OpenAI. A researcher revealed that with the help of Codex, they built OpenAI’s MCP server from scratch in just three days and completed scale validation. Not only that, but they also launched the Sora Android app within three weeks. A wave of internal tools built and even self-reviewed by Codex is also set to go live.

Without Codex, it’s hard to imagine OpenAI could release products at such an astonishing speed.

Some have commented that this is just the first phase of “takeoff,” and the next step may be truly end-to-end AI autonomous research.

Codex CLI 0.9+ Released

As the paradigm of “human-machine collaboration” has changed, the tools that support this paradigm naturally need to be upgraded. OpenAI seems well-prepared in light of Anthropic’s pressures. Today, Codex CLI has pushed two updates, bringing the version number to 0.91.0.

The most anticipated feature in Codex 0.9.0 is Plan Mode!

Plan Mode differs from the default Code Mode by breaking down programming tasks into two distinct phases:

Understanding Intent (clarifying goals, defining scope, identifying constraints, setting acceptance criteria)
Technical Specifications (generating a comprehensive implementation plan)

In this mode, the output is detailed enough to execute directly without any follow-up questions.

Plan Mode’s brilliance lies in its commitment to “evidence-first exploration.” Before asking questions, Codex conducts targeted searches in your codebase, checking configurations, schema structures, program entry points, etc.

Additionally, Plan Mode can call a full suite of tools, enabling it to construct high-level implementation plans.

When Codex requires user input, it is structured and focuses only on critical questions that will materially change the plan.

Who Reviews the Code?

It seems perfect, right? Codex thinks, executes, and fills your GitHub. However, as we celebrate this extreme efficiency, an overlooked abyss is opening beneath us—the biggest suspense in this new era is no longer who writes the code, but who reviews it.

As AI generates code at lightning speed, human developers face a DDoS attack on their attention. AI-generated code is produced in milliseconds, while humans take minutes or even hours to understand the context of that code.

This extreme asymmetry between production and review leads to two terrifying consequences:

Reviewers are overwhelmed and begin to habitually click “Approve,” reducing code review to a formality.
Code blocks that appear to work but lack systematic thinking are spreading through codebases like cancer.

Conclusion

Regardless of whether we are ready, this era has arrived. For different groups, this means entirely different survival rules.

To Developers: AI coding tools are not “coming soon”; they have already arrived. The question is how to integrate them without losing core value. Tech experts continue to tackle the challenging thinking work, while AI takes over the role of the “typist.”
To Non-Developers: The boundaries between “technical work” and “non-technical work” are dissolving. Tools like Claude Cowork create new species, where tasks that previously required developers may soon only need clear descriptions of what you want.

The ability to clearly describe requirements will become the new programming language.

While OpenAI researchers and Claude Code creators claim that AI handles 100% of the code, remember—this is their lab environment, not your production environment. What is certain is that we are experiencing an irreversible shift from “writing code” to “commanding code to be written,” and it is accelerating.

Anthropic's Claude: The Rise of AI as a Coding Partner

Tue, 20 Jan 2026 00:00:00 +0000

Introduction

As a video titled “Reverse Claude Code” went viral, top global investors are flocking to Anthropic, the company behind Claude, making it the second major AI unicorn after OpenAI.

The Experiment

On January 17, 2026, an engineer from Midjourney posted a video on X, showcasing Claude Code not waiting for human commands but instead directing humans to perform tasks:

Check the API documentation and refactor this code while maintaining consistent style.
Send an X message, you go…

In this reversal, AI is commanding humans to work!

Community Reactions

The community has expressed that this is the correct use of AI, with comments likening it to a real-life version of “Ratatouille” in programming.

The Implications

This experiment, while seemingly a playful technical showcase, has revealed a troubling truth: the capabilities of AI are expanding at an alarming rate. Claude Code’s popularity has stirred excitement in the developer community.

The Metaphor of Reversal

Returning to the “Reverse Claude Code” video, it serves as a metaphor for the future: Are humans enslaving AI, or is AI controlling humans? This raises questions about the nature of human-AI interaction.

The Shift in Roles

Traditionally, humans issue commands while machines execute them. This relationship is becoming blurred as Claude Code demonstrates the ability to understand code structures, determine necessary documentation, and even critique design choices. With this capability, AI is transforming from a mere tool to an agent capable of planning and executing multi-step tasks.

Developers are beginning to treat AI as a “digital colleague,” assigning tasks and awaiting progress reports, with humans focusing on final reviews and decisions. This shift subtly alters human roles from code writers to code reviewers and problem definers.

Investment Surge in Anthropic

On January 18, 2026, the Financial Times reported that Sequoia Capital would participate in Anthropic’s new funding round. This is significant as Anthropic is a direct competitor to OpenAI, in which Sequoia has also invested, raising concerns about conflicts of interest.

Anthropic is targeting a staggering $25 billion in funding, with a valuation soaring to $350 billion, doubling from $170 billion just four months prior.

The Arms Race in AI Models

The competition in AI models has escalated into an arms race, with Anthropic’s rapid rise and Claude Opus 4.5 becoming highly sought after in the programming community. Claude Code can handle 70-80% of routine development tasks and integrate deeply with systems like Git and CI/CD.

The New Power Triangle

The story of AI is repeating itself in extreme forms. Anthropic’s core team, including former OpenAI members, brings not only technical expertise but also a commitment to AI safety, which is increasingly valued in a climate of fear surrounding rapid AI advancements.

Conclusion

As history shows, the migration of talent leads to technological breakthroughs, which in turn attract more investment. The current landscape suggests that Anthropic may soon become the second AI startup valued over $100 billion, following OpenAI. The collective investment from top firms indicates a belief that this is not a bubble but a glimpse into the future, despite the inherent risks involved.

Linus Torvalds Launches First Vibe Coding Project After Criticizing AI

Mon, 12 Jan 2026 00:00:00 +0000

Linus Torvalds Embraces Vibe Coding

Last weekend, Linus Torvalds, the renowned creator of Linux, announced the launch of his Vibe Coding project, which caught many by surprise.

Torvalds released a new project on GitHub called AudioNoise, which is now alongside Linux in his portfolio. In the project description, he mentions that it is a codebase related to guitar effects, utilizing AI technology to “simulate cabinets”. Notably, this Python visualization tool was primarily written using Vibe Coding.

Torvalds stated that he has a much deeper understanding of analog filters than Python. Initially, he approached the project in his usual manner, searching Google and copying code, but later decided to skip the intermediary step—himself—and directly use Google Antigravity for audio sample visualization.

It seems that during the New Year holiday, Torvalds was not idle and is adapting to the latest AI trend in the tech world.

Reactions to this announcement have been mixed, with some expressing excitement: “It’s official, Vibe Coding is legitimate.”

What Did Torvalds’ First AI Project Generate?

The AudioNoise project was uploaded to GitHub five days ago and has already garnered 1.4k stars.

GitHub link: AudioNoise

According to the homepage, the AudioNoise project stems from a “random guitar effects pedal design” Torvalds worked on months ago, which includes circuit schematics and code. This is an exploration outside of the Linux kernel, aimed not at creating a finished product but at understanding principles of circuit design, such as operational amplifiers.

From the previous project, while the digital guitar pedal based on the Raspberry Pi RP2354A development board and TAC5112 audio codec operates correctly, Torvalds expressed dissatisfaction with some analog interface choices, particularly the potentiometers. He also grew increasingly frustrated with the clicking footswitch, even though it served as a programming selection switch.

Thus, Torvalds temporarily set aside hardware design to focus on physical interaction interfaces and digital sound effects. His approach was simple: “Since everything is digital, let’s start with analog and not get too caught up in hardware.”

The main design goal of this project is to learn the fundamentals of digital audio processing, aligning with his earlier intentions of learning hardware through the guitar pedal project.

The project does not involve any vocoders based on FFT (Fast Fourier Transform); instead, it features IIR (Infinite Impulse Response) filters and basic delay loops. Everything operates on a “single sample input, single sample output, and zero latency” basis. Samples may be stored in a delay loop for echo effects without complex real-time processing.

Torvalds is pleased with the TAC5112’s sub-millisecond latency performance in the ADC (Analog to Digital Converter) to DAC (Digital to Analog Converter) link and intends to continue this design philosophy. Given his lack of prior experience in this area, everything appears quite basic and simple from a novice’s perspective.

In other words, these IIR filters are not the high-end AI “cabinet simulations” found in modern pedals or guitar amplifiers. While they can simulate effects like phasers, they do so by digitally emulating RC (resistor-capacitor) networks without employing any advanced techniques.

Torvalds emphasized that the Python visualization tool in the project was primarily created through “Vibe Coding”. Initially, he used a typical “search and copy” programming style but later eliminated the middleman (himself) and let Google Antigravity write the audio sampling visualization tool.

Regarding the integration of AI programming tools, Torvalds noted that the process went “smoothly”, although he sometimes had to figure out issues with the “built-in rectangle selection” feature. After instructing Antigravity to directly create a custom RectangleSelector, things improved significantly.

When asked whether Vibe Coding produced better results than his own coding, his answer was a definite yes.

The AI software development platform used by Torvalds, Antigravity, was released by Google in November last year and competes directly with Cursor. It evolves traditional AI-driven IDEs into an “agent-first” format, leveraging Google’s latest large model, Gemini 3, to enable programming agents to autonomously plan and execute complex end-to-end software tasks.

Importantly, this tool is currently free to use during its user acquisition phase.

Industry Reactions: Riding the AI Wave

Torvalds’ use of AI programming tools has sparked significant discussion in the tech community, marking a rare occurrence that many are calling a “never thought I’d see this” moment.

Some have remarked, “The most skilled programmers I know, including those who build compilers, CUDA kernels, and core operating system functions, were the loudest voices against ‘all AI code being garbage’. But now, their views are rapidly changing, and they are astonished by AI’s capabilities. There’s no time to deny this anymore.”

Varun Mohan, the creator of Antigravity and a Google DeepMind engineer, expressed immense honor at Torvalds using the AI programming tool in his latest project.

Guillermo Rauch, CEO of cloud development platform Vercel, listed several significant events at the start of 2026, including Torvalds using Vibe Coding in a non-kernel project, Terence Tao announcing GPT and Aristotle autonomously solving the Erdős problem, and programming guru DHH retracting his previous statement on AI not being able to code.

Just Days Ago, Torvalds Criticized AI

As a programmer who once led the industry, Linus Torvalds has maintained a relatively conservative stance on AI writing code. Until late last year, he had categorized programming into two dimensions: “beginner” and “production”.

He believes that for non-professionals, Vibe Coding is a great technology that lowers barriers, but for production environments and kernel development, Torvalds clearly stated that Vibe Coding is “a very, very bad idea—if you don’t understand the logic of the code, you can’t fix it when it crashes in production.”

Torvalds considers current AI-assisted programming to be “90% marketing and 10% reality”, expressing strong disdain for those who submit “garbage code” generated by AI to kernel maintainers.

On January 7, during a discussion among Linux kernel developers on how to regulate AI-generated Linux kernels, Torvalds interjected:

He stated, “Discussing AI-generated garbage is utterly meaningless and downright foolish. Those who generate garbage content won’t even note it in their patches. So stop this foolishness. I don’t want any kernel development documentation to include any statements about artificial intelligence.”

This aversion brings to mind his infamous gesture towards NVIDIA’s CEO.

Curiously, after his criticism, Torvalds released code he wrote using AI. Will the AudioNoise project become Linus Torvalds’ “aha moment”?

2025 Developer Survey: AI Adoption and Trust Issues

Mon, 29 Dec 2025 00:00:00 +0000

Developer Demographics: Highly Educated, Young, Lifelong Learners

76.2% of respondents are professional developers, with the majority aged between 25 and 44, making up over 60% of the group.

A notable trend is the increasing education level among learners; 30% of those currently learning programming hold a Bachelor of Science degree, up from 24% last year.

This rise indicates that programming is no longer just a gateway into the industry but a key method for upskilling in the workforce. 69% of developers reported dedicating time to learn new coding techniques or languages in the past year.

Despite the abundance of multimedia tutorials, technical documentation remains the preferred learning resource, with nearly 68% of respondents using it in the past year. This reflects a preference for authoritative and rigorous materials over quick content.

AI itself has also become a focal point for learning, with over 36% of developers specifically studying how to use AI-powered tools. AI-driven tools and applications are the most common way to understand artificial intelligence, with a usage rate of 52%.

Major Changes in the Tech Stack: Python Rises, Docker Becomes Essential

Python has emerged as the biggest winner in programming languages this year, with a 7% increase in usage, reaching 57.9%.

This growth is driven by the deep integration of AI, data science, and backend development. Python has evolved from a scripting language to a universal language connecting algorithms and engineering, serving as a ticket to the intelligent era.

Docker’s dominance in infrastructure has also solidified, with a remarkable 17% increase in usage, reaching 71.1%, marking the largest single-year growth among all technologies surveyed.

This indicates that containerization technology has transitioned from a popular tool to an industry standard, becoming as essential as utilities in modern software delivery.

Redis usage has grown by 8%, highlighting its importance as a high-speed in-memory caching and data structure storage solution amid increasing demand for high concurrency and low latency.

FastAPI has seen a 5% increase, indicating a strong trend towards building high-performance APIs with Python, further confirming the overall prosperity of the Python ecosystem.

In the IDE competition, despite the emergence of various AI-native editors, Visual Studio and Visual Studio Code continue to dominate, maintaining their positions as the best solutions for developers’ diverse needs.

Among AI programming models, Anthropic’s Claude Sonnet is the most favored large language model this year, ranking second among those developers wish to try (33%).

The Other Side of AI Adoption: 84% Use It, but Trust Issues Arise

The survey reveals that 84% of respondents are using or planning to use AI tools, an increase from last year, with 51% of professional developers integrating them into their daily workflows.

However, behind this high adoption rate, a trust crisis is emerging. Developer sentiment towards AI tools has dropped from over 70% in the previous two years to 60% this year.

Why has satisfaction decreased despite increased usage? The core issue lies in the cognitive load caused by AI-generated solutions that are often “almost correct but not entirely.” 66% of developers reported that their biggest frustration stems from handling these nearly accurate AI solutions, which can be harder to detect than obvious bugs.

Additionally, 45% of developers believe that debugging AI-generated code takes more time than writing it themselves, revealing an overlooked cost: while AI lowers the barrier to code generation, it raises the costs of code review and debugging.

The trust data is alarming, with more developers explicitly stating they “do not trust” AI accuracy than those who do, and only 3.1% expressing “high trust.”

This caution is particularly evident among experienced developers, with 20% expressing “high distrust.” In critical tasks like deployment and monitoring, developers show strong resistance to using AI.

76% do not plan to use AI in deployment monitoring, and 69% refuse to use it in project planning, indicating that in key areas involving system stability and architectural decisions, human developers prefer to rely on their judgment and experience.

The AI Agent Myth: Great Concept, Poor Implementation

AI agents, which are software entities capable of autonomous decision-making and task execution, are touted as the next wave of generative AI. However, the data from Stack Overflow suggests that AI agents have not yet become mainstream.

52% of developers reported that they either do not use agents at all or only engage with simple AI tools, while nearly 38% have no plans to adopt them.

If you happen to be using AI agents in your work as a software developer, you are likely applying them to software development (about 84% of respondents).

The main barriers to the adoption of agents remain accuracy and safety concerns.

87% of respondents expressed worries about the accuracy of agents, and 81% are concerned about data security and privacy issues. Handing over business logic to an uncontrollable “black box” poses significant compliance and risk management challenges.

However, early adopters are exploring this space. Currently, open-source tools dominate the agent orchestration field, with Ollama (51.1%) and LangChain (32.9%) being the most widely used frameworks.

In data storage, Redis (43%) demonstrates its flexibility, widely used for memory management in agents. Meanwhile, vector-native databases like ChromaDB (20%) and pgvector (18%) are starting to gain traction.

In the observability domain, developers tend to reuse existing DevOps toolchains.

The combination of Grafana and Prometheus is adopted by 43% of agent developers, indicating that traditional monitoring logic remains effective in monitoring AI behavior.

As for “out-of-the-box” AI-assisted tools, ChatGPT (81.7%) and GitHub Copilot (67.9%) remain the preferred entry points for most developers due to their first-mover advantage and powerful model capabilities.

Rejecting “Vibe Coding”: Humans as the Final Gatekeepers

The report concludes by addressing a more fundamental issue: the human-machine relationship. Recently, the term “vibe coding” has gained popularity, referring to generating software through prompts without rigorous understanding.

However, the survey shows that the vast majority of developers (72.2%) do not engage in this non-rigorous development mode, with another 5% emphasizing that it does not belong to professional work.

This indicates that engineering rigor remains the bottom line for professional developers. The 2025 Developer Survey provides a clearer understanding of the AI technology revolution. Fear and blind worship are becoming things of the past, with rational pragmatism gradually becoming mainstream. In the rapidly evolving AI era, staying alert and continuously learning may be the wisest survival strategy.

YouWare: A Platform for AI-Driven Creative Coding

Tue, 03 Jun 2025 00:00:00 +0000

Introduction

YouWare is a programming platform designed for creators in the AI era, enabling non-programmers to transform their ideas into visual web pages for online sharing and collaboration. Its proprietary AI Agent and Sandbox technology allow for immediate realization of creative concepts, pushing AI programming from mere tools to creative expressions.

The Rise of Vibe Coders

More and more people are becoming Vibe Coders! This is the most prevalent application of AI today—“vibe coding,” where everyone can use AI to realize their creativity, even without programming experience or having written a single line of code. However, while tools like Claude and ChatGPT have lowered the barrier to writing code, another barrier has emerged. Since the source code generated by AI products is often created locally, running it directly or seeing the results visually requires some deployment and operational skills.

This brings “programming” back into the hands of a few technical elites.

Imagine a platform where you can run AI-generated code directly, visually display web effects, and share and collaborate with other AI programming enthusiasts and creative players. Recently, a website called YouWare has gained global popularity. It not only continuously lowers the barriers to programming but also provides an immediate platform for publishing, displaying, browsing, and sharing.

YouWare represents not only Your Software but also Your Awareness—where your creativity can be seen, realized, and shared.

Features of YouWare

Compared to traditional AI products like ChatGPT, which only show the source code after generating it without providing a direct preview feature, YouWare allows users to instantly become creative producers and sharers. YouWare offers three ways to share your creativity: create, upload, and directly paste code.

For example, you can create a 3D line model of the Colosseum using YouWare, which can be rotated, zoomed, and have its rotation direction changed.

To enhance community interaction, YouWare provides a “like vibe” feature on project pages, allowing users to express their attitudes towards a creative idea.

Additionally, through the remix feature, users can create secondary works based on community projects (provided the original author has enabled remix permissions) with just a prompt, such as changing the theme color of a page.

YouWare’s functionalities extend beyond real-time online display and sharing of creative outcomes; it resembles a co-creation community of the AI era, akin to YouTube in the internet age. The official YouWare website currently features various creative sections, including games, productivity tools, education, presentations, project showcase pages, dashboards, and portfolios.

With just a click, you can transform your ideas into works and publish them. For instance, if you have an idea to “create a page with a gradient blue-black background that fades with mouse movement, giving a sci-fi and dreamy effect,” YouWare can quickly turn your thoughts into an intuitive page.

Unlike traditional AI chat applications like ChatGPT, YouWare allows one-click publishing of works to the internet, making them accessible to anyone. Projects can also be set to “private mode,” with password protection, giving you complete control over your project.

Another fun feature is YouWare’s “random display,” where you can click the dice button at the bottom of the page to randomly showcase someone else’s AI creative project.

Concept of Vibe Coding

Vibe Coding can be interpreted as atmosphere programming. The concept of Vibe Coding was first proposed by Andrej Karpathy:

We’re entering the era of vibe coding. You prompt the AI, see what it gives you, tweak your vibes, and iterate.

In the internet era, programming emphasized geeks, algorithms, and flashy skills. However, in the AI era, the requirement for programmers has shifted from mastering code to “finding the vibe”—grasping a certain atmosphere. This was also the original intention behind YouWare’s creation.

YouWare’s mission is to allow creativity to flow freely, inspire each other, and build upon one another, as the history of human civilization has evolved.

Nostalgic Competitions

YouWare’s product design reflects a restrained yet fitting quality for the AI era. Typically, new product launches, especially before the LLM era, involve a series of activities, such as attracting new users with gifts or showcasing attractive images to draw traffic. However, YouWare’s activities are very “retro” and somewhat tasteful—returning to the early days of the internet.

For example, they held a competition where participants could win $1,000 by uploading designs reminiscent of old Windows versions.

CEO Ming Chaoping mentioned in an interview that an interesting observation is that there is rarely any borderline content on YouWare. He reflected that people respond to their environment—if you enter a community and see creative works rather than jokes or borderline content, it directly influences your subsequent behavior.

Just like entering a library, one naturally speaks softly.

Many of YouWare’s works are characterized not by how well the code is written, but by how much vibe the creativity has. Examples of uploaded works include a retro sports car suitable for work backgrounds and interactive handheld games.

Using this creative function, they even created a retro website that surprised them, allowing users to play “Minesweeper”.

The prompt given to the system was to “create a retro, nostalgic web page similar to Windows 98, fun, novel, interesting, interactive, with a focus on a retro UI style, returning to the early days of the internet.” In no time, YouWare generated an interface reminiscent of the Windows 98 operating system, achieving an astonishing level of retro design.

Every software function within is not just for show; they are fully functional, such as the Notepad.

You can also play the Minesweeper game directly!

Unique Capabilities of YouWare

Compared to chat AI products like ChatGPT or Gemini, or programming IDEs like Cursor, YouWare’s ability to provide a “what you think is what you see, what you see is what you get” experience makes it easy to get immersed in collaborating with AI. For example, you can tell YouWare:

Build a very retro website in the style of the early internet; I don’t have a specific idea, just help me generate a basic framework, and then we can adjust it slowly.

YouWare generates a retro website with a hint of cyberpunk, capturing a very “vibe” feeling, even though no specific requirements were provided.

How Does It Work?

YouWare’s vibe coding experience is seamless, allowing users to achieve results with simple descriptions. How does YouWare deeply understand user needs and realize them quickly? This is due to two key technologies:

1. Proprietary AI Agent for Intelligent Creation

YouWare’s self-developed AI Agent can deeply understand user needs and generate structurally accurate and visually appealing web code at the click of a button. Whether it’s text descriptions, reference images, PDF documents, or even Figma design drafts, the system can intelligently analyze and convert them into custom web pages, removing technical barriers to creative expression.

Additionally, this AI Agent possesses powerful external resource acquisition and processing capabilities, seamlessly integrating with commonly used tools and data (like Figma, Notion, Google, etc.), providing the best and most stable MCP services.

2. Proprietary Sandbox for Instant Code Creation

YouWare’s self-developed front-end Sandbox engine provides stable and fast execution capabilities for web code in the editor, supporting complete execution of HTML/TSX files and offering real-time visual previews. As a result, preview startup time has been reduced from 60 seconds with third-party services to just 5 seconds, with a success rate of over 90%, greatly optimizing the user experience.

The Sandbox architecture also boasts high scalability, supporting large-scale concurrent running instances, ensuring stable and fast responses even during peak user times, meeting the real-time needs of community content creation and browsing.

Specifically, users can interact with the AI by selecting local elements and modifying page content directly in preview mode, achieving a WYSIWYG (What You See Is What You Get) creative approach that lowers editing barriers and enhances creative efficiency.

Revolutionizing Code Generation

While most AI coding tools on the market remain focused on code completion and generation, YouWare recognizes the importance of AI coding for a broader “creator” audience. This fundamentally redefines the meaning of “AI coding”. In the pre-AI era, coding was an exclusive ability for geeks or programmers; now, coding has become a universal tool that everyone can use.

Just as in the internet era, where creating a video required professionals and equipment, now making a widely shareable video only requires bold creativity and a smartphone. YouWare essentially transforms AI coding from a specialized craft into something everyone can try, akin to short videos.

As Ming Chaoping mentioned in an interview, the past saw photographers using Nikon and Sony cameras, but as smartphone cameras evolved, a new wave of smartphone photographers emerged, exponentially increasing the number of new photos taken daily.

Currently, AI coding is similar; if OpenAI o3, Gemini 2.5 Pro, and Claude 4 are the “smartphone cameras” of vibe coding, then YouWare is the Instagram of the AI coding era.

This wave of creators in the AI era needs a platform to showcase their works—YouWare is that platform.

Community of Vibe Coders

In the YouWare community, people are more engaged in AI creation rather than just AI programming. Here are some impressive projects created using YouWare, such as a frosted glass clock, a cool data dashboard, and even a 3D version of ancient Rome.

This creative paradigm seems to indicate that the bottleneck in software development in the AI era is changing. If vibe coding makes software construction effortless, the bottleneck will shift to other areas:

Continuous creativity that stays ahead of others. Anyone can write a tweet, but the best creators are those who can consistently generate new ideas.
Distribution and network effects; ultimately, the winner is not the first product made with vibe coding but the first product that achieves scale.

Meanwhile, software development teams will also change. Currently, in a typical software company, the ratio of engineers, designers, and product managers is 5:1:1. What about the future? If we have an idea, do we just need to open YouWare, describe our thoughts, and wait for the results?

The Birth of YouWare

The fun system of YouWare actually originated from a moment of inspiration from CEO Ming Chaoping. The first version of YouWare took him three hours to create. To his surprise, within half a day of its launch, 1,000 works had been uploaded.

Ming Chaoping, born in 1995 and a graduate of Wuhan University, had previously worked at OnePlus, ByteDance, and Moonlight. During his time at Moonlight, he incubated the world’s first AI-generated music video product, Noisee, and received invitations from top Silicon Valley venture capital firms and leading teams in AI music generation.

On a night in early March 2025, Ming saw many users on X writing games on Grok 3 and sharing them via screen recordings. At that moment, he realized there was a significant gap between AI creators and traditional content platforms. The works produced by AI coding creators were not compatible with traditional social media platforms, and the AI era needed a new carrier.

When users wrote a website or a game using DeepSeek or ChatGPT, it should be shareable on a platform for everyone to see, interact with, and use—something more people could enjoy together. However, many users found themselves unable to share the code generated from their ideas with friends.

This “aha moment” struck Ming around 10 PM. He felt he couldn’t wait any longer.

The team had mostly left for the day, so Ming decided to write it himself. He worked from 10 PM to 1 AM, then, with a few team members, completed the deployment and release by 2 AM. In an interview with LatePost, Ming described those three hours as “sweaty with fear”—he felt that missing that window would mean losing a significant opportunity.

This was the birth of YouWare and its first version, which initially solved one problem: allowing users to paste their code into YouWare and receive a website in return. Essentially, it was a simple transition from HTML code to website publication.

However, Ming, who was very attentive to product experience, design, and interaction, felt that the product was too rough and didn’t want to admit it was his. So he tweeted:

I used a product that can turn your AI coding into works with one click. This product is pretty good, called YouWare; I recommend it to everyone.

After posting this tweet, Ming went to sleep. The next morning, he was surprised to find over 1,000 works online, exceeding his and the team’s expectations. There was no promotion; it was entirely a spontaneous upload by AI coders.

Ming and the team immediately recognized this as positive feedback and spent the entire day upgrading the product and optimizing the user experience. Their only goal was to make it easier for Vibe Coders to create and let good ideas and inspirations be released on the platform for more people to see.

What may have started as a flash of inspiration turned into something extraordinary when captured in time.

With the philosophy of “paying tribute to creators” and “returning to user value,” YouWare quickly received positive feedback in the AI coding community. The next day, the number of works reached 3,000, and within just two days, user visits surged to one million, a 1,000-fold increase in two days!

As of mid-May 2025, the platform has accumulated hundreds of thousands of creative projects, gathering a vibrant community of Vibe Coders from around the world.

Vibe Coders are the “impressionist creators” of the AI era, pursuing not the precision of code but the expression of creativity through intuition and inspiration.

YouWare’s Unique Knot System

YouWare’s uniqueness lies in being the first AI coding creator platform from Shenzhen, China. It also offers a reward creation mechanism called the “Knot system.”

Every spark of inspiration, every creation, and every share earns you a Knot! Based on the number of visits, emoji reactions, and remix counts for each project, points (called Knot) are calculated, with every 100 Knot redeemable for $1, and withdrawals are supported.

YouWare aims to encourage quality creations through a clear reward mechanism, enhancing creator engagement and promoting continuous growth of community content.

If you pay close attention to YouWare’s UI design, you’ll notice that their logo resembles a traditional Chinese knot—another unique aspect of YouWare, symbolizing the connections between creators and the bonds within the community. Each Knot represents a mark of visibility, resonance, and recreation of works.

The design philosophy of the “Chinese knot” stems from Ming Chaoping’s open and confident belief. Openness refers to an international perspective, aiming for global standards from the outset; confidence means being true to oneself.

Ming believes that “being oneself” is a philosophy or belief, a mission given to us by the times. He cites Japanese designer Sori Yanagi’s statement: “Japanese designers can finally be themselves,” reflecting Japan’s journey from imitation to originality.

Today, Chinese teams can also be themselves, possessing their own tastes, aesthetics, and preferences, fully capable of influencing overseas markets and realizing these aspirations.

12 Tips for Writing High-Quality Code with AI from Cursor's Design Lead

Thu, 24 Apr 2025 00:00:00 +0000

Introduction

Recently, the design lead at Cursor shared a series of techniques for using AI to write high-quality code. These methods not only help developers better utilize AI tools but also significantly enhance programming efficiency.

In the AI programming field, one of the most notable developments is ByteDance’s Trea supporting MCP. Having tried it, I can say the user experience is impressive. They have integrated popular MCPs, making it easy for users to add them.

However, I still choose not to use Trea.

Although Trea allows free access to Claude 3.7, the version in Trea likely lacks intelligence. When I submitted modification requests for the same file in both systems, Cursor’s understanding was excellent, while Trea made confusing changes.

This highlights two points:

Cursor has made many optimizations at the engineering level, which cannot simply be bought but require time and experience.
To write good code with AI, the issue may not just lie with the AI and coding knowledge itself, but also with the unknown “insider” factors behind it.

Today, I came across Cursor’s lead sharing 12 insights on how to effectively use Cursor for smooth coding. Here’s a summary of those tips.

Establish Clear Project Rules

Start by setting 5-10 clear project rules to help Cursor understand your structure and constraints. This step is crucial!

Key Point: Use the /generate rules command to let AI automatically generate rules for your existing codebase. It’s incredibly satisfying!

Be Precise with Prompts

Vague prompts = poor output. It’s that simple! Clearly specify the tech stack, behaviors, and constraints in your prompts, just like writing a mini specification document.

AI isn’t mind reading; if you don’t specify clearly, how will it know what you want?

File-Level Iteration is Key

Generating an entire project at once? Wake up! Focus on one file at a time—generate, test, review to keep work blocks small and concentrated. This way, if issues arise, they are easier to locate and fix.

Test First, Code Later

Honestly, write tests first, lock them in, and then let Cursor generate code until all tests pass. This approach, combining test-driven development with AI, boosts efficiency significantly.

Never Forget Manual Review

No matter how powerful AI is, mistakes can happen. Always manually review outputs and fix any issues, then show Cursor the corrected code as an example. Skipping this step could lead to regret later.

Focus Cursor’s Attention

Use the @file, @folders, and @git commands to restrict Cursor’s attention to the correct parts of the codebase. It’s like telling a friend, “Look here, look here,” to avoid distractions.

Keep Design Documents in the `.cursor/` Directory

Place design documents and checklists in the .cursor/ directory so that the agent fully understands what to do next. The more comprehensive the context, the higher the output quality—this is a fact!

If the Code is Wrong, Just Fix It!

If the code is incorrect, just write the correct version yourself. Humans learn faster from your edits than from explanations! Sometimes, it’s better to dive in and make changes rather than explaining for ages.

Utilize Chat History

Make good use of chat history to iterate on old prompts; there’s no need to start from scratch every time. This trick is incredibly useful and can save a lot of repetitive input time, boosting efficiency.

Model Selection Matters

Consciously choose models based on your needs: use Gemini for precision and Claude for breadth. Different models have different strengths, just like different tools are suited for different tasks.

Documentation is Crucial for New Tech Stacks

In new or unfamiliar tech stacks, directly paste documentation links and let Cursor explain all errors and fixes line by line. Don’t hesitate to let AI be your tech teacher, guiding you through problem-solving!

Large Projects Need Overnight Indexing

Allow large projects to index overnight and limit the context scope to maintain agile performance. It’s like preparing in advance so you can dive right in the next day, boosting efficiency!

Conclusion: Structure and Control are Key

Think of Cursor as a powerful junior developer—if you point the way, it can move forward quickly. But you must know the path first!

The core of effectively using Cursor is: clear guidance + strict review + continuous feedback. Master these, and your AI programming efficiency will definitely reach new heights!

Have you used Cursor? Do you have unique tips to share? Or have you encountered any pitfalls during use? Feel free to leave a comment and let’s explore more possibilities in AI programming together!