--- title: "14 — AI Tools, Agents, and MCP — From Autocomplete to Autonomous" uid: ai-tools-agents-mcp tags: ["prompt-engineering", "roadmap:backend", "copilot", "mcp", "agents", "cursor", "ai", "skills", "claude-code"] excerpt: "Claude Code, Cursor, Copilot, agents, MCP, skills: one gradient of autonomy — from autocomplete's single suggestion to agents pursuing a goal across many steps." date: 2026-08-13T03:28:25+0000 source: https://www.aveshina.my.id/en/blog/ai-tools-agents-mcp --- Claude Code, Cursor, Copilot, Antigravity, prompt engineering, AI agents, MCP, skills — a list that used to read as competing products. Writing them down collapsed it into one spectrum: **it's a gradient of autonomy, from autocomplete (one suggestion, human applies it) through editor-aware AI (the tool sees my project) to agents (a goal pursued across many steps), and MCP + skills are the protocol and capabilities that let any of them actually do things.** [1][6] The frame that helped is *who holds the steering wheel*. At the low-autonomy end, the human drives and the AI suggests — I write, it completes lines. In the middle, the AI sees more context (my whole project, my edits) and can take larger actions I review. At the high-autonomy end, I hand the AI a goal and it pursues the goal across many steps — reading files, running commands, iterating — checking back with me when uncertain. The products differ in where they sit on this gradient and what they can reach. ```figure ``` ## The editor-level tools: Copilot and Cursor **GitHub Copilot** is the AI autocomplete — a model integrated into the editor that suggests the next line or function as I type, based on the surrounding code and comments [5]. It's the lowest-autonomy tier: I drive, it offers one suggestion, I accept or reject. Copilot's value is the removal of friction for boilerplate and obvious continuations; its limitation is that it sees only the local context (the open file, maybe nearby tabs) and proposes, doesn't act. **Cursor** is one step up — an AI-powered *code editor* (a VS Code fork) where the AI is integrated deeply enough to see the whole project, not just the open file [8]. Cursor can answer questions about the codebase, refactor across files, and apply multi-cursor edits with awareness of the project's structure. The shift from Copilot to Cursor is the shift from "completes my typing" to "understands my project and can act on it." Cursor still sits in the human-driven tier — I review and accept its changes — but its reach is larger. The pattern: the lower-autonomy tools add a second brain to *my* editing flow. They make me faster at what I was already doing. They don't take the keyboard. ## The agentic tier: Claude Code and Antigravity **Claude Code** is the step into genuine agency — a CLI-based coding agent that operates inside a repository, can read and edit files, run commands, and iterate over many steps to pursue a goal I describe [9]. Where Copilot suggests one line, Claude Code can take "add a rate-limit middleware to the auth endpoints and update the tests" and do it: read the routes, find the auth middleware, add the limiter, run the tests, fix what breaks, report back. **Antigravity**, Google's entry, sits on the same high-autonomy rung, not the autocomplete tier [7]. It's an agent-first platform: the agent plans a task, writes code, runs terminal commands, and runs tests — including driving a built-in browser to click through the running app and verify the UI — on its own and in the background. Its **Manager View** coordinates several agents at once, watching them work on different projects in parallel from one screen. Don't confuse it with Google's older **Gemini Code Assist**, which is the traditional IDE extension for autocomplete and chat; Antigravity is the agentic platform. Where Claude Code lives in the terminal, Antigravity lives in an IDE plus a browser — the same high hand-over, review the result rather than each step. The autonomy shift is real. The agent holds the keyboard for stretches; my role moves from typing to *specifying and reviewing*. I describe the goal precisely, the agent plans and executes, and I review the diff before it's committed. The verification obligation from the previous AI posts still applies, fully — but the unit of work shifts from a line to a task. ## AI agents: goal-driven loops An **AI agent** generalizes the pattern: an autonomous program that takes a goal, plans steps to achieve it, executes them (calling tools, reading results), observes the outcomes, and iterates until the goal is met or it needs to check in [10]. The shape is a loop: *plan → act → observe → repeat*. The agent's competence depends on its model, its available tools, and how well the goal is specified. The agents-roadmap node is deliberately abstract because the pattern applies widely — a coding agent (Claude Code), a research agent (search the web, summarize), a support agent (look up the user's order, draft a reply). The common engineering challenges are: giving the agent the right tools, bounding its iterations (so it doesn't loop forever), and defining when it must check in with a human (the trust boundary). Agents are powerful exactly where the task is well-bounded and tool-rich; they fail where the goal is vague or the tools don't let them verify their own work. ## Prompt engineering: how to talk to all of them **Prompt engineering** is the skill that spans every tier — crafting the input (instructions, context, examples) so the model produces the desired output [11]. It's not a hack; it's the practical consequence of the model being a next-token predictor. The model can't infer intent I didn't state; clear instructions, relevant context, and examples of the desired output materially change what comes back. The patterns that matter: - **Be explicit about format.** "Return JSON with keys X, Y, Z" beats "give me the data." - **Provide context.** The model knows only what's in the prompt. Relevant code, docs, and constraints belong in the input. - **Give examples.** One or two examples of input → desired output ("few-shot") teaches the pattern far better than description. - **Constrain the output.** Structured output modes (JSON schema) force parseable results. Prompt engineering is not separate from the tools — it's how I drive every tool on the spectrum, from a Copilot comment to a Claude Code task description. The clearer my intent, the better every tier performs. ## MCP and Skills: how agents touch real tools **Model Context Protocol (MCP)** is the piece that makes high autonomy safe and useful — a standard protocol for how an AI agent packs context and calls external tools [12]. MCP standardizes the format (what's the system role, the user's request, the available tool definitions, the tool-call results) so that models, editors, and tools from different vendors can interoperate. The payoff is that any MCP-compatible agent can talk to any MCP-compatible tool — a tool built once (query my database, search my docs, run my tests) is usable by every agent. **Skills** are the capabilities exposed to the agent through this kind of protocol — pre-defined functions or tools the agent can call (run tests, deploy code, query a database) instead of relying solely on its internal model [13]. The shift is that the agent moves from "writing code that might work" to "calling a capability that does work and reading the result." Skills collapse the context window (the agent gets a concise result, not a wall of code it has to reason about) and improve reliability (a tool call is deterministic; generated code is not). Together, MCP and skills are what let agents at the high-autonomy end actually accomplish things in the real world. An agent without tools can only generate text; an agent with tools (search, query, deploy, test) can act, verify, and iterate. The agent's competence is bounded by what its tools let it do. ## How I use this The spectrum maps to how much verification I owe and how precisely I must specify: - **Autocomplete tier (Copilot)** — low specification, low verification per suggestion. I accept completions inline; the unit is a line. - **Editor tier (Cursor)** — medium specification, medium verification. I describe a change, review the diff; the unit is a small refactor. - **Agentic tier (Claude Code, Antigravity, agents)** — high specification, high verification. I describe a task precisely, the agent executes many steps, I review the whole change before it lands; the unit is a feature. The discipline that scales across all three: the clearer my intent (prompt engineering), the better the output; the more autonomous the tool, the more carefully I review. I never let an agent commit unsupervised, and I never accept an autocomplete I didn't read. The spectrum is a gradient of delegation, not of trust — every tier still ends with my name on the commit. ## References [1] IBM, "AI in software development," 2024. [Online]. Available: [https://www.ibm.com/think/topics/ai-in-software-development](https://www.ibm.com/think/topics/ai-in-software-development) [5] GitHub, "Quickstart for GitHub Copilot." [Online]. Available: [https://docs.github.com/en/copilot/quickstart](https://docs.github.com/en/copilot/quickstart) [6] "How to Become an Expert in AI-Assisted Coding," freeCodeCamp. [Online]. Available: [https://www.freecodecamp.org/news/how-to-become-an-expert-in-ai-assisted-coding-a-handbook-for-developers/](https://www.freecodecamp.org/news/how-to-become-an-expert-in-ai-assisted-coding-a-handbook-for-developers/) [7] Google, "Google Antigravity." [Online]. Available: [https://antigravity.google/](https://antigravity.google/) [8] Cursor, "Cursor Docs." [Online]. Available: [https://cursor.com/docs](https://cursor.com/docs) [9] Anthropic, "Claude Code Overview." [Online]. Available: [https://code.claude.com/docs/en/overview](https://code.claude.com/docs/en/overview) [10] IBM, "What are AI Agents?," 2024. [Online]. Available: [https://www.ibm.com/think/topics/ai-agents](https://www.ibm.com/think/topics/ai-agents) [11] IBM, "Prompt engineering techniques," 2024. [Online]. Available: [https://www.ibm.com/think/topics/prompt-engineering-techniques](https://www.ibm.com/think/topics/prompt-engineering-techniques) [12] "Model Context Protocol." [Online]. Available: [https://modelcontextprotocol.io/introduction](https://modelcontextprotocol.io/introduction) [13] "AI Agents or Skills? Why the Answer Is 'Both'," The New Stack. [Online]. Available: [https://thenewstack.io/ai-agents-or-skills-why-the-answer-is-both/](https://thenewstack.io/ai-agents-or-skills-why-the-answer-is-both/) ```quiz Q: Along what single axis do Copilot, Cursor, Claude Code, and AI agents differ? - Degree of autonomy — from suggestions the human applies, to goal-driven loops the agent pursues - Which programming language they support correct: 0 explain: The spectrum runs from low autonomy (Copilot: one suggestion, human applies) through editor-aware (Cursor: sees the project, acts on it) to agentic (Claude Code, agents: take a goal and execute many steps). Language support is orthogonal. Q: What shifts between driving Copilot and driving Claude Code? - With Copilot I drive and it suggests lines; with Claude Code I specify a task and review a multi-step diff — the unit of work moves from a line to a task - Nothing shifts; both are autocomplete tools correct: 0 explain: Copilot completes my typing — the unit is a line, I drive. Claude Code takes a goal and executes many steps — the unit is a task, the agent holds the keyboard for stretches, and my role moves to specifying and reviewing. Q: What is prompt engineering, and which tier does it apply to? - Crafting clear inputs (instructions, context, examples) to guide the model's output; it applies to every tier, from a Copilot comment to a Claude Code task description - A technique only for AI agents correct: 0 explain: The model is a next-token predictor that can't infer unstated intent. Clear specification improves output at every tier. Prompt engineering spans the whole spectrum — it's how I drive any tool on it. Q: What do MCP and skills provide, and why do they matter for high-autonomy agents? - MCP standardizes how agents call external tools; skills are the capabilities exposed — together they let agents act, verify, and iterate instead of only generating text - They are alternative language models competing with the LLM correct: 0 explain: An agent without tools can only generate text. MCP standardizes tool-calling format so any agent can use any tool; skills are the tool capabilities (query, search, deploy, test). With them, agents act deterministically and verify their own work — the foundation of high autonomy. Q: Why is the spectrum described as a gradient of delegation rather than trust? - Every tier still ends with my name on the commit; more autonomy means more careful review, not less verification - Higher autonomy means I can trust the agent fully and skip review correct: 0 explain: Delegating the work doesn't transfer the responsibility. More autonomous tools mean I review larger units (a whole task diff) with more care, not less. I never accept autocomplete unread or let an agent commit unsupervised — the verification obligation is constant. ```