- name
SKILL.md
File skill tetap berada di repositori penerbit.
Tempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add testdouble/han --skill automated-test-planning -a cursor -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add testdouble/han --skill automated-test-planning -a claude-code -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add testdouble/han --skill automated-test-planning -a codex -yTempel perintah yang disalin di terminal. Perintah itu memasang SKILL.md ini ke agen tersebut.
npx skills add testdouble/han --skill automated-test-planning -a grok -yKirim pesan yang disalin di chat Grok Bot. Bot mengambil SKILL.md ini dari GitHub dan menambahkannya ke skill yang dipakai bersama oleh semua Bot Anda.
Install this skill: https://github.com/testdouble/han/tree/HEAD/han-coding/skills/automated-test-planningDari penerbit
Test behavior through the public API, never internals. Every recommended test verifies observable behavior at a public seam: the inputs a real caller supplies, the outputs and side effects they observe, and the interactions the unit has with the other objects and services it collaborates with. Do not recommend tests that reach into private methods, internal state, or implementation structure — those tests pin the how and break on every refactor. When two designs would produce the same observable behavior, the test must pass for both. If a behavior can only be observed by inspecting internals, that is a signal the behavior belongs at a different seam, not a license to test the internal; note it and move the recommendation to the public boundary that exposes it. This is the depth ceiling: cover the critical behaviors a caller depends on, and stop. Do not specify tests for every branch, every private helper, or every intermediate value.
YAGNI is a first-class operating principle for tests. Apply the evidence-based YAGNI rule from ../../references/yagni-rule.md. A test is worth recommending only when (a) the code under review commits to a behavior the test verifies and (b) the failure mode the test would catch is realistic for this codebase. Tests for code paths that don't exist yet, hypothetical adversaries the code doesn't face, hypothetical scaling problems the workload doesn't have, "completeness" with existing tests, or symmetry ("we have a test for create, so we should have one for delete") are YAGNI candidates and go to the Deferred Tests section with the trigger that would justify writing them. When many speculative low-level tests can be replaced by one durable behavioral test that catches the same realistic failure modes, recommend the single test instead. Every test is ongoing maintenance and a brittleness surface.
Dispatch in proportion to the question. The size band chosen in Step 1.5 caps the roster, and a narrow question gets one agent and a prose answer rather than a team and a full document. Never dispatch the full roster for a question a single agent can settle BECAUSE the dispatch overhead exceeds the work, and a reader who asked one question pays for a document they did not want.
which git 2>/dev/null || echo "not installed"find . -maxdepth 1 -name "CLAUDE.md" -type ffind . -maxdepth 3 -name "project-discovery.md" -type fbash "${CLAUDE_PLUGIN_ROOT}/scripts/han-config-dir.sh" 2>/dev/null || echo "$HOME/.claude"cat .han/config.md 2>/dev/null || echo ""As your first action, use the Read tool on .han/config.md inside the personal config directory path above. A read
that returns no file is no personal configuration: continue silently. When that file or the project .han/config.md
probe supplies content, apply it per config-rule.md, which governs precedence
between the two files, relative-path resolution, and what to do with a file that reads but cannot be used.
Resolve project config: read CLAUDE.md's ## Project Discovery section for test command (under
### Commands and Tests, not ### Frameworks and Tooling), language, and framework; fall back to project-discovery.md.
Store found values for use in later steps.
Scope determination: Check git installed from Project Context. If empty or not installed, skip to Mode C
below.
Run ${CLAUDE_SKILL_DIR}/scripts/detect-test-context.sh and parse its output. If git-available: false, skip to Mode
C below.
Mode A: Full git context — git-available: true and the output contains a changed-files-start block with content.
Mode B: Uncommitted changes — git-available: true but output contains changed-files: none.
git diff (unstaged changes), git diff --cached (staged changes), and git status --short
(untracked files) to identify changed files; if any files are found, use those as scopeMode C: No git / no changes found — git missing, not in a repo, or no changes detected in any state.
node_modules/, .git/, vendor/,
dist/, build/, __pycache__/, lock files; present the discovered files and ask the user to confirm scopeBuild a list of source files to analyze: expand directories to find source files; identify relevant source files from branch changes or project structure for descriptions.
Default to small. Start the classification at small and only escalate to medium or large when the signals below clearly require it. When a signal is borderline, stay at the smaller band.
Classify from the user's own request first, and from Step 1's file list only when the request settles nothing. A narrow question asked on a branch with many changed files is still small BECAUSE Step 1 falls back to the whole changed-files list whenever the user named no scope, and that list describes the branch rather than the question.
Size override. If $size is non-empty (the user passed small, medium, large, or dynamic as the first
argument), use it: a band value is the size and skips the signal-based classification above, while dynamic forces the
signal-based classification even when the config sets a default band. If $size is empty and either .han/config.md
supplies a band via default-swarm-size (per ../../references/config-rule.md), use
that band and skip the signal-based classification. Anything that is not one of the four accepted values is trailing
context, not a size.
Bind $focus. Read the user's free-form argument string from the invocation (everything after the optional $size
positional). If non-empty, bind $focus to that string verbatim; if empty, bind it to none provided. This binding is
the description Step 2 passes to each agent prompt.
State the chosen band and mode in one line with the justification before dispatching anything (for example,
Small: the request names two proposed contexts on one method, so focused mode, Medium: passed via $size, or
Medium: from the project .han/config.md default-swarm-size, naming whichever file supplied it). Accept the user's
override of the band, the mode, or both.
In focused mode, dispatch only han-core:test-engineer in Step 2, skip the conditional specialists, answer in prose
per Step 4's focused-mode rules, and skip the two reviewers in Step 5. Step 3 runs in full either way. Its
behavioral, prerequisite, and YAGNI sweeps decide what may be recommended at all, so skipping them would let a focused
answer recommend a test that cannot be written without an out-of-scope production change. In full mode, run every
step as written.
In focused mode, dispatch item 1 alone and skip the conditional-dispatch section entirely.
Launch the testing agents in parallel using the Agent tool with run_in_background: true. Pass each agent the
file list from Step 1. In Mode A or Mode B, include on branch {branch} in agent prompts if a branch name was detected
by the script; in Mode C or when no branch was detected, omit the branch reference entirely. When $focus is anything
other than none provided, include it in every agent prompt so they can focus their analysis; it is what the
{any additional context from user arguments} placeholder below resolves to.
Launch han-core:test-engineer agent — prompt: "Analyze test coverage for the following files{on branch {branch} if applicable}: {file list}. Recommend tests only at the public API: the inputs a real caller supplies, the outputs and side effects they observe, and the interactions the unit has with the objects and services it collaborates with. Do not recommend tests that reach into private methods, internal state, or implementation structure — if two implementations would produce the same observable behavior, the test must pass for both. Cover the critical behaviors a caller depends on and stop; do not specify a test for every branch, private helper, or intermediate value. Apply the YAGNI rule from ../../references/yagni-rule.md — recommend a test only when the code commits to a behavior the test verifies AND the failure mode is realistic for this codebase. Symmetry, completeness, and hypothetical scaling are YAGNI; defer those to the Deferred Tests section with the trigger that would justify writing them. {any additional context from user arguments}"
Launch han-core:edge-case-explorer agent — prompt: "Explore edge cases for the following files{on branch {branch} if applicable}: {file list}. Focus on inputs, integration points, and error paths observable through the public API and through interactions with collaborating objects and services — not internal state or private implementation. Apply the YAGNI rule from ../../references/yagni-rule.md — raise an edge case only when a real caller produces the input, the failure mode has plausible production trigger, or the case is critical-path correctness regardless of caller. Hypothetical adversaries the code doesn't face and symmetry-driven boundaries go to Dropped Edge Cases with the trigger that would justify revisiting. {any additional context from user arguments}"
Skip this whole section in focused mode. Otherwise inspect the file list before launching, and skip any that do not apply.
Launch han-core:concurrency-analyst agent — only if the file list touches threads, async/await, goroutines, actors, shared mutable state across requests, timers, locks, or message queues. Prompt: "Identify concurrency test gaps for the following files{on branch {branch} if applicable}: {file list}. Focus on race conditions, lock ordering, shared-resource contention, deadlock potential, and async error handling that should be covered by tests. {any additional context from user arguments}"
Launch han-core:adversarial-security-analyst agent — only if the file list touches authentication, authorization, input validation, data isolation, session handling, crypto, file uploads, external API calls with secrets, or SQL/ORM query construction. Prompt: "Identify negative security tests that should exist for the following files{on branch {branch} if applicable}: {file list}. Focus on exploit paths that tests could catch before production — authorization bypass, injection, broken isolation, insecure defaults. Return test recommendations, not general threat modeling. {any additional context from user arguments}"
Extra agents named in the project config's ## Extra Agents list join this conditional-dispatch pool under the same
file-list-signal selection, per ../../references/config-rule.md: dispatch one only
when the file list carries a signal matching its stated specialty, and skip an entry that does not resolve to a
dispatchable agent with a one-line note.
Wait for every dispatched agent to complete and collect full output for processing in Step 3.
Combine findings from every dispatched agent into a unified, prioritized test plan:
order,
a new validation, a changed return value, a schema column, or any other edit to shipped code, is not a test to
write. It is a production change wearing a test's clothes, and folding it into the plan hands the implementer a code
change nobody authorized. Move it out of the priority tiers into Blocked by a Production Change, recording the
change it needs, the file that would carry it, and who else consumes that file, so a reader can see the blast radius
and open a separate ticket. Run this sweep before IDs are assigned, and run it over security items too: an honest
finding at CRIT is still out of scope if it cannot be tested without first changing shipped code.Before generating, invoke han-communication:readability-guidance to source the shared readability standard into your
context, then apply it as you write the plan's plain-language spine (Summary, What Needs Testing and Why, What Each Test
Covers), holding the named audience: the engineer who will implement the tests. The frame governs how a fact is said,
never whether a required fact appears — keep the file:line references, test levels, and TP-IDs the plan depends on.
In focused mode, do not use the template. Answer in prose: the verdict on what was asked, the reasoning that settles it, and any test worth writing, with the file:line references and test levels the engineer needs. Write no section that the question did not ask for BECAUSE a reader who asked one question should not have to search a nine-section document for its answer. Skip the rest of this step's template rules and go to Step 5.
In full mode, use the template at template.md for the output structure. The test plan leads with plain language and defers the implementation detail.
Writing rules:
Lead with behavior. These rules make the plan a human-readable overview first and an implementation outline second:
## Technical Reference region. Describe what needs testing and what would break without it, in
functional terms a reader who has not seen the code can follow. Name files, types, and test levels only where they
aid understanding.## Technical Reference region, below the plain-language spine. A reader who only needs to know what to test and why
can stop above.Fill in all sections:
In focused mode, skip the two reviewers below and go straight to the readability editor and the self-check that follow them. The two reviewers audit a document's structure and its plain-language layer, and a focused answer has neither BECAUSE it is a few paragraphs rather than a layered document.
In full mode, dispatch two reviewers against the generated test plan, in parallel, using the Agent tool. The plan is produced
in-channel, so embed the full plan text in each agent's prompt (in place of {plan text} below). If the plan was
written to a file, pass that path instead and let the agent read it.
Launch han-core:information-architect agent — prompt: "Audit the following test plan for findability,
orientation, and comprehension. The intended audience is an engineer or technically-literate stakeholder who needs to
understand what needs testing and why before reading the implementation detail. Check: (1) Do the plain-language
Summary, What Needs Testing and Why, and What Each Test Covers sections appear before the ## Technical Reference
region? If the plain-language content is missing or sits below the reference detail, that is a finding. (2) Does the
Summary paragraph read for someone who has not seen the code — no file paths, TP-IDs, or framework jargon? (3) Does
the heading list let a scanning reader see where the plain-language overview ends and the deep Technical Reference
begins? (4) Do the What Each Test Covers lines cross-link to their TP-IDs so a reader can move from plain language to
detail? Return a list of structural edits; do not return an empty list unless the plan leads with plain language and
defers the implementation detail.\n\n{plan text}"
Launch han-core:junior-developer agent — prompt: "Review the following test plan as a generalist teammate who has not seen this code. Reading only the plain-language sections (Summary, What Needs Testing and Why, What Each Test Covers), can you understand what needs testing and why it matters without dropping into the Technical Reference? Flag any plain-language line that is unclear, leans on undefined jargon, assumes context a reader would not have, or states a test without conveying what would break if it were missing. Return a list of clarity findings with the section and line they apply to; return an empty list only if the plain-language layer stands on its own.\n\n{plan text}"
Apply every actionable edit the agents return. For findings that require author judgment (scope or audience ambiguity), surface them to the user with a recommended resolution; do not silently resolve.
Once every actionable edit is applied and the plan is final, dispatch han-communication:readability-editor (one Agent
call) to audit and rewrite the plan's prose against the readability standard. If the plan was written to a file, pass the
editor that file path; if it is in-channel, pass the plan text and apply the returned rewrite. Also pass the named
audience: the engineer who will implement the tests; the editor reads han-communication's own canonical rule, so pass no
rule path. It must preserve every fact and operate on prose regions only — never inside code fences, tables, or the
TP-NNN test identifiers, which must survive unchanged so they still resolve. Apply its rewrite to the plan.
Then run the standardized readability self-check (the shared standard is in your context from
han-communication:readability-guidance) over the plan's prose regions only — never inside code fences, tables, or the
TP-NNN identifiers. Confirm each criterion and fix any failure before presenting:
Run the readability rule's standardized self-check, which is already in your context from the readability-guidance
invocation above. Correct every failure before presenting. Its fidelity criterion is not optional: the standard governs
how the content is said, and drops a required fact only when the reader asked for less and losing it would not change
what they do next.
>
---name: automated-test-planningdescription: >---# han-coding/skills/automated-test-planning/SKILL.mdFAQ
Unduh han-coding/skills/automated-test-planning/SKILL.md dari penerbit, atau salin path-nya dan buka repositori. PlugMCP hanya mendaftar skill ini dan tidak meng-host filenya.
Penerbit menyimpannya di https://github.com/testdouble/han.
Claude, Cursor, Codex, dan Grok Build bisa membaca SKILL.md yang Anda tambahkan dari repositori penerbit. Grok Bot memasangnya saat Anda mengirim tautan folder GitHub skill tersebut di chat.
Reason: YAGNI — {gate failure} and the trigger that would justify writing the test (a third real customer hits the
edge case, the feature actually ships the path, a measured production failure occurs, etc.). When several recommended
low-level tests can be replaced by one durable behavioral test that catches the same realistic failure modes, replace
them with the single test and record the dropped low-level tests under Deferred with
Reason: YAGNI — single behavioral test catches the same realistic failure modes.