Part 1: Getting Started

Getting Started with Large Models: How Should Non-Programmers Begin Using AI?

🌱 "The first step to using LLMs well is not understanding every technical detail, but knowing what they can do, what they can't, and how to articulate your tasks clearly."

This chapter does not require programming skills or an understanding of neural networks. We approach LLMs purely from a user's perspective, treating them as everyday tools.

You can think of a large model as an assistant who is exceptionally good with language: it can read materials, write drafts, revise expressions, summarize, outline plans, explain concepts, generate code, and brainstorm with you.

But it is not an infallible expert, nor is it a database that inherently knows the truth. It is more like a collaborator who is highly capable and responsive, but whose output you need to verify.

The first step to using LLMs well is not learning complex theory — it is learning to articulate your tasks clearly.

How Should You Read This Chapter?

This chapter is written for absolute beginners. You do not need to memorize model names, calculate tokens precisely, or understand how models are trained internally.

We suggest focusing on just four things:

If, after reading this chapter, you can start using LLMs for learning, writing, office work, or programming assistance, then this chapter has served its purpose.

LLMs Are Not Search Engines — They Are Language Collaborators

Many people treat LLMs like search engines when they first use them:

What is the tallest mountain in the world?
What was Company X's revenue this year?
Is this news story true?

These are certainly askable, but they are not where LLMs provide the most value.

A search engine is better at helping you find source materials; a calculator is better at precise computation; what an LLM truly excels at is processing language and tasks.

For example, given the same long article:

• A search engine can help you find it.
• A browser can help you open it.
• An LLM can help you summarize it, explain it, rewrite it, extract its key points, and even turn it into a presentation script.

So a more accurate understanding is:

A search engine helps you find materials; an LLM helps you process materials.

If you only ask an LLM factual questions, it may be nothing more than an unreliable Q&A machine. But if you give it a piece of material, a task, or a goal, it becomes a very useful collaborator.

Think of an LLM as "a Highly Capable Intern Who Needs Checking"

For absolute beginners, the easiest analogy for an LLM is: an intern.

This intern has read a lot of material, writes quickly, is great at imitation, and can help organize your thoughts. But it has a few obvious shortcomings:

• It may not know your real background.
• It may misunderstand your goals.
• It may fabricate details to produce a complete-sounding answer.
• It may treat outdated information as current.
• What it writes may look convincing but is not necessarily correct.

Therefore, the right way to use it is not "let it give the final answer in one shot," but rather to collaborate with it iteratively.

A common usage loop is:

1. You tell it the task and background.
2. It produces a first draft.
3. You check what's wrong or insufficient.
4. You add requirements.
5. It revises further.
6. You make the final call on whether to use it.

For example, you could say:

You are an expert in AI popular science.
I am preparing to write an AI popular science article for high school students.
Please first outline it for me — do not write the full article yet.
Requirements: use relaxed language, no complex formulas.
Give a real-life analogy for each section.

This is far better than simply saying "write me an AI article," because it gives the model a clear identity, audience, task, constraints, and output target.

What Can LLMs Do for Regular People?

The most fundamental capability of LLMs is not "thinking like a human," but rather performing various transformations and organizations around language.

Give it a paragraph, it can summarize. Give it a topic, it can draft. Give it a jumble of ideas, it can organize. Give it a concept, it can explain. Give it code, it can analyze.

From an ordinary user's perspective, its uses can be roughly divided into several categories:

Here's an important principle:

LLMs are best at helping you produce first drafts, not making final judgments for you.

For example, it can help you draft a resume, but you should verify whether the experiences are accurate. It can help you summarize a contract, but important clauses still need professional review. It can help you interpret a medical report, but it cannot replace a doctor's diagnosis.

How to Ask LLMs Effective Questions

Many people find models unhelpful — not necessarily because the model is bad, but because the question is too vague.

For instance, questions like this usually produce poor results:

Write me a proposal.

The model does not know who you are, who the proposal is for, what the goal is, how long it should be, or what style you prefer. It can only guess.

For beginners, the simplest prompt formula is:

Background + Goal + Materials + Requirements + Output Format

Let's rewrite that vague question:

