🎯 Design an AI Coding Assistant like Copilot

1️⃣ Core Framework

When designing an AI Coding Assistant, I frame it as:

Product requirements
IDE integration
Code context collection
Retrieval over codebase
Model routing and inference
Suggestion ranking
Safety and security
Trade-offs: latency vs quality vs privacy

2️⃣ Product Goal

An AI coding assistant helps developers write, understand, debug, refactor, and test code inside their workflow.

Basic Flow

Developer Context
→ IDE Plugin
→ Context Builder
→ Code Model
→ Suggestion
→ Developer Accepts / Rejects

👉 Interview Answer

An AI coding assistant is an IDE-integrated system that collects relevant code context, sends it to a model, generates code suggestions, and learns from developer feedback.

It must optimize for low latency, code quality, privacy, security, and developer trust.

3️⃣ Functional Requirements

Core Features

The system should support:

Inline code completion
Multi-line code generation
Chat with codebase
Explain code
Generate tests
Refactor code
Debug errors
Suggest documentation
Search relevant files

Advanced Features

Repository-level Q&A
Pull request review
Code migration
Security vulnerability detection
Agentic code editing
Test execution
Terminal command suggestions
Architecture explanation

👉 Interview Answer

Core requirements include inline completion, code chat, code explanation, refactoring, test generation, debugging, and repository search.

Advanced features include pull request review, agentic editing, code migration, and security analysis.

4️⃣ Non-functional Requirements

Important System Qualities

The system should optimize for:

Very low latency
High suggestion quality
Privacy
Security
Reliability
IDE responsiveness
Cost efficiency
Codebase awareness
Developer control

Key Trade-off

More context improves quality,
but increases latency,
cost,
and privacy risk.

👉 Interview Answer

Non-functional requirements are especially important for coding assistants.

Inline completion must be very fast, while codebase-aware chat can tolerate more latency.

The main trade-off is context quality versus latency, cost, and privacy.

5️⃣ High-Level Architecture

Architecture

IDE Plugin
→ Local Context Collector
→ Context Filter
→ API Gateway
→ Auth / Policy Layer
→ Retrieval Service
→ Prompt Builder
→ Model Router
→ Code LLM
→ Suggestion Ranker
→ IDE Renderer

Core Components

IDE Plugin

Collects local coding context and displays suggestions.

Context Collector

Finds relevant files, symbols, cursor context, and diagnostics.

Retrieval Service

Searches codebase, docs, and previous examples.

Model Router

Chooses fast or strong model.

Suggestion Ranker

Ranks and filters candidate completions.

👉 Interview Answer

A coding assistant architecture includes an IDE plugin, context collector, policy layer, retrieval service, prompt builder, model router, code model, suggestion ranker, and feedback pipeline.

6️⃣ IDE Integration

Why IDE Integration Matters

The assistant must work inside the developer’s workflow.

It should understand:

Current file
Cursor position
Selected code
Open tabs
Project structure
Compiler errors
Git diff
Test failures
Language server symbols

Example

Cursor inside function
→ Collect nearby code
→ Collect imports
→ Collect relevant symbols
→ Generate completion

👉 Interview Answer

IDE integration is critical because the assistant needs local context.

It should use cursor position, current file, open tabs, language server symbols, diagnostics, and git diff to build useful prompts.

7️⃣ Code Context Collection

What Context Is Useful?

Useful context includes:

Current file around cursor
Function or class definition
Imports
Type definitions
Related files
Open buffers
Error messages
Test files
README and docs

Context Selection

Available project context
→ Filter relevant context
→ Fit into token budget

Why Important

Sending the entire repository is impossible.

👉 Interview Answer

Code context collection decides what code should be sent to the model.

Since the full repository cannot fit in context, the system must select the most relevant files, symbols, types, errors, and surrounding code.

8️⃣ Codebase Retrieval

Why Retrieval Is Needed

Many coding questions require repository-level knowledge.

Retrieval Sources

File names
Symbol index
Function definitions
Class definitions
Recent git changes
Documentation
Tests
Error logs

Retrieval Flow

Developer query
→ Search code index
→ Retrieve relevant snippets
→ Add to prompt

👉 Interview Answer

Repository-level coding assistance requires retrieval.

The system should index files, symbols, functions, tests, and documentation, then retrieve relevant snippets for the model.

9️⃣ Indexing the Codebase

