home / skills / omer-metin / skills-for-antigravity / blockchain-defi

blockchain-defi skill

safe

This skill helps you design and review DeFi protocols and AMMs, grounding implementations in reference patterns, risk considerations, and secure integration

npx playbooks add skill omer-metin/skills-for-antigravity --skill blockchain-defi

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

1.1 KB

---
name: blockchain-defi
description: Use when building DeFi protocols, implementing AMMs, yield farming strategies, or integrating with Ethereum/L2s - covers smart contract patterns, liquidity pools, and security considerationsUse when ", " mentioned. 
---

# Blockchain Defi

## Identity



## Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

* **For Creation:** Always consult **`references/patterns.md`**. This file dictates *how* things should be built. Ignore generic approaches if a specific pattern exists here.
* **For Diagnosis:** Always consult **`references/sharp_edges.md`**. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
* **For Review:** Always consult **`references/validations.md`**. This contains the strict rules and constraints. Use it to validate user inputs objectively.

**Note:** If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Overview

This skill helps teams design, implement, and audit DeFi protocols on Ethereum and layer-2 networks. It focuses on AMM design, yield strategies, liquidity pool mechanics, and security-aware smart contract patterns. Use it to get actionable patterns, risk explanations, and objective validation checks tailored for production-grade DeFi.

How this skill works

I ground recommendations in three canonical sources: approved design patterns for building DeFi primitives, a catalog of sharp-edge failure modes that explain why critical bugs occur, and a strict validations list to review implementations. For creation tasks I prioritize the recommended patterns; for diagnostics I map observed behavior to known failure modes; for reviews I apply the validations as objective pass/fail criteria.

When to use it

Designing or iterating an AMM (curve, constant product, hybrid) or custom pool math
Implementing yield farming, vault strategies, or composable reward mechanisms
Integrating contracts across Ethereum mainnet and layer-2 rollups
Performing security diagnosis after abnormal behavior or exploit indicators
Conducting objective code reviews against strict validation rules

Best practices

Follow established patterns for token accounting and fee handling instead of ad-hoc logic
Model and test all edge-case flows (reentrancy, oracle manipulation, rounding) against known sharp edges
Keep validation rules deterministic and automatable to enable objective reviews
Minimize privileged roles; require multisig/time-locks for critical upgrades
Instrument pools with clear invariants and on-chain/off-chain alerts for deviation

Example use cases

Build an AMM variant: get the recommended pool math, fee model, and edge-case tests
Validate a vault strategy: run the validations checklist and map risky operations to failure modes
Investigate a suspected exploit: correlate tx traces with known sharp-edge signatures and priority fixes
Integrate L2 support: apply patterns for cross-chain messaging, bridging safety, and liquidity considerations

FAQ

How do you prioritize fixes after a security incident?

Map observed symptoms to the catalog of sharp edges, prioritize fixes that remove single points of failure and prevent FUND loss, then apply validations to confirm remediation.

Can you automate the review rules?

Yes. The validations are written as strict, automatable checks suitable for CI or static analysis tooling to produce objective pass/fail results.