code-yeongyu/my-claude-code-harness — Summary

my-claude-code-harness is a personal Claude Code configuration by Korean developer yeongyu (GitHub: code-yeongyu), a minimal but philosophically opinionated harness for orchestrating multi-agent Claude Code workflows. It has 13 stars, no license, and was last updated 2025-11-28. The developer explicitly states: "I'm confident this setup will become deprecated and outdated in less than 3 months" — acknowledging it as a point-in-time personal setup, not a maintained product.

The harness consists of: 3 agents (orchestrator-style executor, librarian, plan-reviewer), 5 slash commands (/planner, /execute, /commit, /create-pr, /read-pr), 3 skills (git-committer, pr-context-retrieval, pr-creator), and 3 hook event types (UserPromptSubmit, PostToolUse, Stop). The PostToolUse hook runs extensive Python static analysis on every file modification: ruff lint, type checking, import-in-function detection, comment style enforcement, TypedDict detection, language guide injection, and conftest.py injection.

The workflow is: /planner → ai-todolist.md → [optional plan-reviewer loop] → /execute → orchestrator agent → executor agents (Haiku model, one-at-a-time). The executor agent prompt uses aggressive, profane language to enforce atomic task execution — the developer explicitly treats this as "attention weight engineering."

Differs from seeds: Most similar to taskmaster-ai (plan → execute pipeline) and bmad-method (multi-agent persona system), but uniquely combines aggressive attention-weight prompt engineering, comprehensive Python static analysis hooks, and explicit single-task-at-a-time enforcement via profanity. No seed uses hooks for static analysis. The profane executor prompt is the single most unusual feature in the entire batch.

code-yeongyu/my-claude-code-harness — Overview

Origin

Personal Claude Code configuration by yeongyu (GitHub: code-yeongyu), a Korean developer. The README opens with: "I'm confident this setup will become deprecated and outdated in less than 3 months." Published 2025-11-28.

Purpose

Provide a personal multi-agent workflow for software development tasks using Claude Code:

1. Planning via /planner command → ai-todolist.md
2. Execution via /execute command → orchestrator dispatches to executor agents
3. Quality enforcement via PostToolUse hooks (Python static analysis)
4. Git automation via skills and commands

Key Features

• Profane executor prompt: The executor.md agent uses aggressive, profane language to enforce single-task focus — explicitly described by the developer as "attention weight engineering"
• Comprehensive PostToolUse hooks: Python scripts checking ruff lint, types, import style, comment style, TypedDict usage, language guidelines, and conftest.py presence — triggered on every file write/edit
• Model tier routing: Orchestrator on the default model (Sonnet), executors on Haiku (cheap, fast, focused)
• Plan-reviewer loop: Optional second-opinion agent for plan quality before execution

Repo Facts

• GitHub: https://github.com/code-yeongyu/my-claude-code-harness
• Stars: 13 (2026-05-26)
• Language: Python (hooks) + Markdown
• License: none
• Last commit: 2025-11-28
• Status: Personal setup, acknowledged as ephemeral

Developer's Philosophy (from README)

The developer treats executor agents as unreliable by design:

• "SUPER DUMB, liars, extremely lazy"
• "can only do ONE TASK at a time"
• Profane language in prompts is intentional: "I'm using the power of attention weights"
• The hook system enforces quality because the developer doesn't trust the executor to self-check

code-yeongyu/my-claude-code-harness — Architecture

Repository Layout

my-claude-code-harness/
├── CLAUDE.md                       # Global instructions
├── settings.json                   # Claude Code settings (hooks, alwaysThinking, statusLine)
├── agents/
│   ├── executor.md                 # Haiku-model worker agent (aggressive single-task enforcement)
│   ├── librarian.md                # Documentation/reference lookup agent
│   └── plan-reviewer.md            # Plan quality review agent
├── commands/
│   ├── planner.md                  # /planner — generate ai-todolist.md
│   ├── execute.md                  # /execute — orchestrate execution
│   ├── commit.md                   # /commit — git commit via skill
│   ├── create-pr.md                # /create-pr — PR creation via skill
│   └── read-pr.md                  # /read-pr — PR context retrieval
├── skills/
│   ├── git-committer               # Skill: atomic git commit
│   ├── pr-context-retrieval        # Skill: fetch PR context
│   └── pr-creator                  # Skill: create GitHub PR
└── hooks/
    ├── post_tool_use.py            # Main PostToolUse hook script
    ├── stop.py                     # Stop hook script
    ├── post-tool-use/              # Additional PostToolUse hook configs
    ├── stop/                       # Additional Stop hook configs
    └── user-prompt-submit/         # UserPromptSubmit hook configs

Settings Configuration

{
  "alwaysThinkingEnabled": true,
  "statusLine": "bunx --bun ccusage statusline",
  "hooks": {
    "UserPromptSubmit": [system-reminder.py],
    "PostToolUse": [{
      "matcher": "Bash|Write|Edit|MultiEdit|Read|Task",
      "hooks": [post_tool_use.py via uv]
    }],
    "Stop": [stop.py via uv]
  }
}

Agent Architecture

Three tiers:

1. User → /planner command → ai-todolist.md
2. Orchestrator (default model/Sonnet) → reads todolist, dispatches tasks
3. Executor (model: haiku) → executes one atomic task, reports done

The executor is intentionally dumb and cheap (Haiku). The orchestrator is the intelligence layer. The hooks are the quality layer.

Hook Architecture

PostToolUse hooks fire on every Bash|Write|Edit|MultiEdit|Read|Task tool call. The post_tool_use.py script:

