When Agents Meet Serverless: The Quiet Revolution in How We Build Software

Last Thursday afternoon, a colleague and I were chatting about a seemingly ordinary requirement: build an email gateway. It needed to receive mail sent to various addresses, do some preliminary processing, and then push each message into the corresponding application’s SQS queue, where each team could pick it up and use it as they saw fit.

If you’ve ever used Expensify or FrontApp, you’ll appreciate the elegance of this kind of architecture — using that ancient yet universal protocol, email, to dissolve the walls between systems. Expense reports, customer feedback, internal approvals — everything flows through email, and each system only has to mind its own little plot of land.

The requirement isn’t hard, exactly, but it isn’t easy either. The real difficulty lies not in the business logic but in orchestrating the infrastructure: you have to get AWS SES, SQS, Lambda, DynamoDB, S3, and EventBridge all working in concert, like conducting an orchestra.

What did that used to mean? It meant shuttling back and forth between a half-dozen browser tabs and terminal windows, fishing for needles in the vast ocean of CloudWatch logs, and repeatedly stumbling through the gap between local and cloud environments. Every debugging session was a marathon, and every misconfiguration could cost you half a day of frustration.

And yet, once I raised the mighty weapon that is the Coding Agent, the entire situation changed.

The Double-Edged Sword: The Sweetness and Bitterness of Serverless

Speaking of serverless architecture, it truly lives up to the old saying: “Success comes from Xiao He, failure comes from Xiao He.”

On the one hand, it lets you focus on business logic, free from the tedious chores of server operations, scaling up and down. The pay-as-you-go model even lets small teams build distributed systems that once only the big players could afford. Truly, “four ounces deflect a thousand pounds” — marvelous.

On the other hand, serverless complexity is a world of its own. Take this email gateway:

A seemingly clean architecture diagram, yet building it in practice is another story entirely. Behind every arrow hides a pile of configuration: IAM permissions, environment variables, timeout settings, retry policies… And worse, when the system goes wrong, you have to tease apart scattered logs and piece together the full call chain, like solving a detective case.

I once spent an entire afternoon just figuring out why a Lambda function wasn’t being triggered properly. In the end it turned out the Lambda’s execution role lacked write permission on a particular S3 bucket, so the write failed, and no subsequent event fired the next Lambda. In a traditional monolith, this would have been a single log line. In the serverless world, it became a patience-testing game of detective work.

The Agent’s Superpowers: Global Vision and Instant Feedback

In the traditional development model, we’re like horses wearing blinders, seeing only a tiny patch of the world in front of us. When writing code we can’t see the logs; when reading logs we can’t change the config; when changing the config we’ve already forgotten the earlier error. We dash frantically between different tools and interfaces, our cognitive load stretched to its limit.

A Coding Agent is entirely different. In a matter of seconds, it can:

• Survey the configuration of every relevant service
• Analyze the flow of logs across services
• Comprehend the entire system’s call chain
• Pinpoint the problem and propose a fix
• Modify the code, deploy, and verify — all in one breath

Even better, observability becomes the Agent’s all-seeing eye. The flood of logs and monitoring data that serverless naturally produces — once a burden on developers — is now nourishment for the Agent. It can instantly digest this information and construct a panoramic view of the system in operation, like looking down at a sand table.

This loop can complete many iterations within minutes. What once took days might now take a few hours.

From “Writing Code” to “Spec-First”: A Paradigm Shift

This change isn’t merely a boost in efficiency; it’s a fundamental shift in the programming paradigm.

Previously, we sat down and wrote code directly — typing line by line, carving function by function. Now my way of working is entirely different, more like a “collaborative creation” with the Agent:

Step one: I distill the idea in my head into a prompt and toss it to the Coding Agent. The idea may still be rough, but it contains the core requirements.

Step two: The Agent helps me think it through carefully, breaking these scattered ideas into a coherent requirement document. It asks questions, fills in details, and even points out edge cases I hadn’t considered.

Step three: I review this requirements document carefully, correcting misunderstandings and filling in omissions. The process is like “cutting and polishing” — the idea grows clearer with each round trip.

Step four: Once the requirements are confirmed, the Agent continues its reasoning to produce a design document and a development plan. System architecture, technology choices, implementation steps — all laid out.

Step five: I review the design and plan once more to make sure the direction is right. When everything checks out, the Agent follows the map and starts writing actual code.

This is what I call “spec-driven” programming — instead of writing code directly, you think through the ideas, requirements, and design, write them down clearly, and only then start building. In this process, the Agent is both collaborator and executor.

