How Do You Use AI?

Updated: 2026-07-09.
Main topics: basic AI categories, Codex, Claude Code, opencode, relay services, shared subscriptions, proxy protocols, and access environments.

The Short Version

#

This note connects the things programmers actually run into when they start using AI tools seriously:

Code tools (Codex / Claude Code / opencode)
  -> Model capability (OpenAI / Claude / GLM / MiniMax / Kimi / Qwen / DeepSeek)
  -> API shape (official APIs / NewAPI / sub2api / relay services)
  -> Accounts and quota (subscriptions / API keys / shared plans / resource pools)
  -> Access environment (proxy providers / residential IP / overseas systems / proxy protocols)

Codex, Claude Code, and opencode are different from ordinary chatbots. They do not just answer one message. They read repositories, edit code, run commands, inspect logs, repair tests, and keep going across multiple steps. Because of that, they care much more about model quality, API stability, account quota, network conditions, and the local development environment.

For mainland China usage, one sentence is useful: domestic models are already strong, and overseas code agents are genuinely useful; the real bottleneck is often not whether the model can code, but whether accounts, quota, APIs, networks, and devices can be made stable enough.

0. First, Separate The AI Categories

#

When people say “AI”, they may be talking about very different layers. They are all intelligent algorithms, but their boundaries, local hardware needs, and deployment styles are not the same. The table gives both open-source and commercial/cloud examples so the categories are easier to anchor.

A rough mental model: traditional AI is usually a model specialized for one task; OCR and speech recognition are mature specialized capabilities; large models, multimodal models, and code agents are more like general capabilities that understand context and call tools.

OCR and speech recognition are not the same thing as a multimodal large model. OCR focuses on reading text from images. Speech recognition focuses on turning audio into text. A multimodal model can consume text, images, audio, video, and tool results, then continue reasoning, summarizing, coding, or calling tools. OCR and ASR can be preprocessing steps for large models, but they can also be used alone.

For local deployment, traditional models and lightweight OCR/ASR are the easiest to run locally. Multimodal large models and strong coding models are the hardest. For everyday programmers, the practical route is usually: keep the development environment, scripts, cache, and lightweight tools local, and send heavy model inference to a cloud API or a company-managed gateway.

1. Code Agents First

#

1.1 Chatbots vs. Code Agents

#

A normal chatbot usually works like this:

user asks -> model answers -> user copies the result

A code agent usually works like this:

user describes a goal
  -> agent reads project files
  -> agent makes a plan
  -> agent edits multiple files
  -> agent runs tests or commands
  -> agent reads failures and keeps fixing
  -> agent reports the diff, tests, and reasoning

So a code agent is closer to an assistant that can enter the project and work, not just a code Q&A bot. It depends on several things:

• Model capability: understanding large codebases, cross-file changes, and difficult bugs.
• Tool permissions: reading files, editing files, running commands, using a browser, or calling external tools.
• Context window: holding enough code, logs, requirements, and conversation history.
• Streaming and stability: long tasks cannot keep disconnecting or randomly stopping.
• Local environment: dependencies, tests, builds, Git state, and system permissions all matter.

1.2 Why People Keep Mentioning Codex and Claude Code

#

As of July 2026, programmers often talk about three kinds of code-agent tools:

• Codex: OpenAI’s code agent, closely connected with ChatGPT, OpenAI models, CLI, IDE, desktop app, local projects, and cloud tasks.
• Claude Code: Anthropic’s code agent, strong at complex code understanding, long terminal workflows, test repair, and large-context reasoning.
• opencode: an open-source, model-agnostic code agent that can connect to OpenAI, Claude, Gemini, Qwen, DeepSeek, Kimi, local models, and other backends.

They represent three routes:

Once these routes are clear, NewAPI, sub2api, relay services, shared plans, proxy providers, and overseas residential IP become easier to understand. They all answer the same questions: where does the model come from, how is account quota shared, how does traffic reach the service, and how does the environment stay stable?

1.3 Where Domestic Models Fit

#

This note is not mainly about domestic models, but they fit roughly like this:

• GLM-5.2 / GLM-5: a strong domestic default choice for coding, agent engineering, tool use, and long tasks.
• MiniMax M3: useful for long context, multimodal work, complex agents, and large-repository understanding.
• Kimi K2.6 / K2.7 Code: useful for open-weight coding, code agents, local deployment, or private deployment.
• Qwen Max / Qwen open models: natural choices inside the Alibaba Cloud ecosystem and local deployment workflows.
• DeepSeek: useful for low-cost batch work, ordinary Q&A, reasoning backup, and OpenAI-compatible access.
• Doubao: useful in the Volcengine/ByteDance ecosystem, Chinese content, multimodal work, and domestic business scenarios.

In short, domestic models are not the main character here, but they are very suitable behind opencode, self-hosted NewAPI, local inference services, and batch scripts.

1.4 Reading Order

#

The rest of the note follows this order:

