Understanding AI Agents: A Reflection in the Era When AI Touches Everything

The question is no longer whether AI can do the task, but whether I have set up the agent well enough to let it.

Two weeks ago I thought I understood large language models. I had studied them at university, I could draw the attention mechanism on a whiteboard, and I had used ChatGPT like everyone else. Then I actually started building with AI agents — and discovered how shallow my understanding really was. This post is not a tidy tutorial or a set of notes. It is a reflection: on where AI agents stand today, on how steep my own learning curve has been, and on how I am trying to position myself in a world where AI is quietly touching every part of work and life.

The moment AI agents became ordinary

Something has shifted in the last year. AI agents — systems that don't just answer a question but actually carry out multi-step tasks on your behalf — have moved from a research curiosity to an ordinary part of how people and companies get things done. In the office, agents draft documents, summarize meetings, reconcile spreadsheets, triage tickets, and prepare first versions of reports that a human only needs to review. At home, people use them to plan trips, learn new subjects, write code for small personal projects, and organize their lives.

What strikes me most is the shift from tools to collaborators. A traditional tool waits for you to operate it. An agent, once given a goal and the right context, takes initiative: it plans, it calls other tools, it checks its own work, and it comes back with something close to finished. Collaboration between humans and agents — and increasingly between multiple agents — is becoming a normal way of working. We are learning to delegate, to review, and to trust (carefully).

The Chinese LLM wave and the no-code no-brainer

Nowhere is this more visible than in Chinese society right now, where large language models have spread remarkably fast and are deeply woven into everyday products. A few that I keep running into:

• 通义千问 (Qwen) from Alibaba — a strong general-purpose model family that also powers a lot of enterprise and cloud workflows.
• 豆包 (Doubao) and 飞书 (Feishu / Lark) from ByteDance — Doubao as a consumer assistant, and Feishu embedding AI directly into the collaboration suite where people already work.
• 智谱 GLM — another capable domestic model family widely used by developers and businesses.

And then there are the web-based application builders. 秒哒 (miaoda.cn) is a striking example: you describe the application you want in plain language, and it assembles a working app for you. No-code application development has genuinely become a no-brainer. Things that used to require a developer, a sprint, and a deployment pipeline can now be prototyped by a non-engineer in an afternoon by simply describing the intent.

The productivity gain is not incremental — it is a step change. When the cost of turning an idea into a working artifact drops this much, the bottleneck moves away from execution and toward knowing what to ask for and judging whether the result is good. That realization is exactly what forced me to go back and relearn.

A steep two weeks: relearning what I thought I knew

For the past two weeks I have been hands-on with the Feishu AI agent on one side and Claude on the other. The learning curve has been steep — steep enough that I had to stop and admit that my university knowledge of LLMs had quietly gone stale.

Back then, the transformer was the destination: I learned how self-attention lets a model weigh every token against every other token, how multi-head attention captures different relationships, and how stacking these blocks produces a language model. That is still the foundation, and revisiting it was a good reminder of why these models behave the way they do — why context length matters, why prompt position influences output, why they can be confidently wrong.

But the field has moved well beyond "train a transformer." The most useful new concept I had to absorb was RAG (Retrieval-Augmented Generation). The idea is elegant: instead of relying only on what the model memorized during training, you retrieve relevant documents from a knowledge base at query time and feed them into the prompt as context. The model then generates its answer grounded in those retrieved facts. This is how an agent can answer questions about my company's internal documents, my notes, or today's data — none of which were in its training set. Understanding RAG reframed how I think about agents: a lot of the "intelligence" in a useful agent actually lives in how well you feed it the right context, not just in the raw model.

Setting up an agent: system prompt, guidelines, and skills

The most eye-opening part has been getting my hands dirty with the actual setup of an agent. It turns out that "configuring an AI agent" is a real craft with several layers:

• System prompt — the agent's identity and standing instructions. This is where you define who the agent is, what its objective is, what tone it takes, and what it must never do. I learned quickly that vague system prompts produce vague agents; precision here pays off everywhere downstream.
• Guidelines — the rules of engagement. When should the agent ask for clarification versus act? How should it handle uncertainty? What does "done" look like? Writing good guidelines feels a lot like writing a good onboarding document for a new colleague.
• Skills — packaged, reusable capabilities the agent can invoke for specific kinds of tasks. Writing a skill forces you to think clearly about a workflow: its inputs, its steps, its outputs, and the conditions under which it should be used. A well-written skill is the difference between an agent that knows a procedure and one that improvises it badly every time.

What surprised me is how much this resembles management more than programming. You are not writing imperative code line by line; you are describing intent, setting boundaries, and delegating judgment. The agent fills in the rest. Getting good at this is a genuinely new skill, and I suspect it will be as valuable in the coming years as knowing how to write a clean function was in the last decade.

A separate note: automating company workflows with n8n

One thread deserves its own section, because it is where individual AI use turns into organizational efficiency: workflow automation, and specifically n8n.

n8n is an open-source workflow automation platform — think of it as visual plumbing that connects your apps, data, and now AI models into automated pipelines. You build a workflow by wiring together nodes: a trigger (a new email, a form submission, a scheduled time), a series of actions (query a database, call an API, transform data), and increasingly an LLM node that injects reasoning into the middle of the pipeline.

This is where AI agents stop being a personal assistant and become company infrastructure. A few patterns I find compelling:

• An incoming customer email triggers a workflow that uses an LLM to classify the request, drafts a reply grounded in the knowledge base via RAG, and routes it to the right person for approval.
• A scheduled job pulls yesterday's operational data, asks a model to summarize anomalies, and posts a digest into Feishu or Slack every morning.
• A document uploaded to a shared drive is automatically read, summarized, tagged, and filed — no human in the loop until review.

The efficiency gain compounds because these workflows run continuously, without fatigue, and they free people to focus on the judgment calls that actually need a human. Combining n8n's orchestration with a well-configured agent feels like the practical, unglamorous frontier where most of the real corporate value will be created — not in flashy demos, but in hundreds of small automations that quietly remove friction.

Self-positioning in an era when AI touches everything

So what does all this mean for me, and for how I work?

The honest answer is that it has unsettled me in a productive way. If a no-code platform can build an app from a sentence, and an agent can draft the report I used to spend an afternoon on, then my value is no longer in being the one who executes those tasks. It is in something harder to automate: framing the right problem, supplying the right context, exercising judgment about quality, and taking responsibility for the outcome. The agent is a tireless junior colleague; I have to become a better senior one.

I am also struck by how much this rewards curiosity and humility. The two weeks that humbled me were also the most energizing I have had in a long time. The technology is moving fast enough that nobody's university knowledge is current for long — which means the durable advantage is not what you know but how quickly you are willing to relearn. Going back to the transformer, picking up RAG, learning to write a system prompt and a skill, wiring an n8n workflow: each of these was a small act of staying current.

If I had to compress this reflection into a single sentence, it would be this: in an era when AI can touch everything, the most important thing I can cultivate is the judgment to decide what it should touch, and the discipline to keep learning fast enough to direct it well.

This is a draft of my thinking, not a conclusion. I expect to revise it as the tools — and I — keep changing. If you are on a similar journey, I'd genuinely like to hear how you are positioning yourself. Drop a comment :)