14 — AI Tools, Agents, and MCP — From Autocomplete to Autonomous

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.

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

[5] GitHub, "Quickstart for GitHub Copilot." [Online]. Available: 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/

[7] Google, "Google Antigravity." [Online]. Available: https://antigravity.google/

[8] Cursor, "Cursor Docs." [Online]. Available: https://cursor.com/docs

[9] Anthropic, "Claude Code Overview." [Online]. Available: https://code.claude.com/docs/en/overview

[10] IBM, "What are AI Agents?," 2024. [Online]. Available: 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

[12] "Model Context Protocol." [Online]. Available: 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/