I am a university lecturer preparing a 90-minute AI introductory class for students with no prior background.
The goal is for them to understand what LLMs can do and complete one effective prompt.
Please help me design a course outline.
Requirements:
1. No formulas;
2. One interactive activity every 20 minutes;
3. Include an in-class exercise at the end;
4. Output in table format.

This question is much clearer now.

It tells the model:

• Background: University lecturer, students with no background.
• Goal: Understand LLM capabilities and complete one effective prompt.
• Task: Design a course outline.
• Requirements: No formulas, interactive, with an exercise.
• Format: Output as a table.

You can also memorize it as a template:

You are playing the role of [role].
I want to accomplish [task].
The background is [background information].
The materials I have are [materials].
Please complete this according to [requirements].
Output format: [format].
If you lack sufficient information, please ask me questions first.

The last line — "If you lack sufficient information, please ask me questions first" — is extremely useful. It prevents the model from rushing to fabricate and instead prompts it to fill in critical missing information first.

What Are Tokens?

When using LLMs, you will often encounter a term: token.

You can roughly think of a token as: the small granules that a model uses when processing text.

For example, take this sentence:

I want the large model to help me summarize this article.

Internally, the model does not read this sentence holistically like a human. It breaks the text into smaller units. In Chinese, a token might be roughly one character, one word, or one punctuation mark. In English, a token might be a whole word or part of a word.

Regular users do not need to calculate tokens precisely. Just remember one thing:

The longer the input, the longer the output — the more tokens are consumed.

"Input" here includes more than just the question you just typed. It can also include:

• The history of your previous conversation turns.
• Documents you upload.
• Code you paste.
• System instructions given to the model.
• Content returned by tool calls.

The model's response to you becomes the output tokens.

Thus, the cost of a single LLM call can be roughly understood as:

Total cost ≈ input token cost + output token cost

For many models, output tokens are more expensive than input tokens because generating content requires more computation.

How Much Does Using an LLM Cost?

If you are using consumer-facing products like ChatGPT, Claude, Gemini, Kimi, Doubao, Tongyi, or DeepSeek, you typically do not need to calculate per-token costs yourself. What you are more likely to encounter are free quotas, membership subscriptions, usage limits, or plan caps.

If you are a developer calling models via API, you need to pay closer attention to token costs.

As of this book's writing, LLM APIs have become much cheaper compared to earlier days. Tasks like casual chat, short text polishing, and simple summaries typically incur very low per-call costs. But if you ask the model to process long documents, entire codebases, or let an Agent execute many steps autonomously, the cost can rise significantly.

Use the following table to build intuition:

Pay special attention to multi-turn conversations.

Many chat products send the conversation history to the model each time so the model can "remember what was said earlier." This is convenient, but it also means the longer the conversation, the more input tokens may be used.

If you find a conversation has grown very long, consider starting a new one, first asking the model to summarize the key points from before, and then bringing that summary into the new conversation.

Which AI Should a Beginner Actually Use? How to Download? Should You Pay?

Many beginners' biggest concern is not model leaderboards, but three very practical questions: Which one should I use right now? Where do I download it? Do I need to pay?

Here's the direct takeaway:

For absolute beginners, don't research all models at once. First pick one chat product that's easy to access, has good Chinese-language experience, and offers sufficient free quota. Use it for a week before deciding whether to pay.

If You Just Want to Start Right Now, Here's How to Choose

If you still don't know how to choose, follow this order:

1. Step 1: Start with a domestic chat product, such as Doubao or Kimi.
2. Step 2: If you can normally access overseas services, try ChatGPT, Claude, or Gemini.
3. Step 3: If you start writing code or modifying projects, consider programming tools like Cursor, Trae, or GitHub Copilot.

For most absolute beginners, one tool for the first week is enough. Don't switch from one to another every day — otherwise you'll struggle to tell whether the tool is the problem or your prompting approach is still unclear.

Where to Download or Access?

The safest approach is: Prioritize official websites and official app stores. Do not casually download installation packages from unknown sources.

Beginners can remember these principles:

