DEV Community: dead1786

I Built 3 Tools to Stop My AI from Being a Yes-Man (and forgetting everything)

dead1786 — Sun, 22 Mar 2026 04:43:17 +0000

The Problem

If you use Claude Code (or any AI coding assistant) seriously, you've hit these:

Your AI agrees with everything you say. You challenge it, it immediately surrenders. No pushback, no analysis — just "you're right, sorry."
Your AI asks instead of doing. "Want me to fix that?" Just fix it. You told it to.
Your AI forgets things after context compression. Important context evaporates. Old memories pollute new decisions. There's no cleanup.
Your AI keeps making the same mistakes. You correct it, it says "I'll do better," then does the exact same thing tomorrow.

These aren't bugs. They're structural problems with how AI assistants work. And prompts in CLAUDE.md don't fix them — they get ignored after the first compact.

The Fix: Code, Not Prompts

We built three tools that solve these problems with actual enforcement — Python scripts you drop in and forget.

1. Self-Guard (PreResponse Hook)

A hook that intercepts your AI's response before it reaches you and detects bad behavior patterns:

Mode F: Ask instead of do — Catches "want me to...?", "shall I...?" and injects a correction
Mode G: Acknowledge without action — User says "change X to Y", AI says "got it" but never touches a file
Mode E: Sycophancy — User challenges, AI immediately surrenders without evidence
Passive deferral — "I'll do that tomorrow" with no concrete plan

It's a PreResponse hook, meaning it runs before the response is finalized. The AI gets a system warning and has to fix its own output. Physical enforcement, not wishful thinking.

Fully configurable via JSON — add your own patterns, disable modes you don't care about, works in English and Chinese out of the box.

2. Memory GC (Lifecycle Manager)

Your AI's memories should have an expiry date. This tool manages the full lifecycle:

Add memories with type, importance, and automatic TTL
Garbage collect expired memories on schedule
Deduplicate similar memories (with CJK-aware similarity matching)
Promote frequently-accessed memories from temporary to permanent
Validate for contradictions and injection patterns

Default TTLs: context (14 days), preferences (30 days), progress (7 days), insights (21 days). Importance multipliers extend or shorten TTL automatically. Access count extends lifetime.

No vector DB needed. No pip dependencies. One Python file.

3. Pitfall Tracker (Learn From Mistakes)

Track AI mistakes systematically instead of hoping "I'll try harder" works:

The magic is in the escalation logic:

3 occurrences -> tagged — this isn't a one-off
5 occurrences -> tagged — suggested for CLAUDE.md hard rules
8+ occurrences -> — the AI can't fix this alone

Run to auto-generate improvement items from recurring patterns. Track resolution. Measure your AI's actual improvement rate with .

Quick Start

Self-Guard:

Memory GC:

Pitfall Tracker:

Background

These tools were built while running a team of 7+ AI agents 24/7 across multiple terminals. Every tool exists because we hit the problem repeatedly and prompts didn't fix it.

Self-guard came from an AI that said "want me to...?" hundreds of times despite being told not to
Memory GC came from context pollution after months of accumulated memories with no cleanup
Pitfall tracker came from the same mistakes appearing in nightly reflections week after week

If your AI keeps agreeing with you, keeps forgetting things, or keeps making the same mistakes — these tools are for you.

Zero dependencies. Python 3.8+. MIT licensed.

GitHub: permafrost-tools

Grid Trading Bot: Earn While the Market Goes Sideways

dead1786 — Sat, 21 Mar 2026 06:00:36 +0000

How to profit from cryptocurrency price oscillation with zero directional bias.

The Problem with Directional Trading

Most traders try to predict if prices go up or down. They're wrong about half the time.

Grid trading doesn't care about direction. It profits from movement itself — every oscillation within a price range triggers a buy-low-sell-high cycle automatically.

How Grid Trading Works

Imagine BTC is trading between $80,000 and $90,000. You set up a grid:

$90,000  ──── sell ────
$89,000  ──── sell ────
$88,000  ──── sell ────
$87,000  ──── sell ────  ← price here
$86,000  ──── buy  ────
$85,000  ──── buy  ────
$84,000  ──── buy  ────
$83,000  ──── buy  ────
$80,000  ──── buy  ────

Below current price: limit buy orders
Above current price: limit sell orders
When a buy fills: immediately place a sell one grid above
When a sell fills: immediately place a buy one grid below

Every completed buy→sell cycle earns one grid's worth of profit. The more the price bounces, the more you earn.

The Math

With $200 invested in a 15-grid BTC setup ($80K-$92K range):

Grid spacing:  $800 per grid
Per-grid profit: $800 / $86,000 = 0.93%
After fees:     0.93% - 0.18% = 0.75% net per cycle
Dollar profit:  $13.3 × 0.75% = $0.10 per cycle

In a ranging market (3-5 grids trigger daily):
Daily:  $0.30 - $0.50
Monthly: $9 - $15 (4.5% - 7.5% monthly return)

