This skill should be used when starting any feature or bug fix, exploring unfamiliar code, making commits or PRs, or when unsure which agent or approach to use. Covers agent routing, git discipline, testing workflow, and proactive quality practices.
Routes development tasks to specialized agents: uses feature-dev for complex features, code-explorer for unfamiliar code, and code-reviewer before commits. Guides git workflow, testing, and PR creation.
/plugin marketplace add ImproperSubset/hh-agentics/plugin install cc-governance@hh-agenticsThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Purpose: Establish efficient, high-quality development practices using AI code assistant agents and tools.
Category: Meta-Skill (Development Process)
This skill applies throughout the entire development lifecycle:
Triggers:
Use the right tool for the job. Don't do manually what specialized agents can do better.
/feature-dev?Use /feature-dev if:
Skip /feature-dev if:
If using /feature-dev:
1. Invoke Skill tool with skill="feature-dev:feature-dev"
2. Let the feature-dev workflow handle:
- Codebase exploration
- Clarifying questions
- Architecture design
- Implementation
- Code review
3. Done - feature-dev handles end-to-end
If NOT using /feature-dev (simple change):
1. Read relevant files to understand current implementation
2. Ask clarifying questions if anything is ambiguous
3. Implement the change
4. Run build/lint/tests
5. Consider code-reviewer agent for non-trivial changes
Anti-pattern:
❌ User: "Add a new selector component"
Assistant: *immediately starts writing code*
✅ User: "Add a new selector component"
Assistant: "I'll use /feature-dev to explore the codebase,
understand existing patterns, and design the implementation."
Use code-explorer agent if:
Manual search (Glob/Grep) if:
For exploration (use code-explorer):
1. Launch Task tool with subagent_type="Explore"
2. Provide clear question: "How does authentication work?"
3. Specify thoroughness: "medium" or "very thorough"
4. Read files identified by agent
5. Summarize findings
For needle queries (manual search):
1. Use Glob for file patterns: "**/*auth*.js"
2. Use Grep for code patterns: "getUser.*session"
3. Read matched files
4. Provide answer
Use EnterPlanMode if ANY of:
Skip plan mode if:
1. Use EnterPlanMode tool
2. In plan mode:
a. Explore codebase thoroughly
b. Understand existing patterns
c. Identify decision points
d. Use AskUserQuestion for clarifications
e. Design implementation approach
f. Write plan to plan file
g. Use ExitPlanMode
3. Wait for user approval
4. Implement according to approved plan
Use code-reviewer proactively when:
Workflow
1. Complete implementation
2. Launch Task tool with subagent_type="pr-review-toolkit:code-reviewer"
3. Specify files to review (usually unstaged git diff)
4. Review agent findings
5. Fix high-priority issues
6. Commit changes
NEVER:
git commit via Bash without crafted message--no-verify to skip hooks (unless user explicitly requests)ALWAYS:
skill="commit-commands:commit"git status and git diff in parallel first1. Run in parallel:
- git status (see untracked files)
- git diff (see staged + unstaged changes)
- git log -10 --oneline (see commit style)
2. Analyze changes and draft commit message:
- Type: feat/fix/refactor/docs/chore/test
- Summary: What changed and why (focus on "why", not "what")
- Keep under 72 characters for summary line
3. Stage relevant files (git add)
4. Commit with proper message and attribution
5. Run git status after commit to verify success
ALWAYS search (don't assume) for:
Safe to assume (from training):
1. Identify knowledge gap
2. Use WebSearch or documentation tools
3. Cite sources in response
4. Apply findings to implementation
Minimum (ALWAYS):
1. Build (if applicable)
2. Lint (if applicable)
3. Describe what to test manually
1. Implement feature
2. Run build/lint commands
3. Describe manual testing steps
4. If update handlers involved:
- Review safety checklist
- Recommend appropriate tests
Feature request
├─ Trivial (1-5 lines)? → Implement directly
├─ Exploration needed? → code-explorer
├─ Architecture decision? → feature-dev (includes exploration + planning)
├─ Just planning? → EnterPlanMode
└─ Implementation done? → code-reviewer (proactive)
Code question
├─ Needle query (know what to find)? → Glob/Grep
├─ "How does X work?" → code-explorer
└─ "Where is X?" → code-explorer
Commit/PR
├─ Ready to commit? → Use commit skill (never raw git)
├─ Ready for PR? → Analyze full diff, draft description
└─ Unsure if ready? → code-reviewer first
Knowledge question
├─ Framework API? → SEARCH (changes between versions)
├─ Recent library features? → SEARCH
├─ Security concern? → SEARCH
├─ Browser compatibility? → SEARCH
├─ Basic JavaScript? → Assume (from training)
└─ Git basics? → Assume
Problem: Implementing without understanding existing patterns
❌ User: "Add a new field component"
Assistant: *immediately writes new code from scratch*
✅ User: "Add a new field component"
Assistant: *uses code-explorer to understand existing patterns first*
Problem: Doing manually what agents do better
❌ User: "Where are errors handled?"
Assistant: *manually greps for "error", reads 3 files*
✅ User: "Where are errors handled?"
Assistant: *launches code-explorer to trace error handling comprehensively*
Problem: Using outdated or incorrect API information
❌ Assistant: "I'll use the deprecated API pattern"
✅ Assistant: "Let me verify the current API pattern..."
Problem: Raw git commands, poor messages, no attribution
❌ Assistant: *runs bash* `git commit -m "fix"`
✅ Assistant: *uses commit skill*
Assistant: *analyzes changes, drafts message, includes attribution*
Problem: Declaring done without verification steps
❌ Assistant: "Feature complete!"
✅ Assistant: "Feature complete. To test:
1. Run the build
2. Open the application
3. Verify the new feature works"
/feature-devcode-explorerEnterPlanModeYou're following this workflow correctly when:
Last Updated: 2026-01-04 Status: Active - use throughout development lifecycle
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.