Overview

Inspired by Claude Code's /simplify skill (announced by Boris Cherny, Feb 27 2026 — tweet), this proposes a simplify skill that spawns three parallel sub-agents to review recent code changes for reuse opportunities, code quality issues, and efficiency problems, then aggregates findings and applies fixes.

Claude Code's implementation was reverse-engineered from the compiled binary (v2.1.63) — the full internal prompts are documented below. The key insight is that three focused review agents running in parallel produce better results than a single monolithic review, because each agent can deeply search the codebase for a specific class of issues without context dilution.

This is directly implementable today using delegate_task's existing batch mode (3 concurrent sub-agents), requiring zero core code changes — only a new skill.

---

Research Findings

How Claude Code's /simplify Works

The skill operates in three phases:

Phase 1: Identify Changes

• Runs git diff (or git diff HEAD for staged changes) to capture what changed
• Falls back to recently modified/mentioned files if no git changes exist

Phase 2: Launch Three Review Agents in Parallel
Each agent receives the full diff and searches the codebase for specific issues:

Agent 1 — Code Reuse Review:

• Searches for existing utilities/helpers that could replace newly written code
• Uses grep to find similar patterns elsewhere in the codebase (utility directories, shared modules, adjacent files)
• Flags new functions that duplicate existing functionality
• Flags inline logic that could use existing utilities (hand-rolled string manipulation, manual path handling, custom environment checks, ad-hoc type guards)

Agent 2 — Code Quality Review:

• Redundant state: state duplicating existing state, cached values that could be derived, observers/effects that could be direct calls
• Parameter sprawl: adding new parameters instead of generalizing/restructuring
• Copy-paste with slight variation: near-duplicate blocks that should share an abstraction
• Leaky abstractions: exposing internals that should be encapsulated, breaking existing abstraction boundaries
• Stringly-typed code: raw strings where constants, enums, or branded types already exist

Agent 3 — Efficiency Review:

• Unnecessary work: redundant computations, repeated file reads, duplicate API calls, N+1 patterns
• Missed concurrency: independent operations run sequentially
• Hot-path bloat: blocking work on startup or per-request paths
• TOCTOU anti-patterns: pre-checking existence before operating instead of operating and handling errors
• Memory: unbounded data structures, missing cleanup, event listener leaks
• Overly broad operations: reading entire files when only portions needed

Phase 3: Aggregate and Fix

• Waits for all three agents to complete
• Aggregates findings, discards false positives
• Applies fixes directly
• Summarizes what was fixed

Key Design Decisions

1. Three focused agents > one general agent: Each reviewer deeply searches the codebase for its specific concern. A single agent trying to do all three would spread attention too thin.
2. Full diff as context: Every agent gets the complete diff, not fragments. This prevents missing cross-file issues.
3. Fix, don't just report: Agents apply fixes directly rather than just listing findings. The agent can skip false positives without arguing.
4. Optional focus parameter: User can narrow the review (e.g., "simplify focus on memory efficiency") to direct attention.

---

Current State in Hermes Agent

What we have:

• delegate_task batch mode: Supports up to 3 concurrent sub-agents via ThreadPoolExecutor — exactly the right number for this pattern
• subagent-driven-development skill: Has serial review stages (spec compliance + code quality) but not parallel holistic review
• search_files tool: Our equivalent of Claude Code's Grep, available to sub-agents
• git via terminal: Full git diff capabilities
• No existing skill or workflow for automated post-change code review/cleanup

Gap: No automated "review my recent changes" workflow that leverages parallel sub-agents. The subagent-driven-development skill reviews per-task during development, but there's no standalone cleanup pass.

---

Implementation Plan

Skill vs. Tool Classification

This should be a bundled skill because:

• It can be fully expressed as instructions + existing tools (delegate_task, terminal for git, search_files)
• No custom Python integration needed — it orchestrates existing tools
• No API key management required
• It's broadly useful to all developers using Hermes — post-change code review is universal
• Per CONTRIBUTING.md: "Make it a Skill when the capability can be expressed as instructions + shell commands + existing tools"

What We'd Need

1. A new skill at skills/software-development/simplify/SKILL.md
2. The skill triggers on phrases like "simplify my changes", "review my code", "clean up my recent changes"
3. The skill instructs Hermes to:
   • Run git diff to capture changes
   • Use delegate_task batch mode with 3 tasks, each getting the diff + focused review instructions
   • Aggregate results and apply fixes

Phased Rollout

Phase 1: Core Skill - MVP

• Create the skill with the three-agent parallel review pattern
• Each agent uses search_files to find existing patterns in the codebase
• Parent aggregates and applies fixes
• Trigger: user says "simplify" or "review my changes"

Phase 2: Context-Aware Enhancements

• Support optional focus parameter ("simplify focus on efficiency")
• Auto-detect project conventions (linting config, type systems, test patterns) and incorporate into review prompts
• Support reviewing staged changes, specific files, or a commit range
• Integration with CLAUDE.md/HERMES.md project guidelines if they exist

Phase 3: Integration with Other Workflows

• Auto-invoke after subagent-driven-development completes all tasks
• Integration with the batch skill (see related issue) — workers run simplify before committing
• Integration with Feature: Acceptance Criteria & Independent Judge for Sub-agent Delegation (inspired by OpenPlanter) #356 (Acceptance Criteria) — use judge model to evaluate if simplifications are improvements
• Configurable review depth (quick scan vs. deep analysis)

---

Pros & Cons

Pros

• Zero core changes required — uses existing delegate_task batch mode (3 agents = 3 reviewers)
• Immediate value — code quality improvement on every change
• Proven pattern — Claude Code users report significant code quality improvements from this workflow
• Composable — can be invoked standalone or integrated into other workflows (subagent-driven-development, batch)
• Leverages Hermes strengths — search_files is powerful for finding existing patterns; delegate_task batch is mature

Cons / Risks

• Cost: 3 parallel sub-agents = 3x the API calls for review. May be expensive for large diffs
• False positives: Aggressive reviewers may suggest changes that break intent or reduce readability
• Token limits: Very large diffs may exceed context windows for sub-agents
• Consistency: Three independent agents may make conflicting suggestions (e.g., Agent 1 says "use existing util X" while Agent 3 says "X is inefficient, write custom")

---

Open Questions

• Should the skill auto-run simplify after every code change, or only when explicitly invoked?
• Should there be a "dry run" mode that reports findings without applying fixes?
• How should conflicting suggestions between the three agents be resolved?
• Should the skill respect .hermes/review-config or similar project-level configuration for what to check?

---

References

• Boris Cherny's announcement: https://x.com/bcherny (Feb 27, 2026)
• Claude Code Skills docs: https://code.claude.com/docs/en/skills
• Claude Code CHANGELOG: https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md
• Internal prompts extracted from Claude Code v2.1.63 binary
• Related: Feature: Multi-Agent Architecture — Orchestration, Cooperation, Specialized Roles & Resilient Workflows #344 (Multi-Agent Architecture), Feature: Acceptance Criteria & Independent Judge for Sub-agent Delegation (inspired by OpenPlanter) #356 (Acceptance Criteria), Feature: Inception Prompting — Hardened Sub-Agent Prompts Against Delegation Failures (inspired by CAMEL-AI) #375 (Inception Prompting)