AI 编码工具默认给 Agent 多大权限？三家差在这三处 – 码哥字节

A technical leader asked in the group: Claude Code, Google Antigravity, OpenAI Codex, which one should the team use uniformly? The basis for the judgment he posted was an article about “Writing 25,000 lines of code in 10 days, improving efficiency by 36%.” I couldn’t review that 36% for him – there were no scenarios, no baselines, no failure cases, and no reruns.

But there is one question that can be reviewed, and it is more critical to “do you dare to let it touch the production warehouse?”:After installation, you don’t need to change a single line of configuration. By default, these three tools can read which files on your machine, which commands can be run, and whether they can connect to the Internet by themselves.

The reason why this matter deserves its own article is that recent public signals point to the same position. OpenAI disclosed multiple incidents of out-of-control agents in 2026-09, including agents using DNS vulnerabilities to connect to the Internet and leaking GitHub tokens; in the Perplexity red team SPACE sandbox, 9 models failed to escape the virtual machine in 108 runs, but 4 models used network access to bypass the blockade. The execution layer is blocked, but the network exit is not blocked – this is where the “default permissions” should be managed.

This article does not compare code quality, only three dimensions that you can review yourself: default permission boundaries, cost controllability, and scalability boundaries. After reading it, you can directly draw up a baseline of your own permissions instead of getting a table with “each has its own advantages and disadvantages”.

Let me make it clear first: there is no actual test with the same question this time

Declare the evidence boundaries to avoid misunderstanding later:

• There is no actual test on the same question this time. We did not let the three tools write the same requirements, and we did not run benchmarks. Therefore, this article will not and cannot give a conclusion on “who writes better code”. All comparisons are based on officially documented facts and verifiable mechanisms.
• Codex’s default sandbox policy, approval mode name, and network default switch are not officially available this time. The official documentation site is JS rendering, WebFetch and .md Suffix crawling all returns 404. These four pages do exist in the document directory:/codex/sandboxing、/codex/permission-modes、/codex/permissions、/codex/cloud/internet-access。Please verify these default values ​​by yourself. This article will not guess.
• The version number, star number, and price are all 2026-09-29 Grabwill expire, please refer to your own verification results.

