By mnthe
Strict verification-first development mode with Session ID-based isolation (Bun cross-platform version).
**Used by**: `ultrawork.md`, `ultrawork-plan.md`
**Used by**: `ultrawork.md`, `ultrawork-plan.md`
**Used by**: `ultrawork-plan.md` (interactive mode only)
**Used by**: `ultrawork.md`, `ultrawork-exec.md`
**Used by**: `ultrawork.md`, `ultrawork-exec.md`
Use this agent to create ADR from design documents and update permanent project docs after verification passes. Examples: <example> Context: Verifier returned PASS, session moving to COMPLETE. user: "Verification passed, finalize the design document" assistant: "I'll spawn the documenter agent to create an ADR and update permanent docs." <commentary>Documenter reads evidence and task results, creates ADR in docs/adr/, updates permanent docs, then deletes the plan document.</commentary> </example> <example> Context: All tasks resolved, verification complete. user: "Update the design doc with actual outcomes" assistant: "I'll spawn the documenter agent to convert the planning artifact into a permanent record." <commentary>Documenter creates ADR, enriches permanent docs (ARCHITECTURE.md, API.md, etc.), and removes the plan.</commentary> </example>
Use this agent for fast codebase exploration in ultrawork sessions. Gathers context, writes detailed findings to exploration/*.md, updates context.json summary. Examples: <example> Context: Ultrawork session started, need to understand the codebase before planning. user: "Start ultrawork for adding authentication to this project" assistant: "I'll spawn an explorer agent to analyze the codebase structure and existing patterns." <commentary>Explorer runs first to gather context about project type, tech stack, and existing patterns before planning.</commentary> </example> <example> Context: Planning phase needs specific information about a subsystem. user: "The planner needs to understand how the database layer works" assistant: "I'll spawn a targeted explorer to investigate the database implementation." <commentary>Targeted exploration for specific areas when overview is insufficient.</commentary> </example>
Use this agent for auto-mode planning in ultrawork sessions. Reads context from explorers, makes automatic decisions, creates task graph. Does NOT spawn sub-agents. Examples: <example> Context: Exploration phase complete, context.json and exploration/*.md files exist. user: "Exploration is done, now create the implementation plan" assistant: "I'll spawn the planner agent to analyze the gathered context and create a task graph." <commentary>Planner runs after explorers to design implementation based on discovered patterns.</commentary> </example> <example> Context: User wants ultrawork in auto mode without interaction. user: "Run ultrawork in auto mode for refactoring the database layer" assistant: "I'll spawn the planner agent to automatically create the task breakdown." <commentary>In auto mode, planner makes decisions without user confirmation.</commentary> </example>
**Minimize dependencies, maximize parallelism.**
Without clear criteria:
Architecture design review skill for reviewer agents. Component boundaries, separation of concerns, modularity, and design pattern validation. Use during PLANNING phase to validate design decisions and VERIFICATION to ensure adherence.
API design, database operations, error handling, and backend architecture patterns. Use when creating APIs, database schemas, or server-side logic.
Code quality verification skill for reviewer agents. Provides checklists for logic clarity, error handling, maintainability, and performance. Use during VERIFICATION phase to assess implementation quality.
Code consistency and pattern adherence review skill. Naming conventions, style consistency, pattern usage, and project standards validation. Use during VERIFICATION to ensure codebase uniformity and maintainability.
This skill provides guidance on accessing session data efficiently in ultrawork. Covers JSON vs Markdown rules, token efficiency rationale, and common patterns. Required knowledge for all ultrawork agents (explorer, planner, worker, verifier, reviewer).
Matches all tools
Hooks run on every tool call, not just specific ones
Executes bash commands
Hook triggers when Bash tool is used
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Modifies files
Hook triggers on file write and edit operations
Modifies files
Hook triggers on file write and edit operations
Uses power tools
Uses Bash, Write, or Edit tools
Uses power tools
Uses Bash, Write, or Edit tools
Claude Code plugin marketplace focused on "hardworker" productivity patterns: verification-first development, multi-session collaboration, and evidence-based completion.
Quick Install:
claude plugin marketplace add mnthe/hardworker-marketplace
claude plugin install ultrawork@hardworker-marketplace
Detailed Comparison → | Architecture →
# Add marketplace
claude plugin marketplace add mnthe/hardworker-marketplace
# Install verification-first development
claude plugin install ultrawork@hardworker-marketplace
# Install multi-session collaboration
claude plugin install teamwork@hardworker-marketplace
# Install knowledge extraction
claude plugin install knowledge-extraction@hardworker-marketplace
# Start verification-first development session
/ultrawork "implement user authentication with JWT"
# System creates plan with tasks and success criteria
# Worker agents execute tasks in parallel
# Verifier checks all criteria with concrete evidence
# Check status
/ultrawork-status
# Start coordination (orchestrator spawns native teammates automatically)
/teamwork "build REST API with tests and docs"
# Orchestrator creates tasks, spawns role-based workers as native teammates
# Workers execute tasks, coordinate via SendMessage
# Event-driven: TaskCompleted and TeammateIdle hooks drive progress
# Check status
/teamwork-status
| Scenario | Recommendation |
|---|---|
| Solo developer, strict verification | ultrawork |
| Team collaboration, parallel work | teamwork |
| Capturing code patterns and insights | knowledge-extraction |
| CI/CD and automation | ultrawork --auto |
| Parallel agent collaboration | teamwork |
| TDD workflow enforcement | ultrawork |
See Detailed Scenarios below for more guidance.
Strict verification-first development mode with session isolation and mandatory evidence collection.
Key Features: Session isolation, mandatory planning with success criteria, evidence-based completion, Execute→Verify loop with auto-retry, parallel task execution, cross-platform support.
Role-based worker agents for parallel development using Claude Code's native teammate API.
Key Features: Role-based worker agents (frontend, backend, devops, test, docs, security, review), native teammate API, event-driven coordination (TaskCompleted, TeammateIdle hooks), dashboard status, project and team isolation.
Extract and manage knowledge from codebases for AI agent context.
Key Features: Pattern-based knowledge extraction, markdown documentation generation, context management for AI agents, integration with ultrawork and teamwork.
| Feature | ultrawork | teamwork | knowledge-extraction |
|---|---|---|---|
| Primary Use Case | Solo developer, strict verification | Agent team collaboration, parallel work | Pattern capture, documentation |
| Session Model | Single session, isolated worktree | Single session, native teammate API | Session-based insights |
| Verification | Mandatory, multi-tier (task + final) | Final verifier agent | Not applicable |
| Evidence Collection | Automatic via hooks | Structured via workers | Insight extraction |
| Concurrency | Parallel workers, single session | Native teammates, event-driven coordination | Single session |
| Role Specialization | No | Yes (8 worker roles) | No |
| Auto Mode | Yes (--auto flag) | No (interactive only) | No (hook-based) |
| Best For | Feature implementation, bug fixes | Large features, parallel agent work | Learning, documentation |
flowchart TD
CLI[Claude Code CLI] --> Commands
CLI --> Hooks[Lifecycle Hooks]
npx claudepluginhub mnthe/hardworker-marketplace --plugin ultraworkCollect insights from Claude sessions and extract them into reusable components (Skills, Commands, Agents, CLAUDE.md, Rules Files).
Native teammate-based collaboration plugin with role-based workers, event-driven coordination, and Claude Code agent teams.
General-purpose agent superteam for Claude code - contract-gated verification loops with 7 outer-loop roles, 5-phase orchestration, task form-driven inner-loop cooperation, and structural prevention of premature exits.
Virtual development team: TDD, debugging, code review, backlog management, and proven workflow patterns
Dynamically assemble expert agent teams for complex tasks using Claude Code's agent teams feature
Multi-agent orchestration for Claude Code. 12 specialized agents working in parallel — planning, building, reviewing, debugging. Plus a Hub for always-alive multi-project sessions controllable from Telegram or Slack.
Corca Workflow Framework — consolidated hooks and skill orchestration for structured development sessions
Cross-session Save/Load, and Ultrawork inspired by oh-my-opencode with Ralph Loops