Index Types

A coding assistant may build:

Keyword index
Vector index
Symbol index
Dependency graph
Call graph
File tree index
Git history index

Why Multiple Indexes?

Code search needs both exact and semantic retrieval.

Keyword search → exact symbol names
Vector search → semantic intent
Symbol graph → relationships

👉 Interview Answer

Codebase indexing should combine keyword search, vector search, symbol indexing, and dependency graphs.

Keyword search handles exact names, vector search handles semantic queries, and symbol graphs capture code relationships.

🔟 Prompt Building

Prompt Builder Inputs

The prompt may include:

Task instruction
Current file context
Cursor location
Retrieved snippets
Type information
Diagnostics
Style rules
User constraints
Output format

Prompt Example

You are editing a TypeScript file.
Current function:
...
Relevant type definitions:
...
User request:
Add validation for missing email.

👉 Interview Answer

The prompt builder combines developer intent, cursor context, nearby code, retrieved snippets, diagnostics, type definitions, and style rules into a compact model input.

1️⃣1️⃣ Model Routing

Different Tasks Need Different Models

Inline completion
→ Small fast model

Complex refactor
→ Larger reasoning model

Codebase Q&A
→ Retrieval + strong model

Security review
→ Specialized model + rules

Routing Signals

Task type
Latency target
Code length
Language
Risk level
User tier
Context size
Required reasoning

👉 Interview Answer

Model routing is important for coding assistants.

Inline completion needs a fast model, while complex refactoring, debugging, or repository-level reasoning may require a larger model.

1️⃣2️⃣ Inline Completion

Latency Requirement

Inline completion must feel instant.

Usually it needs:

Low time-to-first-token
Low total latency
Small context
Fast model

Flow

Developer pauses typing
→ IDE sends context
→ Fast model predicts completion
→ IDE shows ghost text
→ User accepts or ignores

👉 Interview Answer

Inline completion is the most latency-sensitive feature.

The system should use small context, fast models, aggressive caching, and lightweight ranking so suggestions appear quickly.

1️⃣3️⃣ Code Chat

Code Chat Is Different

Code chat can tolerate more latency, but needs better context.

Flow

User asks question
→ Retrieve repository context
→ Build prompt
→ Strong model answers
→ Cite files and symbols

Examples

Explain this function
Where is auth handled?
Why is this test failing?
How do I add a new endpoint?

👉 Interview Answer

Code chat is less latency-sensitive than inline completion, but it needs stronger retrieval and more reasoning.

The assistant should retrieve relevant files and symbols, then answer with references to code locations.

1️⃣4️⃣ Agentic Code Editing

What Is Agentic Editing?

The assistant plans and applies multi-file changes.

Flow

User request
→ Analyze repo
→ Create plan
→ Edit files
→ Run tests
→ Fix errors
→ Show diff
→ Human approves

Important Rule

Human approval should be required before applying risky changes.

👉 Interview Answer

Agentic code editing allows the assistant to modify code across files.

The system should plan changes, apply diffs, run tests, iterate on errors, and require human review before final acceptance.

1️⃣5️⃣ Safety and Security

Risks

Coding assistants can introduce:

Insecure code
Dependency vulnerabilities
Secret leakage
License issues
Prompt injection from files
Dangerous shell commands
Incorrect production changes

Controls

Secret scanning
Dependency scanning
Command approval
Sandbox execution
License filtering
Output validation
Human review
Policy enforcement

👉 Interview Answer

Coding assistants need strong security controls.

The system should prevent secret leakage, unsafe commands, vulnerable code, license issues, and unauthorized repository access.

1️⃣6️⃣ Privacy and Enterprise Controls

Enterprise Requirements

Enterprise customers may require:

No code training
Tenant isolation
Data retention controls
Audit logs
Private model deployment
Access control
SSO and RBAC
Policy-based tool access

Important Principle

Source code is sensitive intellectual property.

👉 Interview Answer

Source code is highly sensitive.

Enterprise coding assistants need tenant isolation, access control, audit logs, data retention policies, no-training guarantees, and strong privacy controls.

1️⃣7️⃣ Feedback Loop

What Feedback Is Useful?

The system can learn from:

Accepted completions
Rejected completions
Edited suggestions
Regeneration requests
Test outcomes
User ratings
PR review outcomes

Feedback Flow

