Agent task recipes

Copyable prompts for AI agents working with GitMyABI.

Build with AI

Recipes are copyable prompts you can paste into an AI agent for a specific task. Skills are reusable instructions an agent loads once; recipes are task-specific prompts you paste in when you need a particular piece of work done.

If the GitMyABI MCP server is configured, prefer it — agents can call GitMyABI tools directly. Without MCP, agents should rely on the docs, the build detail page, and information you paste in.

Rules for every recipe

  • Do not invent contract addresses, networks, package names, or registry URLs.
  • Do not invent CLI flags, environment variables, or MCP tool names.
  • Ask the user for missing deployment details instead of guessing.
  • Treat API keys and install URLs that contain keys as sensitive.

1. Add generated bindings to a frontend

Use when: The user wants typed contract calls in a frontend app.

Copyable promptprompt
Task: add GitMyABI generated TypeScript bindings to my frontend.

Constraints:
- Prefer GitMyABI generated TypeScript bindings if a bindings package is available for the contract.
- Use the package name and version shown on the GitMyABI build detail page. Do not invent a package name or version.
- Install the package with the project's package manager.
- Wire the generated contract class into the frontend using the user's chosen web3 library (viem, ethers, wagmi, etc.).
- Ask me for the contract address and the network/chain ID if I have not provided them. Do not invent deployment addresses.
- Do not assume GitMyABI provides a complete frontend. Only the typed bindings come from GitMyABI.

If the GitMyABI MCP server is configured, use it to look up the project, build, and bindings package. Otherwise use the build detail page output I provide.

Reference: Generated contract bindings · Use generated bindings in a frontend

2. Use ABI JSON from the CDN

Use when: The user wants a lightweight integration without generated TypeScript bindings.

Copyable promptprompt
Task: integrate a contract using the ABI JSON hosted on the GitMyABI CDN.

Constraints:
- Fetch the ABI JSON from the CDN URL shown on the GitMyABI build detail page. Do not invent a CDN URL.
- Create a contract instance with the user's chosen web3 library (viem, ethers, web3.js).
- Ask me for the contract address and the network/chain ID if I have not provided them. Do not invent deployment addresses.
- Recommend GitMyABI generated TypeScript bindings instead if the user wants compile-time type safety.
- Do not assume GitMyABI performs on-chain calls. The app code performs the calls.

If the GitMyABI MCP server is configured, use it to look up the build artifacts. Otherwise use the URLs I paste from the build detail page.

Reference: Contract ABI · Package format

3. Verify GitMyABI package integration

Use when: Reviewing a codebase that already uses GitMyABI outputs.

Copyable promptprompt
Task: review this codebase's GitMyABI integration.

Constraints:
- Inspect imports and usages of any GitMyABI generated bindings package.
- Check that the package name and version match a real GitMyABI build for the project. Do not assume a version.
- Verify there is no hardcoded placeholder API key (for example a literal "gma_sk_REPLACE_ME") and no fake contract address.
- Verify that contract addresses come from configuration, deployment metadata, or user input — not from constants invented by an earlier agent.
- Report any missing project ID, build ID, package name, or contract address that the integration depends on.
- Do not modify on-chain logic to compensate for missing deployment data. Ask me for the missing values instead.

Reference: Package format

4. Set up GitMyABI MCP for an IDE

Use when: The user wants GitMyABI available as MCP tools in their IDE or agent.

Copyable promptprompt
Task: set up the GitMyABI MCP server in my IDE or agent.

Constraints:
- Use the documentation at /docs/build-with-ai/mcp as the source of truth.
- Use my own GitMyABI API key. Do not paste any key from documentation examples.
- Treat install URLs and deeplinks that contain an API key as sensitive — do not log them, commit them, or share them.
- Do not invent client-specific commands (for example for Claude Code or Codex) that are not documented. Use the manual JSON config when a client-specific command is not source-backed.
- After setup, verify the connection by listing tools through the MCP client. Do not invent tool names.

Reference: MCP Server

5. Use the GitMyABI CLI in CI

Use when: The user wants a scripted or CI workflow.

Copyable promptprompt
Task: use the GitMyABI CLI in a CI workflow.

Constraints:
- Use only commands and flags documented at /docs/cli and the GitHub Action documentation. Do not invent flags.
- Use environment variables documented in /docs/cli/environment-variables. Do not introduce new environment variables.
- For publishing, use the documented npm token environment variable rather than embedding tokens in the workflow file.
- Prefer a dry-run / preview step where the CLI documents one. If no dry-run is documented, do not invent one.
- If the workflow needs a project ID, build ID, or package name that I have not provided, ask me — do not guess.

Reference: CLI overview · CI and GitHub Action

Related

  • MCP Server

    Connect MCP-compatible AI clients (VS Code, Cursor, Kiro, Claude Code, Codex) to GitMyABI.

  • Skills

    Reusable agent instructions for using GitMyABI correctly.

  • Start

    Pick the right GitMyABI path for AI-assisted development.

  • CLI overview

    What the gma CLI does and when to use it.

  • CI and GitHub Action

    Run gma generate and publish from CI using the official GitHub Action.

  • Generated contract bindings

    TypeScript packages produced from contract ABIs for typed integration.