Compare this to a savings account at 2% per year.

Setting Up on OKX

OKX has a built-in grid trading bot. You can also use their API:

import hmac
import hashlib
import base64
import json
import time
import urllib.request

API_KEY = "your_key"
SECRET = "your_secret"
PASSPHRASE = "your_passphrase"
BASE_URL = "https://www.okx.com"


def sign_request(timestamp, method, path, body=""):
    message = timestamp + method + path + body
    signature = hmac.new(
        SECRET.encode(), message.encode(), hashlib.sha256
    )
    return base64.b64encode(signature.digest()).decode()


def create_grid_bot(symbol, lower, upper, grid_count, investment):
    """Create a spot grid trading bot on OKX."""
    path = "/api/v5/tradingBot/grid/order-algo"
    body = json.dumps({
        "instId": symbol,          # e.g., "BTC-USDT"
        "algoOrdType": "grid",     # spot grid
        "maxPx": str(upper),       # upper price bound
        "minPx": str(lower),       # lower price bound
        "gridNum": str(grid_count),
        "quoteSz": str(investment), # USDT to invest
        "runType": "1",            # 1 = auto
    })

    timestamp = datetime.utcnow().isoformat(timespec="milliseconds") + "Z"
    signature = sign_request(timestamp, "POST", path, body)

    headers = {
        "OK-ACCESS-KEY": API_KEY,
        "OK-ACCESS-SIGN": signature,
        "OK-ACCESS-TIMESTAMP": timestamp,
        "OK-ACCESS-PASSPHRASE": PASSPHRASE,
        "Content-Type": "application/json",
    }

    req = urllib.request.Request(BASE_URL + path, data=body.encode(), headers=headers)
    resp = urllib.request.urlopen(req, timeout=10)
    return json.loads(resp.read())

Optimal Parameters

The key parameters and how to choose them:

1. Price Range (Upper/Lower Bound)

Look at the 30-day high and low
Add 5-10% padding on each side
Too narrow = price breaks out, grid stops working
Too wide = each grid earns too little

2. Grid Count

More grids = more frequent trades, smaller profit per trade
Fewer grids = less frequent, larger profit per trade
Rule of thumb: each grid's profit should be at least 3x the trading fee
For OKX (0.1% taker fee): minimum grid spread > 0.6%

3. Investment Amount

Minimum ~$10 on OKX
$100-300 is a practical starting point
Capital is split equally across all grids

Quick Formula

def calculate_grid(capital, current_price, volatility_30d):
    """Calculate optimal grid parameters."""
    # Range: 1.5x of 30-day volatility
    range_size = current_price * volatility_30d * 1.5
    upper = current_price + range_size / 2
    lower = current_price - range_size / 2

    # Grid count: ensure profit > 3x fees
    fee_rate = 0.001  # 0.1%
    min_spread = fee_rate * 2 * 3  # 0.6%
    max_grids = int(range_size / (current_price * min_spread))
    grid_count = min(max_grids, int(capital / 5))  # min $5 per grid

    return {
        "upper": round(upper),
        "lower": round(lower),
        "grids": grid_count,
        "per_grid": round(capital / grid_count, 2),
    }

# Example: $200, BTC at $84K, 12% monthly volatility
print(calculate_grid(200, 84000, 0.12))
# {'upper': 89040, 'lower': 78960, 'grids': 16, 'per_grid': 12.5}

Risks

Grid trading is not risk-free:

Price breaks below lower bound → you're holding assets at a loss (same as buying the dip)
Price breaks above upper bound → you sold everything and miss the pump
Prolonged downtrend → grid keeps buying as price falls, accumulating losses
Low volatility → no trades trigger, capital sits idle

Risk Management

Set a stop-loss at 3-5% below the lower bound
Don't use more than 20% of your portfolio
Choose established coins (BTC, ETH) over volatile altcoins
Monitor and adjust the range monthly

Grid Trading vs Funding Rate Arbitrage

	Grid Trading	Funding Rate Arb
Risk	Medium (directional exposure)	Low (delta-neutral)
Return	3-8% monthly (ranging market)	1-2% monthly (stable)
Best when	Market oscillates	Market is bullish (positive funding)
Capital needed	$100+	$1,000+ for meaningful returns

They complement each other perfectly. Run both: grid for active income during ranging markets, funding arb for passive income during trends.

Getting Started

Open an OKX account and deposit USDT
Start small — $100 is enough to test
Pick BTC-USDT — most liquid, most predictable range
Set conservative parameters — use the formula above
Monitor weekly — adjust range if market shifts significantly

The grid runs 24/7. You check it once a week. That's it.

Follow live grid + arbitrage performance: Telegram - @PERMAFROSTK

Built with Permafrost AI — an open-source AI brain framework.

How to Build a Funding Rate Arbitrage Bot with Python

dead1786 — Fri, 20 Mar 2026 17:14:08 +0000

How to Build a Funding Rate Arbitrage Bot with Python

A step-by-step guide to earning passive income from cryptocurrency funding rates — with zero directional risk.

