Skip to content
Skills Library
Programming · Building & coding

alchemy-local-dev-loop

/alchemy-local-dev-loop

Establish a deterministic local EVM development loop with pinned forks, synthetic fixtures, and bounded Alchemy usage. Use when adding local chain tests or repairing flaky fork-based development. Trigger with "Alchemy local dev", "Hardhat fork with Alchemy", or "pin a mainnet fork".

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Establish a deterministic local EVM development loop with pinned forks, synthetic fixtures, and bounded Alchemy usage. Use when adding local chain tests or repairing flaky fork-based development. Trigger with "Alchemy local dev", "Hardhat fork with Alchemy", or "pin a mainnet fork".

Triggers from the description

Alchemy local devHardhat fork with Alchemypin a mainnet fork

Arguments

/alchemy-local-dev-loop <framework> <chain> <fork-block>
Original author description

Establish a deterministic local EVM development loop with pinned forks, synthetic fixtures, and bounded Alchemy usage. Use when adding local chain tests or repairing flaky fork-based development. Trigger with "Alchemy local dev", "Hardhat fork with Alchemy", or "pin a mainnet fork".

How it works

  1. Overview
  2. Prerequisites
  3. Current Contract
  4. Authentication
  5. Instructions
  6. Tool Discipline
  7. Approval Boundaries
  8. Error Handling
  9. Output
  10. Examples
Original SKILL.md headings · 68 lines, 582 words
SKILL.md preview
---
name: alchemy-local-dev-loop
description: >-
  Establish a deterministic local EVM development loop with pinned forks, synthetic fixtures, and bounded Alchemy usage. Use when adding local chain tests or repairing flaky fork-based development. Trigger with "Alchemy local dev", "Hardhat fork with Alchemy", or "pin a mainnet fork".
allowed-tools: Read,Glob,Grep,Write,Edit
argument-hint: "<framework> <chain> <fork-block>"
version: 2.0.0
license: MIT
author: Jeremy Longshore <jeremy@intentsolutions.io>
tags: [saas, alchemy, testing, hardhat]
model: inherit
effort: high
compatibility: "Designed for Claude Code; live Alchemy access requires network access, an appropriate credential, account capacity, and explicit approval"
---
# Alchemy Deterministic Local Development Loop

## Overview

Establish a deterministic local EVM development loop with pinned forks, synthetic fixtures, and bounded Alchemy usage. This workflow produces a reviewable artifact and negative-path evidence before any live side effect.

## Prerequisites

- Current first-party Alchemy documentation for the selected product, chain, feature, client, authentication method, limit, and lifecycle.
- Named product, application, security, data/privacy, budget, release, and operations owners appropriate to the requested scope.
- Synthetic or approved non-production fixtures, a credential canary, explicit success criteria, and a tested rollback boundary.

## Current Contract

A remote mainnet fork is reproducible only when the chain, block number, dependency versions, and fixture state are pinned. It still consumes account-level throughput and can diverge when historical access, method support, or upstream state is unavailable. Alchemy Sandbox is a separate simulation option and must be evaluated against the required test semantics.

## Authentication

Use a development-only app key from local secret injection. Never copy a production key or deployer private key into `.env`, task output, shell history, fixtures, or committed fork URLs.

## Instructions

1. Inventory the project's current Hardhat, Foundry, Anvil, or other EVM test runner and preserve its existing commands.
2. Confirm the target chain and historical method support, then select and record a stable fork block with the business reason for changing it.
3. Inject a development Alchemy endpoint through the established local secret mechanism and ensure configuration fails clearly when it is absent.
4. Use synthetic accounts and deterministic impersonation or funded fixtures; never import a real user or production signer.
5. Run the smallest fork test, a clean-room rerun, and an offline/unit fallback; record request volume and wall time without claiming a universal benchmark.
6. Document how to advance the fork block, refresh fixtures, distinguish provider drift from code failure, and restore the prior block.

## Tool Discipline

Use Read, Glob, and Grep to inspect current documentation, configuration, code, fixtures, and evidence. Use Write and Edit only for approved repository artifacts. Skill invocation alone does not authorize network access, credentials, wallet addresses, customer data, plan changes, spend, key creation or rotation, webhook changes, deployment, replay, transaction construction, signing, broadcast, or deletion.

## Approval Boundaries

The test owner approves the pinned state and fixture refresh. Security approves secret injection. Forking production state, using customer addresses, or funding a test signer requires data/security approval.

## Error Handling

- A latest-block fork that passes once is not deterministic evidence.
- If the historical block or method is unavailable, stop and classify the provider/test assumption rather than silently changing the block.
- A leaked endpoint is a credential incident even when the key is development-only.

## Output

Return the pinned chain/block/dependency matrix, redacted local configuration, deterministic fixtures, positive and clean-room test receipts, usage observation, drift procedure, and rollback. Mark assumptions, observations, source dates, environment-specific behavior, owners, and unresolved gaps explicitly.

## Examples

- Pin an Ethereum fork to the block needed by a contract regression and prove the same result in two clean runs.
- Compare a fork test with Alchemy Sandbox only after documenting which state mutation and tracing behavior the test requires.

## Validation

Exercise and record expected and observed results for:

- missing endpoint
- wrong chain ID
- unpinned block rejected
- fixture reset
- provider timeout
- offline/unit fallback

## Resources

- [Current first-party evidence map](references/official-docs.md) — recheck dated Alchemy sources before execution.
- Treat observed account, application, network, indexer, chain, or provider behavior as environment-specific evidence, never a universal guarantee.
Files in this package (2)
  • SKILL.md 5 KB
  • references/official-docs.md 3 KB

Versions

The database has no other skills named alchemy-local-dev-loop.

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 95b7e4fa9519 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100alchemy-ci-integration
    Gate Alchemy integration changes with deterministic unit, contract, fork, secret, and negative-path checks. Use when adding Alchemy to CI or hardening an existing pipeline. Trigger with "Alchemy CI", "Alchemy GitHub Actions", or "test Alchemy in CI".
  • 100alchemy-common-errors
    Classify Alchemy authentication, JSON-RPC, Data API, throughput, and partial-response failures before applying bounded recovery. Use when an Alchemy integration fails or degrades. Trigger with "Alchemy error", "Alchemy 429", or "debug an Alchemy request".
  • 100alchemy-webhooks
    Receive and verify Alchemy Notify webhooks. Use when setting up Alchemy webhook handlers, debugging X-Alchemy-Signature verification, or handling onchain events like ADDRESS_ACTIVITY, NFT_ACTIVITY, or GRAPHQL (Custom Webhook).
  • 100alchemy
    Alchemy is RPC and data-API infrastructure for EVM chains (World Chain, Unichain, Arc, Base, Ethereum and more). Use this skill when you need an Alchemy API key or RPC URL, viem/ethers on Alchemy, token balances, NFTs by owner, transfer/activity history…
  • 100alchemy-api
    Integrates Alchemy blockchain APIs using an API key. Requires $ALCHEMY_API_KEY to be set; if unavailable, use the alchemy-agentic-gateway skill instead. Use when user asks about EVM JSON-RPC calls, token balances, NFT ownership or metadata, transfer history, token prices,…
  • 96warp-fork
    Fork a warp route from the local HTTP registry for development and testing. Forks each chain with the right local node per protocol — anvil for EVM chains, surfpool (Solana mainnet fork) for Sealevel chains. Use when the goal is to simulate transactions on a set of local forks…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.