George Cao

Software Developer

[George Cao @ge0rgeca0]

原来如此

[AI最严厉的父亲 @dashen_wang]

真正玩过 Linux 的人，现在看很多 AI Agent 教程，心情其实挺复杂的。

因为你会发现，AI 是 2026 年的。

很多所谓 Agent 基础设施，大概是 1996 年的。

给 Agent 单独建用户，叫身份隔离。

chmod 一下，叫最小权限。

分个目录，叫 Workspace Sandbox。

限制 sudo，叫安全边界。

systemd 守护进程，叫 Agent Runtime。

cron 定时跑，叫 Autonomous Scheduler。

journalctl 看日志，叫 Observability。

SSH 远程进去，叫 Human in the Loop。

Docker 套一层，叫 Secure Execution Environment。

进程挂了自动拉起，叫 Self Healing。

几个脚本互相调用一下，已经开始画 Multi Agent Architecture 了。

再配个 Redis，恨不得第二天融资。

我有时候看这些架构图，确实挺受教育的。

原来我以前管服务器的时候，每天都在做 Agent Infrastructure，只是当年没人告诉我这个词值钱。

Linux 真正舒服的地方就在这里。

你根本不用相信 Agent。

给它一个普通用户。

一个 home 目录。

该读的给读。

该写的给写。

不该碰的连看都别让它看。

CPU、内存、进程、端口、文件、网络，全都能管。

想长期跑就 systemd。

想临时跑就 tmux。

想定时跑就 cron。

想隔离就 container。

还不放心就 VM。

再不放心直接断网。

所以很多 Linux 老用户玩 Agent 上手特别快。

因为别人还在研究怎么优雅地管理一个会执行命令的 AI。

Linux 用户看了半天。

哦。

不就是又来了一个不太靠谱的普通用户吗。

[Nandkishor @devops_nk]

https://t.co/HCKTlAXi2j

[George Cao @ge0rgeca0]

Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems

[George Cao @ge0rgeca0]

COMPLETE DOMINANCE! 👏 Isaac del Toro and Tadej Pogačar go 1-2 on Stage 2... https://t.co/8G032i0ppe via @YouTube

[George Cao @ge0rgeca0]

@XCaptaincc 通用能力服务化和中台的差异是“通用能力服务化”说的是后台？

[George Cao @ge0rgeca0]

@cloudwu @disksing 迷糊了，微信占用空间多是因为sqllite吗

[George Cao @ge0rgeca0]

Stanford CS229 I Machine Learning I Building Large Language Models (LLMs) https://t.co/2juAtPVMfv via @YouTube

[火山哥🕊️ @huoshan007]

兄弟们今天给大家免费分享一个斯坦福这课。

直接把 Claude 和 ChatGPT 的内部工作原理，拆开讲了 1 小时 30 分钟，而且是免费的。

很多人天天用 AI，其实连 10% 都没榨出来。

不是模型不行，是你根本不知道它脑子里怎么转的。

这种课建议直接收藏。

你少刷一小时短剧，把这 1 多小时啃完，明天醒来可能就多了一门能赚钱的路径。

[George Cao @ge0rgeca0]

@tison1096 寻找实现业务逻辑的最快选择，而不是默认用代码实现。

[George Cao @ge0rgeca0]

看到了还是要发一发

[Mathematica @mathemetica]

@Orwelian84 Here's the full Oxford Mathematics lecture with Terence Tao:

https://t.co/kPHKdwL4VM

[George Cao @ge0rgeca0]

https://t.co/XtYC88eDrf

[George Cao @ge0rgeca0]

结果导向：以终为始，站在结果的角度考虑问题，将结果作为行动的逻辑终点和衡量标准。

[AsyncTrix @asynctrix]

Kubernetes - In Plain English ☸️

- Pod → Smallest unit where your app runs
- Deployment → Manages replicas & updates
- StatefulSet → Stable identity + persistent storage
- DaemonSet → One Pod on every node

- Service → Stable internal access
- Ingress → External HTTP/HTTPS access