What is Funding Rate Arbitrage?

Perpetual futures contracts have no expiry date. To keep their price aligned with spot, exchanges use a funding rate — a fee paid between longs and shorts every 8 hours.

When the market is bullish (most of the time), longs pay shorts. This creates a structural opportunity: go long on spot, short on perpetual, and collect the funding rate with zero price risk.

This is called delta-neutral funding rate arbitrage, and it's one of the lowest-risk strategies in crypto.

How Much Can You Earn?

Based on 2024-2025 data:

Asset	Avg 8h Rate	Annual Return
BTC	0.01%	~11%
ETH	0.008%	~8.7%
Altcoins	0.02-0.05%	~22-55%

That's 10-15% annually on a delta-neutral position — significantly better than most savings accounts, with much lower risk than directional trading.

The Strategy

Scan all perpetual contracts for positive funding rates
Buy spot (e.g., 1 BTC on spot market)
Short perpetual (e.g., short 1 BTC perpetual contract)
Collect funding rate every 8 hours
Rotate when funding rate turns negative — close position, find the next best coin

Your total exposure is zero — if BTC goes up $1,000, your spot gains $1,000 and your short loses $1,000. Net effect: $0. You only care about the funding rate.

Building the Bot

Prerequisites

pip install ccxt

We'll use ccxt — a unified API for 100+ cryptocurrency exchanges.

Step 1: Scan Funding Rates

import ccxt

exchange = ccxt.okx({
    'apiKey': 'YOUR_KEY',
    'secret': 'YOUR_SECRET',
    'password': 'YOUR_PASSPHRASE',
})

markets = exchange.load_markets()
perp_symbols = [
    s for s in markets
    if markets[s]['swap'] and markets[s]['quote'] == 'USDT'
]

rates = []
for symbol in perp_symbols:
    info = exchange.fetch_funding_rate(symbol)
    rate = info['fundingRate']
    if rate and rate > 0.0001:  # > 0.01%
        rates.append({
            'symbol': symbol,
            'rate': rate,
            'annual': rate * 3 * 365,
        })

# Sort by rate descending
rates.sort(key=lambda x: x['rate'], reverse=True)
for r in rates[:10]:
    print(f"{r['symbol']}: {r['rate']*100:.4f}% per 8h ({r['annual']*100:.1f}% annual)")

Step 2: Open Delta-Neutral Position

def open_position(exchange, symbol, usdt_amount):
    spot_symbol = symbol.split(':')[0]  # BTC/USDT:USDT -> BTC/USDT

    # Get price
    ticker = exchange.fetch_ticker(spot_symbol)
    price = ticker['last']
    amount = usdt_amount / price

    # Round to exchange precision
    amount = float(exchange.amount_to_precision(symbol, amount))

    # Set leverage to 1x (no leverage!)
    exchange.set_leverage(1, symbol)

    # Buy spot
    exchange.create_market_buy_order(spot_symbol, amount)

    # Short perpetual
    exchange.create_market_sell_order(symbol, amount)

    print(f"Opened: long {amount} {spot_symbol} + short {amount} {symbol}")

Step 3: Monitor and Rotate

def check_and_rotate(exchange, positions):
    for symbol, info in positions.items():
        rate = exchange.fetch_funding_rate(symbol)['fundingRate']

        if rate < -0.0001:  # Negative rate threshold
            # Close both positions
            close_position(exchange, symbol, info['amount'])

            # Find new best rate
            new_rates = scan_funding_rates(exchange)
            if new_rates:
                open_position(exchange, new_rates[0]['symbol'], info['usdt_value'])

Step 4: Risk Management

Key rules:

Never use leverage — 1x only
Keep 20% reserve — don't deploy all capital
Max 30-40% per coin — diversify across 2-3 coins
Close on sustained negative rates — 2 consecutive negative periods = close
Monitor margin ratio — alert if below 300%

What About Fees?

Each open+close cycle costs ~0.20-0.28% in trading fees. This means:

Only open positions when funding rate > 0.01% per 8h
Don't rotate too frequently (wait for 2+ negative periods before closing)
Higher-rate coins are more profitable after fees

Running It 24/7

The bot runs as a scheduled task, checking every 8 hours:

while True:
    check_and_rotate(exchange, state['positions'])
    time.sleep(8 * 3600)  # Check every 8 hours

Add Telegram notifications for:

New positions opened
Positions closed (with PnL)
Negative funding rate alerts
Daily summary report

Results

With $5,000 deployed across 2-3 coins:

Conservative (BTC/ETH only): ~$40-60/month
Aggressive (including altcoins): ~$60-100/month
Bull market peaks: 2-3x these numbers

It's not get-rich-quick money, but it's genuinely passive — the bot runs itself, you just top up capital and collect.

Get the Code

Full source code and setup instructions: GitHub - funding-arb

Follow our live signals: Telegram - @PERMAFROSTK

Built with Permafrost AI — an open-source AI brain framework.