> ## Documentation Index
> Fetch the complete documentation index at: https://felimet-hub.jmcores.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 04-8 Vendor Built-in Tools and Features: Use Them Fully, Stop Wasting Money
> The AI tools you pay for ship a full suite of built-in features, and most users tap less than a third of them. This unit inventories the built-in capabilities of the main tools so you know what each feature solves, where its limits are, and when to prefer it over a custom build.
export const LearnerPrimer = ({items = [], lang = "zh"}) => {
const t = lang === "en" ? {
title: "Before this unit, be honest with yourself",
sub: "If you can't answer these, that gap is exactly what this unit closes."
} : {
title: "讀這個單元前，先誠實面對",
sub: "這幾題答不出來，正是這個單元要替你補的洞。"
};
const css = `
.lp-root{--lp-bg:#FAF7F1;--lp-surface:rgba(191,117,81,0.05);--lp-border:rgba(0,0,0,0.09);--lp-edge:rgba(191,117,81,0.42);--lp-text:#2b2722;--lp-dim:#6f6a62;--lp-accent:#bf7551;border:1px solid var(--lp-border);border-left:3px solid var(--lp-edge);border-radius:13px;background:var(--lp-bg);color:var(--lp-text);overflow:hidden;margin:1.25rem 0;}
.dark .lp-root{--lp-bg:#1b1a18;--lp-surface:rgba(207,138,104,0.07);--lp-border:rgba(255,255,255,0.08);--lp-edge:rgba(207,138,104,0.5);--lp-text:#e7e3da;--lp-dim:#a8a299;--lp-accent:#cf8a68;}
.lp-head{display:flex;align-items:center;gap:9px;padding:13px 18px 11px;border-bottom:1px solid var(--lp-border);background:var(--lp-surface);}
.lp-ic{color:var(--lp-accent);flex-shrink:0;}
.lp-htx{display:flex;flex-direction:column;gap:1px;min-width:0;}
.lp-title{font-size:14px;font-weight:650;line-height:1.3;letter-spacing:.01em;}
.lp-sub{font-size:12px;color:var(--lp-dim);line-height:1.4;}
.lp-list{list-style:none;margin:0;padding:10px 18px 14px;display:flex;flex-direction:column;gap:0;}
.lp-item{display:flex;align-items:baseline;gap:11px;padding:7px 0;font-size:14px;line-height:1.6;border-top:1px solid var(--lp-border);}
.lp-item:first-child{border-top:none;}
.lp-mark{flex-shrink:0;color:var(--lp-accent);font-size:13px;font-weight:700;line-height:1.55;font-variant-numeric:tabular-nums;opacity:.85;}
.lp-q{flex:1 1 0;min-width:0;color:var(--lp-text);}
@media (max-width:620px){.lp-head{padding:12px 14px 10px;}.lp-list{padding:8px 14px 12px;}}
`;
return
{t.title}{t.sub}
{items.map((q, i) =>
{String(i + 1).padStart(2, "0")}{q}
)}
;
};
**What this unit solves**
The AI tools you pay for ship a full suite of built-in features: web search, code execution, Artifacts, persistent memory, connectors, slash commands. Most users tap less than a third of them. The problem is not complexity -- it is the absence of a systematic way to track "what capabilities exist right now." This unit inventories the built-in capabilities of the main tools so you know what each feature solves, where its limits are, and when it should be your first choice. It also establishes a rhythm for staying current: since you are already paying, use everything.
## Learning objectives
* [ ] Inventory the currently available built-in features of your primary AI tools (at minimum Anthropic Claude and OpenAI ChatGPT).
* [ ] Track official changelogs and release notes for each tool so you know when new features land.
* [ ] Explain what each built-in feature solves, where its limits are, and when to prefer it.
* [ ] Identify plugins or custom-built solutions in your workflow that have already been superseded by built-in features, and decide whether to retire them.
***
## 1. Why tracking built-in capabilities matters: you are paying for more than you use
The largest hidden cost of a paid plan is not the bill -- it is "feature sitting there unused equals money wasted." A typical example: you subscribe to Claude Pro but only use the chat window to write prompts. Web search is off, Projects is empty, Artifacts has never run a front-end prototype, Cowork is not connected to anything on your desktop. A year passes and you have used 20% of what you paid for. The other 80% is not "irrelevant" -- you just never read the changelog.
**Build the update habit**
Spend 30 minutes each month scanning the release notes for your primary tools. **Do not rely on third-party article summaries** (they go stale and get truncated). Subscribe directly to official changelogs. Anthropic release notes: `support.claude.com/en/articles/12138966-release-notes` (as of 2026-05; verify the current URL on the official site). OpenAI: `help.openai.com/en/collections/3742473-chatgpt`. Google: `support.google.com/gemini`. GitHub: `github.blog/changelog/label/copilot/`. Cursor: `cursor.com/changelog`.
The reality of **feature flags**: some features roll out gradually to accounts and are not visible to all users at the same time. The settings panel in the Claude.ai interface and the `/config` command in Claude Code are the places where you **actively confirm what is currently enabled**. Features that are off by default are often the most undervalued and the ones that justify the paid tier.
## 2. Built-in tool inventory (as of 2026-05)
**Claude.ai chat interface:**
| Built-in feature | Purpose | Limits |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
| Web search | Real-time web lookup with citations during chat | Citation source quality varies; academic verification still requires manual cross-checking |
| Code execution (Artifacts) | Run JavaScript / Python in a sandbox during chat; output shareable HTML, SVG, interactive components | Sandbox resources are limited; not suitable for heavy computation. Language support: see current official docs |
| Projects (incl. Project Knowledge) | Create a project for a specific topic; keep documents, guidelines, and conversation context persistent | Each project has a storage cap; curate what goes in rather than dumping entire folders |
| Memory | Save preferences and facts across conversations (upgraded plans) | Training opt-out and retention period must be confirmed in settings |
| Connectors | Connect Claude.ai to Google Drive, Dropbox, Gmail, and other sources | Requires manual authorization; review OAuth scope |
| Research (Deep Research) | Multi-step research tasks, cross-source synthesis with citations | Requires Pro / Max / Team plan |
| Slash commands | `/help`, `/clear`, `/compact`, `/init`, and others | Full list: run `/help` in the interface |
**Claude Code CLI:**
| Built-in feature | Purpose | Limits |
| --------------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Read / Write / Edit | File read and write | Use `permissions.deny` to block access to `.env`, sensitive paths, and restricted directories |
| Glob / Grep | File search | Heavy file loads consume context; use path-scoped rules or Subagent isolation |
| Bash | Execute shell commands | Read-only commands (`ls`, `cat`, `grep`, `git status`, etc.) proceed without a prompt \[1]; others follow `settings.json` allow / deny rules |
| WebFetch | Fetch content from a specified URL | Subject to `WebFetch(domain:...)` permission allowlist; fetched content is a prompt injection surface |
| WebSearch | Web search | Same underlying capability as Claude.ai built-in Web search |
| Slash commands | `/help`, `/clear`, `/compact`, `/init`, `/agents`, `/mcp`, `/permissions`, and others | Full list: run `/help` |
| Agent / Subagent | Sub-tasks with isolated context | See [04-5 Subagent](/en/code-agent/customization/subagents) |
| Skill / Hook / Plugin | Custom extensions | See [04-3](/en/code-agent/customization/commands), [04-4](/en/code-agent/customization/skills), [04-6](/en/code-agent/customization/hooks), [04-7](/en/code-agent/customization/plugins) |
| MCP client | Connect to external tools | See [04-9 MCP Integration](/en/code-agent/customization/mcp-integration) |
| LSP server | Real-time code intelligence | See [04-7 Plugin](/en/code-agent/customization/plugins); for TypeScript, Python, Rust and other mainstream languages, prefer pre-built integrations from the `claude-plugins-official` marketplace \[1] |
| Worktree | Physical isolation | See `isolation: worktree` in [04-5 Subagent](/en/code-agent/customization/subagents) |
**Claude Cowork:**
A desktop agentic product from Anthropic, aimed at knowledge workers, capable of completing multi-step tasks on local files and applications. For the distinction from Claude Code, see [01-7 AI Tool Landscape 2026](/en/code-agent/foundations/tool-landscape-2026) and [02-2 Anthropic Claude Setup](/en/code-agent/configuration/anthropic-claude-setup). The full built-in feature list for Cowork (file search, desktop integration, callable applications) is available at `anthropic.com/product/claude-cowork`.
| Built-in feature | Purpose | Limits |
| --------------------------------------- | ------------------------------------------------------------ | --------------------------------------------------------------------- |
| Web search | Real-time web lookup during chat (Plus / Pro) | Citations require manual verification |
| Code execution (Advanced Data Analysis) | Python sandbox; supports file upload, analysis, charting | Sandbox resources limited; state persists only within a session |
| Memory | Save preferences across conversations | Training opt-out: check `help.openai.com` |
| DALL-E image generation | Generate images during chat | Usage subject to plan limits |
| Canvas | Interactive document / code editing | Best suited to long-form writing and refactoring |
| Operator | Cloud browser agent that can operate websites on your behalf | Pro plan; for GUI-based web interactions |
| GPTs / Custom GPT | Customized chat assistants | Conceptually analogous to Skill / Subagent, but a different ecosystem |
| Connectors | Connect ChatGPT to Google Drive, Dropbox, GitHub, and others | Requires manual authorization |
| Built-in feature | Purpose | Limits |
| ----------------------- | ----------------------------------------------------------------- | ------------------------------------------------- |
| Web search (Grounding) | Real-time Google Search lookup during chat | Citations link to Google Search results |
| Deep Research | Multi-step research tasks, cross-source synthesis | Requires Advanced plan |
| Gems | Customizable chat assistants (reusable at the account level) | Conceptually analogous to Skill / Subagent |
| Workspace integration | Operate Google Docs / Drive / Gmail / Calendar from within Gemini | Requires Workspace subscription and authorization |
| Long context window | Gemini Advanced offers 1M+ token windows | Usage depends on plan |
| Code execution | Python sandbox during chat | Sandbox resources limited |
| Imagen image generation | Generate images during chat | Requires Advanced plan |
**Naming clarification**
"Gemini for Google Workspace" and the "Gemini App" are two separate product lines: the former is a sidebar assistant embedded within Workspace applications; the latter is a standalone chat app. The full feature list and plan tiers are available at `support.google.com/gemini`.
| Built-in feature | Purpose | Limits |
| ---------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Code completion (Ghost Text) | Line-by-line / multi-line completion inside the editor | Supports VS Code, JetBrains, Visual Studio, and others |
| Copilot Chat | Chat interface inside the IDE | Supports context keywords `@workspace`, `@github`, and others |
| Copilot Edits | Multi-file editing | Best suited to cross-file refactoring |
| Agent mode | Autonomously complete multi-step tasks | Preview stage; supported IDEs and scope: verify against current official docs |
| Coding agent (cloud) | Cloud-environment autonomous task completion with PR creation | Requires Copilot Enterprise |
| Slash commands | `/fix`, `/tests`, `/explain`, `/doc`, and others | Full list: open the `/` menu in your IDE |
| Personal instructions | `copilot-instructions.md` and personal-level settings | See comparison table in [04-1](/en/code-agent/customization/claude-md-memory) and [04-2](/en/code-agent/customization/rules) |
| Built-in feature | Purpose | Limits |
| --------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------ |
| Tab completion (Cursor Tab) | Multi-line / multi-cursor completion inside the editor | A differentiating Cursor feature |
| Chat | Chat interface inside the IDE | `@Codebase` semantic indexing, `@File`, `@Docs` |
| Composer | Cross-file editing | Best suited to medium-scale refactoring |
| Background Agent | Cloud agent | Preview stage |
| Rules | `.cursorrules` and `.cursor/rules/*.mdc` | See comparison table in [04-2](/en/code-agent/customization/rules) |
| MCP client | Connect to external MCP servers | Supported versions and scope: verify against `cursor.com/docs` |
**Cursor is a third-party IDE**
Cursor (Anysphere) is a third-party AI IDE. This Playbook lists it briefly for comparison purposes only. Full built-in features are available at `cursor.com/docs`.
## 3. Cross-vendor comparison
| Concept | Anthropic Claude (primary) | OpenAI | Google | GitHub Copilot | Cursor (brief) |
| --------------------------------------- | ------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------- | ------------------------------------- |
| Web search | Claude.ai and Claude Code, can be enabled \[1] | ChatGPT Plus/Pro built-in | Gemini Grounding built-in | Triggered via Chat in IDE (semantic search) | Triggered via Chat in IDE |
| Code execution sandbox | Claude.ai Artifacts (JS/Python) | Advanced Data Analysis (Python) | Gemini sandbox (Python) | Cloud coding agent runs in isolated environment | Not in primary workflow |
| Persistent memory | Projects Knowledge, Claude Code Memory \[1] | ChatGPT Memory | Gems memory | Not in primary workflow | Not in primary workflow |
| Built-in connectors | Claude.ai connects to Google Drive, Dropbox, etc. | ChatGPT connects to Google Drive, Dropbox, GitHub | Deep Workspace integration (Docs / Drive / Gmail / Calendar) | `@github` context (PRs, issues) | `@Codebase` and `@Docs` |
| Slash commands | Claude Code `/help`, `/compact`, `/init`, etc. | ChatGPT does not emphasize slash commands; GPTs provide entry points | Gemini built-in commands | `/fix`, `/tests`, `/explain` | IDE `/` menu |
| Interactive output (Artifacts / Canvas) | Artifacts (HTML, code, SVG) | Canvas | (primarily conversational) | Not applicable | Not applicable |
| Multi-file editing agent | Claude Code + Subagent | Codex CLI / Cloud | Antigravity CLI | Copilot Edits, Agent mode | Composer |
| MCP client | Built-in (`/mcp` and `.mcp.json`) \[2] | Scope: verify against current OpenAI docs | Scope: verify against current Google docs | Preview stage | Built-in |
| Custom extension mechanism | Skill / Subagent / Hook / Plugin | Custom GPT, Codex skills / agents | Gems, Antigravity skills / agents | `.prompt.md`, prompt files | `.cursor/rules/*.mdc`, Composer rules |
**Naming clarifications**
* **Claude Code and Claude.ai are two separate products**: the former is a CLI agent (developer-facing); the latter is a chat interface (knowledge-worker-facing). Claude Cowork is a third product (desktop agentic), and it is not interoperable with Claude Code.
* **OpenAI Codex CLI, ChatGPT, and Operator** are three separate product lines: CLI for developers, chat for knowledge workers, cloud browser agent. Their built-in features do not cross over.
* **Google Gemini, Gemini for Google Workspace, and Antigravity** are three separate product lines: standalone chat app, Workspace assistant, CLI agent. Their built-in features do not cross over.
* **Cursor is a third-party IDE** (Anysphere). This Playbook lists it briefly for comparison only.
## 4. How to stay current
Four tracking paths, from lightest to deepest:
Anthropic: `support.claude.com/en/articles/12138966-release-notes` (as of 2026-05; verify the current URL on the official site). OpenAI: `help.openai.com/en/collections/3742473-chatgpt`. Google: `support.google.com/gemini`. GitHub: `github.blog/changelog/label/copilot/`. Cursor: `cursor.com/changelog`.
Most vendors provide an RSS feed. Subscribe with any RSS reader and get notified automatically when features land.
`@AnthropicAI`, `@OpenAI`, `@GoogleAI`, `@GitHubCopilot`, `@cursor_ai`. Feature announcements typically appear before the full release notes.
**Do not wait for the changelog** to find out what is new. Once a month, open your primary tool's settings page and scan the "Experimental features," "Beta," and "What's new" sections.
**Version number does not equal new features**
The difference between Claude Code v2.1.x and v2.1.y **does not necessarily indicate a feature change**. Read the "What's new" section of the release notes; do not rely on the version number alone. For CLI tools, `claude --version` returns the patch version number, which frequently has no relationship to functional changes.
**The 30-minute monthly routine**
Put it on the calendar: the first Monday of every month at 09:00, 30 minutes, scan "primary CLI release notes + chat interface changelog + settings page new feature flags" in that order. Thirty minutes multiplied by the value of the features you discover and actually use compounds faster than any prompt engineering gains.
## 5. The criteria for full use: what each feature solves and where it stops
Do not use something just because it looks impressive. Do not ignore something just because you have never tried it. Run every feature through these three questions:
1. **What problem does it solve?** If you cannot describe a concrete scenario for it, it is not worth adopting.
2. **Where are its limits?** Input capacity, output constraints, rate limits, quotas, plan tiers, failure conditions.
3. **Which step in your workflow can it replace?** Replacement has value; stacking it on top only adds complexity.
Common judgment traps:
* **Web search**: excellent for recent data, pricing, news, documentation changes. **Not a substitute for academic citation work that requires precise sourcing** (citation quality varies; URL hallucination is a real risk).
* **Code execution / Artifacts sandbox**: excellent for quick verification, interactive demos, front-end prototyping. **Not suitable for heavy computation** (resources are limited) or services that require persistent state.
* **Projects / Memory**: excellent for standing information you want across every conversation (glossaries, team conventions, research direction). **Not appropriate for sensitive personal data** (training opt-out requires per-item confirmation), or for infrequent one-off context.
* **Connectors**: excellent for letting the model read from data sources you already own (Drive, Dropbox, Notion, Linear, GitHub). **Not a substitute for a proper ETL pipeline** (OAuth scope, rate limits, and auditability are fundamentally different).
**Judgment example: should you build a custom web search wrapper?**
Before writing a line of code, check:
1. Does Claude.ai Pro have built-in Web search? Yes.
2. Can it handle your verification use case? In 90% of scenarios, yes (citations included, recent data covered).
3. What does your custom wrapper add over the built-in? Probably just "a URL allowlist I control" and "custom output format."
Conclusion: for most people, **use Claude.ai built-in Web search and instruct it in the prompt to "only cite domains from my allowlist."** A custom wrapper only makes sense when allowlist enforcement is a hard compliance requirement or when you need to connect custom back-end logic.
## 6. Anti-patterns
* **Installing plugins to recreate built-in functionality**: custom web search wrappers, custom long-context summarizers, custom memory systems. When built-in features already cover 90% of the use case, this wastes maintenance budget. The exception is compliance or customization requirements that built-in features genuinely cannot meet.
* **Paying for features and leaving them off**: subscribing to Pro and never enabling Web search, never using Projects, never running Artifacts for front-end prototyping. That is loss, not frugality. Monthly changelog scanning is the prevention.
* **Building custom solutions without checking the changelog**: what you spent two weeks building may have been shipped by the vendor last month. The cost of staying current is far lower than the cost of duplicate work.
* **Mixing equivalent features from multiple tools**: running web search simultaneously in Claude.ai, ChatGPT, and Gemini produces "same query, different sources, contradictory conclusions" and makes debugging integration behavior almost impossible. Pick one primary tool per workflow; treat the others as fallback only.
## Hands-on exercise
**30-minute practice**
Open the settings page of your primary AI tool and list every built-in feature currently enabled. Compare that list against what you have actually used in the past month. Where are the gaps? Sort unused features into "worth trying once" and "not relevant." Write down three you want to try.
Pick one official changelog for your primary tool (URL or RSS feed) and add it to your RSS reader or browser bookmarks.
Read the last 90 days of release notes. List three features you did not know about until now and evaluate whether each is worth adopting.
## Common pitfalls
**Anti-pattern list**
* **Assuming a feature does not exist when it is just not enabled**: many features (Web search, Projects, Memory, Connectors, experimental flags) require manual activation or authorization in settings. Opening the settings page and scanning it once is worth more than any amount of prompt engineering.
* **Mixing built-in features with third-party plugins for the same task, creating inconsistent behavior**: if "look up the latest docs" runs through both the built-in Web search and an external wrapper simultaneously, you cannot tell which source produced which result when debugging. **Pick one primary tool per workflow.**
* **Learning a tool's capabilities from third-party tutorials rather than official documentation**: tutorials go stale; the official changelog is the source of truth. When writing instructional material, always annotate "as of YYYY-MM" with a link to the official URL.
* **Treating Beta / Preview features as Production-ready**: Agent mode, Memory, Background Agent, and similar preview features can change model behavior, APIs, and UX at any time. Production environments should be pinned to GA (General Availability) features.
* **Believing that "tracking updates" is only for engineers**: researchers, product managers, and students need it equally. The prompts and workflows you write depend on the tool's current capabilities; not knowing what has been added means you keep working within last year's constraints.
## Self-check
**The bar for passing this unit**
1. Can you list five built-in features of your primary tool in under five minutes, and for each one describe what it solves and where its limits are?
2. Do you have a fixed update-tracking routine? Thirty minutes per month, on the calendar.
3. Is there anywhere in your workflow where a custom component already has a built-in equivalent? Identify at least one and decide whether to retire it.
4. Has anything shipped in the past month that you did not know about? Open the changelog now and record the most recent entry you find.
## Sources and further reading
Factual claims are grounded in official documentation; fast-changing items are annotated as of 2026-05.
* \[1] Anthropic, "Claude Code overview & permissions," code.claude.com, 2026. \[Online]. Available: [https://code.claude.com/docs/en/permissions](https://code.claude.com/docs/en/permissions) (as of 2026-05; covers tool tiers, read-only command list, permission rules)
* \[2] Anthropic, "Connect Claude Code to tools via MCP," code.claude.com, 2026. \[Online]. Available: [https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp) (as of 2026-05; MCP client and `.mcp.json` configuration)
* Built-in connector details and configuration: [02-2 Anthropic Claude Setup: Chat, Cowork, Code](/en/code-agent/configuration/anthropic-claude-setup).
* Cross-tool integration (CLI, MCP, Skill): [04-9 MCP Integration](/en/code-agent/customization/mcp-integration) and [04-10 CLI-First vs MCP](/en/code-agent/customization/cli-first-vs-mcp).
* Custom extensions: [04-4 Skills](/en/code-agent/customization/skills), [04-5 Subagents](/en/code-agent/customization/subagents), [04-6 Hooks](/en/code-agent/customization/hooks), [04-7 Plugins](/en/code-agent/customization/plugins).
* Tool landscape: [01-7 AI Tool Landscape 2026](/en/code-agent/foundations/tool-landscape-2026).