How To Vibe Code With Inco

AI-assisted coding has crossed a threshold. Anyone can build an app, even those who aren’t technical; the only limiting factor is your imagination.

We want to make using AI tools with Inco as effective as possible. In order for developers to get the most out of using AI to build apps with Inco, there are a few things to keep in mind and a few extra tools you can leverage. We’ve put together a quick guide to getting started with using AI to build with Inco, including how to leverage the Inco MCP.

Vibe Coding With Inco 

Instead of treating the model as an external assistant that guesses at how to build with the protocol you’re trying to leverage, it’s best to give it as much context as possible. The best thing to do is plug your chosen AI tool directly into the developer environment. This means that you can issue prompts to outline what you want to build in natural language and your model will consult the relevant documentation. As the information models have about a protocol is patchy at best, often out of date as a result of its inclusion in its initial training, you need to make sure they’re consulting the right material. You probably wouldn’t want to build with a protocol without referencing its docs; your model isn’t well set up to do this either. 

If you’re using Claude Code or using an IDE with an Anthropic model, there’s an easy way to do this through MCP and Skills. If you’re using another tool, you need to make sure it has as much information as possible: try linking it to the Inco docs.

Now we’re going to go into some more depth about how to use AI tools with Inco, covering what MCP is and why it matters, how we’ve structured the MCP, and how to integrate it into an IDE (in this case, Cursor). Then, we’ll walk through how to create a confidential token contract without knowing how to write code. Cool!

What Is MCP?

MCP stands for Model Context Protocol. It is a standard for giving language models structured access to external context: codebases, documentation, tools, and runtime information.

Without MCP, a model only sees the prompt you type. It has no awareness of the SDK you’re using, the structure of your project, or the real function signatures in your libraries. It only has any related data that it’s picked up during training or the results of browser searches.

With MCP, the model can inspect SDK source code, look up documentation (provided by the protocol), and query external tools when needed.

In short, MCP turns a model from a text generator into a development collaborator that is aware of its environment.

Why Use MCPs?

If you use general-purpose models to write smart contracts, the failure mode is familiar. The model often produces code that looks plausible but subtly mismatches the SDK: wrong type names, nonexistent functions, outdated patterns, or incorrect imports. It’s likely that it’s referencing out-of-date information or can’t access it at all. Like a human building without docs access; it’s basically guessing.

MCP changes this dynamic by allowing the model to verify its assumptions against reality. Instead of recalling how a confidential mapping might be declared, it simply reads the declaration in the SDK. Instead of hallucinating a coprocessor call, it finds the real function signature. Instead of guessing folder layouts, it sees your actual project tree. The model’s output becomes anchored to your environment, not to its internal memory.

Inco MCP

The Inco MCP exposes the Inco development environment to MCP-compatible clients. It gives models access to the official documentation

This means the model does not need pre-existing knowledge of Inco but rather learns by reading the most relevant documentation. When you ask it to create encrypted storage or wire a confidential input into a contract function, it looks up the real patterns and reproduces them. The difference is reliability: instead of code that “sounds right,” you get code that is consistent with the actual framework version you are using.

The Inco MCP can be leveraged in Cursor or installed to use with Claude Code.

Integration With Cursor

Getting started with the Inco MCP in Cursor is easy.

‍

1. After creating the project directory, create a “.cursor” folder.
2. Within that folder, create a mcp.json file and enter the following JSON text:

{
 "mcpServers": {
   "Inco-mcp": {
     "url": "https://docs.inco.org/mcp"
   }
 }
}

Integration With Claude Code

To install the Inco MCP server to use with Claude code, follow these steps:

1. Enter this command into your CLI: claude mcp add inco-mcp --transport http https://docs.inco.org/mcp
2. You can verify it's configured by running: claude mcp list

You should be all set!

Example: Vibe Code a Confidential Token Contract

Now for an example. Open a fresh project in Cursor and write: “Create a confidential token contract for Base Sepolia (EVM) with encrypted balances and transfer functionality using Inco.” 

With the Inco MCP enabled, the model reads how confidential storage is declared, identifies the encrypted integer types, finds examples of coprocessor-based arithmetic, and assembles a contract where balances live as encrypted state and transfers are executed through confidential computation.

The model should build something like this:

And that’s it! You created a confidential token contract without writing a line of code. With the Inco MCP, the model can refer to the right documentation and has a great understanding of how to build. Now, you can try building any confidential application you want. Good luck!

Let us know how this approach works by joining the Inco Discord and posting your experience in the dev-chat channel.