1. Basic terms: LLM, token, API, agent, and OpenAI-compatible API.
2. What ChatGPT, Codex, Claude Code, and opencode are.
3. Why relay services, NewAPI, and sub2api exist.
4. Shared subscriptions, overseas credit cards, residential IP, servers, and overseas computer systems.
5. Proxy protocols, the GFW, and proxy providers, because these directly affect whether overseas AI products and code tools are stable.

2. Basic Terms

#

LLM

#

LLM means Large Language Model. It can receive text, images, audio, code, and tool results, then continue generating content. Modern models are not only chat systems; they can call tools, write code, edit code, extract information, and make lightweight plans.

Token

#

A token is the basic unit processed by a model. It is not exactly a Chinese character, an English word, or a byte. API billing, context length, and output length are usually calculated by token count.

API

#

An API is the interface a program uses to call a model. ChatGPT’s website is for humans. OpenAI API, Claude API, DeepSeek API, and Alibaba Bailian API are for programs. People often mix up subscription accounts and API quota, but they are different things.

OpenAI-Compatible API

#

Many model services say they support an OpenAI-compatible API. This means their URLs, request fields, and streaming response format try to imitate OpenAI. Then many clients, SDKs, and agent tools do not need a separate adapter for every model provider.

Agent

#

An agent is not a single model. It is a way to use a model: the model reads context, makes a plan, calls tools, sees results, and continues. A code agent can usually read files, edit files, run commands, run tests, and produce diffs.

API Gateway, Aggregator, Relay Service

#

These usually sit between the client and the model provider:

client / code agent / script
  -> gateway or relay
  -> OpenAI / Claude / Gemini / Qwen / DeepSeek / Kimi / local model

They often provide unified model names, key management, quota allocation, request logging, rate limits, billing, and OpenAI-compatible endpoints.

3. ChatGPT, Codex, Claude Code, And opencode

#

ChatGPT

#

ChatGPT is mainly an interactive product for humans. It is good for writing, Q&A, code explanation, ideas, and lightweight task planning. It can also use tools and projects, but the basic experience is still conversational.

Codex

#

Codex is OpenAI’s code agent route. It is designed to work with real projects: read files, edit code, run commands, understand tests, and produce changes. It fits people who already use OpenAI models, ChatGPT, CLI tools, IDE workflows, or a desktop coding assistant.

The important point is that Codex is not only a model name. In daily usage, it usually means a toolchain: model capability plus project access plus command execution plus developer workflow.

Claude Code

#

Claude Code is Anthropic’s terminal-first code agent. Its strength is usually visible in large codebases, long tasks, careful reasoning, and iterative repair. A common workflow is: describe a bug or feature, let it inspect the project, let it patch files, run tests, and keep fixing.

It is popular because it feels close to the way programmers already work in terminals.

opencode

#

opencode is an open-source code-agent shell. Its key value is that the agent interface and the model backend are separated. You can connect different OpenAI-compatible APIs, domestic models, local models, or relay services behind it.

For domestic users, this is important because the most stable model route may change frequently. A model-agnostic tool makes switching cheaper.

4. Why Relay Services, NewAPI, And sub2api Exist

#

The Problem They Solve

#

If every tool directly connects to every model provider, the configuration becomes messy:

Tool A -> OpenAI key
Tool B -> Claude key
Tool C -> DeepSeek key
Tool D -> Qwen key
Tool E -> shared subscription conversion

A gateway or relay tries to make it look like this:

all tools -> one OpenAI-compatible endpoint -> many models or account resources

This gives users one base URL, one API key, and one model-name convention.

NewAPI

#

NewAPI is a self-hosted model gateway style. In practice, people use this kind of system to manage multiple upstream providers, keys, quotas, logs, user accounts, and OpenAI-compatible endpoints. It is useful when a team wants a unified API entrance instead of handing many raw keys to many tools.

Typical uses:

• unify OpenAI, Claude, Gemini, Qwen, DeepSeek, Kimi, and local models;
• allocate quota to different users or tools;
• observe which model and key are being used;
• expose one OpenAI-compatible endpoint to clients;
• reduce configuration work for code agents.

sub2api

#

sub2api usually means converting subscription-style resources into API-style access. In plain words: some resources are not originally official API keys, but a conversion layer exposes them in an API-like way so tools can call them.

This area can be fragile. It depends on account rules, platform changes, request patterns, and network stability. It is useful to understand the idea, but production work should prefer stable and compliant official API routes when possible.

Relay Services

#

Relay services are third-party API entrances. They often aggregate multiple upstream providers and expose an OpenAI-compatible API. The advantage is convenience; the risk is stability, privacy, pricing, quota transparency, and whether the upstream route is reliable.

For code agents, relay instability is more painful than normal chat. A long task may fail in the middle after editing files, running tests, or streaming a large response.

5. Accounts, Quota, Shared Plans, And Resource Pools

#

Subscription Accounts vs. API Keys

#

A subscription account is usually for using a product UI, such as ChatGPT Plus/Pro or Claude subscription plans. An API key is for programs to call a model service. They can have different billing, limits, rate policies, and terms.

Do not assume that paying for a chat product automatically gives you the same API quota.

Shared Subscriptions

#