Suggestion shown
→ User accepts / edits / rejects
→ Feedback stored
→ Evaluation improves routing and prompts

👉 Interview Answer

Feedback is critical for improving coding assistants.

Acceptance rate, edit distance, rejection rate, test success, and user feedback help evaluate suggestion quality.

1️⃣8️⃣ Observability

What to Monitor

Suggestion latency
Acceptance rate
Edit distance
Model errors
Retrieval quality
Tool failure rate
Test execution results
Cost per suggestion
Security blocks
User feedback

Debugging Questions

Was the right context retrieved?
Was the suggestion syntactically valid?
Did tests pass?
Was latency from retrieval or model inference?
Did the model violate policy?

👉 Interview Answer

Observability should track latency, accepted suggestions, edit distance, retrieval results, model errors, tool calls, test outcomes, security blocks, and cost per feature.

1️⃣9️⃣ Common Failure Modes

Failure Modes

AI coding assistants can fail because of:

Wrong code context
Hallucinated APIs
Broken imports
Type errors
Insecure code
Bad multi-file edits
Slow completions
Overconfident answers
Repository access mistakes

Example

Assistant suggests API that does not exist in repo.
Code compiles fail.
Developer loses trust.

👉 Interview Answer

Coding assistant failures often come from missing context, hallucinated APIs, type errors, insecure code, bad retrieval, or slow suggestions.

The system needs retrieval, validation, testing, and feedback loops.

2️⃣0️⃣ Best Practices

Practical Rules

Keep inline completion fast
Use stronger models for complex tasks
Retrieve codebase context before answering
Index symbols and dependencies
Validate generated code
Run tests for agentic edits
Require review for risky changes
Protect secrets and private code
Track acceptance and edit distance
Optimize for developer trust

Design Principle

A coding assistant must understand local context,
not just generate code.

👉 Interview Answer

A production coding assistant needs IDE context, codebase retrieval, model routing, low-latency completion, secure tool execution, validation, testing, privacy controls, and feedback loops.

🧠 Staff-Level Answer Final

👉 Interview Answer Full Version

To design an AI coding assistant like Copilot, I would treat it as an IDE-integrated product system, not just a code generation model.

The system must support inline completion, code chat, code explanation, refactoring, test generation, debugging, and possibly agentic multi-file editing.

The architecture starts with an IDE plugin.

The plugin collects local context such as current file, cursor position, selected code, open tabs, diagnostics, imports, git diff, and language server symbols.

The context builder then selects the most relevant information within a token budget.

For repository-level understanding, the system needs codebase indexing and retrieval.

It should combine keyword search, vector search, symbol indexes, dependency graphs, and file structure.

Keyword search is useful for exact symbol names.

Vector search helps with semantic queries.

Symbol and dependency graphs help understand relationships between files.

Model routing is important.

Inline completion should use a fast low-latency model.

Complex debugging, repository-level Q&A, refactoring, and agentic editing may require a stronger model with retrieval.

Agentic editing should be handled carefully.

The assistant can plan changes, apply diffs, run tests, fix errors, and show a final diff, but humans should approve risky changes.

Security and privacy are critical because source code is sensitive intellectual property.

The system needs tenant isolation, access control, secret scanning, data retention controls, audit logs, sandbox execution, and safe command approval.

Feedback loops are also important.

The system should track accepted completions, rejected completions, edit distance, test outcomes, user ratings, and PR outcomes.

Observability should capture latency, retrieval quality, model errors, tool calls, security blocks, cost, and suggestion acceptance.

The core principle is: a coding assistant must understand local context, not just generate code.

⭐ Final Insight

AI Coding Assistant 的核心不是：

“LLM 生成代码”

而是：

IDE Integration

Local Context Collection

Codebase Indexing

Symbol Retrieval

Model Routing

Low-latency Completion

Code Chat

Agentic Editing

Test Validation

Security Controls

Feedback Loop。

最重要的一句话：

A coding assistant must understand local context, not just generate code.

中文部分

🎯 Design an AI Coding Assistant like Copilot

1️⃣ 核心框架

设计 AI Coding Assistant 时，我通常从这些方面分析：

Product requirements
IDE integration
Code context collection
Retrieval over codebase
Model routing and inference
Suggestion ranking
Safety and security
核心权衡：latency vs quality vs privacy

2️⃣ Product Goal

