Claude Skill

insight-explore

Explore possible implementations before committing, targeting three distinct options while reporting evidenced constrained or unresolved outcomes honestly. Trigger when the user runs /explore or asks to "brainstorm options", "what are the ways to do this", "explore approaches", "

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download allemaar-open-skills-skills_insight-explore-acf5f79.zip · 4 KB

Install

skills CLI npx skills add https://github.com/allemaar/open-skills/tree/main/skills/insight-explore
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install allemaar-open-skills@llmmart
Git git clone https://github.com/allemaar/open-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole allemaar/open-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

/explore

Divergent thinking — target three distinct feasible implementation options, then converge on a recommendation. Produces options, not plans.

Structured execution spec: protocol.yon. Read it for the canonical rules and step sequence; this file is explanation. The two must stay in sync — if you edit one, update the other and refresh the @STAMP date.

Brainstorming Protocol — explore before committing. /insight-explore generates alternatives (divergent). /insight-assess evaluates them (convergent). /plan-create designs the chosen approach.

Phase 1 — Divergence

  1. Analyze constraints — what are we optimizing for? What are the hard requirements vs. preferences?
  2. Option A: The Standard Pattern — the obvious, well-trodden approach. What would most engineers reach for first?
  3. Option B: The Performance Way — optimized for speed, scale, or efficiency. Possibly more complex.
  4. Option C: The Minimalist — YAGNI. Smallest footprint that still solves the problem.

Additional options may be added if the problem space warrants them (e.g., event-driven, type-safe, or zero-dependency variants).

Phase 2 — Convergence

Compare all options across:

  • DX — developer experience, API ergonomics, debuggability
  • Robustness — error handling, edge case coverage, failure modes
  • Timeline fit — how long does each take to implement and validate?
  • Alignment — does it match existing patterns and coding standards in the repo?

Phase 3 — Recommendation

Output:

  • Winner — which supported option and why, or an explicit constrained/unresolved outcome with its decisive gap
  • Reason — 1–2 sentences, referencing the comparison
  • Next step — ask the user: "Shall I /plan-create this?"

Rules

  • Target three distinct feasible options and search for at least two; if evidence supports only one or none, report that constrained or unresolved result, the bounded search scope and decisive gap. Never invent cosmetic alternatives or a winner.
  • MUST NOT write code or make changes — this is ideation only.

Next Steps

  • /insight-assess — evaluate the winner in depth before committing
  • /plan-create — design the chosen approach

Human output. This skill's handler-facing output obeys the human-output contract (human-output/SKILL.md).

Next skills. On completion, run the Next Skills protocol (next-skills/SKILL.md): surface the next-skills recommendations from front-matter for the caller to pick. Offer only — never auto-invoke.

Self-improvement. On completion, run the Self-Improvement Protocol (self-improve/SKILL.md): apply its signal taxonomy and threshold to this run; surface any surviving proposal for handler approval. Conservative — silent otherwise. Never auto-apply.

Files (open-skills)
  • protocol.yon 5.5 KB · in bundle
  • SKILL.md 3.8 KB
    ---
    name: insight-explore
    description: >
      Explore possible implementations before committing, targeting three distinct options while reporting evidenced constrained or unresolved outcomes honestly. Trigger when the user runs /explore or asks to "brainstorm options", "what are the ways to do this", "explore approaches", "give me alternatives", or wants divergent thinking before planning or assessment. Use insight-assess to evaluate known options, insight-critique to review an existing output, and plan-create to turn a chosen direction into an implementation plan.
    visibility: public
    self-improvable: true
    next-skills:
      - skill: insight-assess
        phrase: "/insight-assess"
        why: "Evaluate the options you just generated and pick one"
      - skill: plan-create
        phrase: "/plan-create"
        why: "Turn a chosen option into a phased plan"
    triggers:
      - "/explore"
      - "brainstorm options"
      - "what are the ways to do this"
      - "explore approaches"
      - "give me alternatives"
    ---
    
    # /explore
    
    Divergent thinking — target three distinct feasible implementation options, then converge on a recommendation. Produces options, not plans.
    
    > **Structured execution spec:** [`protocol.yon`](protocol.yon). Read it for the canonical rules and step sequence; this file is explanation. The two must stay in sync — if you edit one, update the other and refresh the `@STAMP` date.
    
    > **Brainstorming Protocol — explore before committing.** `/insight-explore` generates alternatives (divergent). `/insight-assess` evaluates them (convergent). `/plan-create` designs the chosen approach.
    
    ## Phase 1 — Divergence
    
    1. **Analyze constraints** — what are we optimizing for? What are the hard requirements vs. preferences?
    2. **Option A: The Standard Pattern** — the obvious, well-trodden approach. What would most engineers reach for first?
    3. **Option B: The Performance Way** — optimized for speed, scale, or efficiency. Possibly more complex.
    4. **Option C: The Minimalist** — YAGNI. Smallest footprint that still solves the problem.
    
    Additional options may be added if the problem space warrants them (e.g., event-driven, type-safe, or zero-dependency variants).
    
    ## Phase 2 — Convergence
    
    Compare all options across:
    
    - **DX** — developer experience, API ergonomics, debuggability
    - **Robustness** — error handling, edge case coverage, failure modes
    - **Timeline fit** — how long does each take to implement and validate?
    - **Alignment** — does it match existing patterns and coding standards in the repo?
    
    ## Phase 3 — Recommendation
    
    Output:
    
    - **Winner** — which supported option and why, or an explicit constrained/unresolved outcome with its decisive gap
    - **Reason** — 1–2 sentences, referencing the comparison
    - **Next step** — ask the user: *"Shall I `/plan-create` this?"*
    
    ## Rules
    
    - Target three distinct feasible options and search for at least two; if evidence supports only one or none, report that constrained or unresolved result, the bounded search scope and decisive gap. Never invent cosmetic alternatives or a winner.
    - MUST NOT write code or make changes — this is ideation only.
    
    ## Next Steps
    
    - `/insight-assess` — evaluate the winner in depth before committing
    - `/plan-create` — design the chosen approach
    
    > **Human output.** This skill's handler-facing output obeys the human-output
    > contract (`human-output/SKILL.md`).
    
    > **Next skills.** On completion, run the Next Skills protocol (`next-skills/SKILL.md`): surface the `next-skills` recommendations from front-matter for the caller to pick. Offer only — never auto-invoke.
    
    > **Self-improvement.** On completion, run the Self-Improvement Protocol (`self-improve/SKILL.md`): apply its signal taxonomy and threshold to this run; surface any surviving proposal for handler approval. Conservative — silent otherwise. Never auto-apply.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.