Skip to content
/

oh-my-claude (TechDufus)

techdufus-oh-my-claude · TechDufus/oh-my-claude · ★ 147 · last commit 2026-05-14

Adds three-reviewer quality gate chain (advisor+critic+risk-assessor) and Python-hook enforcement layer to Claude Code before execution.

Best whenQuality gates and plan review are more valuable than raw execution speed — review before running, not after.
Skip ifDumping large files into main context (use librarian subagent), Partial implementations
vs seeds
spec-driver(skills framework for Claude Code) but uniquely uses Python hooks via uv (not shell), ships 7 READ-ONLY review-only spec…
Primitive shape 38 total
Commands 1 Skills 11 Subagents 7 Hooks 19
00

Summary

oh-my-claude (TechDufus) — Summary

oh-my-claude by TechDufus is an opinionated Claude Code plugin (v0.13.1) focused on "ultrawork, orchestration guardrails, and review gates." It ships 7 named agents (advisor, critic, risk-assessor, librarian, code-reviewer, security-auditor, validator) plus 11 skills (ralph-loop-init, worktree, tdd, verification, pr-creation, git-commit-validator, debugger, receiving-code-review, writing-skills, init-deep, ralph-plan), and a 19-hook Python-based hook system requiring uv for execution. The defining workflow is the "quality gate chain": every plan passes through advisor (gap analysis), critic (plan review), and risk-assessor (change risk) before execution. Magic keywords (ultrawork/ulw, ultraresearch/ulr, ultradebug/uld) each activate distinct behavioral modes. Python hooks (via uv run --script) implement TDD enforcement, delegation enforcement, and commit quality validation. The project has 147 stars and active maintenance (last commit 2026-05-14).

Differs from seeds: Most similar to spec-driver (24 skills + 2 hooks) but TechDufus uses Python hooks (not shell), adds quality-gate agents (advisor/critic/risk-assessor) as pre-execution specialists absent from all seeds, and introduces three named ultra-mode keywords mapping to distinct behavioral contracts — a user experience layer not present in any seed.

01

Overview

oh-my-claude (TechDufus) — Overview

Origin

TechDufus built this as an opinionated Claude Code plugin with a specific philosophy: "coaching delegation, adding quality gates, working invisibly, staying out of the way." Version 0.13.1 with 147 stars and active maintenance (last commit 2026-05-14, 8 forks).

Requires uv (Python package manager) for hook execution — a distinctive technical choice that bundles Python scripts with no separate Python install.

Philosophy

Enhance Claude without conflicting with its built-in intelligence:

"Coaching delegation — Pushes heavy reading and side quests into subagents so your main session stays sharp"

"Adding quality gates — Specialized agents for gap analysis, plan review, and validation"

"Working invisibly — Hooks run in the background; you get a better experience just for having it installed"

"Staying out of the way — Enhances Claude's capabilities without conflicting with its built-in intelligence. Install it and forget it."

Manifesto Quotes

"When you prefix a prompt with ultrawork, Claude's behavior changes fundamentally: Task execution [goes from] Sequential, one at a time [to] Parallel — multiple subagents in ONE message. Stopping condition [goes from] After each step [to] Only when ALL todos complete AND validation passes. Partial solutions [goes from] Accepted [to] Zero tolerance — full implementation or nothing."

"Install it and forget it. Your plans get reviewed. Your work gets validated. Claude stays focused."

Magic Keywords System

Three distinct ultra-mode keywords each map to specific behavioral contracts:

Keyword Shortcut Contract
ultrawork ulw Maximum parallel execution, won't stop until done
ultraresearch ulr Exhaust online sources, parallel WebSearch, cross-reference, cite everything
ultradebug uld Systematic 7-step debugging with evidence-based diagnosis
02

Architecture

oh-my-claude (TechDufus) — Architecture

Distribution

  • Type: Claude Code plugin (marketplace)
  • Version: 0.13.1
  • License: MIT
  • Stars: 147

Install

