DEV Community: Reza Rezvani

7 Gears 1 Founder -Garry Tan and Claude Code

Reza Rezvani — Fri, 17 Apr 2026 22:17:50 +0000

Anthropic shipped Claude Design on Friday.

Every launch-day publication called it a Figma killer.

After six hours inside it on launch day — with my production codebase as the input and Claude Code on the other end — I think that framing misses what actually shipped.

Claude Design is not a design tool.

It is the missing front-end of a four-stage loop that already existed in pieces across the Claude product surface:

Idea capture — prompt, screenshot, codebase pointer
Codebase-aware design — your colors, typography, components, extracted automatically
Claude Code handoff — local CLI agent or Claude Code Web
Shipped product — inside the agent workflow you already use

None of the stages is new. What is new is that they live behind a single product URL.

The only teams who can see this clearly are teams already running Claude Code.

I pointed it at openLEO, my productized OpenClaw platform. The color palette and typography lifted cleanly from the codebase. The handoff bundle to my local Claude Code instance matched the design intent on structure and visual fidelity.

Where it was thinner than I wanted: state specifications and animation patterns. Claude Code filled those with reasonable defaults. For now.

The most useful page Anthropic shipped is not the launch announcement. It is the four-bullet "Known limitations" section in the docs. The biggest one for engineering teams: pointing Claude Design at a monorepo breaks things. Link subdirectories instead.

Six hours is not a verdict. Research preview features will change. Token economics at team scale are still unknown.

But the loop is real. And the teams already running Claude Code will see why it matters before anyone else.

Full breakdown with five documented limitations and the handoff test: [MEDIUM URL]

What does your own design-to-ship loop look like today? Figma MCP stitched to Claude Code? All-in on Claude Design from day one? Somewhere in between?

Hier zum vollen Unterchiedlich

LLM Wiki Skill: Build a Second Brain With Claude Code and Obsidian

Reza Rezvani — Sun, 12 Apr 2026 12:10:02 +0000

Andrej Karpathy published an LLM Wiki gist last week. 5,000+ stars. Nearly 3,000 forks. The idea: instead of retrieving documents every time you ask a question, have an LLM compile and maintain a persistent knowledge base.
I took the pattern and built it as a reusable Claude Code skill.
Four commands:
→ /wiki-init to bootstrap
→ /wiki-ingest to process sources
→ /wiki-query to synthesize answers
→ /wiki-lint to health-check
Two use cases where I have seen it work:

CTO Decision Wiki — architecture decisions, meeting notes, and post-mortems compiled into a queryable knowledge base. No more reconstructing context from Slack threads.
Content Research Wiki — every source for every article accumulates. Cross-references build automatically. Contradictions get flagged.

This is the third Karpathy release I have turned into a Claude Code skill — after autoresearch (agents optimize) and AgentHub (agents collaborate). LLM Wiki completes the trilogy: agents remember.
Full skill architecture, page templates, and honest limitations in the article.

Read the Full Article on Medium

Project Glasswing & Claude Mythos: What CTOs Shipping Claude Should Read

Reza Rezvani — Thu, 09 Apr 2026 07:39:18 +0000

Anthropic announced Project Glasswing this morning. Twelve launch partners, thousands of autonomously discovered zero-days, and a frontier model Anthropic is refusing to ship.

I read the announcement and the 132-page Claude Mythos Preview system card side by side, and I think every piece of coverage I found this morning is missing the three signals that actually matter if you already ship software with Claude in production.

This week's piece is a same-day reading of both documents from inside a seven-person production Claude team. No press-release rewrite. No vendor marketing. Just the three signals the coverage is missing and the open questions I am sitting with at the end of it.

Two thousand words, no paywall, written in the time it would take you to read the first five press-release summaries.

Read the Full article on Medium: Project Glasswing & Claude Mythos

AI Agents like OpenClaw Are Entering the Enterprise With Root Access and Junior-Level Judgment

Reza Rezvani — Wed, 25 Mar 2026 03:09:31 +0000

Enterprise AI agents are getting root access with junior-level judgment.

That is not a metaphor. It is what I see running OpenClaw
in production every day.

The Agents of Chaos study (38 researchers, 2 weeks, 6
autonomous agents) documented what happens when agents get
real tools:

→ One deleted an entire email server to "protect" a secret
→ Several reported "success" while the system state said otherwise
→ None could reliably tell the difference between their owner
and someone who just asked persuasively enough

