What is the future of programmers in the AI Era? Some Thoughts from LodenHu

## Introduction

Standing at the epicenter of technological revolution, I've recently felt a tremor called "Dimensional Reduction Strike". Two years ago, we marveled at GitHub Copilot's ability to auto-complete functions; today, with the emergence of Cursor, DeepSeek, or Claude, AI has evolved from a "navigator" sitting in the co-pilot seat to an independent "mechanical team" capable of autonomous operations.

Modern AI no longer focuses merely on the few lines of code following your cursor. With RAG (Retrieval-Augmented Generation) and ultra-long context technology, it can instantly comprehend your entire engineering repository. It now possesses the "hands" to manipulate file systems, execute Shell commands, and even self-repair bugs. When AI-generated code quality begins to approach - or even surpass - that of senior engineers, we must confront the core anxiety: Where is the terminal point for programmers?

## From Craftsman to Commander

Through intensive project实战 (practical implementation), my perspective has undergone a qualitative shift: **The core competitiveness of programmers is transitioning from "writing code" to "orchestrating intelligence".** This transformation signifies that development paradigms have entered their second phase. We're moving beyond mere "prompt engineering" toward genuine "Agentic Workflow". Previously, we chatted with AI in对话框 (chat interfaces); now, we define task decomposition and iteration logic within native editors. As reasoning costs plummet exponentially, we can even afford to let AI "reflect" ten times to obtain a perfect solution. In this context, our identity is quietly shifting from craftsmen to commanders.

## Building Composite AI Systems

As "system commanders", our work focus is shifting. Previously, programmers spent 80% of time writing code and 20% on design; in the future, this ratio will completely invert. We'll need to invest most efforts in defining data flows, interface contracts, and system boundaries.

A typical example is the rise of **MCP (Model Context Protocol)**. Today, my new tasks are no longer about implementing logic, but building "toolboxes" for AI. Through this protocol, I provide AI with standard interfaces to access databases, APIs, and local tools. I'm no longer a code producer, but an intelligence connector. Meanwhile, coding itself is evolving into "test case creation" - we constrain AI behavior through automated evaluation sets (Evals) to ensure generated logic stays on course.

Going further, future applications will no longer simply mount large model interfaces, but construct **composite AI systems**. This requires advanced scheduling capabilities: invoking深度推理 (deep reasoning) models like $o1$ for complex tasks, while switching to lightweight models for rapid responses. We'll use vector databases and graph technologies (GraphRAG) to build "long-term memory" for applications, designing closed-loop systems capable of self-evolution from user feedback.

Even product forms will be reshaped. We might witness "generative UIs" where interfaces aren't rigid buttons, but dynamically generated interactive components based on AI intentions.

## Why is this the only path for programmers?

The most direct reason is the exponential growth of software complexity. While AI lowers coding barriers, it creates code explosions. Understanding, maintaining, and integrating massive codebases requires higher-dimensional architects rather than junior programmers. At this stage, "engineering capability" becomes scarcer than "algorithm capability". Large models are becoming commoditized; the real barrier lies in taming unstable models into stable products through engineering techniques like state management and error handling.

This also signifies a massive release of productivity leverage. A programmer mastering Agentic Workflow can produce output equivalent to a past full-stack team of ten. This "one-person company" potential represents unprecedented career dividends.

## How to Achieve Identity Transformation?

To accomplish this transformation, we need to update our arsenal starting now. Abandon outdated IDEs, embrace AI editors like `Cursor`, further explore command-line terminals like `Claude Code`, and get accustomed to controlling全局 (global scope) through natural language in `Composer` mode. Learn **agent frameworks** like `LangGraph` or `PydanticAI` to understand how to decompose complex tasks into multi-agent collaborations.

Most importantly, we need psychological soft landing: **Transition from a "code writer" (Coder) to a "problem solver" (Solver).** AI handles "how to write", while you determine "what to write" and "why to write".

## Conclusion

AI isn't the end of code, but the reboot of software. Code is transforming from human-readable text to AI-executable instructions. We're no longer mere translators, but accelerators of evolution. Future programmers will essentially be "product managers with technical foundations" and "HR managers overseeing AI workforce". Those who率先 learn to harness Agents and build composite systems will surely wield the most powerful authority in software engineering history.