How to Prompt Claude with Circle Skills to Build a Crosschain USDC App

Prompting an AI assistant often feels straightforward. You describe what you want to build, and it gives you something that looks usable. 

But once you move beyond small tasks, the gaps start to show. The prompt might be clear, but the implementation underneath it is not. There are still decisions to make around how the app should be structured, which tools to use, and what the right setup looks like.

This becomes more noticeable in workflows that span multiple systems. The assistant can generate something that looks correct, but the underlying approach may not be the most appropriate for the problem.

That is where Circle Skills become useful.

Circle Skills is an open-source library of specialized guidance for working with Circle products. It gives the assistant more than general product awareness. It provides decision frameworks, implementation patterns, and common pitfalls to avoid. Rather than leaving Claude to rely on generic coding patterns, Circle Skills give it reusable context for reasoning about Circle-specific workflows.

That matters because many of these workflows are not just about writing code. They involve choosing the right path from the start. A crosschain app might need to decide between CCTP and Gateway. An app that creates or manages wallets needs to determine which wallet model fits the use case, whether that is Dev-Controlled Wallets, User-Controlled Wallets, or Modular Wallets. Even a simple USDC integration can involve differences in how USDC is represented and how its contracts are handled across chains.

Circle Skills helps make those decisions clearer by giving the assistant better context for how these flows are typically implemented. Part of that value is helping the assistant avoid common mistakes up front, instead of improvising around product-specific edge cases.

This post walks through how to prompt Claude with Circle Skills to build a sample app that moves USDC from Ethereum Sepolia to Arc Testnet, and how the assistant is better positioned to choose a more appropriate implementation path for the transfer.

Installing Circle Skills

The first step is making Circle Skills available inside Claude Code. This is done by running the following plugin commands:

/plugin marketplace add circlefin/skills
/plugin install circle-skills@circle

These commands install Circle Skills so Claude can reference them during planning and code generation.

Prompting Claude with Circle Skills

With Circle Skills installed, the prompt can be as simple as asking Claude to use Circle Skills for the task:

Use Circle Skills to build a sample app that moves USDC from Ethereum Sepolia to Arc Testnet, using Dev-Controlled Wallets with one wallet created on each chain.

By explicitly asking Claude to use Circle Skills, the assistant can identify and invoke the relevant skills for the task. In this case, that included circle:bridge-stablecoin and circle:use-developer-controlled-wallets.

Project setup and dependencies

Claude initialized the project with the relevant dependencies for the workflow:

{
  "dependencies": {
    "@circle-fin/adapter-circle-wallets": "^1.2.0",
    "@circle-fin/bridge-kit": "^1.6.0",
    "@circle-fin/developer-controlled-wallets": "^10.1.0"
  }
}

These dependencies map directly to the app’s structure:

• @circle-fin/developer-controlled-wallets for wallet creation and management
• @circle-fin/bridge-kit for the USDC crosschain transfer flow
• @circle-fin/adapter-circle-wallets for connecting wallets to the transfer logic

Instead of building the flow around direct API calls or lower-level primitives, the assistant structured the app around Circle’s SDKs from the start. This avoids a more verbose implementation where each step of the workflow needs to be handled manually, and results in a cleaner, more maintainable code path.

Generated Structure

From there, Claude generated two scripts:

• create-wallets.ts: for creating wallets on each chain
• bridge-usdc.ts: for handling the USDC crosschain transfer

These map directly to the two main parts of the workflow: provisioning the wallets required for the transfer, and then executing the transfer itself.

Wallet setup: one wallet per chain

In create-wallets.ts, Claude creates a wallet set and provisions one wallet on each chain:

const sourceResponse = await client.createWallets({
  accountType: "SCA",
  blockchains: ["ETH-SEPOLIA"],
  count: 1,
  walletSetId,
});

const destResponse = await client.createWallets({
  accountType: "SCA",
  blockchains: ["ARC-TESTNET"],
  count: 1,
  walletSetId,
});

This reflects the structure of the transfer. Since the app moves USDC across chains, it needs a source wallet on Ethereum Sepolia and a destination wallet on Arc Testnet.

Instead of managing private keys directly, the flow uses Dev-Controlled Wallets with Smart Contract Accounts. This keeps the wallet setup aligned with how applications typically manage accounts in production, rather than introducing additional complexity at the key management layer.

Crosschain transfer: using Bridge Kit

In bridge-usdc.ts, the transfer itself is handled through Bridge Kit:

const result = await kit.bridge({
  from: {
    adapter,
    chain: "Ethereum_Sepolia",
    address: sourceAddress,
  },
  to: {
    adapter,
    chain: "Arc_Testnet",
    address: destAddress,
  },
  amount,
});

Instead of implementing the full crosschain flow manually, the assistant uses Bridge Kit to abstract the process into just a few lines of code. Bridge Kit wraps the underlying CCTP flow into a higher-level interface, allowing the app to focus on the transfer itself rather than coordinating each step individually.

This is another example of choosing the right level of abstraction. A lower-level implementation would require handling each stage of the transfer explicitly, which adds complexity without improving the outcome for a sample app like this.

Making the transfer flow visible

The script also logs each step of the transfer lifecycle:

kit.on("approve", (payload) => {
  console.log("[approve]", payload.values.txHash);
});

kit.on("burn", (payload) => {
  console.log("[burn]", payload.values.txHash);
});

kit.on("fetchAttestation", () => {
  console.log("[attestation] received");
});

kit.on("mint", (payload) => {
  console.log("[mint]", payload.values.txHash);
});

This makes the flow easier to follow end-to-end:

• Approve
• Burn
• Fetch attestation
• Mint

Rather than hiding the process behind a single function call, this makes each stage visible, which is especially useful when understanding or debugging crosschain flows.

What this shows

The interesting part of this flow is not just that the assistant can generate working code, but how the implementation is shaped by the context it has. With Circle Skills, the assistant is not starting from general knowledge alone. It can reason from more appropriate patterns for wallets, crosschain transfers, and how Circle products fit together, and that shows up directly in the choices it makes.

In this example, that meant using Dev-Controlled Wallets for the wallet layer and relying on Bridge Kit instead of a lower-level implementation for the transfer flow. Those choices lead to a cleaner structure, more appropriate abstractions, and less time spent figuring out the right path, especially in workflows that involve multiple systems.

Try it out

Circle Skills is open source and available to use with Claude and other supported clients. Install the skills, prompt Claude with your own use case, and see how the implementation changes as you refine the prompt.

Explore the repository: https://github.com/circlefin/skills

‍

_{Circle Technology Services, LLC (“CTS”) is a software provider and does not provide regulated financial or advisory services. You are solely responsible for services you provide to users, including obtaining any necessary licenses or approvals and otherwise complying with applicable laws. For additional details, please click here to see the Circle Developer terms of service.} 

_{USDC is issued by regulated affiliates of Circle. See Circle’s list of regulatory authorizations.}

_{Arc testnet provided by Circle Technology Services, LLC, a software provider. Not a financial or advisory service. Not reviewed or approved by NYDFS. Users responsible for their own compliance. See arc.network for more.}