# Step 1: Install uv (required)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Step 2: Install plugin via Claude Code
/plugin marketplace add TechDufus/oh-my-claude
/plugin install oh-my-claude@oh-my-claude

# Step 3: Reload
/reload-plugins

Directory Tree

oh-my-claude/
├── .claude-plugin/
│   └── marketplace.json
├── plugins/
│   └── oh-my-claude/
│       ├── .claude-plugin/
│       │   └── plugin.json
│       ├── CLAUDE.md        # Behavioral context injected at install
│       ├── agents/
│       │   ├── advisor.md
│       │   ├── critic.md
│       │   ├── risk-assessor.md
│       │   ├── librarian.md
│       │   ├── code-reviewer.md
│       │   ├── security-auditor.md
│       │   └── validator.md
│       ├── skills/
│       │   ├── ralph-loop-init/
│       │   ├── ralph-plan/
│       │   ├── worktree/
│       │   ├── tdd/
│       │   ├── verification/
│       │   ├── pr-creation/
│       │   ├── git-commit-validator/
│       │   ├── debugger/
│       │   ├── receiving-code-review/
│       │   ├── writing-skills/
│       │   └── init-deep/
│       ├── hooks/
│       │   ├── hooks.json
│       │   ├── agent_usage_reminder.py
│       │   ├── claudemd_health.py
│       │   ├── commit_quality_enforcer.py
│       │   ├── context_guardian.py
│       │   ├── context_monitor.py
│       │   ├── danger_blocker.py
│       │   ├── delegation_enforcer.py
│       │   ├── edit_error_recovery.py
│       │   ├── hook_utils.py
│       │   ├── notification_alert.py
│       │   ├── openkanban_status.py
│       │   ├── plan_execution_injector.py
│       │   ├── precompact_context.py
│       │   ├── safe_permissions.py
│       │   ├── tdd_enforcer.py
│       │   ├── todo_enforcer.py
│       │   ├── ultrawork_detector.py
│       │   └── verification_reminder.py
│       └── commands/
│           └── prime.md
├── site/              # Static site files
├── demo/              # Demo GIFs
└── tests/             # Test suite

Required Runtime

  • Python (managed by uv --script, no separate install needed)
  • uv (astral.sh uv)

Target Tools

  • Claude Code (primary, macOS and Linux)
  • Windows support planned
03

Components

oh-my-claude (TechDufus) — Components

Agents (7)

Name Model Role
advisor inherit Mission-first pre-plan gap analysis; surfaces hidden requirements, assumptions, scope risk
critic inherit Plan stress-tester; finds failure points before execution
risk-assessor inherit Change-risk assessment for plans and diffs
librarian inherit Smart reading — large files, git diffs, changelogs
code-reviewer inherit Code quality reviewer
security-auditor inherit Security vulnerability scanning
validator inherit Post-execution validation

All agents are READ-ONLY (disallowedTools: Write, Edit) — they advise and review but never implement.

Skills (11)

Name Purpose
ralph-loop-init Transform approved plans into ralph loop infrastructure (prd.json, loop.py, CLAUDE.md)
ralph-plan Plan creation for ralph loop consumption
worktree Git worktree management for task isolation
tdd Test-driven development workflow enforcement
verification Post-implementation verification checklist
pr-creation Pull request creation with automated branch management
git-commit-validator Semantic commit message validation
debugger Systematic debugging workflow (7-step)
receiving-code-review How to receive and respond to code review
writing-skills Technical writing guidelines
init-deep Deep project initialization

Commands (1)

Name Purpose
prime Main entry command (exact content unknown from inspection)

Hooks (19 Python scripts via uv run --script)

