From godmode
Use when starting any conversation - establishes how to locate and invoke skills, mandating Skill tool usage before ANY response including clarifying questions
npx claudepluginhub noobygains/godmode --plugin godmodeThis skill uses the workspace's default tool permissions.
<CRITICAL-OVERRIDE>
Establishes protocol for invoking relevant skills before any response, even clarifying questions, at conversation start. Checks 1% relevance threshold.
Mandates invoking relevant skills via tools before any response in coding sessions. Covers access, priorities, and adaptations for Claude Code, Copilot CLI, Gemini CLI.
Share bugs, ideas, or general feedback.
YOU DO NOT HAVE THE OPTION TO SKIP A RELEVANT SKILL. IT IS MANDATORY.
This requirement is absolute. It cannot be reasoned away or deferred.
Plugin installation (standard setup): Invoke skills directly through the Skill tool. All protocols are auto-registered.
Example: Skill("godmode:intent-discovery")
When the Skill tool cannot locate a protocol: Fall back to reading the file directly with the Read tool:
[plugin-root]/skills/[plugin-root]/skills/[protocol-name]/SKILL.mdLocating the plugin root:
CLAUDE_PLUGIN_ROOT environment variable contains the pathOther platforms: Consult platform-specific documentation for skill loading mechanisms.
Invoke applicable skills BEFORE generating any response or taking any action. Even a marginal chance of relevance is sufficient reason to invoke. If an invoked skill turns out to be inapplicable, you can simply move on.
digraph protocol_flow {
"Message arrives" [shape=doublecircle];
"About to enter planning?" [shape=doublecircle];
"Intent discovery done?" [shape=diamond];
"Run intent-discovery" [shape=box];
"Could any skill apply?" [shape=diamond];
"Invoke Skill tool" [shape=box];
"Skill tool errored?" [shape=diamond];
"Read SKILL.md fallback" [shape=box];
"Announce: 'Applying [skill] for [goal]'" [shape=box];
"Contains checklist?" [shape=diamond];
"Track each checklist item" [shape=box];
"Execute skill instructions" [shape=box];
"Generate response" [shape=doublecircle];
"About to enter planning?" -> "Intent discovery done?";
"Intent discovery done?" -> "Run intent-discovery" [label="no"];
"Intent discovery done?" -> "Could any skill apply?" [label="yes"];
"Run intent-discovery" -> "Could any skill apply?";
"Message arrives" -> "Could any skill apply?";
"Could any skill apply?" -> "Invoke Skill tool" [label="yes, any chance"];
"Could any skill apply?" -> "Generate response" [label="clearly not"];
"Invoke Skill tool" -> "Skill tool errored?";
"Skill tool errored?" -> "Read SKILL.md fallback" [label="yes"];
"Skill tool errored?" -> "Announce: 'Applying [skill] for [goal]'" [label="no"];
"Read SKILL.md fallback" -> "Announce: 'Applying [skill] for [goal]'";
"Announce: 'Applying [skill] for [goal]'" -> "Contains checklist?";
"Contains checklist?" -> "Track each checklist item" [label="yes"];
"Contains checklist?" -> "Execute skill instructions" [label="no"];
"Track each checklist item" -> "Execute skill instructions";
}
These internal thoughts are warning signs that you are rationalizing:
| Thought | Truth |
|---|---|
| "This is a straightforward question" | Questions are tasks. Look for applicable skills. |
| "I should gather more context first" | Skill invocation precedes clarification. |
| "Let me scan the codebase first" | Skills define HOW to scan. Invoke first. |
| "I can check files and history quickly" | Files lack conversational context. Invoke skills. |
| "Let me collect some data first" | Skills prescribe data collection methods. |
| "This doesn't warrant a formal skill" | If a matching skill exists, it must be used. |
| "I recall what this skill says" | Skills get updated. Read the current version. |
| "This isn't really a task" | Any action is a task. Look for skills. |
| "The skill is too heavy for this" | Seemingly simple tasks often have hidden complexity. Use it. |
| "I'll do this one thing first" | Invoke BEFORE doing anything. |
| "I'm making good progress" | Undirected effort creates waste. Skills prevent this. |
| "I understand that concept already" | Understanding a concept is not the same as following a skill. Invoke it. |
When several skills might be relevant, follow this sequence:
"Let's build X" -> rationale -> intent-discovery -> reference-engine (routes to appropriate references) -> design skills -> implementation skills. "Build a website" -> rationale -> intent-discovery -> reference-engine -> design-research + ux-patterns -> ui-engineering -> implementation. "Fix this bug" -> fault-diagnosis first, then domain-appropriate skills. (rationale skipped for bugs) "Big project" -> rationale -> intent-discovery -> reference-engine -> task-planning -> team-orchestration (when warranted). "Agent is stuck" -> error-recovery activates proactively based on failure count detection. "What database/hosting should I use?" -> environment-awareness -> deployment-advisor -> system-design.
When a user says "use godmode" for a task, evaluate the task and suggest the optimal execution strategy:
digraph execution_guidance {
"Evaluate task" [shape=box];
"Single atomic step?" [shape=diamond];
"Handle directly" [shape=box];
"Multiple independent parts?" [shape=diamond];
"Requires peer coordination?" [shape=diamond];
"Suggest Agent Teams" [shape=box style=filled fillcolor=lightgreen];
"Suggest Parallel Delegation" [shape=box];
"Multi-step sequence?" [shape=diamond];
"Suggest Delegated Execution" [shape=box];
"Suggest single-agent workflow" [shape=box];
"Evaluate task" -> "Single atomic step?";
"Single atomic step?" -> "Handle directly" [label="yes"];
"Single atomic step?" -> "Multiple independent parts?" [label="no"];
"Multiple independent parts?" -> "Requires peer coordination?" [label="yes"];
"Multiple independent parts?" -> "Multi-step sequence?" [label="no"];
"Requires peer coordination?" -> "Suggest Agent Teams" [label="yes"];
"Requires peer coordination?" -> "Suggest Parallel Delegation" [label="no"];
"Multi-step sequence?" -> "Suggest Delegated Execution" [label="yes"];
"Multi-step sequence?" -> "Suggest single-agent workflow" [label="no"];
}
Present the suggestion before acting:
Based on my analysis, I suggest:
[Suggested strategy] because [reasoning]
- Agent Teams: [X] agents collaborating on [modules] concurrently
- OR Delegated Execution: [N] sequential tasks with review gates
- OR Parallel Delegation: [N] independent tasks running simultaneously
- OR Single agent: manageable enough to handle in one flow
Shall I proceed this way, or do you prefer a different approach?
Rigid (test-first, fault-diagnosis): Follow precisely. Do not deviate from the discipline.
Flexible (design patterns): Adapt the principles to fit the situation.
The skill definition itself indicates which category applies.
When the user signals they want autonomous execution, skip all confirmation prompts and compress workflows — but never auto-pick labeled options.
Trigger phrases (case-insensitive):
Behavior when active:
How skills reference YoloMode:
If YoloMode is active:
-> State: "YoloMode active — proceeding with recommendation [X] because [reason]"
-> Execute immediately
-> Log which option was auto-selected
If YoloMode is NOT active:
-> Present options with labels and recommendation
-> Wait for user selection
YoloMode does NOT bypass:
YoloMode is about speed, not recklessness. It trusts the agent's recommendation for design choices, not for safety checks.
User directives specify WHAT needs to happen, not HOW. "Add X" or "Fix Y" does not mean bypass established workflows.