It’s remarkably reminiscent of the leap from assembly language to high-level languages. Back then, too, there were doubters: how could you write efficient programs without touching the registers directly? But history proved that raising the level of abstraction unleashed productivity and brought more people into software development. “Take a step back and the sky opens up” — that’s the principle.

Today we are experiencing another such leap:

Every leap is not a replacement but an enhancement. Assembly didn’t disappear; high-level languages won’t disappear; and writing code directly still has its value. But most of the time, we can think at a higher level of abstraction — like climbing a tower to gaze far, planning the whole before tending to the details.

The Developer’s New Role: From Executor to Conductor

In the age of Agents, the developer’s role is undergoing a subtle yet profound change.

We are no longer just the “executors” of code; we are more like the system’s “conductors.” This involves four essentials:

• Express intent clearly: Know what you want and be able to describe it precisely — “a full bamboo in your chest.”
• Understand system architecture: You needn’t hand-write every line, but you must grasp how the system works — “grasp the collar and the whole coat follows.”
• Verify and optimize: Judge whether the Agent’s output meets expectations and guide its improvement — “distinguish right from wrong.”
• Handle edge cases: The Agent may miss details that require human experience and intuition — “the finishing touch that brings the dragon to life.”

This reminds me of an orchestra conductor. They needn’t play every instrument, but they must understand each instrument’s character and know how to make them work in harmony. Likewise, tomorrow’s developers needn’t memorize every API parameter, but must understand the principles of system design and know how to orchestrate each component.

The New Shape of Software Engineering

The impact on software engineering is comprehensive. At least three aspects come to mind:

Docs-as-Code, Finally Realized

We used to say “docs as code,” but it was usually just a fond vision. Now, when you describe requirements in natural language, that description itself can generate the code. The boundary between documentation and code begins to blur, like milk dissolving into water. “Speak, and the law follows” — that’s roughly it.

Test-Driven Development, Reinterpreted

TDD emphasizes writing tests first, then the code. In the Agent era, you can describe the expected behavior and let the Agent generate both tests and implementation. This isn’t laziness — it’s focusing attention on “what the system should do” rather than “how to implement it.” “Goal-oriented,” just so.

Continuous Integration, Accelerated

When the cycle of modification and verification shrinks from hours to minutes, CI/CD is no longer a separate stage but dissolves into every breath of the development process, like flowing clouds and running water — utterly natural.

Signals That the Future Has Already Arrived

Back to the email gateway that started this essay: I ultimately used Claude Code to finish in about two hours what had been estimated at a week. This is not an isolated case; it’s a signal.

The signal tells us:

• Complexity is no longer an obstacle: Agents can help us manage cognitive load — “lifting the heavy as if it were light.”
• The true spring of serverless has arrived: With Agents, serverless complexity is well encapsulated — “transforming the complex into the simple.”
• A golden age for the solo developer: One person plus an Agent can do what once required a team — “one rider matching a thousand.”

Yet the new era brings new challenges:

• How do we ensure the security of Agent-generated code? “Prevent trouble before it arises.”
• How do we maintain deep understanding of systems under Agent assistance? “Know the what, and also the why.”
• How do we cultivate the next generation of developers? “Pass the torch from one generation to the next.”

Coda: Embrace Change, but Don’t Forget the Original Intent

Standing at this turning point, I think of Wang Guowei’s three realms of achievement from Renjian Cihua.

“Last night the west wind withered the green trees; alone I climbed the high tower, gazing to the ends of the earth.” — We have already seen the direction of change, like climbing high and looking far.

“My clothes grow looser and looser, yet I never regret; for her I am worn thin and weary.” — We are exploring and practicing, like a seeker of the Way.

“In the crowd I searched for her a thousand times; then, turning suddenly, there she was — in the dim light where the lanterns fade.” — The best tools are often right beside us; we just hadn’t noticed.

Agents are not here to replace us; they are here to augment us. Just as with the leap from assembly to high-level languages, from command line to graphical interfaces, from CGI to Rails, every tool’s evolution frees developers from tedious detail to think about more essential questions. So it is with Agents: they let us put our energy into “what value to create” rather than “how to implement the details.”

This doesn’t make developers less important — on the contrary, it makes us more important. Because once execution is carried by Agents, our value resides in judgment, decisions, and innovation — precisely the things machines find hardest to replace. “Human-machine collaboration” means each plays to its strengths, and each enhances the other.

This quiet revolution has already begun. Are you ready? If this stirs something in you and you want to take a deeper part in this revolution, you’re welcome to join my AI programming bootcamp and explore the infinite possibilities of AI-assisted programming with me.