Today’s snapshot of version and ecology (source:gh api 与 npm registry，2026-09-29）：

project	numerical value
anthropics/claude-code stars	148,547
Claude Code latest GitHub release	v2.1.284（2026-09-28T18:02:03Z）
npm @anthropic-ai/claude-code	latest 2.1.284（2026-09-28T17:11:59Z），stable 2.1.277
openai/codex stars	127,070
Codex latest GitHub release	rust-v0.159.0（2026-09-29T08:05:42Z）
npm @openai/codex	0.159.0（2026-09-29T08:10:59Z）

The Antigravity column is empty:As of 2026-09-29, no official Google main repository has been found.. What the community can search for are third-party ecological projects——lbjlaq/Antigravity-Manager 31,812 stars、google-antigravity/antigravity-sdk-python 3,568 stars. These two numbers belong to these two third-party projects and not to Antigravity itself. Do not take them as official popularity.

You can reproduce the table above yourself:

gh api repos/anthropics/claude-code --jq '{stars:.stargazers_count}'
gh api repos/openai/codex --jq '{stars:.stargazers_count}'
npm view @anthropic-ai/claude-code version
npm view @openai/codex version
claude --version; codex --version; agy --version

Dimension 1: Default permission boundaries

This is a real watershed moment for the three tools. Let’s look at the structure first, and then look at the default values ​​of each family.

The permission engine is actually four layers, not a “sandbox switch”

Many people think that “turning on the sandbox” is just a switch. The actual structure is a four-layer series connection. The release of any layer does not mean that the previous layer has been bypassed:

• The first level: running mode preset. Claude Code defaultMode have default(alias manual）/ acceptEdits / plan / auto / dontAsk / bypassPermissions Sixth gear; Antigravity is Default / Request Review / default0 third gear.
• Second level: rule table. Both companies use three types of rules: deny / ask / allow, and both deny has the highest priority. The evaluation order of Claude Code is fixed as deny → ask → allow; the priority of Antigravity is Deny > Ask > Allow.
• The third layer: execution sandbox. Decide which isolation the command runs in – Claude Code uses Seatbelt on macOS, bubblewrap + socat on Linux/WSL2; Antigravity uses OS-level containers.
• The fourth layer: network outbound allowlist. Decide whether the sandbox can connect to the external network. This floor is independent of the first three floors and is where the accidents above actually occurred.

Claude Code: The sandbox is not enabled globally by default, and read permissions are enabled globally by default.

There are three default values, which can be verified by yourself one by one (source: code.claude.com/docs/en/permissions, /docs/en/sandboxing, 2026-09-29):

1. The sandbox is not enabled globally by default. Or use it in the project /sandbox Select mode (auto-allow/regular permissions), or in ~/.claude/settings.json Inside sandbox.enabled: true. If it is not set up, it will not be opened.
2. The default read permission is the entire machine. Documentation clearly lists ~/.aws/credentials、~/.ssh/ All within the readable range. The default writable range is much smaller: working directory + --add-dir Specified directory + per-user $TMPDIR。
3. The network does not pre-allow any domains by default. You will be prompted when accessing a new domain for the first time; v2.1.219+ can set strictAllowlist: trueso that all hosts outside the list will be directly rejected without prompting.

The underlying dependencies must also be confirmed first: macOS Seatbelt requires no installation, Linux/WSL2 requires apt-get install bubblewrap socat，WSL1 and native Windows do not support sandboxing。

Why is it designed this way: The sandbox defaults to fail-open, not fail-closed

This is most likely to be regarded as a bug: when dependencies are missing or the platform does not support it, the default behavior of Claude Code isIssue a warning and then continue without sandbox. On Ubuntu 24.04+, bubblewrap may not be started directly due to AppArmor restrictions on user namespace.

This is not an oversight, it is a clear trade-off. Claude Code is first of all a CLI tool that can be “installed and run” on any machine: if the sandbox cannot be started and hard fails, then users on WSL1, native Windows, and machines lacking socat will be directly blocked. For a developer tool that relies on word-of-mouth diffusion, this cost is much greater than “downgrading and running on a few machines.” So the default is availability, and strictness is given to configuration: organizations can use failIfUnavailable: true Change it to boot hard fail.

Once you understand this trade-off, you will knowDefaults are not security baselines, they are release defaults. Whether you want to change it to a hard failure depends on whether you are trying it on a personal machine or whether you want to hand over the Agent to an entire team.

“The default read permission is the entire machine” is the same kind of trade-off, but this official document does not explain the reason. The following is my judgment: when a coding agent works normally, it does need to read things outside the working directory——~/.gitconfig、~/.npmrc、~/.ssh/known_hostsglobal tool chain configuration, dependencies introduced by symlink. If these are all denied by default, the Agent will hit a wall on a large number of irrelevant tasks, and the user’s first reaction is “This tool is not easy to use.” So the default is given to availability, put ~/.aws、~/.ssh、~/.kube This type of truly dangerous directory is handed over to denyRead Explicit block. You may disagree with this judgment, but the configuration actions are the same:First list the directories on your machine that cannot be read by the Agent, and then write them into denyRead。

From “giving an order” to “actually executing the order”, there are several gates in between.

Process and two details that are easily overlooked:allow direct sum ask After release, they will eventually enter the sandbox, butCommands that fail in the sandbox can be pulled outside the sandbox and retried.——This is dangerouslyDisableSandbox This escape hatch. To block it, set allowUnsandboxedCommands: false。

After configuring, don’t just trust the document, verify it with a real action: let the Agent read it ~/.aws/credentialsto see whether it is rejected or the content is returned directly. This is the only observation point that can prove that your deny is effective.

Pitfall: Denying with a naked name is not “rejection”, it is “disappearance of a tool”

I recommend that everyone with permissions know about this pit first, because its phenomenon will completely deviate from the direction of your investigation.

Claude Code documentation states: If you write in denyNaked tool name(for example Bash、WebFetch), this tool will beCompletely removed from Claude’s context. The expression is not “Claude’s request was rejected”, but “Claude doesn’t seem to know how to use this tool at all.” You will check the model, check the prompt, and check the MCP server, but the real reason is just that there is a Bash。

The accompanying second rule is equally counterintuitive:allow cannot dig exceptions from deny. The example given in the documentation is Bash(aws *) After being denied,Bash(aws s3 ls) The allow is invalid. If you want to “disable aws as a whole and only allow s3 ls”, the correct way to write it is to deny only to the specific granularity, or simply use ask instead of deny.

Antigravity has corresponding implicit rules: Write implies Read (when writing is granted, reading is implied), and Deny Read implies Deny Write (when reading is prohibited, writing is also prohibited).

Antigravity: The sandbox is on by default and the network is disconnected by default. Turbo is another matter.

Default preset for Antigravity Default It looks like this (source: antigravity.google/docs/permissions, 2026-09-29):

• terminal sandboxopencommands inside the sandbox run directly, commands outside the sandbox Ask
• File access is limited to workspace + temp
• No network
• MCP and Web Action Default Ask

Sensitive operations are represented as action(target) form, such as read_file(./src/**)、read_url(domain:registry.npmjs.org). There is a design at this layer of the network that deserves to be mentioned separately: Grant read_url(domain) The domain name will beOutbound allowlist compiled into the sandboxso in the sandbox curl、npm Only then can you pass. In other words, what you release is the semantic action of “reading a certain domain name” rather than the switch of “letting go of the network” – the granularity is much finer than giving a Boolean value.

macOS and Linux adopt a new unified permission system.Windows is still the old permissions systemplus Terminal Sandboxing (Preview) and unsandboxed(...) action. Platform threshold: macOS minimum 12 (Monterey), Windows 10 (64 bit), Linux requires glibc >= 2.28 and glibcxx >= 3.4.25. The official page also provides Intel downloads and says “X86 is not supported”. These two sentences are contradictory in themselves. I will not draw conclusions for the official. You should try it yourself before installing it on Intel Mac.

CLI configuration falls under ~/.gemini/antigravity-cli/settings.json;Agent has Local Mode(operate directly on the current folder) and New Worktree Mode(Isolated Git worktree) Two ways to run.

Why it’s designed this way: Use OS-level containers, not Seatbelt

Antigravity chose OS-level container isolation (Terminal Sandbox) instead of macOS’ Seatbelt.

Seatbelt is the sandbox mechanism of macOS. Claude Code uses it directly on macOS because it is “installation-free” – there is no need for users to install anything. The price is that it is only available on macOS, the semantics are the profile language defined by Apple, andDoes not provide independent network outbound control(Claude Code’s network restrictions are implemented by another set of domain allowlists).

Antigravity requires three things to be true at the same time: macOS and Linux Behave consistentlythe network outbound can beCompile into sandboxand unified permission semantics across platforms. Container-level isolation naturally provides a network namespace, and the outbound allowlist is its first-class citizen; the same semantics can also be applied to Linux. The price is that the Windows side cannot keep up for the time being – so Windows users get the old permission system plus the Preview sandbox.

To sum up the trade-offs between the two companies in one sentence: Claude Code prioritizes “zero installation cost” and Antigravity prioritizes “cross-platform semantic unification”.

Pitfall: Turbo is not a performance switch, it is a lock removed

Assume such a scenario (this is a hypothetical case, used to illustrate configuration semantics, not a real accident that I ran out of): Some people think that Antigravity runs tasks slowly, see Turbo I thought this name meant “faster mode”, so I passed it and continued to use it.

Turbo The actual content of the preset is:Sandbox is closed, commands are unlimited, full file system is accessible, MCP and Web are allowed by default. It relaxes the second, third, and fourth layers of the above four layers together, and has nothing to do with inference speed or concurrency.

The name is like a performance switch, and the semantics is “release all”. If you really need the Agent to access files outside the workspace, the correct approach is to stay in Default or Request Reviewthen press action(target) Add a whitelist instead of switching to Turbo as a whole.

Request Review It is the intermediate file: sandbox level, command Always askfiles are limited to workspace.

Codex: I can’t give you the default value in this section, I can only give you the verification action.

Codex’s document system has the most formats among the three companies – six types: Desktop app / Remote / Web / CLI / IDE extension / Cloud. The environment dimension is divided into four categories: Modes, Local environments, Cloud environment, and Git worktrees. Windows also has independent sandbox and WSL documents (the Windows side of the three documents is the most detailed).

butThe default sandbox policy, the name of the approval mode, and the network default switch are not available at this time.. The document site is JS rendering, WebFetch and .md All crawls return 404. I won’t guess a default value to write to you.

What you are given are executable verification actions. You will have the answer after running:

codex --help | grep -i sandbox
# 或直接读官方这四页（需自行打开确认）：
# /codex/sandboxing
# /codex/permission-modes
# /codex/permissions
# /codex/cloud/internet-access

If you have completed the verification, you are welcome to send me the results and I will update it to subsequent versions – this is the only part of this article where I dare not draw a conclusion.

The sandbox cannot control the MCP server. This is a bypass outside the fourth layer.

There is another location that is easily missed: the MCP server you connect to the Agent may itself have network exits and file system access. The sandbox limits the commands executed by the Agent and does not control the MCP server process itself from sending out requests.

Of the three, only Antigravity clarifies this in the documentation: applicable to local and remote MCP serversThe same set of permission rulesthat is action(target) That set of things also restricts MCP calls. By default, the MCP action is Ask. I couldn’t find equally clear statements from the other two companies – this doesn’t mean they don’t have control, it just means I don’t have first-hand evidence.

Therefore, when connecting to MCP, in addition to configuring the sandbox on the Agent side, you also need to ask a separate question: whether this server can access the production library, whether it can send external network requests, and whether there is a read-only switch. 088 That article talked about how to use MCP to connect MySQL + Loki + Grafana. The permissions layer is its upstream.

Dimension 2: Cost controllability

The monthly fee number is the least important part. What really determines whether you will be hit with a bill are two things:Who is competing for the same pool with you?,as well asShould it stop or continue burning after it exceeds the limit?。

Claude Code: Terminal and web chat compete for the same pool

Price (as of 2026-09-29): Pro $20/month (monthly payment) or $17/month (annual payment, $200 prepaid); Max starts at $100/month (5x / 20x two levels); Team standard seat $20 (annual payment) / $25 (monthly payment), advanced seat $100 / $125; Enterprise $20/seat/month annual payment + according to API For rate billing, administrators can set user/org spend limits.The Free plan does not include Claude Code.

The credit mechanism is a rolling 5-hour window + a weekly cap for paid plans.The terminal and web chat share the same usage pool——If you chat on the web during the day and run the Agent in the terminal at night, you will be deducted the same amount. The official caliber of the context window is “Up to 1M (varies by model)”.

Codex: included in all packages, but competes with three agents for quota

Codex is included inAll ChatGPT packages, including Free and Gothe amount varies by plan (the official does not give a specific value). For Plus/Pro, you can buy credits directly without changing the package.

The point is this:Codex shares a quota pool with ChatGPT Work, Excel, and Workspace Agents. Therefore, “Codex alone calculates the limit” is an illusion. The window is 5 hours + weekly, banked reset can refresh both windows. Amount self-check:https://chatgpt.com/codex/settings/usageor type /status。

There are two types of billing on the enterprise side: token-based (billed in USD, no credits deducted) or credit-based; Compliance API covers CLI / IDE / web / cloud.

There is also a timeline that affects automation:GPT-5.4 / GPT-5.4 mini will be offline from 2026-08-31replaced by GPT-5.6 Terra / GPT-5.6 Luna (takes effect when logging in with ChatGPT; API and built-in keys are not affected). Workspace defaults, saved model settings, managed configurations, and automations must be changed before the deadline – if the model name is hard-coded in your CI, this is a change that will interrupt the pipeline.

Antigravity: The free file is refreshed every week, and the paid file is refreshed every 5 hours.

Antigravity is tied to a Google AI subscription. The refresh strategy is the most different among the three:

• Baseline quota (free file): refreshed every week. Contains all the features of Gemini 3.1 Pro / 3.8 Flash, unlimited Tab completion, Scheduled Tasks and CLI.
• Pro/Ultra: Refresh every 5 hoursuntil the week limit is reached.
• Tab completes unlimited files.
• Only Pro/Ultra can buy AI Credits to pay overage.
• Officially, it is clear that BYOK/bring your own endpoint is not supported.

Model side: Core inference models include Gemini 3.8/3.7/3.6 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6 (thinking), Claude Opus 4.6 (thinking), GPT-OSS 120B (Medium); the additional image model Nano Banana 2 cannot be customized.Enterprise can only use Gemini seriesClaude and GPT-OSS are not available for enterprises – if your team specifies to use the Claude model, Antigravity Enterprise Edition is directly eliminated.

Amount self-check: in the model selector View Usagelook at the two remaining percentages of Weekly and Five Hour.

Decision rules: What to do after exceeding

tool	Short window exhausted	Week limit exhausted	Can I pay to continue?
Claude Code	Wait for scrolling window to reset	Waiting weeks for reset/upgrade package	Available usage credits
Codex	Waiting for reset, or banked reset to refresh	Wait for week to reset	Plus/Pro can buy credits without changing the package
Antigravity	Wait 5 hours to refresh (free version does not have this option)	Wait for week to reset	AI Credits can only be purchased in Pro/Ultra

Judgment in one sentence:These three companies are all “waiting type” rather than “stop type”no one will cut off your Agent to save you money when your quota is exhausted. If you need a hard budget cap, the only close options are Claude Code Enterprise’s administrator spend limits or Codex’s token-based billing.

Dimension three: scalable boundaries

The ability to access your internal system determines whether it is a “personal toy” or a “team infrastructure.”

ability	Claude Code	Codex	Antigravity
Project directive file	CLAUDE.mdand read AGENTS.md	AGENTS.md	Rules / IDE Workflows
Reusable capability package	Skills	Build skills、Plugins、Marketplace	Agent Skills、Marketplace、Plugins
Child Agent	Sub-agents + Background agents + Agent SDK	Subagents	Custom Subagents
life cycle hooks	Hooks	Hooks	Lifecycle Hooks
external tool protocol	MCP	MCP（含 WebMCP site tools）	MCP (local/remote equal permissions rule)
Scheduled/long tasks	Routines (cloud), Desktop scheduled tasks,/loop	Scheduled tasks (automations)、Long-running work	/schedule、Scheduled Tasks
CI/CD	GitHub Actions、GitLab CI/CD、GitHub Code Review	GitHub Action、GitLab CI/CD（Security CLI）	No documents of the same level were found
Third party integration	Slack、GitHub、Chrome、Channels（TG/Discord/iMessage/webhooks）	GitHub、GitLab (Beta)、Slack、Linear	No list of the same level found
CLI pipeline	claude -p non-interactive, such as tail -200 app.log | claude -p "..."	Non-interactive mode	agy TUI
Bring your own key	support ANTHROPIC_API_KEY;Terminal/VS Code/JetBrains supports third-party providers	Support API key (requires additional configuration)	BYOK is not supported

How to read this table:To access CI and auditing, Codex and Claude Code have clear paths. Antigravity does not have the same level of public documentation at this layer. To connect to internal databases, logs, and work order systems, all three have MCPs. There is not much difference in capabilities. The difference lies in permissions – Antigravity uses the same set of permission rules for local and remote MCP servers. This is easier to reason about than the other two.

Two unique abilities of Claude Code deserve separate mention:--teleport(Pull long tasks initiated by the web/mobile terminal back to the terminal) and /desktop handoff; and Agent SDK, suitable for packaging coding agents into your own products. Antigravity Here are Artifacts (Implementation Plan / Walkthrough / Visual Screenshots),/goal(autonomy runs to the end),/grill-me(Ask about alignment before taking action)——/grill-me He is the only one among the three families who has made “align the needs first and then take action” into a first-level command.

The installation method is also given (as of 2026-09-29):

# Claude Code
curl -fsSL  | bash      # macOS / Linux / WSL
brew install --cask claude-code
winget install Anthropic.ClaudeCode                  # Windows

# Codex CLI
curl -fsSL  | sh
npm install -g @openai/codex
brew install --cask codex

# Antigravity CLI（二进制落在 ~/.local/bin/agy）
curl -fsSL  | bash

Comparison of three companies: the default permission boundary column

The conclusions of the three companies in this column are different, but they are all verifiable:

• Claude Code: The default is the widest. The sandbox is not enabled globally, has full read permission, and fails-open when dependencies are missing. Its default assumption is that “you are in a trusted, rollbackable environment.”
• Antigravity: The default is the tightest. Sandbox is on, no network is available, files are limited to workspace+temp, Web and MCP default Ask. Its default assumption is “you don’t necessarily trust this Agent.”But the Turbo default will override the entire set of default values.
• Codex: The official document has five independent pages: sandboxing, permission modes, permissions (Profiles), agent approvals & security, and cloud internet-access. It has the most forms and the Windows document is the most detailed——The default switch has not retrieved the text this time. You need to verify it yourself.。

Minimum privilege baseline that can be copied directly

Claude Code（~/.claude/settings.json）：

{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true,
    "allowUnsandboxedCommands": false,
    "filesystem": { "denyRead": ["~/.aws", "~/.ssh", "~/.kube"] },
    "network": { "allowedDomains": [] }
  },
  "permissions": {
    "defaultMode": "default",
    "deny": ["Bash(git push --force *)", "Bash(rm -rf *)", "WebFetch"]
  }
}

Four things correspond to four holes:enabled: true Add “not enabled by default”;failIfUnavailable: true Change “Dependencies missing → Run without sandbox” to start hard failure;allowUnsandboxedCommands: false Block it dangerouslyDisableSandbox escape hatch;denyRead Added “default full disk readable”.allowedDomains: [] It means not to pre-release any domains – add them one by one when you need to connect to the Internet, don’t release them all at once.

Antigravity（~/.gemini/antigravity-cli/settings.json）：

{
  "permissions": {
    "deny": ["command(curl *)", "unsandboxed(*)"],
    "ask": ["read_url(*)", "execute_url(*)"],
    "allow": ["read_file(./**)", "write_file(./**)", "read_url(domain:registry.npmjs.org)"]
  }
}

Keep the Default default (sandbox on, no network), and only add the npm registry to the inbound and outbound allowlist.read_url The default is Ask, which is written explicitly here to prevent it from being overwritten by the Turbo preset.

Codex: There is no configuration that can be copied, give the verification action – run codex --help | grep -i sandboxread the four pages of official documents again, confirm the default values, and then write your own baseline according to the two ideas above.

After the configuration is completed, use the same action to check once in each of the three homes: let the Agent read ~/.aws/credentialsto see whether the content is returned, a prompt pops up, or it is rejected. Three results correspond to three default strategies, and the conclusion can be reached in five minutes.

Three common failure boundaries

1. Windows is a common shortcoming of all three companies. Claude Code’s native Windows does not support sandbox (WSL2 is required); Antigravity Windows is still an old permission system and the sandbox is Preview; Codex has an independent Windows sandbox document, but it must be configured separately. If your team’s main focus is Windows, the conclusions in this section should be re-evaluated.
2. bypassPermissions Should not appear on the development machine. The original Claude Code document states that it “should only be used in isolated environments such as containers/VMs.”
3. Taking a model offline interrupts automation. Codex’s GPT-5.4 offline is a ready example – CI with hard-coded model names will fail directly on the deadline.

Who to choose when

Don’t choose based on “who is smarter”, choose based on your constraints:

• You want to run quickly on your personal machine and are willing to assign permissions yourself → Claude Code. The most complete form (Terminal / VS Code+Cursor / JetBrains / Desktop / Web / iOS+Android / Slack / GitHub Actions / GitLab CI), Agent SDK can be developed twice.The premise is that you accept to copy the settings.json into it first.
• You are handing over the Agent to an entire team and hope that the default values ​​are conservative enough → Antigravity. By default, the sandbox is turned on and the network is disconnected, except for Windows teams, and the enterprise version can only use the Gemini series model.
• You need to connect to CI, audit, and comply with API → Codex. Compliance API covers CLI/IDE/web/cloud, and GitHub Action and GitLab CI/CD have official paths.Please verify the default permissions before pushing in batches.
• Budget sensitive, want to try first → Codex’s Free and Go packages include quota, Antigravity has a free package that is refreshed every week, and Claude Code’s Free package does not.

The next minimum action is not to “choose an installation”, but to spend ten minutes copying the above Claude Code configuration or Antigravity configuration into your settings.jsonthen read with ~/.aws/credentials This action verifies that it takes effect. This action can be done on all three tools. After doing it, you will have your own first-hand data, not someone else’s percentage.

———

🔧 Complete configuration list used in this article

Above, I have given the minimum permission baselines of the two companies and Codex’s verification actions. The full version (including deny/ask/allow rule templates, the three companies’ quota self-check entrances, and the Codex official document verification list) has been compiled.

Reply “prompt” to get itcontinuously updated.

———

If this article is helpful to you, forward it to your programmer friends — Everyone is exploring AI to improve efficiency, and your sharing may help them save a lot of time.