The Next Evolution in AI-Powered Coding

Understanding MCP and the Future of AI-Driven Development

New AI models are released every couple of weeks, but what's genuinely transforming AI's coding capabilities?

Is it simply larger models, or is there something more significant on the horizon? Let's explore MCP and how you can use it today with Claude Code and Cursor. But first, let's review recent developments.

AI Recap

Here's an overview of recent developments in AI, though this list isn't exhaustive given the field's rapid pace:

• Claude 3.7 Sonnet: A reasoning model, continuing its position as one of the strongest coding LLMs. Along with it came Claude Code, a command-line coding agent.

• Gemma 3: Google released their open-source model that handles both text and images.

• Gemini 2.5: Google's reasoning model that outperforms Claude 3.7 in some areas while being faster and more cost-effective.

• GPT 4.5: OpenAI's latest release, focusing on more human-like responses.

• LLama 4: Meta's open-source model similar to DeepSeek R1. It uses specialized expert models, making it efficient on smaller machines. As a multimodal model, it handles various input types, and one variant features a massive 10M context window.

We can expect new models from other vendors like Mistral in the coming weeks.

The key advancement is the shift toward two capabilities:

• Reasoning models: Break down tasks into smaller steps before generating results

• Multimodal processing: Handle more than just text—including images, videos, and speech

MCP

Model Context Protocol is a new protocol that connects applications with LLMs. For developers, it's like REST or SOAP, which defined how we connect applications together—but now between applications and AI. If you're not familiar with REST or SOAP, think of USB-C, a standard that defines how to connect to a device, except in this case, we're connecting to an LLM.

Why do we need that? While LLMs are powerful, they lack interactive capabilities to help us in everyday work. MCP changes that. Consider how an LLM could now control any application you use.

Just look at this LinkedIn post showing how an LLM controls Blender to create a 3D model.

MCP is a standard developed by Anthropic, the creator of the Claude models. It has taken the internet by storm and has become the de facto standard—even OpenAI has embraced it after its own more complex model didn't gain traction.

Architecture MCP

MCP defines a client that lets users interact with MCP servers via the MCP protocol. These servers connect to local or remote applications, data sources, or anything else.

Architecture diagram of MCP taken from https://modelcontextprotocol.io/introduction

For more information, check out a sample MCP server like the one for kubectl https://github.com/Flux159/mcp-server-kubernetes.

Available SDKs include:

• Python

• TypeScript

• Java

• Kotlin

• C#

Learn more at https://modelcontextprotocol.io/introduction.

What is the impact on coding?

Let's revisit how MCP changes coding. Consider frontend development as an example. With the Playwright MCP, an LLM can verify if your application looks and behaves correctly during development. LLMs can also be enhanced with thinking MCPs and web search capabilities, allowing them to consider a broader context when solving problems beyond the immediate request. While conveying how this transforms AI interaction is challenging, I encourage you to experience it firsthand.

Model capabilities remain crucial, and for coding, I currently recommend only Claude 3.7 and Gemini 2.5.

Several MCP clients are available today, including:

• Claude Desktop

• Claude Code

• Cursor

• Cline

• Windsurf

Let's explore how to connect two of these—Claude Code and Cursor—to essential MCPs.

Claude Code

Claude Code is a CLI tool exclusively connected to the latest Claude models. Instead of a subscription, you pay per token. While expensive, you get access to the full models. Many subscription-based IDEs limit the context window to reduce costs. Using Claude Code helps you understand the potential expenses—you could easily spend $50 in just a few hours.

Cursor

Cursor uses a subscription model and connects to multiple models, including Claude 3.7 and Gemini 2.5. You can pay an additional fee per usage for access to the full model (called MAX in Cursor).

Recommended MCP Installation

Here are the essential MCPs I recommend for optimizing your workflow:

• Brave Search - requires an account, which includes 2,000 free search queries

• Fetch - An LLM-optimized tool that converts HTML pages to Markdown. Works great alongside Brave MCP, enabling the LLM to search the internet and analyze results.

• Sequential-thinking - Enhances reasoning models with structured, reflective problem-solving capabilities. Highly recommended for its additional layer of analysis.

• Playwright MCP - Created by the Playwright team, this MCP enables browser control and screenshot capabilities for visual verification. Particularly useful when fetch fails to retrieve web content.

Below, I'll share the Cursor global MCP config file. Note that Claude Code uses a different configuration method—you can search for it or ask Claude directly.

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR-API-KEY"
      }
    },
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest",
        "--vision"
      ]
    },
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ]
    }
  }
}

LLM model and prompt recommendation

I currently use both Claude 3.7 and Gemini 2.5 Pro for my work. These models are versatile and integrate seamlessly with MCPs.

When writing prompts, always remind the LLM about available MCPs. For example, a typical command entry prompt might be

Use MCP sequential-thinking, playwright, brave-search and fetch to fix this.  

Then, describe the issue you want to solve and how to implement it. If you're running your application locally, provide the URL (e.g., localhost:3000).

Important advice: don't become complacent. Even when AI handles the heavy lifting, you must think strategically and plan. Your job shifts from coding to defining what you want to solve and how to solve it. Remember that LLMs aren't good at understanding your goals and intentions.

Context is key. You can provide this in Claude Code by describing your requirements in a CLAUDE.md file, while Cursor uses Project Rules. These files should detail the following:

• Your tech stack

• Exactly what technologies to use

• Development strategies (like avoiding version downgrades and writing tests)

While the AI won't follow every guideline perfectly, it generally tries to stay within the specified parameters.

Quality Control: To ensure AI-generated code quality, use linting, type checking, formatting checks, and tests. However, don't disengage—review what the AI writes and intervene if it takes a wrong turn. Refine your prompts, write code yourself when needed, and think through how you want problems solved before involving the AI.

This process resembles traditional coding, except someone else writes the code. It's similar to the role of an architect or anyone who describes what needs to be done. It's no surprise that people skilled at describing problems and possible solutions excel at using LLMs.

Using this approach, I achieve manageable results. However, I'm skeptical about using it to write production code for large applications—unless your codebase is AI-friendly, meaning it uses common languages, frameworks, and architecture that AI can easily understand.

But this landscape is rapidly evolving, and changes have happened faster than anticipated. Let's see where we stand by the end of this year.

Key Takeaways

The AI development landscape is experiencing rapid transformation, driven by two key factors:

• The emergence of increasingly sophisticated models like Claude 3.7 and Gemini 2.5, which excel at reasoning and multimodal tasks

• The Model Context Protocol (MCP) revolutionizing how we interact with AI by enabling LLMs to control applications directly

For developers, this means:

• A shift from writing code to architecting solutions and crafting precise prompts

• The need to maintain active engagement and oversight of AI-generated code

• The importance of creating AI-friendly codebases using common technologies and clear architecture

While these tools show immense promise, they require thoughtful implementation and a clear understanding of their capabilities and limitations. The key to success lies not in complete reliance on AI but in learning to collaborate effectively with it while maintaining human oversight and strategic thinking.