AI coding assistant 帮助 developers 在 workflow 中写代码、理解代码、 debug、refactor 和生成 tests。

Basic Flow

Developer Context
→ IDE Plugin
→ Context Builder
→ Code Model
→ Suggestion
→ Developer Accepts / Rejects

👉 面试回答

AI coding assistant 是一个 IDE-integrated system。

它收集相关 code context，发送给 model，生成 code suggestions，并从 developer feedback 中学习。

它必须优化 low latency、code quality、 privacy、security 和 developer trust。

3️⃣ Functional Requirements

Core Features

系统应该支持：

Inline code completion
Multi-line code generation
Chat with codebase
Explain code
Generate tests
Refactor code
Debug errors
Suggest documentation
Search relevant files

Advanced Features

Repository-level Q&A
Pull request review
Code migration
Security vulnerability detection
Agentic code editing
Test execution
Terminal command suggestions
Architecture explanation

👉 面试回答

核心需求包括 inline completion、 code chat、code explanation、 refactoring、test generation、 debugging 和 repository search。

Advanced features 包括 pull request review、 agentic editing、code migration 和 security analysis。

4️⃣ Non-functional Requirements

Important System Qualities

系统应该优化：

Very low latency
High suggestion quality
Privacy
Security
Reliability
IDE responsiveness
Cost efficiency
Codebase awareness
Developer control

Key Trade-off

More context improves quality,
but increases latency,
cost,
and privacy risk.

👉 面试回答

Non-functional requirements 对 coding assistants 特别重要。

Inline completion 必须非常快， codebase-aware chat 可以接受更高 latency。

核心权衡是 context quality 和 latency、cost、privacy 的平衡。

5️⃣ High-Level Architecture

Architecture

IDE Plugin
→ Local Context Collector
→ Context Filter
→ API Gateway
→ Auth / Policy Layer
→ Retrieval Service
→ Prompt Builder
→ Model Router
→ Code LLM
→ Suggestion Ranker
→ IDE Renderer

Core Components

IDE Plugin

收集 local coding context 并展示 suggestions。

Context Collector

找到 relevant files、symbols、 cursor context 和 diagnostics。

Retrieval Service

搜索 codebase、docs 和 previous examples。

Model Router

选择 fast 或 strong model。

Suggestion Ranker

排序和过滤 candidate completions。

👉 面试回答

Coding assistant architecture 包括 IDE plugin、 context collector、policy layer、 retrieval service、prompt builder、 model router、code model、 suggestion ranker 和 feedback pipeline。

6️⃣ IDE Integration

为什么 IDE Integration 重要？

Assistant 必须在 developer workflow 内工作。

它应该理解：

Current file
Cursor position
Selected code
Open tabs
Project structure
Compiler errors
Git diff
Test failures
Language server symbols

Example

Cursor inside function
→ Collect nearby code
→ Collect imports
→ Collect relevant symbols
→ Generate completion

👉 面试回答

IDE integration 很关键，因为 assistant 需要 local context。

它应该使用 cursor position、current file、 open tabs、language server symbols、 diagnostics 和 git diff 来构建有用 prompts。

7️⃣ Code Context Collection

什么 Context 有用？

有用 context 包括：

Current file around cursor
Function or class definition
Imports
Type definitions
Related files
Open buffers
Error messages
Test files
README and docs

Context Selection

Available project context
→ Filter relevant context
→ Fit into token budget

为什么重要？

发送整个 repository 不现实。

👉 面试回答

Code context collection 决定哪些 code 应该发送给 model。

因为完整 repository 无法放进 context，系统必须选择最相关的 files、symbols、 types、errors 和 surrounding code。

8️⃣ Codebase Retrieval

为什么需要 Retrieval？

很多 coding questions 需要 repository-level knowledge。

Retrieval Sources

File names
Symbol index
Function definitions
Class definitions
Recent git changes
Documentation
Tests
Error logs

Retrieval Flow

Developer query
→ Search code index
→ Retrieve relevant snippets
→ Add to prompt

👉 面试回答

Repository-level coding assistance 需要 retrieval。

系统应该 index files、symbols、 functions、tests 和 documentation，然后为 model 检索 relevant snippets。

9️⃣ Indexing the Codebase

Index Types

Coding assistant 可以建立：

Keyword index
Vector index
Symbol index
Dependency graph
Call graph
File tree index
Git history index

