By testdouble
Drive a disciplined BDD-framed TDD loop with enforced red-green-refactor, restructure code via test-gated refactoring, review and analyze code architecture, investigate root causes, and create coding standards — all within a structured workflow for writing, reviewing, and improving code.
Performs deep architectural analysis of a specified module, directory, or feature area by examining structural coupling, data flow, concurrency patterns, risk, and SOLID alignment. Use when the user wants to assess, evaluate, or review the architecture, design quality, dependency structure, coupling, cohesion, or technical debt of an existing part of the codebase. Not for investigating specific bugs, runtime errors, or failures — use investigate. Not for test planning — use test-planning. Not for file-level code review — use code-review. Not for researching open-ended options, prior art, or how something works — use research. Not for writing documentation or architectural decision records.
Produces a human-readable, progressive-disclosure overview of unfamiliar code or a pull request's changes — why it exists (the real problem it solves or goal it serves for the business or a user), and from there what it does, how it flows, and where to start — so you can get up to speed before working on or reviewing it. Use when you want to understand, get oriented in, make sense of, explain, or get up to speed on a chunk of code, a file, a directory, a symbol, or a PR's changes. Writes the overview to a scratch file and changes no code. Does not review code quality or raise findings — use code-review for auditing changes or post-code-review-to-pr for posting them. Does not produce durable feature or system documentation — use project-documentation. Does not assess architecture or structural risk — use architectural-analysis. Does not diagnose bugs or root-cause failures — use investigate.
Run a comprehensive code review on local source files. Use this skill when the user asks to review, audit, inspect, evaluate, or check code, even if they never use the word "review." Does not post comments to GitHub pull requests — use post-code-review-to-pr for that. Does not analyze architectural structure or module boundaries — use architectural-analysis for that. Does not explain code or a PR to build understanding before reviewing — use code-overview for that. Does not capture feedback on Han's own skills — use han-feedback for that.
Creates and updates coding standards, conventions, rules, and guidelines for the current project. Use when creating new standards from scratch, converting existing documents into coding standards, or updating existing standards. Does not create architectural decision records — use architectural-decision-record for ADRs. Does not write feature or system documentation — use project-documentation for that. Does not research open-ended options — use research. Does not produce runbooks for operational scenarios — use runbook for that.
Evidence-based investigation of issues, bugs, API calls, integrations, and other aspects of software development that need a deep dive to find the root cause and solutions. Use when you need to debug, troubleshoot, diagnose, or figure out why something is broken. Does not review code for quality or style — use code-review for auditing changes or post-code-review-to-pr for posting review feedback to GitHub. Does not assess architectural health or structural risk — use architectural-analysis for architectural concerns. Does not research open-ended options, prior art, or how something works when nothing is broken — use research for that. Does not capture feedback on Han's own skills — use han-feedback for that.
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.
Han is a suite of AI skills and agents for solo (or small-team) product engineers. It combines evidence-based planning, test-driven implementation, full documentation maintenance, deep code review, and architectural analysis into a team of specialists you can dispatch from Claude Code.
Han turns planning, implementation, review, and documentation work that would normally take a team into a set of deterministic skills you run from Claude Code.
Each skill dispatches specialist agents, such as project managers, adversarial reviewers, investigators, architectural analysts, and testing and security specialists, to do the judgment-heavy work. It then folds their findings into an artifact you can trust.
The skills are designed to compose. You can plan a feature, then plan its implementation, then iterate on the plan, then build it test-first, then review the resulting code, then write the PR description. All through named skills that hand off to each other cleanly.
Read Concepts for the skill-and-agent model that runs through the whole plugin.
Han is purpose-built for solo product engineers and small teams, instead of large teams or enterprise. This does not mean it can't work in larger teams, though. Read about why Han's focus is solo product engineers and small teams to understand Han's positioning and what it does not bring to the table.
Add the Test Double skills marketplace to Claude Code, then install the plugin:
/plugin marketplace add testdouble/han
/plugin install han@han
Han ships as multiple plugins:
| Plugin | Type | What it brings |
|---|---|---|
han | parent | the parent plugin that brings in han-core, han-planning, han-coding, han-github, and han-reporting |
han-core | bundled | research, analysis, and documentation skills plus every agent |
han-planning | bundled | planning skills you reach for before implementation |
han-coding | bundled | coding skills you reach for while working in code |
han-github | bundled | GitHub-facing skills like posting a code review on a PR |
han-reporting | bundled | reporting skills like the stakeholder summary |
han-feedback | opt-in | skill for capturing post-session feedback on Han skill runs |
han-atlassian | opt-in | skills for publishing docs and work items to Atlassian products |
han-linear | opt-in | skill for publishing work items to Linear (requires a Linear MCP server) |
han-plugin-builder | opt-in | carries the guidance and skills for building your own skills, agents, and plugins |
Installing han@han pulls in the bundled suite (the meta-plugin plus han-core, han-planning,
han-coding, han-github, and han-reporting), and is the right choice for most people. If you do
not want the planning, coding, GitHub, or reporting skills, install han-core@han instead, and add other
specific plugins as desired.
For the full picture and a quick "which one do you need?" guide, see Choosing a Han plugin.
Add this repo as a Codex marketplace:
codex plugin marketplace add testdouble/han
Codex does not yet support meta-plugins like han@han (see openai/codex#23531,) so install the Han packages directly:
codex plugin add han-core@han
codex plugin add han-planning@han
codex plugin add han-coding@han
codex plugin add han-github@han
codex plugin add han-reporting@han
Install han-feedback, han-atlassian, han-linear, or han-plugin-builder
separately when you want those opt-in packages.
npx claudepluginhub testdouble/han --plugin han-codingGithub specific extensions to the Han plugin for agentic planning and coding. Provides skills to post code reviews as PR comments, update a PR description with a consistent format, etc.
Planning-facing skills for the Han suite: specifying, planning, sequencing, breaking down, and stress-testing work before implementation. Home of plan-a-feature (build a feature specification from scratch through a relentless, evidence-based interview that walks the design tree), plan-implementation (turn a feature specification into an implementation plan through a project-manager-led team conversation), plan-a-phased-build (split a body of context into a sequence of independently demoable vertical-slice phases), plan-work-items (break a trusted implementation plan into independently-grabbable, atomic work items), and iterative-plan-review (stress-test an existing plan through multiple codebase-grounded review passes). Depends on han-core; bundled by the han meta-plugin.
Guidance and tooling for building Claude Code skills and plugins. Carries the full body of skill-authoring, agent-authoring, and plugin-configuration guidance, and an init step that vendors that guidance into any repo as a path-scoped rule index so contributors get the right guidance loaded for the file they are editing. Standalone and opt-in: depends on nothing and is not bundled by the han meta-plugin.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.
Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.
Consult multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, plus codex, antigravity, and grok CLIs when installed) to get diverse perspectives on coding problems
Comprehensive PR review agents specializing in comments, tests, error handling, type design, code quality, and code simplification