Shared subscriptions are common because official overseas subscriptions may require overseas payment methods, stable IPs, phone verification, or account risk control. Shared usage lowers cost but introduces risks:

• account may be locked or rate-limited;
• quota may be consumed by others;
• privacy is weaker;
• service quality depends on the operator;
• policy changes can break everything quickly.

For personal learning, shared plans may be acceptable. For work, they are usually not a stable foundation.

Overseas Credit Cards And Payment

#

Some overseas AI services require international cards, local billing addresses, or risk-control-friendly payment behavior. Virtual cards and shared cards may work for a while, but the risk is always higher than normal official payment routes.

Resource Pools

#

A resource pool means combining many accounts, keys, or upstream routes and distributing traffic among them. It can improve availability, but it also adds operational complexity. You need monitoring, rate limits, fallback rules, and clear separation between personal, team, and production usage.

6. Network And Device Environment

#

Why Network Quality Matters

#

AI coding tools use long streaming responses, tool calls, uploads of context, downloads of large outputs, and sometimes browser or remote execution. Packet loss, IP reputation, DNS pollution, TLS interference, or unstable proxy routing can all make the tool feel broken.

For ordinary web chat, reconnecting once may be acceptable. For a code agent that is in the middle of editing files, an unstable connection is much more annoying.

Proxy Providers And Airports

#

In Chinese developer slang, an “airport” usually means a proxy service provider. It sells nodes and traffic so users can access overseas websites through proxy protocols.

The important practical variables are:

• node region;
• bandwidth and latency;
• IP type and reputation;
• stability during long connections;
• whether streaming responses work well;
• whether DNS and routing are clean;
• whether the provider is oversold.

Residential IP

#

Residential IP means an IP address that looks like a normal home broadband connection. Some overseas services trust residential IPs more than data-center IPs. This may reduce account risk controls, but it is more expensive and not always necessary.

Overseas Computer System

#

Some users use an overseas VPS, cloud desktop, remote Mac, or remote Windows machine to run AI tools. This can make network access more stable because the tool runs closer to overseas services. The tradeoff is latency when you operate the remote desktop, plus the cost and maintenance of the remote environment.

7. Proxy Protocols

#

Common proxy protocols include Shadowsocks, VMess, VLESS, Trojan, Hysteria, TUIC, and WireGuard. From a programmer’s perspective, the protocol itself is less important than whether your client, node, DNS, routing rules, and target service work reliably together.

For AI tools, pay attention to:

• whether HTTP/2 and streaming responses are stable;
• whether WebSocket or gRPC-like traffic is affected;
• whether the command-line tool actually uses the proxy;
• whether Git, npm, pnpm, Homebrew, curl, and browser traffic share the same route;
• whether system proxy and terminal proxy are different.

A common pitfall is that the browser can access a site, but the terminal tool cannot. The browser uses system proxy, while the CLI may need HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, Git proxy settings, npm registry settings, or tool-specific proxy options.

8. How To Choose A Route

#

For Learning

#

Use the lowest-friction route first:

• ChatGPT or a domestic model product for chat and learning;
• Codex or Claude Code if you can access them stably;
• opencode plus an OpenAI-compatible domestic or relay endpoint if official overseas access is unstable;
• keep a simple proxy setup and avoid overengineering.

For Personal Coding

#

A practical setup is:

• one strong code agent as the main tool;
• one cheaper model route for drafts, search, and batch tasks;
• one fallback model when the main route is down;
• a clean terminal proxy setup;
• Git, package managers, and build tools tested under the same environment.

For Team Or Work

#

Prefer stable, auditable, and compliant routes:

• official APIs when possible;
• a self-hosted gateway such as NewAPI if the team needs unified access;
• separate keys and quota for people, tools, and environments;
• avoid putting private code or sensitive data into unknown relay services;
• keep logs, budgets, and fallback rules clear.

9. Practical Mental Model

#

When an AI coding tool fails, do not immediately blame the model. Check the chain:

client -> local proxy -> DNS/routing -> API gateway/relay -> upstream model -> quota/account -> streamed response -> client parser -> local project tool execution

Any one of these can break the experience.

A useful debugging order:

1. Can the browser access the service?
2. Can curl access the API endpoint from the terminal?
3. Does the CLI tool use the same proxy as the browser?
4. Is the API key valid and does it have quota?
5. Does a small request work?
6. Does streaming work?
7. Does the selected model name actually exist on that endpoint?
8. Does the tool support the response format returned by the gateway?
9. Does the task fail only on long context or tool calling?
10. Does switching model or route fix it?

10. Final Notes

#

The AI tooling ecosystem is not one thing. It is a stack:

model -> API -> account/quota -> gateway/relay -> network -> local tool -> project workflow

Programmers often feel that they are choosing between Codex, Claude Code, opencode, ChatGPT, GLM, Kimi, Qwen, or DeepSeek. In real use, the better question is: which complete route is stable enough for the job I am doing today?

For small learning tasks, convenience wins. For daily coding, stability wins. For team and production work, auditability and compliance win. The best setup is usually not the most powerful single model, but the route that keeps working when you are halfway through a real task.