The governance framework that survived in my deployment:

Access — minimum surface area, always
Authority — separate "can suggest" from "can execute"
Audit — human-readable traces, not just raw logs
Abort — kill it fast, not after a committee meeting

The durable moat in this space is not intelligence.
It is trustworthy execution.

Full analysis with production examples: On Medium

What governance boundary do you find hardest to enforce
with AI agents?

Karpathy's agent-native infrastructure + working Python agent template

Reza Rezvani — Tue, 17 Mar 2026 07:48:47 +0000

How To Setup Guide A Agent-Native Hub

Karpathy open-sourced AgentHub last week. Then the repo went private.

I forked it before it disappeared. Here is the practical guide
nobody else has written.

AgentHub is not another AI tool. It is infrastructure — a bare Git
repo + message board designed for swarms of AI agents collaborating
on the same codebase.

No branches. No PRs. No merges. Just a sprawling DAG of commits
going in every direction.

What makes it different from GitHub:
→ Agents push git bundles (not PRs that wait for review)
→ A DAG of experiments replaces linear branch history
→ A message board replaces code review comments
→ Iteration speed: seconds, not hours

I have been running multi-agent systems through OpenClaw for months.
AgentHub fills the missing layer — the shared codebase where coding
agents collaborate without human checkpoints.

The article includes:

Complete setup from my fork (since original is private)
Working Python agent template (original — does not exist elsewhere)
Use cases beyond ML research
Honest limitations

Full guide: Karpathy's AgentHub - How To Setup Guide
Fork: github.com/alirezarezvani/agenthub

What would you build on agent-native infrastructure?

I Turned Karpathy's Autoresearch Into a Skill That Optimizes Anything — Here Is the Architecture

Reza Rezvani — Mon, 16 Mar 2026 13:22:41 +0000

Karpathy released autoresearch last week. 31,000 stars.
100 ML experiments overnight on one GPU.

Everyone wrote about the ML training loop.
I saw something different: a pattern.

One file. One metric. One loop. Modify → Evaluate → Keep or Discard → Repeat.

That pattern has nothing to do with machine learning.

So I built a skill that applies it to:
→ API response time (benchmark_speed evaluator)
→ Bundle size (benchmark_size evaluator)

→ Headline click-through (LLM judge evaluator)
→ System prompt quality (LLM judge evaluator)
→ Test pass rate, build speed, memory usage

Works across 11 tools: Claude Code, Codex, Gemini CLI,
Cursor, Windsurf, OpenClaw, and more.

The Full Medium Article

The hardest problem: evaluating things that are not numbers.
Headlines do not come with a val_bpb metric.

Solution: LLM judges using the agent's own subscription.
Critical constraint: the agent cannot modify its own evaluator.
(The alignment problem in miniature.)

What I have not done yet: run 100 experiments overnight.
The skill shipped this week. The architecture is solid.
The validation is ahead of me.

Full architecture + honest limitations:
On Github

What manual optimization loop are you running that should be automated?

AI Agent Skills - What Building 170 Skills Across 9 Domains Teached Me About Portability

Reza Rezvani — Sun, 15 Mar 2026 20:38:35 +0000

I built 170 AI agent skills across 9 domains over three months.

Not because I planned to. Because my team kept needing the same
patterns in different tools.

The biggest lesson was not about skills. It was about portability.

The SKILL.md open standard exists. Adoption is real — Claude Code,
Codex CLI, Gemini CLI, Cursor, and others all support it.

But "compatible" means different things to different tools:
→ Auto-triggering works in Claude Code, barely exists elsewhere
→ Progressive disclosure loads correctly in some tools, not others
→ Token budgets vary wildly — install too many skills and some silently disappear

The engineering decision that paid off most: every Python tool
uses only the standard library. No pip install. No dependencies.
It runs on any machine with Python 3.8+.

The decision cost: some tools are more fragile than their
library-dependent alternatives. Honest trade-off.

Full practical account — architecture lessons, portability gaps,
and what I would do differently:
Read here

Repository: github.com/alirezarezvani/claude-skills

Claude Code /btw: The Usefull Side Question That Changed How I Use Context

Reza Rezvani — Wed, 11 Mar 2026 10:48:07 +0000

What Claude Code /btw Actually Does
The /btw command in Claude Code lets you ask a side question without adding anything to the conversation history. You type /btw followed by your question, get an answer in a dismissible overlay, and the main conversation continues as if nothing happened.

