Building an AI-Native Ethereum Developer Stack

For years, we've been building our dev tools and learning materials primarily for humans. Docs explained what our toolkit did. We taught developers with guided, hands-on experiences. Extensions shipped as mergeable code.

But we're finding that this model gets a bit clunky when an AI agent is driving the keyboard.

Instead of just asking "how do we add AI to our tools" we started asking ourselves: what would our stack look like if we treated the AI as a primary user alongside the developer?

For us, that meant rethinking some of our core primitives rather than just patching on new features. We've been doing exactly that across our dev toolkit (Scaffold-ETH 2) and our Solidity curriculum (Speedrun Ethereum). The Sand Garden, an intentional team within BuidlGuidl, is executing this vision.

Here is a look at how we're restructuring our own Web3 stack for this shift.

Structuring Docs for Agents

We removed Cursor rules from Scaffold-ETH 2 and replaced them with AGENTS.md.

Cursor rules only work in Cursor. AGENTS.md is picked up by Claude Code, Cursor, Windsurf, and any other agent harness. One file, every tool. Every conversation starts with the full stack context already loaded.

In these new workflows, we're noticing the main consumer of our docs is often an agent loading context before writing code. So we shipped llms-full.txt: the entire SE-2 documentation as a single flat file. Not a website. A file an agent loads into context and reasons against.

It's the exact same information, just formatted for how an AI actually consumes it.

Swapping Complex Code for AI Skills

Adding a Scaffold-ETH extension used to mean resolving package.json conflicts through hundreds of lines of template processing code.

We replaced it with /add-extension: a simple agent skill built to work across different harnesses. Node.js handles the deterministic operations (fetching, copying), while the AI handles the judgment calls (merging). Hundreds of lines of template code became a markdown file and a focused script.

Same pattern for developer workflow. Our pr-create skill is a markdown file that tells an agent how to inspect the diff, format the PR body, and open it via gh. No custom script. No alias. Just context.

We've started stripping out custom scripts wherever we find that a model just naturally handles the task better.

Rethinking How We Teach

Speedrun Ethereum is how many developers learn to build on Ethereum. We're rebuilding the learning layer to the same standard.

Per-challenge context files. Each challenge gets an AGENTS.md detailing the challenge overview, smart contract structure, and frontend architecture. When a learner opens a challenge in their IDE, the agent already knows the environment.

AI Teacher Mode. Type /start in the directory and an agent walks you through it. It asks questions, checks your understanding, guides you without giving the answer away, and reviews your code at your pace.

Build ideas are also migrating. Old format: a GitHub repo link. New format: a prompt you paste into your agent. The agent reads context and starts building with you.

The Research Layer

The agent ecosystem shifts weekly. That's why we aren't assembling heavy wrappers. We need to understand the raw primitives so we can adapt the moment a new paradigm drops.

raked is a minimal TypeScript agent built for exactly this: the agent loop, sessions, memory, tools, skills. It's under 100 lines for the core. Built to be read, understood, and extended to solve your specific use cases.

Alongside it: an experimental RAG pipeline on Arbitrum DAO governance data. Vector search via pgvector, retrieval via LlamaIndex, automated evaluation scoring Faithfulness, Relevancy, and Correctness.

We built both because we really wanted to understand the underlying mechanisms before building heavier tools on top of them.

Figuring Out the Boundaries

Security stays deterministic. Wallet interactions, transaction signing, and key management require hard boundaries. An agent making onchain transactions autonomously is an attack surface. That problem isn't solved yet.

But code review is a perfect fit for AI judgment.

Take Grumpy Carlos: a Claude Code subagent with a review personality inferred from scraped BuidlGuidl PR history. Drop it in .claude/agents/, ask for a review, and it responds exactly the way Carlos would: specific, strict, no vague feedback.

The right context, structured for an AI to use, produces better output than general AI applied to problems without context.

The Compounding Effect

To us, this is what going "AI-first" actually looks like in practice. It's not just dropping a Copilot plugin into Scaffold-ETH. It's a stack where every layer—the framework, the docs, the extensions, the curriculum—is structured to be used by an agent, not just tolerated by one.

An agent building with SE-2 understands the stack. An agent teaching on Speedrun Ethereum understands the challenge. With /add-extension the agent can install new capabilities without leaving the conversation.

Next up: an open-source plugin that packages all of this into one installable toolkit for Claude Code, OpenCode, and Cursor.

Try It Today

The PRs are open and the code is live. If you're building at the intersection of AI and Ethereum:

• —Start with raked: Read the agent loop. Understand what a tool call actually is before building on top of abstractions.
• —Look at Scaffold-ETH 2: See the AGENTS.md and /add-extension skills in progress. Build your first Dapp with it and your favourite agent.
• —Try the AI challenges: Available on Speedrun Ethereum as they ship.