New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Elaborate Spec

by danielvm-git in danielvm-git/bigpowers

Refine a rough idea into a clear, detailed specification through dialogue.

MITAuto-check passed

Install Elaborate Spec

skills CLI
$ npx skills add danielvm-git/bigpowers --skill elaborate-spec -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install danielvm-git/bigpowers elaborate-spec --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/danielvm-git/bigpowers.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/elaborate-spec .claude/skills/elaborate-spec && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
elaborate-spec
GitHub stars
257
Token cost
~991 tokens
SKILL.md length
480 words
Files
1
Skills in repo
39
Repo updated
First seen
Licence
MIT

At a glance

Refine a rough idea into a clear, detailed specification through dialogue.

  • Works in 6 steps: Listen first → Ask clarifying questions → Surface hidden assumptions → …
  • User has a vague idea
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Wants to think through a feature before planning

What it does

Elaborate Spec is an agent skill from danielvm-git/bigpowers. Refine a rough idea into a clear, detailed specification through dialogue. Does not produce code. Use when user has a vague idea, wants to think through a feature before planning, or needs to turn "I want X" into a concrete spec.

Its SKILL.md is about 990 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers. The licence is MIT.

When your agent uses it

  • User has a vague idea
  • Wants to think through a feature before planning
  • Needs to turn I want X into a concrete spec

Example prompts

  • “I want X”
  • “/elaborate-spec”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Listen first
  2. Ask clarifying questions
  3. Surface hidden assumptions
  4. Synthesize and confirm
  5. Write specs/planning-context.yaml
  6. Suggest next skill

What it can do on your machine

Read from SKILL.md and the folder at commit 812d57a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are yaml).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Elaborate Spec loads about 991 tokens when it runs. Until then it costs about 61 tokens; SKILL.md has 480 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~61
When it runs · the whole SKILL.md, loaded when a task matches
~991

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from danielvm-git/bigpowers at commit 812d57a, republished under its MIT licence (© danielvm-git). 480 words, ~991 tokens.