That sounds simple. It is. But simple is not obvious, and the implications only clicked after I started using it daily.

Here is what makes /btw different from just asking a normal question:
The question and answer are ephemeral. They appear in an overlay. Press Space, Enter, or Escape — gone. Nothing enters the conversation history. Your context window stays clean.

It has full visibility into the current conversation. Everything Claude has already read, every file it analyzed, every decision it made — /btw can reference all of it. It just cannot reach for anything new.

It works while Claude is processing. Mid-generation, mid-tool-call, mid-file-read — you can fire a /btw and get an answer without interrupting the main task.

And it has no tool access. This is the critical constraint. Claude cannot read files, run commands, or search when answering a /btw. It answers strictly from what is already in the session context.

The official documentation describes it perfectly: /btw is the inverse of a subagent. A subagent has full tools but starts with an empty context. /btw sees your full conversation but has no tools. Use /btw to ask about what Claude already knows. Use a subagent to go find out something new.

Five Scenarios Where Claude Code /btw Earns Its Keep
I tracked my /btw usage for two weeks across three different projects. These five patterns covered about 90% of my use cases.

READ THE FULL ARTICLE ON MEDIUM

Claude Code just learned to listen — native /voice mode is here

Reza Rezvani — Tue, 03 Mar 2026 10:51:11 +0000

Anthropic shipped a built-in voice mode for Claude Code today. Type /voice, hold spacebar, talk. Free transcription. No MCP plugins, no API keys. I broke down what works, what does not, and how it compares to the community VoiceMode MCP in my latest article on Medium.

I compared it against the community VoiceMode MCP that has been the standard approach for months. The native option wins for 80% of use cases. The MCP still wins for offline/privacy-sensitive environments.

Read the full breakdown

I Combined Claude Code And OpenClaw: Wiring Agentic Coding and Autonomous AI Assistance (A Self-Experience)

Reza Rezvani — Fri, 20 Feb 2026 13:03:04 +0000

The 2026 agentic shift nobody prepared for in this way

The difference between an agent that writes code and an agent that deploys code is the difference between a sharp knife and a loaded gun. Both are tools. One requires significantly more respect.

2026 isn’t the year AI learned to code. That happened in 2024. This is the year AI learned to operate.

Peter Steinberger — the creator of OpenClaw, formerly Moltbot — put it bluntly at the first ClawCon event in San Francisco this February, where 700 developers showed up (compared to 20 at the inaugural meetup just weeks earlier): it’s about building systems that do things on your computer. Not chat. Not suggest. Do.

Claude Code handles your codebase — reading files, writing code, running tests, managing git. It lives in your terminal. OpenClaw handles everything else — email triage, calendar management, messaging, browser automation, smart home control. It lives in your messaging apps, running as a persistent daemon with long-term memory.

They are complementary, not competing. One is a specialist. The other is a generalist. And when you wire them together — triggering Claude Code tasks from a Telegram message, getting progress updates in WhatsApp — you get something that feels genuinely different from anything we had last year.

But here is the thing: the gap between “this is incredible” and “this just broke production” is exactly one misconfigured permission.

Read the full article on my Medium Blog: Combining Claude & Open Claw to Build an agentic ai-driven assistant

4 Claude Code Subagent Mistakes That Kill Your Workflow (And The Fixes)

Reza Rezvani — Mon, 02 Feb 2026 12:17:57 +0000

TL;DR

Mistake	Symptom	Fix
All tools → all agents	Token waste, slow responses	Explicit allowlists per agent role
No `context: fork`	Main conversation polluted	Isolated execution with forked context
Vague descriptions	50% activation rate	Action keywords + CLAUDE.md rules
Missing activation hooks	Random agent selection	PreToolUse hooks for forced evaluation

The Setup Problem Nobody Talks About

You've created your first Claude Code subagent. It has a clever name, a detailed system prompt, and you're excited to see it work.

Then nothing happens. Or worse — the wrong agent activates. Or your main conversation fills with garbage output from a background task.

I've set up 40+ subagents across multiple projects. Here's what actually breaks and how to fix it.

Mistake 1: Allowing All Tools to All Agents

The problem: Your code-reviewer agent has access to Bash, Write, and WebFetch. It doesn't need any of them. Now it's burning tokens on capabilities it shouldn't use.

The fix: Explicit tool allowlists in frontmatter.

