🧠 Lead Agents with Prompts

Reviewing Andrej Karpathy’s definition of "vibe coding", I think he captured a new "hands-free" way of building with LLMs.

AI Coding Tools like Cursor and GitHub Copilot’s Agent Mode are bringing that vision to life—turning the IDE into a collaborative, autonomous workflow engine powered by protocols like MCP.

In this post, we’ll explore how features like MCP, NES, and customizable agents are driving a new wave of intelligent, agentic development across modern AI Coding Tools such as:

• Visual Studio Code

• Cursor - The AI Code Editor

• Claude Code

• OpenAI Codex CLI

We’ve been playing with AI completing snippets or suggesting one-liners. Agent Mode goes further—it’s closer to working with a smart developer who can write, run, and even fix things. Whether inside the IDE or through CLI tools like Claude Code or OpenAI Codex, it’s the closest we’ve gotten to truly collaborative AI in the development workflow.

So what does Agent Mode really do?

• Writes code — Think full files, not just lines. You feed it intent, it returns structure.

• Iterates — It reviews its own output and revises.

• Executes commands — From installing dependencies to scaffolding projects.

• Self-corrects — When it fails (e.g., bad lint or broken build), it often recovers on its own.

It can plan, execute, and react. That’s not a glorified copilot—that’s autonomous task flow.

🧠 The Real Engine: Model Context Protocol (MCP)

Let’s talk architecture. Agent Mode’s capabilities are powered by MCP, and if you’re a builder, this is the rabbit hole you want to go down.

What Makes MCP Essential for You

• MCP Servers

Value: You can build custom, domain-specific agents that interact with your company’s internal tools or data. The community already supports 1,000+ MCP servers: modelcontextprotocol.io

🔗 What is MCP?

• (MCP) in Copilot Studio

• Add and MCP Server

MCP is an open protocol for feeding LLMs with structured, real-world dev context.

Think of it like what LSP (Language Server Protocol) did for syntax and intellisense—MCP does for AI agents.

• It standardizes how tools like VS Code provide context to AI models.

• It connects your AI not just to code, but to:

  • Figma designs.
  • Internal wikis.
  • GitHub repos.
  • Databases.
  • APIs.

🌱 Why Should You Care?

Because with MCP, you can build custom agents that:

• Understand your product domain.
• Use internal tools.
• Access backend APIs or datasets.
• Help teammates onboard faster.

And with it being just HTTP or std I/O, developers are shipping servers for everything: modelcontextprotocol.io

🛠️ How to Plug MCP Into Your Stack

Getting Started

• Add an MCP server (e.g. GitHub) to your workspace using .vscode/mcp.json or via VS Code's Command Palette.

• Install methods range from Docker to Python CLI wrappers.

Security Improvements

MCP started with JSON env var keys (yes, the usual papercut). But we’re moving toward:

• Secure input variables inside VS Code.

• OAuth-enabled remote MCP servers.

• Less friction, more security.

Example: GitHub MCP Server

It allows Agent Mode to:

• Create repos.
• Open pull requests.
• Search issues.
• Manage branches.

Everything works via natural language. You can literally type:

"open a PR with changes from main to staging"

…and it’ll handle it.

Building Your Own Server?

It’s easier than you think. SDKs exist for:

• Python (my go-to)
• Node
• Go
• C#

Wrap your internal logic or APIs, write solid descriptions, and boom—you’ve got a tool your Agent can invoke. Test locally with tools like mcp-inspector.

💬 Agent Mode Features Worth Using Daily

Unified Chat Modes

One chat window, three gears:

• Ask Mode: Like Stack Overflow meets your context.

• Edit Mode: Tightly scoped changes to known files.

• Agent Mode: All tools, full workspace, terminal, and file edits unlocked.

Switch freely mid-convo:

• Plan in Ask.

• Execute in Agent.

Powerful Context Tags

• #codebase: Grants search across files.
• #file: Targets specific files.
• #fetch: Pull in web content.

You can also drag and drop code, images, or datasets into the chat window.

Prompt Files

Save reusable .prompt.md files inside .github/prompts/ to standardize workflows, like scaffolding components or writing tests with mocks.

Interact with Changes

• Keep — Approve generated diffs.

• Undo/Redo — Navigate iterations.

• History — All sessions saved.

• Compact Chat Window — Keep the convo in your flow, not your face.

Tool Permissions

Agent Mode asks before running tools. Grant:

• Per tool.

• Per session.

• Per workspace.

• Or globally (not recommended for the careless among us).

📓 Jupyter Notebook Integration

• Jupyter Notebooks

Agent Mode + Jupyter = 🔥

• Auto-setup environments with uv.
• Fix import errors via built-in terminal actions.
• Explain outputs or improve charts.
• Generate entire notebooks from scratch via prompt.

Try: “Create a notebook to analyze Titanic dataset” and watch the structure roll in.

🧠 Next Edit Suggestions (NES)

• Next Edit Suggestions

This is inline magic. NES predicts the next logical change as you edit.

Examples:

• Rename Point to Point3D? NES adds the z-axis logic.
• Add get_max after get_min? NES updates your comparator.
• Misspell const? NES fixes it.

Press Tab to accept, Esc to skip. It’s contextual, real-time, and fast.

🔧 Model Customization & BYOK

You’re not locked into GPT-4.

Agent Mode supports:

• OpenAI (03, 04 Mini, 4.1).
• Claude.
• Gemini.
• Ollama (local LLMs!).
• Anthropic, OpenRouter, Azure, and more...

Plug in your own API keys (BYOK) and experiment. Some models don’t support tool calling—so test before going all in.

Bonus: .github/copilot-instructions.md

• Copilot Customization

Standardize your LLM behavior:

• "Always write unit tests"
• "Use React hooks"
• "Don’t use for-loops"

codeGeneration.instructions.file

Also, auto-include certain files (like schema.sql) using codeGeneration.instructions.files in your workspace.

🔭 Looking Ahead: Project Padawan

This is the asynchronous agent future—running directly on GitHub.com.

How It Works:

• Assign an issue to Copilot.

• It works in the background via GitHub Actions.

• Opens a PR with a proposed fix.

• You review + comment → it iterates.

Imagine automating your backlog, onboarding smart tasks, or killing tech debt without opening VS Code.

🧩 My Dev Recommendations

• Context matters: Better input = better output.

• Break down work: Guide the agent like you would a smart dev.

• Use NES: Inline intelligence that complements completion.

• Explore MCP: Build agents tailored to your stack.

• Experiment with models: BYOK is a playground.

• Always commit: Let Git be your safety net.

• Stay curious: This space is moving fast—ride the wave.

Agent Mode is the real deal. It’s not just about AI writing lines of code—it’s about building with you. And with MCP, NES, and customizable tooling, it’s evolving into something that can actually improve how we build, collaborate, and ship.

I’ve already made it part of my dev workflow—and honestly, I don’t want to go back.

Let’s Chat

• What tool would you wrap into an MCP server?

• What’s your favorite Agent Mode use case?

• Tried Padawan yet?