Download SKILL.mdSave it as .claude/skills/elaborate-spec/SKILL.md (or your agent's skills folder).
name
elaborate-spec
description
Refine a rough idea into a clear, detailed specification through dialogue. Does not produce code. Use when user has a vague idea, wants to think through a feature before planning, or needs to turn "I want X" into a concrete spec.
model
opus
effort
standard

Elaborate Spec

Turn a rough idea into a clear specification through focused dialogue. No code is written during this skill — the output is shared understanding and a refined problem statement.

HARD GATE — Do NOT proceed with planning or implementation until the problem space is clearly understood. Success criteria, actors, and scope must be explicit before drafting a plan.

Process

1. Listen first

Let the user describe their idea in their own words. Do not interrupt or redirect. Take notes on:

  • The core problem they're trying to solve
  • Who is affected (actors)
  • What success looks like to them
  • Any constraints they've already identified
2. Ask clarifying questions

Ask one question at a time. Work through these areas:

Problem clarity

  • What is the current behavior (or lack of behavior) that prompted this?
  • Who experiences this problem? How often?
  • What's the cost of not solving it?

Solution boundaries

  • What is explicitly IN scope?
  • What is explicitly OUT of scope?
  • Are there existing solutions (internal or external) this replaces or integrates with?

Success criteria

  • How will you know this is done?
  • What does the happy path look like end-to-end?
  • What are the key failure modes to handle?

Constraints

  • Any performance requirements?
  • Any compatibility constraints (existing APIs, data formats)?
  • Any non-negotiable implementation decisions already made?
2.5. Multiple Interpretations (HARD GATE)

HARD GATE — If the request admits ≥2 valid interpretations, do NOT guess. You must list them and ask the user to choose before proceeding. Proceeding with unresolved ambiguity is a failure of integrity.

Present the options clearly:

"I see two ways to read this:

  1. [Interpretation A] — my recommendation because [reason]
  2. [Interpretation B] Which is closer to what you mean?"
Show full SKILL.md (204 more words)Show less
3. Surface hidden assumptions

Once the user has answered the main questions, probe for assumptions:

  • "You mentioned X — does that mean Y is also true?"
  • "What happens when Z fails?"
  • "Is this for internal users, external users, or both?"
4. Synthesize and confirm

Summarize your understanding in 3–5 bullet points aligned with countable-story-format.md:

  • The problem (feeds into §1 Business narrative)
  • The solution and main flow (feeds into §5)
  • The key constraints and alternative flows (feeds into §6)
  • The success criteria (feeds into §17 Gherkin)
  • What's out of scope (feeds into §18)

Ask: "Is this an accurate summary? Anything missing or wrong?"

5. Write specs/planning-context.yaml

After the user confirms the summary in step 4, persist the key decisions:

yaml
# specs/planning-context.yaml — written by elaborate-spec; consumed by scope-work and slice-tasks
feature_name: "<from step 1>"
problem_statement: "<one paragraph>"
constraints:
  - "<constraint 1>"
out_of_scope:
  - "<excluded item 1>"
key_decisions:
  - decision: "<what was decided>"
    rationale: "<why>"

If specs/planning-context.yaml already exists, ask: "Planning context from a prior session exists. Update it? [Y/n]". Overwrite on Y; leave unchanged on N.

6. Suggest next skill

Once the spec is clear, recommend the next step:

  • If domain model needs work → model-domain
  • If ready to plan → plan-release (creates epic capsules with epic.yaml + story .md + -tasks.yaml) then plan-work per story
  • If a spike is needed first → spike-prototype
  • If architecture decisions are needed → deepen-architecture or grill-me
  • If the plan depends on a specific library or API → grill-me in docs mode

© danielvm-git, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/elaborate-spec of danielvm-git/bigpowers.

Open the folder on GitHubat commit 812d57a

Compare with similar skills

Elaborate Spec next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Elaborate Spec compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Elaborate Spec this skilldanielvm-git/bigpowers257—~991Automated safety check: PassMIT
Idea Refinementaddyosmani/agent-skills103k6 repos~2kAutomated safety check: PassMIT
Idea Darwinsickn33/agentic-awesome-skills47k2 repos~1.1kAutomated safety check: PassMIT
Sparc Refineruvnet/ruflo74k—~1.5kAutomated safety check: NotesMIT
Agent Specificationruvnet/ruflo74k3 repos~1.8kAutomated safety check: PassMIT
Agent Refinementruvnet/ruflo74k2 repos~3.5kAutomated safety check: PassMIT

Similar skills

  • Idea Refinement

    addyosmani/agent-skills

    Guides a conversation that takes a vague idea through divergent and convergent thinking and ends in a markdown one-pager covering scope and assumptions.

    103k GitHub starsUsed in 6 repos~2k tokens
    Agent WorkflowsAuto-check passed

  • Idea Darwin

    sickn33/agentic-awesome-skills

    Darwinian idea evolution engine — toss rough ideas onto an evolution island, let them compete, crossbreed, and mutate through structured rounds to surface your strongest concepts.

    47k GitHub starsUsed in 2 repos~1.1k tokens
    Auto-check passed

  • Sparc Refine

    ruvnet/ruflo

    Run the SPARC Refinement and Completion phases — review code, improve test coverage, validate against specification, and generate documentation

    74k GitHub stars~1.5k tokensUpdated today
    Testing & QAAuto-check: notes

  • Agent Specification

    ruvnet/ruflo

    Agent skill for specification - invoke with $agent-specification

    74k GitHub starsUsed in 3 repos~1.8k tokens
    Product & Project ManagementAuto-check passed

  • Agent Refinement

    ruvnet/ruflo

    Agent skill for refinement - invoke with $agent-refinement. An agent skill from ruvnet/ruflo.

    74k GitHub starsUsed in 2 repos~3.5k tokens
    DevelopmentAuto-check passed

  • Idea

    Chorus-AIDLC/Chorus

    Chorus Idea workflow on Hermes — claim ideas, run elaboration rounds (asked in chat, or via @mention when Chorus wakes the gateway), and prepare for proposal creation.

    1.2k GitHub stars~7.2k tokensUpdated today
    Sales & SupportAuto-check passed

More from danielvm-git/bigpowers

All 39 skills in this repo

  • Extract Design

    danielvm-git/bigpowers

    Extract a Google DESIGN.md file from an HTML prototype (claude.ai/design or any styled page) using Puppeteer, producing machine-readable tokens and AI-generated prose.

    257 GitHub stars~1k tokensUpdated 16 days ago
    Auto-check passed

  • Align Grid

    danielvm-git/bigpowers

    Build editorial/magazine/report webpages on a GENUINE Müller-Brockmann modular grid (International Typographic Style) — not a decorative one.

    257 GitHub stars~3k tokensUpdated 16 days ago
    Auto-check passed

  • Assess Impact

    danielvm-git/bigpowers

    Analyze the blast radius of a proposed change before any code is written.

    257 GitHub stars~766 tokensUpdated 16 days ago
    Auto-check passed

  • Audit Code

    danielvm-git/bigpowers

    Self-review checklist for the coding agent to run before dispatching a reviewer.

    257 GitHub stars~1.6k tokensUpdated 16 days ago
    Auto-check: notes

  • Audit Plan

    danielvm-git/bigpowers

    Evaluate an incoming project plan against bigpowers principles and conventions, surface gaps, and produce a READY/NOT READY verdict before engagement begins.

    257 GitHub stars~880 tokensUpdated 16 days ago
    Auto-check passed

  • Compose Workflow

    danielvm-git/bigpowers

    Chain multiple bigpowers skills into a custom workflow recipe saved in specs/.

    257 GitHub stars~723 tokensUpdated 16 days ago
    Auto-check passed

Questions about Elaborate Spec

What does Elaborate Spec do?

Refine a rough idea into a clear, detailed specification through dialogue. Elaborate Spec is an agent skill from danielvm-git/bigpowers. Refine a rough idea into a clear, detailed specification through dialogue.

When should I use Elaborate Spec?

Elaborate Spec fits situations like: user has a vague idea; wants to think through a feature before planning; needs to turn I want X into a concrete spec.

How do I install Elaborate Spec in Claude Code?

Run `npx skills add danielvm-git/bigpowers --skill elaborate-spec -a claude-code`. Or copy the skill folder (skills/elaborate-spec in danielvm-git/bigpowers) into .claude/skills/elaborate-spec in your project. Claude Code loads it when a task matches its description.

How do I install Elaborate Spec in Codex?

Run `npx skills add danielvm-git/bigpowers --skill elaborate-spec -a codex`. Or copy the skill folder (skills/elaborate-spec in danielvm-git/bigpowers) into .agents/skills/elaborate-spec in your project. Codex loads it when a task matches its description.

Can I use Elaborate Spec in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add danielvm-git/bigpowers --skill elaborate-spec -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/elaborate-spec, .gemini/skills/elaborate-spec, .github/skills/elaborate-spec and .opencode/skills/elaborate-spec in your project.

What does Elaborate Spec need to run?

SKILL.md names no scripts, command-line tools or credentials: Elaborate Spec is instructions for the agent only.

Does Elaborate Spec access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Elaborate Spec safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Elaborate Spec use?

Elaborate Spec is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Elaborate Spec use?

About 991 tokens (SKILL.md is roughly 4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Elaborate Spec?

Skills that share tags, products or a category with Elaborate Spec: Idea Refinement (addyosmani/agent-skills, 103k stars), Idea Darwin (sickn33/agentic-awesome-skills, 47k stars), Sparc Refine (ruvnet/ruflo, 74k stars) and Agent Specification (ruvnet/ruflo, 74k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Elaborate Spec?

danielvm-git (a GitHub user) maintains it in danielvm-git/bigpowers, which has 257 GitHub stars. The repository holds 39 skills in this directory. The repository was last updated on September 21, 2026.

Source: danielvm-git/bigpowers on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.