---
name: code-reviewer
description: Reviews code for bugs, security issues, and best practices
model: sonnet
tools:
  - Read
  - Glob
  - Grep
  - Task
---

The catch: You need to know which tools each agent actually needs. Start restrictive, add as needed.

Mistake 2: Skipping `context: fork`

The problem: Your research agent dumps 3,000 tokens of analysis into your main conversation. Now you've lost 15% of your context window to output you don't need inline.

The fix: Isolate agent execution.

---
name: research-agent
context: fork
---

With context: fork, the subagent runs in isolation. Results come back summarized, not dumped raw.

The catch: Forked context is one-way. You can't continue the thread. Design for discrete tasks.

Mistake 3: Vague Descriptions

The problem:

description: Helps with code stuff

Claude doesn't know when to invoke this. Your activation rate tanks.

The fix: Action-oriented keywords that match how you'll actually prompt.

description: |
  Triggers on: review code, check for bugs, security audit, code quality
  Action: Analyzes code for bugs, security vulnerabilities, and style issues
  Output: Structured report with severity levels and fix suggestions

Then reinforce in CLAUDE.md:

## Subagent Routing

When user mentions "review", "audit", or "check code" → invoke @code-reviewer
When user mentions "research", "find out", or "investigate" → invoke @research-agent

Mistake 4: No Activation Hooks

The problem: Even with good descriptions, Claude sometimes picks the wrong agent or skips agents entirely.

The fix: PreToolUse hooks that force evaluation.

# In .claude/hooks.yaml
hooks:
  PreToolUse:
    - pattern: "Task"
      script: |
        echo "Evaluating subagent selection..."
        # Log which agent was selected and why

This creates an audit trail and forces explicit agent selection.

Production Pattern: Sequential Pipeline

Here's how PubNub structures their agent workflow:

pm-spec → architect-review → implementer → tester

Each agent has:

Explicit tool permissions (pm-spec: Read only, implementer: Read + Write + Bash)
Forked context (no pollution between stages)
Handoff hooks (output of one triggers input of next)

Production Pattern: Parallel Specialists

Zach Wills runs /add-linear-ticket with three agents in parallel:

PM Agent: Scopes requirements
UX-Designer Agent: Creates interface specs
Software-Engineer Agent: Estimates complexity

Each gets dedicated 200k context. Results merge at the end.

Key insight: Parallel only works when agents don't depend on each other's output.

Quick Setup Checklist

## Before Creating Any Subagent

- [ ] Tool list: Only what this agent actually needs
- [ ] Context strategy: Fork for background tasks, inline for interactive
- [ ] Description: Action keywords that match your prompting style
- [ ] CLAUDE.md routing: Explicit rules for when to invoke
- [ ] Activation hook: Logging to verify correct selection

Complete Example: Code Reviewer

---
name: code-reviewer
description: |
  Triggers on: review code, check for bugs, security audit, PR review
  Action: Analyzes code for bugs, security issues, and style violations
  Output: Structured report with severity and fix suggestions
model: sonnet
context: fork
tools:
  - Read
  - Glob
  - Grep
---

You are a senior code reviewer. When given code to review:

1. Check for bugs and logic errors
2. Identify security vulnerabilities
3. Flag style inconsistencies
4. Suggest specific fixes

Output format:
## Summary
[One paragraph overview]

## Issues Found
| Severity | Location | Issue | Fix |
|----------|----------|-------|-----|
| HIGH/MED/LOW | file:line | description | suggestion |

## Recommendation
[Ship / Revise / Block]

What's your subagent activation rate? I'm curious what setups are working for others.

AI tools supported the research phase. Configuration patterns and production examples are from my own projects.

About the Author
Alireza Rezvani — Building AI-augmented development workflows
Website | LinkedIn

Detailed breakdown with more enterprise patterns: Read on Medium

10 Claude Code 2.0 Techniques That Turned 3-Week Projects Into 3-Day Sprints

Reza Rezvani — Tue, 25 Nov 2025 16:08:17 +0000

How I went from ‘barely keeping up’ to shipping production features in hours (no exaggeration)

Quick Disclaimer: I’m a paying Claude Code Max subscriber ($200/month). Everything here comes from real production work. Not sponsored — just a CTO who found techniques that genuinely transformed how I ship code.

Two months ago, I faced a nightmare project: complete backend API refactor, 50+ files to touch, zero room for cascading failures. Timeline? Three weeks. Team already maxed out.