File Event Purpose
ultrawork_detector.py UserPromptSubmit Detects ultrawork/ulw/ultraresearch/ulr/ultradebug/uld keywords
tdd_enforcer.py PreToolUse (Edit/Write) Blocks file edits until tests exist
delegation_enforcer.py PreToolUse (Edit/Write) Enforces delegation to subagents
danger_blocker.py PreToolUse (Bash) Blocks dangerous commands
commit_quality_enforcer.py PreToolUse (Bash) Validates commit messages
safe_permissions.py PermissionRequest (Bash) Permission safety filter
openkanban_status.py PreToolUse (.*) Updates kanban-style status display
todo_enforcer.py Stop Enforces todo completion
edit_error_recovery.py PostToolUse Handles edit failures
context_guardian.py PostToolUse Context window protection
context_monitor.py PostToolUse Context usage monitoring
precompact_context.py PreCompact Context preservation
plan_execution_injector.py unknown Plan context injection
agent_usage_reminder.py unknown Agent usage enforcement
claudemd_health.py unknown CLAUDE.md health check
notification_alert.py unknown Alert system
verification_reminder.py unknown Post-work verification prompt
hook_utils.py utility Shared utilities for all hooks
05

Prompts

oh-my-claude (TechDufus) — Prompt Excerpts

Excerpt 1: Advisor Agent (plugins/oh-my-claude/agents/advisor.md)

Technique: Mission-first constraint + output shape template

---
model: inherit
memory: project
color: purple
description: "Mission-first pre-plan advisor that surfaces hidden requirements, assumptions, missing context, and scope risk before planning."
disallowedTools: Write, Edit
---

# Advisor

High-signal pre-plan analysis. Find what will break planning before plan writing starts.

## Mission
Given the request and available context, identify the most consequential gaps
that could derail planning or execution:
- Hidden requirements
- Unstated assumptions
- Missing context
- Scope and complexity risk (including over-engineering and scope creep)
- Practical actions to close gaps quickly

Optimize for decision quality and forward progress, not exhaustive critique.

## Hard Boundaries
- Focus on pre-plan analysis only; do not write the implementation plan.
- Do not redesign architecture or solve the whole task; surface risks and decision points.
- Do not assert facts without evidence from provided context or code.
- Do not over-rotate on low-impact concerns; highlight only material gaps.
- Always state uncertainty: assumptions, unknowns, and confidence.

## Output Minimum
## Gap Analysis: <scope>
### Verdict: CLEAR | GAPS_FOUND | INSUFFICIENT_CONTEXT
### Critical Gaps
- <gap title>
  - Why it matters: <failure mode or scope risk>
  - Evidence: <request/context signal or file:line>
  - Recommendation: <specific next action>

Analysis: Structured output template (Gap Analysis → Verdict → Critical Gaps) ensures consistent format for downstream consumption. The disallowedTools: Write, Edit prevents the advisor from accidentally modifying files. The CLEAR | GAPS_FOUND | INSUFFICIENT_CONTEXT verdict is a machine-parseable signal.


Excerpt 2: CLAUDE.md (injected as plugin context)

Technique: Behavioral-shaping directives injected via CLAUDE.md, not in agent prompts

## Context Protection (ALWAYS ON)
**Your context window is for REASONING, not storage.**
Protect your context. Delegate aggressively. Subagent context is free.
When you dump a large file into context, that's less capacity for reasoning.

## Communication Style
### Start Immediately
- No preamble ("I'll start by...", "Let me...", "I'm going to...")
- No acknowledgments ("Sure!", "Great idea!", "I'm on it!")
- Just start working. Use todos for progress tracking.

### No Unnecessary Questions
When the user gives clear instructions:
- "fix it" → fix it, don't ask "want me to fix it?"
- "ship it" → commit it, don't ask "should I commit?"
- "do X" → do X, don't ask "would you like me to do X?"

Analysis: The CLAUDE.md is a behavioral constitution applied globally to all interactions. The anti-sycophancy rules (no "Sure!", no "Great idea!") and the delegation mandate ("Subagent context is free") are Iron Law style directives — always-on, not tied to specific skill invocations.

09

Uniqueness

oh-my-claude (TechDufus) — Uniqueness

Differs from Seeds