为什么需要 Multiple Indexes？

Code search 需要 exact 和 semantic retrieval。

Keyword search → exact symbol names
Vector search → semantic intent
Symbol graph → relationships

👉 面试回答

Codebase indexing 应结合 keyword search、 vector search、symbol indexing 和 dependency graphs。

Keyword search 处理 exact names， vector search 处理 semantic queries， symbol graphs 捕捉 code relationships。

🔟 Prompt Building

Prompt Builder Inputs

Prompt 可能包含：

Task instruction
Current file context
Cursor location
Retrieved snippets
Type information
Diagnostics
Style rules
User constraints
Output format

Prompt Example

You are editing a TypeScript file.
Current function:
...
Relevant type definitions:
...
User request:
Add validation for missing email.

👉 面试回答

Prompt builder 组合 developer intent、 cursor context、nearby code、 retrieved snippets、diagnostics、 type definitions 和 style rules，形成 compact model input。

1️⃣1️⃣ Model Routing

Different Tasks Need Different Models

Inline completion
→ Small fast model

Complex refactor
→ Larger reasoning model

Codebase Q&A
→ Retrieval + strong model

Security review
→ Specialized model + rules

Routing Signals

Task type
Latency target
Code length
Language
Risk level
User tier
Context size
Required reasoning

👉 面试回答

Model routing 对 coding assistants 很重要。

Inline completion 需要 fast model， complex refactoring、debugging 或 repository-level reasoning 可能需要 larger model。

1️⃣2️⃣ Inline Completion

Latency Requirement

Inline completion 必须感觉 instant。

通常需要：

Low time-to-first-token
Low total latency
Small context
Fast model

Flow

Developer pauses typing
→ IDE sends context
→ Fast model predicts completion
→ IDE shows ghost text
→ User accepts or ignores

👉 面试回答

Inline completion 是最 latency-sensitive 的功能。

系统应该使用 small context、fast models、 aggressive caching 和 lightweight ranking，让 suggestions 快速出现。

1️⃣3️⃣ Code Chat

Code Chat 不同

Code chat 可以接受更多 latency，但需要更好的 context。

Flow

User asks question
→ Retrieve repository context
→ Build prompt
→ Strong model answers
→ Cite files and symbols

Examples

Explain this function
Where is auth handled?
Why is this test failing?
How do I add a new endpoint?

👉 面试回答

Code chat 比 inline completion 更能接受 latency，但需要更强 retrieval 和更多 reasoning。

Assistant 应该 retrieve relevant files 和 symbols，并用 code locations 作为 references 回答。

1️⃣4️⃣ Agentic Code Editing

什么是 Agentic Editing？

Assistant 计划并应用 multi-file changes。

Flow

User request
→ Analyze repo
→ Create plan
→ Edit files
→ Run tests
→ Fix errors
→ Show diff
→ Human approves

Important Rule

Risky changes 应该需要 human approval。

👉 面试回答

Agentic code editing 允许 assistant 跨文件修改代码。

系统应该 plan changes、apply diffs、 run tests、iterate on errors，并在 final acceptance 前要求 human review。

1️⃣5️⃣ Safety and Security

Risks

Coding assistants 可能引入：

Insecure code
Dependency vulnerabilities
Secret leakage
License issues
Prompt injection from files
Dangerous shell commands
Incorrect production changes

Controls

Secret scanning
Dependency scanning
Command approval
Sandbox execution
License filtering
Output validation
Human review
Policy enforcement

👉 面试回答

Coding assistants 需要强 security controls。

系统应该防止 secret leakage、 unsafe commands、vulnerable code、 license issues 和 unauthorized repository access。

1️⃣6️⃣ Privacy and Enterprise Controls

Enterprise Requirements

Enterprise customers 可能要求：

No code training
Tenant isolation
Data retention controls
Audit logs
Private model deployment
Access control
SSO and RBAC
Policy-based tool access

Important Principle

Source code is sensitive intellectual property.

👉 面试回答

Source code 是非常敏感的 intellectual property。

Enterprise coding assistants 需要 tenant isolation、 access control、audit logs、 data retention policies、no-training guarantees 和强 privacy controls。

1️⃣7️⃣ Feedback Loop

什么 Feedback 有用？

系统可以从这些学习：

Accepted completions
Rejected completions
Edited suggestions
Regeneration requests
Test outcomes
User ratings
PR review outcomes

