跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

vibespec-explore

Spec-aware Explore → Plan → Implement for projects that use the vibespec specification system. A thinking partner for exploring ideas and clarifying requirements that grounds investigation in the project's specs/ before reaching for code, produces a roadmap (What / How / Where / Spec footprint / Acceptance criteria) for user approval, then implements it while keeping specs synchronized via the spec lifecycle skills. Use when requirements are unclear, when discussing architecture and design decisions, or before a structural change in a spec-governed project. Falls back to plain code exploration when no specs/ directory exists.

v0lka · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add v0lka/skills --skill vibespec-explore

技能说明


name: vibespec-explore description: Spec-aware Explore → Plan → Implement for projects that use the vibespec specification system. A thinking partner for exploring ideas and clarifying requirements that grounds investigation in the project's specs/ before reaching for code, produces a roadmap (What / How / Where / Spec footprint / Acceptance criteria) for user approval, then implements it while keeping specs synchronized via the spec lifecycle skills. Use when requirements are unclear, when discussing architecture and design decisions, or before a structural change in a spec-governed project. Falls back to plain code exploration when no specs/ directory exists.

Spec-aware Explore → Plan → Implement

vibespec-explore is the spec-aware counterpart of the standalone explore skill. It is a three-mode workflow — thinking partner, then structured planning, then implementation — with one difference that shapes every mode: the project's specification system (specs/) is the entry point, not the codebase.

     ┌───────────┐  ideas      ┌───────────┐  approve     ┌──────────────┐
     │  Explore  │ crystallize │   Plan    │─────────────▶│Implementation│
     │   Mode    │────────────▶│   Mode    │              │    Mode      │
     │           │             │           │              │              │
     │ specs +   │             │ roadmap + │              │ consult →    │
     │ thinking  │             │ spec      │              │ implement →  │
     │ no code   │             │ footprint │              │ update specs │
     └─────┬─────┘             └─────┬─────┘              └──────┬───────┘
           ▲                         │                           │
           │   unknowns              │ revise                    │ plan
           │   emerge                │                           │ broken
           └─────────────────────────┘                           │
                                     ◀───────────────────────────┘

Mode transitions are driven by the skill itself. Announce each transition explicitly ("Entering Plan Mode", "Entering Implementation Mode") and follow the mode-appropriate rules below. No external mode-switching function is involved.


Where this skill sits in the spec loop

vibespec-explore ──► vibespec-consult ──► [implement] ──► vibespec-update ──► vibespec-check
      │  approved roadmap        ▲                                │
      │                          └────────────────────────────────┘
      ▼
vibespec-create          (new spec or ADR when the roadmap needs one)

vibespec-explore is the on-ramp for work whose requirements are not yet clear. Once a roadmap is approved, the ordinary spec-aware loop (consult → implement → update) carries it out. This skill reads specs and delegates every spec edit to vibespec-update or vibespec-create — it never edits specs/ itself.


Grounding rule (applies to all modes)

Ground in specs first, code second:

  1. Locate the spec system — specs/INDEX.md (task → spec navigation) and specs/META.md (formats and rules). This is exactly the procedure of the vibespec-consult skill.
  2. Read specs in dependency order — domain README → domain detail → contract → architecture. Treat them as the map of intended behavior, interfaces, and invariants.
  3. Confirm and extend against code — where specs are silent, code is the only source of truth, and that silence is itself a finding (see Undocumented areas).
  4. If no specs/ directory exists — say so and fall back to plain code exploration. Every spec-aware step below becomes a no-op; do not invent specs.

Mode 1: Explore

Enter explore mode. Think deeply. Visualize freely. Follow the conversation wherever it goes.

IMPORTANT: Explore mode is for thinking, not implementing. You may read files, read specs, search code, and investigate — but you must NEVER write code or implement features. If the user asks you to implement something, remind them that implementation happens in Implementation Mode, after exploration, planning, and approval. You MAY offer to enter Plan Mode when ideas crystallize.

This is a stance, not a workflow. There are no fixed steps, no required sequence, no mandatory outputs. You are a thinking partner who happens to have the project's spec system open on the desk.

The Stance

  • Curious, not prescriptive — ask questions that emerge naturally, don't follow a script
  • Open threads, not interrogations — surface multiple directions, let the user follow what resonates
  • Visual — use ASCII diagrams liberally when they clarify thinking
  • Adaptive — follow interesting threads, pivot when new information emerges
  • Patient — don't rush to conclusions; let the shape of the problem emerge
  • Spec-grounded — start from documented domains, contracts, and invariants; treat specs/ as the map before the territory

What You Might Do

Consult the spec system

  • Load specs/INDEX.md and match the discussion against documented domains
  • Read the domain README for the area under discussion; pull in contracts when the topic crosses a layer boundary
  • Surface documented invariants, extension points, and anti-patterns before the idea hardens around them

Explore the problem space — ask clarifying questions, challenge assumptions, reframe the problem, find analogies

Investigate the codebase — but after specs: confirm the spec's claims against reality, map integration points, and notice where behavior has drifted from what the spec asserts (note the drift; do not fix it in Explore mode)

Compare options — brainstorm approaches, build comparison tables, sketch tradeoffs; check each option against the documented invariants and extension points it would touch

Visualize — ASCII diagrams for state machines, data flows, architecture sketches, dependency graphs, and comparison tables

**Surface risks and un

阅读完整来源 ↗