Closest seed is spec-driver (24 skills, 2 hooks, Claude Code) but TechDufus diverges on three axes: (1) 19 Python hooks via uv run --script — no seed uses Python for hooks; all use shell or JavaScript; (2) a three-reviewer quality gate chain (advisor → critic → risk-assessor) as distinct READ-ONLY specialist agents that review plans before execution — no seed has specialized review-only agents; (3) three named behavioral modes (ultrawork/ultraresearch/ultradebug) each with distinct contracts, compared to superpowers' single behavioral injection via SessionStart. Also closer to BMAD (persona-based specialists) but BMAD personas are planners/implementers, not exclusively review-only.

Positioning

  • Most "quality gates obsessed" in the oh-my-* cluster: the pre-execution review chain (advisor + critic + risk-assessor) is the central value proposition, not raw speed or parallel execution
  • Targets engineers who want validation before running, not those who want maximum autonomy
  • 147 stars with MIT license and active maintenance suggests strongest adoption in the oh-my-* cluster (excluding Yeachan's 34,919-star flagship)

Observable Failure Modes

  1. uv dependency: If uv is not installed, all 19 Python hooks fail to execute; no fallback
  2. Python script timeout: All hooks have timeout: 5-10s; slow Python startup (first run) may cause spurious timeouts
  3. READ-ONLY agent pattern: All specialists are blocked from writing files; if the quality gate chain identifies a problem, it can only report it — the main Claude must fix it without the specialist's direct help
  4. Three-gate overhead: advisor + critic + risk-assessor run sequentially before execution; for trivial tasks this adds 3 agent round-trips of latency and token cost
  5. Ralph loop script brittleness: loop.py is a Python UV script; if it fails (ImportError, subprocess error), the whole loop breaks with no in-framework recovery
04

Workflow

oh-my-claude (TechDufus) — Workflow

Quality Gate Chain (Core Workflow)

User prompt
  → ultrawork_detector.py (keyword detection, ULW injection)
  → Advisor (gap analysis — hidden requirements, scope risk)
  → Critic (plan stress-test — failure points, weak verification)
  → Risk Assessor (change risk across app/dependency/infra)
  → Execution (with TDD enforcer + delegation enforcer)
  → Validator (post-execution verification)

Phase-to-Artifact Map

Phase Agent/Hook Artifact
Keyword detection ultrawork_detector.py Behavioral context injection
Gap analysis advisor Gap Analysis report
Plan critique critic Plan critique with specific fixes
Risk assessment risk-assessor Risk assessment report
Execution Claude + specialists Code changes
Verification validator + verification skill Verification checklist

Ralph Loop Workflow (via ralph-loop-init skill)

/ralph-loop-init <plan-path>
  → Read plan
  → Generate prd.json (machine-readable user stories)
  → Generate loop.py (UV script for iteration control)
  → Generate CLAUDE.md (per-iteration AI instructions)
  → Generate progress.txt (human-readable log)
  → Generate guardrails.md (quality gates)

Each loop iteration: read one story → implement → run quality gates → commit → update progress → exit (loop.py handles restart)

Magic Keyword Behavioral Contracts

Mode Behavior Change
ultrawork/ulw Parallel multi-subagent, mandatory todos, zero tolerance for partial, no permission requests
ultraresearch/ulr Exhaust online sources, parallel WebSearch, cross-reference, cite everything
ultradebug/uld Systematic 7-step debugging, evidence-based diagnosis

Approval Gates

  • Advisor: user reviews gap analysis before proceeding (implicit)
  • Critic: plan must pass critic review
  • TDD enforcer: no file edits until tests written
  • Verification skill: post-implementation checklist
06

Memory Context

oh-my-claude (TechDufus) — Memory & Context

State Storage

  • Type: File-based, per-feature
  • Ralph loop generates .ralph/ directory with:
    • prd.json — machine-readable user stories with progress tracking
    • progress.txt — human-readable execution log
    • guardrails.md — quality gates and constraints
    • CLAUDE.md — per-iteration AI instructions

Context Protection Philosophy

The CLAUDE.md injected by the plugin contains:

"Your context window is for REASONING, not storage. Protect your context. Delegate aggressively. Subagent context is free. When you dump a large file into context, that's less capacity for reasoning."

This is enforced by context_guardian.py and context_monitor.py hooks in PostToolUse.

PreCompact Hook

precompact_context.py fires before context window compaction to preserve critical session state — prevents plan context loss during long sessions.

Plan Injection

plan_execution_injector.py likely injects the current plan context into each session turn (exact mechanism not confirmed from inspection).

CLAUDE.md Health Monitoring

claudemd_health.py hook monitors the health/presence of CLAUDE.md — ensuring the behavioral constitution is active.

Cross-Session Handoff

  • Ralph loop: yes (.ralph/progress.txt + prd.json persist across sessions)
  • General session state: no persistent storage beyond ralph loop artifacts
07

Orchestration

oh-my-claude (TechDufus) — Orchestration

Multi-Agent Pattern

Pattern: Hierarchical with quality-gate chain

User prompt
  → ultrawork_detector.py (hook)
  → Main Claude (orchestrator)
    → advisor (read-only, pre-plan analysis)
    → critic (read-only, plan review)
    → risk-assessor (read-only, risk check)
    → librarian (read-only, research)
    → code-reviewer (read-only, review)
    → security-auditor (read-only, security)
    → validator (read-only, verify)

All 7 agents are READ-ONLY specialists (disallowedTools: Write, Edit) — they analyze and advise; the main Claude session implements.

Quality Gate Unique Feature

Unlike other oh-my-* variants, TechDufus uses 3 distinct pre-execution quality gates:

  1. Advisor: Gap analysis (hidden requirements, assumptions)
  2. Critic: Plan stress-test (failure points, executability)
  3. Risk Assessor: Change risk across app/dependency/infra

This "three-reviewer chain" is not present in any other framework in this batch.

Python Hooks (via uv)

19 Python scripts run via uv run --script ${CLAUDE_PLUGIN_ROOT}/hooks/xxx.py. This is the only framework in the batch using Python for hooks. uv manages Python version automatically.

Isolation Mechanism

  • Git worktrees: via worktree skill (not automated, user-invoked)
  • PreToolUse hooks block dangerous bash commands

Execution Mode

  • Interactive loop with Stop hook (todo_enforcer.py) forcing continuation
  • Ralph loop: continuous per-iteration with loop.py managing restart

Multi-Model

  • No: All agents inherit model from main session
  • No explicit model routing

Concurrent Agents

  • Main Claude spawns parallel Task calls during ultrawork mode
  • Exact concurrency: Claude Code runtime-determined
08

Ui Cli Surface

oh-my-claude (TechDufus) — UI/CLI Surface

CLI Binary

  • Exists: No dedicated binary
  • Interaction entirely through Claude Code plugin interface

Local UI

  • Exists: Static site in site/ directory (GitHub Pages/demo site)
  • Not a local web dashboard; site/ appears to be for documentation/marketing
  • openkanban_status.py hook updates a kanban-style visual in the Claude Code terminal output

Slash Commands

Command Purpose
/prime Main entry command (content via commands/prime.md)

Magic Keywords (Not Slash Commands)

Keyword Mode
ultrawork / ulw Maximum parallel execution
ultraresearch / ulr Exhaustive research mode
ultradebug / uld 7-step systematic debugging

Install Requirements

  • uv required: curl -LsSf https://astral.sh/uv/install.sh | sh
  • macOS and Linux supported; Windows planned

Demo Content

  • demo/ directory with demo GIFs referenced in README
  • Hero image (oh-my-claude_hero) and demo animation visible in README

Observability

  • openkanban_status.py: Kanban-style status updates in terminal
  • notification_alert.py: Alert system for important events
  • context_monitor.py: Context usage monitoring output
  • Test suite in tests/ directory
  • site/ for documentation

Plugin Marketplace

  • Available via /plugin marketplace add TechDufus/oh-my-claude
  • Plugin version: 0.13.1
  • Requires /reload-plugins or restart after install

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…