• Use the web version first if possible: No installation, lowest risk.
• Mobile is suitable for daily use: For example, photo recognition, voice questions, quick summaries.
• Don't install programming tools too early: If you're not coding yet, a chat product is enough.
• Verify the official source: Before downloading, confirm the product name, developer, and official website to avoid counterfeit apps.

Quick Reference: Official Entry Points for Common AI / Agent Tools

The table below is not a leaderboard. It is a safe entry-point checklist for beginners. Links and product forms may change — always rely on official websites, official app stores, and project READMEs when downloading.

If you just want to start using AI, you don't need to install all of these. A more sensible order is: Start with chat products like Doubao, Kimi, ChatGPT. When you start coding, use Cursor, Trae, Copilot. When you need AI to truly operate on files and workflows, consider Agent tools like WorkBuddy, OpenClaw, or Hermes Agent.

Is the Free Version Enough? When Should You Pay?

Beginners generally do not need to pay right away. Start with the free version for these tasks:

• Explain a concept.
• Summarize an article.
• Polish a passage.
• Create a study plan.
• Help revise an email.
• Analyze a screenshot or a short document.

If after a week of continuous use you find it genuinely saves you time, then consider paying.

Two things to note when paying:

1. Paying does not mean answers are necessarily correct: Important facts, numbers, legal, medical, and financial advice still need verification.
2. Don't subscribe to too many tools at once: Regular users should stick with one primary tool first and switch only when they hit a clear bottleneck.

A simple selection guideline:

Don't want to tinker: Start with Doubao or Kimi. Want stronger all-around capability: Then try ChatGPT, Claude, or Gemini. Starting to code seriously: Then use Cursor, WorkBuddy, or GitHub Copilot.

Most importantly:

Don't ask "which model is always the best." Ask "for this task right now, which one makes it easiest."

From Chat Window to AI Tools: How Should Regular People Choose?

Earlier we discussed "which model to choose." But when you actually start using AI, you will quickly run into another question:

• Should I use chat products like ChatGPT, Claude, Gemini directly, or specialized AI programming tools?
• Claude Code, Codex, Cursor, Trae all seem to write code — what's the difference?
• Are desktop Agents like WorkBuddy, OpenClaw more advanced?
• Do I need to care about engineering concepts like Harness and Trace right now?

Start by remembering a very practical distinction:

The model is the "brain"; the tool is the "workbench, hands and feet, permissions, and process record."

The same model, placed in a chat window, mainly answers you. Placed in a coding Agent, it can read projects, edit files, and run tests. Placed in an office Agent, it might also organize documents, manipulate spreadsheets, and generate PPTs. Placed in an enterprise Agent system, it needs permissions, logging, evaluation, and auditing to ensure safety and reliability.

So beginners don't need to research all tools at once. Just ask yourself three questions first:

In one sentence:

First learn to prompt with chat products, then handle real tasks with Agents, and only then consider engineering systems like Harness and Trace.

First, Distinguish: Models, Chat Products, Agents, Harness, Trace Are Not the Same Thing

These terms are often mixed together, but they sit at different layers.

Think of them as a progressively enhanced system:

Model → Chat Product → Agent Tool → Harness → Trace / Audit / Evaluation

The further right you go, the more the AI can do, but the higher the risk and management cost. For beginners, the right order is not "jump straight to the strongest tool," but rather start from low-risk scenarios and gradually delegate more authority.

1. Chat Products: The Best First Stop for Beginners

If your tasks are mainly reading, writing, editing, summarizing, explaining, or planning, chat products are usually sufficient.

Common choices include:

• ChatGPT: Mature all-around capability and tool ecosystem, suitable for general Q&A, writing, and code assistance.
• Claude: Typically excels at long-document reading, precise expression, and rigorous summarization.
• Gemini: Strong multimodal and long-context capabilities, suitable for images, video, long materials, and Google ecosystem.
• Kimi: Friendly Chinese long-document reading experience, suitable for material summarization, paper reading, and report reading.
• Doubao, Tongyi, Wenxin, GLM: Suitable for Chinese office work, content generation, and domestic application ecosystems.
• DeepSeek, Qwen: Often used by developers for coding, reasoning, low-cost API, or local deployment.

For example, you could ask:

I have a 20-page industry report.
Please first summarize it into 10 key points, then list 3 risks I should focus on.
Requirement: Do not fabricate information not present in the report.

