Are We Claude Maxxing?

What is a skill?

A reusable prompt template, invoked via slash command. Loaded on-demand -- doesn't waste context. Think of skills as equippable armour pieces.

Slash command

→

Load prompt

→

Execute

→

Verified output

Remotion

Describe a video in natural language. Claude writes React components that render each frame — animations, subtitles, TTS audio. Full video from a prompt.

Anthropic Official

Document skills: /pdf, /pptx, /xlsx, /docx. Create and edit Office docs and PDFs directly from Claude Code.

How skills load.

Progressive disclosure. Two levels — only what's needed enters context.

Metadata

Name + description only · ~100 tokens/skill · loads at startup

Full Prompt

Complete instructions · loads on invoke only

                
# SKILL.md — only frontmatter loads at startup

---

name: my-skill

description: When to use this skill

---

# Body loads on-demand when /my-skill is invoked

Full instructions, examples, templates...

The CoVe model.

Chain-of-Verification. Claude tests its own code.

Create

Generate initial response from the prompt

Outline

Decompose into independent verification questions

Verify

Sub-agents check each claim against docs & codebase

Emit

Synthesize corrected, verified output

+28%

Accuracy

Stages

Vibes

A CoVe prompt, dissected.

                
# STAGE 1: CREATE

Implement a Stripe checkout flow for our

Next.js app with price ID lookup.

# STAGE 2: OUTLINE (auto-generated)

- Does stripe.prices.retrieve() exist in v14?

- Is the redirect URL using the App Router pattern?

- Does the webhook verify the Stripe signature?

- Are environment variables named correctly?

# STAGE 3: VERIFY (parallel checks)

✓ stripe.prices.retrieve — confirmed in Stripe SDK

✗ redirect used pages/ pattern — fixed to app/

✓ webhook signature verification present

✗ STRIPE_KEY should be STRIPE_SECRET_KEY — fixed

# STAGE 4: EMIT

Final code with all 4 corrections applied.

The enemy: context rot.

As the context window fills, quality degrades. Earlier instructions get buried. Output falls off a cliff.

We need systems that manage context automatically.

GSD under the hood.

All state lives in files, not in context. Sessions are resumable. Context stays clean.

PROJECT.md

High-level vision. Always loaded into context.

ROADMAP.md

Phases, completion status, release tags.

STATE.md

Session memory. Decisions, blockers, current position. The handoff document.

PLAN.md

Executable XML task plans. 2-3 atomic tasks per plan — not docs, but prompts.

Orchestrator stays at ~30-40% context utilization. Each executor gets a fresh 200K window with only the relevant plan files — no conversation history passed down.

The Ralph Loop.

Autonomous iteration via stop hooks. Named after Ralph Wiggum — persistent iteration despite setbacks. /spidey is a Ralph Loop — it keeps iterating until the UI matches your intent.

What are stop hooks?

Hooks are shell commands that fire in response to Claude Code events. A stop hook intercepts Claude's exit — the mechanism that makes the Ralph Loop possible.

                
# .claude/hooks.json

{

  "hooks": {

    "Stop": [{

      "matcher": "",

      "hooks": [{

        "type": "command",

        "command": "cat PROMPT.md"

      }]

    }]

  }

}

When Claude tries to exit, the stop hook fires, feeds the prompt back in, and Claude starts a fresh iteration. The files it changed are still on disk — so each loop builds on the last.

Ralph Loop in the wild.

3 months → a programming language

Geoffrey Huntley ran Claude in a continuous loop for 3 months and built "Cursed" — a fully compiled GenZ-themed programming language like Go, with keywords like slay for functions and sus for variables. Compiles to macOS, Linux, and Windows via LLVM.

$297 for $50K of work

One engineer set up a Ralph Loop before bed. Woke up to 1,100+ commits across 6 repos — including a near-complete port of Browser Use from Python to TypeScript. Total API cost: $297. Traditional contract value: $50,000.

Fruit Ninja in 1 hour

A fully functional Fruit Ninja clone — collision detection, scoring, sound effects — built autonomously in 1 hour across 8 context rotations. Zero human guidance after the initial prompt.

$15K hackathon winner

Affaan Mustafa built zenith.chat entirely with Claude Code in 8 hours at the Anthropic x Forum Ventures hackathon. Won $15K in API credits. The repo hit 16K GitHub stars and 900K views on X.