- ConfigMap → Non-sensitive configuration
- Secret → Sensitive data

- Node → Machine that runs Pods
- Control Plane → Brain of the cluster
- RBAC → Controls permissions
- Namespace → Logical isolation

Understand the building blocks → Kubernetes becomes simple.

[George Cao @ge0rgeca0]

Each node must be indented further than its parent node. All sibling nodes must use the exact same indentation level. However the content of each sibling node may be further indented independently.
https://t.co/gSFim7W8Nf

[George Cao @ge0rgeca0]

SRE team should be responsible for this, right?

[Ayaan 🐧 @twtayaan]

🔍 What is Observability?

Most people think it’s just monitoring.

It’s not.

Observability = knowing what’s happening inside your system without guessing.

It answers 3 simple questions:

1. What is happening?
2. Why is it happening?
3. How is it happening?

1. Metrics:
→ What’s happening
(CPU, memory, latency, traffic)

2. Logs
→ Why it happened
(Errors, events, debug info)

3. Traces
→ How it happened
(Request flow across services)

Metrics = What
Logs = Why
Traces = How

If you don’t have observability,
you’re just guessing in production.

[George Cao @ge0rgeca0]

Kubernetes is beautiful. Every Concept Has a Story, you just don't know it yet.

[Akhilesh Mishra @livingdevops]

Kubernetes is beautiful.
Every Concept Has a Story, you just don't know it yet.

In k8s, you run your app as a pod. It runs your container. Then it crashes, and nobody restarts it. It is just gone.

So you use a Deployment. One pod dies and another comes back. You want 3 running, it keeps 3 running.

Every pod gets a new IP when it restarts. Another service needs to talk to your app but the IPs keep changing. You cannot hardcode them at scale.

So you use a Service. One stable IP that always finds your pods using labels, not IPs. Pods die and come back. The Service does not care.

But now you have 10 services and 10 load balancers. Your cloud bill does not care that 6 of them handle almost no traffic.

So you use Ingress. One load balancer, all services behind it, smart routing. But Ingress is just rules and nobody executes them.

So you add an Ingress Controller. Nginx, Traefik, AWS Load Balancer Controller. Now the rules actually work.

Your app needs config so you hardcode it inside the container. Wrong database in staging. Wrong API key in production. You rebuild the image every time config changes.

So you use a ConfigMap. Config lives outside the container and gets injected at runtime. Same image runs in dev, staging and production with different configs.

But your database password is now sitting in a ConfigMap unencrypted. Anyone with basic kubectl access can read it. That is not a mistake. That is a security incident.

So you use a Secret. Sensitive data stored separately with its own access controls. Your image never sees it.

Some days 100 users, some days 10,000. You manually scale to 8 pods during the spike and watch them sit idle all night. You cannot babysit your cluster forever.

So you use HPA. CPU crosses 70 percent and pods are added automatically. Traffic drops and they scale back down. You are not woken up at 2am anymore.

But now your nodes are full and new pods sit in Pending state. HPA did its job. Your cluster had nowhere to put the pods.

So you use Karpenter. Pods stuck in Pending and a new node appears automatically. Load drops and the node is removed. You only pay for what you actually use.

One pod starts consuming 4GB of memory and nobody told Kubernetes it was not supposed to. It starves every other pod on that node and a cascade begins. One rogue pod with no limits takes down everything around it.

So you use Resource Requests and Limits. Requests tell Kubernetes the minimum your pod needs to be scheduled. Limits make sure no pod can steal from everything around it. Your cluster runs predictably.

[George Cao @ge0rgeca0]

https://t.co/F07Q7rRiMQ

It's really useful for writing your own recipes based on recipes already exists.

[George Cao @ge0rgeca0]

好像是没有数据库连接池支持像缓存一样的LRU、LFU或者MRU的策略来获取连接的

[George Cao @ge0rgeca0]

Java迭代的太快了，整个工具链和生态圈更不上节奏的样子。 要升级一个repo到Java 25 LTS，总有一些工具和 类库需要等一下。