Feedback Flow

Suggestion shown
→ User accepts / edits / rejects
→ Feedback stored
→ Evaluation improves routing and prompts

👉 面试回答

Feedback 对 improving coding assistants 很关键。

Acceptance rate、edit distance、 rejection rate、test success 和 user feedback 可以帮助评估 suggestion quality。

1️⃣8️⃣ Observability

What to Monitor

Suggestion latency
Acceptance rate
Edit distance
Model errors
Retrieval quality
Tool failure rate
Test execution results
Cost per suggestion
Security blocks
User feedback

Debugging Questions

是否 retrieved 了正确 context？
Suggestion 是否 syntactically valid？
Tests 是否通过？
Latency 来自 retrieval 还是 model inference？
Model 是否违反 policy？

👉 面试回答

Observability 应追踪 latency、 accepted suggestions、edit distance、 retrieval results、model errors、 tool calls、test outcomes、 security blocks 和 cost per feature。

1️⃣9️⃣ Common Failure Modes

Failure Modes

AI coding assistants 可能失败因为：

Wrong code context
Hallucinated APIs
Broken imports
Type errors
Insecure code
Bad multi-file edits
Slow completions
Overconfident answers
Repository access mistakes

Example

Assistant suggests API that does not exist in repo.
Code compiles fail.
Developer loses trust.

👉 面试回答

Coding assistant failures 通常来自 missing context、hallucinated APIs、 type errors、insecure code、bad retrieval 或 slow suggestions。

系统需要 retrieval、validation、testing 和 feedback loops。

2️⃣0️⃣ Best Practices

Practical Rules

Keep inline completion fast
Use stronger models for complex tasks
Retrieve codebase context before answering
Index symbols and dependencies
Validate generated code
Run tests for agentic edits
Require review for risky changes
Protect secrets and private code
Track acceptance and edit distance
Optimize for developer trust

Design Principle

A coding assistant must understand local context,
not just generate code.

👉 面试回答

Production coding assistant 需要 IDE context、codebase retrieval、 model routing、low-latency completion、 secure tool execution、validation、testing、 privacy controls 和 feedback loops。

🧠 Staff-Level Answer Final

👉 面试回答完整版本

设计一个像 Copilot 的 AI coding assistant，我会把它看作 IDE-integrated product system，而不是简单的 code generation model。

系统必须支持 inline completion、code chat、 code explanation、refactoring、 test generation、debugging，以及可能的 agentic multi-file editing。

Architecture 从 IDE plugin 开始。

Plugin 收集 local context，比如 current file、cursor position、 selected code、open tabs、diagnostics、 imports、git diff 和 language server symbols。

Context builder 在 token budget 内选择最相关的信息。

对 repository-level understanding，系统需要 codebase indexing 和 retrieval。

它应该结合 keyword search、vector search、 symbol indexes、dependency graphs 和 file structure。

Keyword search 适合 exact symbol names。

Vector search 适合 semantic queries。

Symbol 和 dependency graphs 帮助理解 files 之间的 relationships。

Model routing 很重要。

Inline completion 应该使用 fast low-latency model。

Complex debugging、repository-level Q&A、 refactoring 和 agentic editing 可能需要更强 model + retrieval。

Agentic editing 必须谨慎处理。

Assistant 可以 plan changes、apply diffs、 run tests、fix errors，并展示 final diff，但 risky changes 应该由 humans approve。

Security 和 privacy 非常关键，因为 source code 是 sensitive intellectual property。

系统需要 tenant isolation、access control、 secret scanning、data retention controls、 audit logs、sandbox execution 和 safe command approval。

Feedback loops 也很重要。

系统应该追踪 accepted completions、 rejected completions、edit distance、 test outcomes、user ratings 和 PR outcomes。

Observability 应该捕获 latency、retrieval quality、 model errors、tool calls、security blocks、 cost 和 suggestion acceptance。

核心原则是： coding assistant 必须理解 local context，而不只是 generate code。

⭐ Final Insight

AI Coding Assistant 的核心不是：

“LLM 生成代码”

而是：

IDE Integration

Local Context Collection

Codebase Indexing

Symbol Retrieval

Model Routing

Low-latency Completion

Code Chat

Agentic Editing

Test Validation

Security Controls

Feedback Loop。

最重要的一句话：

A coding assistant must understand local context, not just generate code.