Model Context Protocol.

MCPs let Claude interact with external services. Portals to other worlds.

n8n

Create workflows via MCP. Brain dump your process, get a live deployed workflow.

Notion

Screenshot an expense, Claude adds it to your tracker. Any page, any database.

Figma

Design to code. Read Figma files, generate matching components.

Playwright

Browser control. Click, type, screenshot, iterate. Full automation.

n8n MCP + Skills: the combo.

The MCP gives Claude tools. The skills teach Claude how to use them well.

You: "automate my Stripe→Slack flow"

↓

n8n MCP

↓

Claude gets 525+ node tools

↓

n8n Skills (7 skills)

↓

Claude knows patterns, syntax, validation

Without skills

Claude has the MCP tools but guesses at expression syntax, misconfigures nodes, gets stuck in validation loops.

With skills

Claude knows {{$json}} syntax, proven workflow patterns, node-specific config, and auto-validates before deploying.

github.com/czlonkowski/n8n-skills — 7 skills, 2,653+ templates

My personal recommendations.

Three things to get the most out of Claude Code.

Git worktrees & Conductor

Clone repos or use git worktrees. Run Claude Code from terminal or Conductor — not just the IDE. Parallel workstreams on the same repo without conflicts.

--dangerously-skip-permissions

Run claude --dangerously-skip-permissions. No approval prompts breaking the flow. Essential for autonomous loops. Use in a sandbox.

Let it use CLI tools

Tell Claude to use gcloud CLI, AWS CLI, Supabase CLI, Vercel CLI — whatever's installed. Risky, but allows full end-to-end completion without you copy-pasting between terminals.

My skills.

/rnv

CoVe prompting. Wraps any prompt in the 4-stage verification pipeline. Create → Outline → Verify → Emit.

/spidey

Generates a full PRD from a one-liner, derives a task plan from it, configures the Ralph loop, then runs autonomously until every acceptance criterion passes.

/wavybaby

Meta-orchestrator. Analyzes your task, auto-selects optimal skills + MCPs + CoVe. Lazy prompt in, rigorous output out.

/steve

The full stack. Combines GSD's structured project management with Ralph's autonomous execution loop. Generates a PRD, bootstraps .planning/, then runs Ralph until the milestone is complete.

/herobrine

Proactive agents that work while you sleep. Schedule autonomous Claude Code instances via macOS launchd. Results delivered to Beeper. Run overnight builds, morning briefings, or recurring research.

Get the skills.

Click to copy. Paste in your terminal.

/rnv Self-checking code generation

Wraps any prompt in 4-stage Chain-of-Verification. Claude generates code, decomposes it into verification questions, checks each claim against real docs, then emits corrected output. Use: /rnv "implement stripe checkout"

                        npx skills add aaarnv/claude-skills@rnv
                        Click to copy
                    

/spidey Autonomous dev loop

Give it a one-liner. It interviews you, generates a full PRD, derives a task plan, configures a Ralph loop with circuit breakers, then runs autonomously — visually verifying UI with Playwright after each change. Use: /spidey "build a habit tracker app"

                        npx skills add aaarnv/claude-skills@spidey
                        Click to copy
                    

/wavybaby Meta-orchestrator

Analyzes your task, auto-discovers and installs the best skills from skills.sh, sets up MCP servers, and applies CoVe on non-trivial code. The skill that equips other skills. Use: /wavybaby "add google auth to my next.js app"

                        npx skills add aaarnv/claude-skills@wavybaby
                        Click to copy
                    

/steve Full autonomous pipeline

The full stack. Combines wavybaby (tool equipping + CoVe) + GSD (roadmaps, phases, plans, state tracking) + Ralph (autonomous loop). Generates a PRD, bootstraps .planning/, then runs autonomously through every phase until the milestone is complete. Use: /steve "build a SaaS dashboard with billing"

                        npx skills add aaarnv/claude-skills@steve
                        Click to copy
                    

/herobrine Scheduled autonomous agents

Run Claude Code on autopilot. Create agents with a name, prompt, and schedule (cron or interval). They execute headlessly via macOS launchd and deliver results to your Beeper. Use for morning briefings, overnight builds, or recurring research. Use: /herobrine create

                        npx skills add aaarnv/claude-skills@herobrine
                        Click to copy
                    

Are we Claude Maxxing?

Steve needs diamond armour.