Claude-skill-registry dev-inquiry

Developer inquiry skill for technical investigation, validation, and decision-making. Use when exploring unfamiliar technology, validating approaches with spikes, comparing options, or making architecture decisions. Covers the full thinking process from "I don't know" to confident decision.

install
source · Clone the upstream repo
git clone https://github.com/majiayu000/claude-skill-registry
Claude Code · Install into ~/.claude/skills/
T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/dev-inquiry" ~/.claude/skills/majiayu000-claude-skill-registry-dev-inquiry && rm -rf "$T"
manifest: skills/data/dev-inquiry/SKILL.md
source content

Dev Inquiry

Feynman-style technical inquiry for developers. Understand before you decide. Validate before you build.

"The first principle is that you must not fool yourself—and you are the easiest person to fool." — Richard Feynman

Inquiry Modes

This skill supports four modes that often chain together:

ModeWhen to UseTrigger Phrases
InvestigateUnderstand something unfamiliar"explore", "understand", "how does X work"
SpikeValidate approach before building"spike", "validate", "prove this works"
CompareEvaluate options for your context"compare", "vs", "which is better"
DecideMake a concrete choice"should we", "decide", "recommend"

How to Use This Skill

  1. Identify the mode from the user's request
  2. Load the appropriate reference:
    • Investigation → Read
      references/investigation.md
    • Spike validation → Read
      references/spike.md
    • Comparison → Read
      references/scoring.md
    • Decision → Read
      references/scoring.md
      (uses comparison + decision framework)
  3. Follow the workflow in that reference
  4. Chain if needed — investigation often leads to spike, spike informs comparison

Mode Details

Investigate Mode

For understanding unfamiliar technology from first principles.

Process: Admit ignorance → Simplest experiment → Poke edges → Build mental model → Explain simply

Output: Mental model you can teach to someone else

Spike Mode

For validating technical feasibility before full implementation.

Process: Define scope (4-8 hours) → Write tests first → Implement minimal → Test with real data → Document pattern

Output: Proven pattern ready to replicate, or pivot decision

Compare Mode

For evaluating multiple options against your specific context.

Process: Define context → Choose criteria → Weight by importance → Score with evidence → Sanity check

Output: Weighted comparison matrix with evidence

Decide Mode

For making a concrete choice with documented reasoning.

Process: Ensure understanding (investigate if needed) → Compare options → State recommendation → Document tradeoffs → Assess reversibility

Output: Clear recommendation with rationale and risks

The Natural Flow

"Let's explore @Observable"
        ↓ Investigation
"Can I actually build nested observation?"
        ↓ Spike (validates understanding)
"@Observable vs @StateObject for my app"
        ↓ Comparison
"Should we adopt the new Observation framework?"
        ↓ Decision

Each mode builds on the previous. Don't decide before you understand. Don't compare before you investigate.

Quick Reference

RequestModeReference
"Let's explore Swift macros"Investigate
references/investigation.md
"I want to understand async/await"Investigate
references/investigation.md
"Spike SwiftData before we commit"Spike
references/spike.md
"Validate this architecture works"Spike
references/spike.md
"Compare REST vs GraphQL"Compare
references/scoring.md
"SwiftData vs CoreData?"Compare
references/scoring.md
"Should we use Combine?"Decide
references/scoring.md
"Recommend an approach"Decide
references/scoring.md

Examples

For concrete examples across all modes, see

references/examples.md
.