• Runs ruff lint on modified Python files
• Checks type annotations
• Detects imports inside functions
• Enforces comment style (no Chinese/Korean/Japanese — English only)
• Detects TypedDict anti-patterns
• Injects language guidelines
• Injects conftest.py if missing

Skill Architecture

Three skills activated via the Skill tool:

• git-committer: atomic commit with conventional format
• pr-context-retrieval: fetch PR diff/comments for context
• pr-creator: create GitHub PR with structured description

code-yeongyu/my-claude-code-harness — Skills & Commands

Skills (3)

git-committer

• Purpose: Create atomic git commits in conventional format
• Activation: Invoked by /commit command and by executor agent on task completion
• Behavior: Stages changed files, writes conventional commit message, enforces one-commit-one-purpose rule

pr-context-retrieval

• Purpose: Fetch GitHub PR diff, comments, and review context
• Activation: Invoked by /read-pr command
• Behavior: Pulls PR metadata and comments into context for the agent to reason about

pr-creator

• Purpose: Create a GitHub PR with structured title and body
• Activation: Invoked by /create-pr command
• Behavior: Drafts PR description from commit history and diff, creates via gh pr create

Commands (5)

/planner

• Purpose: Generate ai-todolist.md from a task description
• Output: Structured markdown todolist with atomic tasks, each mapped to an executor call
• Gating: Optional: pass the todolist to /plan-reviewer before executing

/execute

• Purpose: Orchestrate execution of ai-todolist.md
• Mechanism: Reads todolist, spawns executor sub-agents one task at a time
• Key constraint: ONE task per executor call — no batching

/commit

• Purpose: Git commit the current changes
• Delegates to: git-committer skill

/create-pr

• Purpose: Create a GitHub PR
• Delegates to: pr-creator skill

/read-pr

• Purpose: Load PR context into the conversation
• Delegates to: pr-context-retrieval skill

Agents (3)

executor.md

• Model: haiku (fast/cheap)
• Constraint: ONE task at a time — enforced via aggressive/profane prompting
• Key excerpt (paraphrased): "YOU ARE SUPER DUMB AND LAZY. DO. ONE. TASK. ONLY. [profanity]. DO NOT MOVE ON TO THE NEXT TASK."
• Rationale: Developer states this uses attention weight mechanics to prevent context drift

librarian.md

• Purpose: Lookup documentation, reference materials, file contents
• Use case: When executor needs to understand an API or read a large codebase section

plan-reviewer.md

• Purpose: Review ai-todolist.md before execution
• Behavior: Critiques plan for completeness, atomicity, and feasibility
• Loop: Can be called multiple times until plan quality is acceptable

alwaysThinkingEnabled

Set to true in settings.json — forces extended thinking mode on every Claude interaction. The developer believes this improves reasoning quality for orchestration tasks.

statusLine

bunx --bun ccusage statusline — shows Claude Code token usage in the terminal status line. Practical cost visibility during development.

code-yeongyu/my-claude-code-harness — Uniqueness & Positioning

differs_from_seeds

Most architecturally similar to taskmaster-ai (plan → execute pipeline, sequential task dispatch) and bmad-method (named agent personas). Differs from both in three key ways: (1) explicit model-tier routing (Sonnet orchestrator → Haiku workers), (2) comprehensive PostToolUse static analysis hooks as quality enforcement, (3) aggressive/profane prompt engineering in the executor agent as an intentional "attention weight" technique. No seed uses hooks for automated static analysis. No seed uses profanity in agent prompts.

Distinctive Positioning

1. Profane executor prompt as attention-weight engineering: The executor.md uses intentionally aggressive and profane language to enforce single-task focus. The developer explicitly theorizes this creates stronger attention patterns in the model for the critical constraint. This is the most unusual prompt engineering technique in the entire batch of 33 — likely in any Claude Code configuration corpus.

2. PostToolUse as automated QA gate: Running ruff, type checking, import analysis, comment language enforcement, TypedDict detection, and conftest.py injection on every file write is a sophisticated quality enforcement loop. No other entry in the batch uses hooks this way. The hooks function as a continuous CI that runs inline during agent execution.

3. Model-tier cost optimization: Routing orchestration to Sonnet and atomic execution to Haiku is an explicit cost optimization. The developer acknowledges executor agents are "dumb" (Haiku model) — this is the point. Cheap execution, expensive planning.

4. Radical self-deprecation as design signal: Opening the README with "I'm confident this setup will become deprecated and outdated in less than 3 months" is notable epistemic honesty. Most harness authors present their work as definitive. This framing is more useful to a researcher — it signals that the author understands they're capturing a moment in a fast-moving space.

5. ccusage statusline integration: Showing token costs in the terminal status line is a practical UX detail not seen in larger/more ambitious frameworks. The developer uses their own tool in their harness.

Observable Limitations

• 13 stars — nearly no adoption
• No license — cannot be forked/incorporated commercially
• Acknowledged as ephemeral (last commit 2025-11-28)
• No documentation beyond what's in the files
• Sequential execution only — no parallelism
• No persistent memory across projects
• Profane prompts may not transfer well to team environments

Why It Matters Despite Small Scale

This harness documents a real developer's actual Claude Code workflow. The hook system is a genuine engineering contribution — a working PostToolUse static analysis pipeline that others can adapt. The profane prompt technique, while controversial, is an empirically motivated experiment. The model-tier routing is a practical cost optimization pattern applicable to any multi-agent workflow.

13 stars understates its value as a documented pattern source.