The advantages of chat products are low barrier to entry, low risk, and fast feedback. They don't directly operate on your computer or automatically modify files, making them perfect for building your basic feel for using AI.

Tasks they're suited for:

• Learning a new concept.
• Polishing a passage.
• Summarizing an article or report.
• Creating a study plan, work plan, or activity proposal.
• Explaining code or an error message.

If you're still unsure what tool to use, start with a chat product — you generally can't go wrong.

2. AI IDE / Coding Agent: For Development Tasks in Real Projects

When the task shifts from "answer a question" to "please modify this project for me," a chat window becomes inconvenient.

This is where AI coding tools like Claude Code, Codex, Cursor, Trae, Copilot come in. What they share: they don't just answer questions — they can work around a codebase.

They can typically help you:

• Read project structure.
• Search for functions and call relationships.
• Explain unfamiliar code.
• Modify files.
• Continue fixing based on error messages.
• Generate test cases.
• Run tests or commands and iterate based on results.

Different tools can be roughly understood as follows:

A safer usage approach: let it read first, then let it modify.

Please first read the login flow of this project — do not modify code yet.
First tell me:
1. Where the login entry point is;
2. Where tokens are generated and stored;
3. If I want to add SMS verification, which files need to change.

Once it explains clearly, then let it execute:

Modify according to the plan just discussed.
Requirements:
1. Do not change the existing password login logic;
2. Add SMS verification code validation;
3. Run relevant tests after modification;
4. Finally summarize which files were changed.

Beginner reminder: Don't start by saying "refactor my entire project." A better approach is to let the AI first explain the flow, locate issues, modify a small feature, and then gradually expand the task scope.

3. Office / Desktop Agent: For Multi-File, Multi-Tool, Multi-Step Tasks

If your tasks are not coding but processing documents, spreadsheets, PPTs, folders, messages, and workflows, then office or desktop Agents like WorkBuddy, OpenClaw are more appropriate.

The difference from chat products: chat products mainly "answer," while desktop Agents emphasize "execution."

For example, you can ask it to:

• Organize materials in a folder.
• Summarize multiple customer interview transcripts.
• Extract key information from a spreadsheet.
• Generate a presentation outline or PPT first draft.
• Convert daily reports, weekly reports, meeting notes into to-do items.
• Call external tools and send results to team groups or workflows.

WorkBuddy is more like an office assistant for workplace users, suitable for documents, spreadsheets, PPTs, meeting notes, and workflow organization.

OpenClaw is more like an extensible Agent workbench, focused on letting AI connect tools, execute skills, call interfaces, and even integrate with Feishu, Telegram, Discord, and other workflows.

You could describe a task like this:

Please organize the 20 customer interview transcripts in this folder.
Output:
1. Each customer's core needs;
2. Top 5 frequent issues;
3. A three-page summary outline suitable for a PPT.

For automated workflows, you could say:

Every morning at 9 AM, read the daily reports in the designated folder,
summarize new issues from yesterday,
rank by severity,
then send to the team group.

These tools are highly efficient but require more attention to permissions. Any Agent that can read/write local files, access enterprise data, send messages, or call interfaces should have its scope limited upon first use — test with a sandbox folder or non-sensitive materials first.

4. Harness: The "Shell" That Enables Agents to Work Safely and Stably

Harness is not a product that ordinary users open daily to chat with. It is more like the engineering shell of an Agent system.

For an Agent to do real work reliably, a model alone is not enough. It needs a whole set of supporting capabilities:

• Tool List: What tools can it invoke?
• Permission Control: Which files can it read? Which commands can it execute? Which operations require human confirmation?
• Memory System: What information needs long-term storage? What must not be saved?
• Execution Environment: Where does the code run? How does it stop on failure? Can it roll back?
• Evaluation Mechanism: How do you judge whether it did the right thing?
• Logging and Auditing: What did it do at each step? Who approved it?

Together, these capabilities can be understood as the Agent's Harness.

In one sentence:

The model determines how smart the Agent is; the Harness determines whether the Agent can do work safely, stably, and controllably.

