This is an open-source project: https://github.com/shaowenchen/applab

1. Building an Application with AppLab

• Clone the repository

1

git clone https://x:xxx@applab.chenshaowen.com/applab/git/app.git

• Let the Agent build it

1

claude

Once you describe what you need, just sit back and wait — you will see output like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

构建成功，镜像已产出（shaowenchen/applab:demo-myapp1-cb6c88944e41）。但 deploy 那次只是触发了构建，应用还没部署。再部署一次复用这个镜像。

  Thought for 3s, ran 2 shell commands

部署成功：1/1 就绪，0 次重启。现在对线上地址做端到端验证。

  Thought for 2s, ran 1 shell command

线上服务已跑起来。现在测完整的上传→列表→下载→删除链路，重点验证中文文件名（走 filename*）和二进制的类型嗅探。

  Thought for 2s, ran 1 shell command

路径里的空格把我的 curl 参数拆散了，换个无空格的临时文件名。

⏺ Running 1 shell command…
  ⎿  $ BASE=https://applab.chenshaowen.com/applab/apps/myapp1
     printf 'hello 文件上传\n第二行\n' > /tmp/src.txt
     NAME=$(python3 -c "import urllib.parse;print(urllib.parse.quote('测试 文档.txt'))")
     echo "=== 上传中文名文本 ==="
     curl -sS -X POST "$BASE/api/upload?name=$NAME" -H "Content-Type: text/plain" \
     --data-binary @/tm…

✶ 部署上线… (5m 42s · ↓ 61.0k tokens · thinking with medium effort)
✔ 用 Python 重写文件上传服务
✔ 改 Dockerfile 为单阶段 Python 构建
✔ 改前端上传为原始请求体
✔ 删除 Go 源码并更新 README
◼ 推送构建并部署上线

No need to switch back and forth between a web console and an Agent — a Git repository and a single CLI are enough to complete the full development and deployment of an application.

• View the application

You can also view the application’s configuration in the platform.

2. Why VibeCoding Leaves You More Exhausted

VibeCoding only solves the problem of writing code. It does not cover the full application development lifecycle.

From requirements to running in production and ongoing operation, an application passes through many stages: middleware management, scaling, monitoring and alerting, troubleshooting, and more.

Developers do not just write code — they have to get features shipped and keep the service stable. What lies beneath the waterline is enormous.

And as VibeCoding spreads, production stability becomes precarious. Project complexity is rising sharply, while our ability to review it is steadily eroding.

That is simply where things stand. There is nothing we can do to change it.

3. Even Individuals Have a Chance Under AGI

Faced with code spinning out of control, we may think AGI is just around the corner and we can hand everything to AI. Release, deployment, operations, change management — if the Agent is strong enough, all of it can be automated. If it cannot be done, the model and the Agent simply are not strong enough.

I find that hard to argue against, but impossible to disprove either — like saying bullets cannot kill a fast enough runner; if he was hit, he just was not fast enough.

What I think really matters is the boundary: which things go to the Agent, and which things we must keep under our own control. Finding that boundary takes constant experimentation.

With anything new, we tend to magnify the short-term impact and overcorrect.

As AGI arrives, we should compete with AI for more of the work — that is how we find our place.

I will not hand an entire Kubernetes cluster to an Agent. But I can constrain it through AppLab first, and then hand it over.

4. We Need New Infrastructure

Early on, to connect models we added an adaptation layer and built all kinds of CLIs.

On top of those CLIs, Agents drive the whole development workflow through manual review and feedback-driven fixes.

A system bolted together this way is clearly not an AI-native system. Having too many CLIs brings environment dependency issues, token consumption issues, slow response issues, and slow maintenance and release issues — all of which demand enormous human cost.

The image above is an idea I am proposing: every application deserves its own CLI. If a CLI or MCP can drive an application directly, why not provide it at the moment the application is born?

5. The Repository Is Everything

Everything an application depends on lives in the code repository — not only the code, configuration files, and environment variables, but also the ability to release, change, operate, and troubleshoot it online.

Static code plus a dynamic runtime is what lets an Agent drive a fast-iterating flywheel.

In a newly created application repository, the platform initializes an application-specific applab.sh that contains every platform operation.

Clone the repository and you can fully control the application, including its access credentials. The old tradition of keeping keys out of the repository may need to be retired — after all, we have already leaked so much in AI chat windows; can we not extend a little more trust to our own people?

6. Make the CLI a First-Class Citizen

While VibeCoding AppLab, I kept emphasizing parity across the three ends: the Web, API, and CLI must offer exactly the same capabilities.

The traditional approach builds the Web first, then opens up a subset of API calls, and finally wraps a CLI around that open API. This treats the CLI as a third-class citizen, and it cannot keep up with the Agent era.

Agents are a revolution in production efficiency. Every design decision should prioritize how the Agent uses it. Whether a human uses it is no longer important — what matters is that the Agent can deliver the final result.