If you're just an individual user, knowing the concept is enough for now. If you're deploying Agents in a team or enterprise, Harness becomes very important.

5. Trace: Leaving an Inspectable Trail of the AI's Execution Process

Trace or Agent Trace refers to the mechanism for recording the Agent's execution process.

When AI is only helping you rewrite a single sentence, complex recording isn't needed. But when it starts modifying code, processing customer data, calling interfaces, and sending messages, you need to know:

• Which files did it read?
• What content did it modify?
• Why did it make that decision?
• Which step introduced the problem?
• Did a human review it?
• Can accountability be traced and rollback performed if something goes wrong?

This is the value of Trace: not making the AI better at answering, but making what the AI did inspectable, reviewable, and accountable.

Also note a similarly named tool: Trae.

Simply put: Trace is "recording the process"; Trae is "helping you code."

Which Should You Actually Use? A Choice Roadmap for Beginners

If you still don't know how to choose, follow the roadmap below.

A more sensible onboarding order is:

1. Start with chat products: Learn to articulate tasks clearly.
2. Then use AI IDE / coding Agent: Let AI read code, modify small features, run tests.
3. Then use office / desktop Agent: Let AI process files, spreadsheets, PPTs, and multi-step tasks.
4. Finally consider Harness and Trace: Bring these in when you need long-running execution, team collaboration, permission control, and auditing.

Most importantly, don't pursue "full automation" from the start.

The more automated the AI tool, the more gradually you should delegate authority: first let it suggest, then let it modify, and only finally let it execute.

A 7-Day Beginner Practice Plan

If you're just starting with LLMs, spend a week on the following exercises.

These exercises require no programming and no professional background. The key is to integrate them into your real life and work.

As you practice, consciously observe three things:

1. When you provide more information, do the answers become more aligned with your needs?
2. When you specify an output format, are the results easier to use?
3. When you point out issues and ask for revisions, do the results noticeably improve?

If the answer is yes, you have already grasped the most important part of using LLMs: they are not one-shot answer machines, but iterable collaborators.

What Are LLMs' Most Common Mistakes?

LLM responses are often fluent, confident, and even beautifully formatted. But that doesn't mean they're necessarily correct.

There are five main categories of risk.

1. Confidently Fabricating

LLMs may invent non-existent papers, authors, links, legal provisions, statistics, or even give citations that look real.

So when you ask factual questions, it's best to require sources and verify them yourself.

2. Treating Old Information as Current

Some models lack internet access; some models' knowledge is not updated promptly. They may not know about the latest policies, latest product prices, latest model names, or latest company developments.

If the question involves "current time," it's better to use a tool with web search capability, or look up official sources yourself.

3. Getting Math and Precise Calculations Wrong

LLMs are good at explaining mathematical reasoning, but not always good at precise calculations. Simple arithmetic can also be wrong; complex calculations should definitely be handed off to calculators, spreadsheets, or code.

A practical approach: have the model write out the calculation process, then verify the result with a reliable tool.

4. Misunderstanding Your Real Intent

If you just say "write me a proposal," it doesn't know whether you want a business proposal, course proposal, event proposal, or project proposal.

The less background you provide, the more it has to guess; the more it guesses, the higher the chance of going off track.

5. Correct Format but Incorrect Content

This is the most deceptive category.

LLMs can present wrong content in a very tidy way: with headings, tables, numbering, and conclusions — looking very professional. But good formatting does not equal reliable content.

Therefore, the more important something is, the less you should rely on just one query.

You can have the model perform these self-checks:

Please check your previous answer: which parts are certain, and which parts need further verification.

Please critique this proposal from an opposing perspective and point out the three most likely reasons it could fail.

Please list the key assumptions your answer depends on. If these assumptions don't hold, how would the conclusions change?

This kind of follow-up questioning can significantly improve result quality.

From "Using" to "Mastering": What to Learn Next?

When you start consciously providing background, setting requirements, checking results, and asking follow-up questions, you have in fact entered the world of Prompt Engineering.

From here, you can continue learning several more advanced topics to build a holistic understanding of Agents and the LLM fundamentals that drive them. If you only wanted to learn how to use LLMs, reading this far is enough.

Start learning: Chapter 1: What is an Agent?