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

Think

by agentculture in agentculture/culture

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the devague CLI).

Apache-2.0Auto-check passed

Install Think

skills CLI
$ npx skills add agentculture/culture --skill think -a claude-code

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

GitHub CLI
$ gh skill install agentculture/culture think --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/agentculture/culture.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/think .claude/skills/think && 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
think
GitHub stars
113
Token cost
~2.7k tokens
SKILL.md length
1,141 words
Files
2 (incl. scripts)
Skills in repo
18
Repo updated
First seen
Licence
Apache-2.0

At a glance

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the devague CLI).

  • Works in 2 steps: Commit the spec. Commit the exported… → Hand off to /spec-to-plan. The forward…
  • The user says think this through
  • SKILL.md covers How to run, Hard rules (do not violate), Output contract and Worked example, plus 2 more sections
  • Runs Shell scripts from its folder; calls bash and uv

What it does

Think is an agent skill from agentculture/culture. Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the devague CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame converges. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request…

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including scripts (for example `scripts/think.sh`).

The repository describes itself as: Culture turns isolated stochastic agents into cooperative, inspectable, improvable artificial colleagues. The licence is Apache-2.0.

When your agent uses it

  • The user says think this through
  • Turn this idea into a spec
  • Announcement frame
  • A feature request is too vague to build yet

Example prompts

  • “pretend it shipped”
  • “think this through”
  • “spec this”
  • “/think”

Requirements

  • A Bash shell

Workflow steps

2 steps, taken from the first numbered list in SKILL.md.

  1. Commit the spec. Commit the exported docs/specs/.md (along with
  2. Hand off to /spec-to-plan. The forward leg is the sibling skill

What it can do on your machine

Read from SKILL.md and the folder at commit d5b5715. 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

    Ships 1 file in scripts/ (Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • bash
    • uv

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

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com

    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

Think loads about 2.7k tokens when it runs. Until then it costs about 215 tokens; SKILL.md has 1,141 words of instructions outside code blocks.

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

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); the scripts in this folder are not scanned.

SKILL.md

The full file from agentculture/culture at commit d5b5715, republished under its Apache-2.0 licence (© agentculture). 1,141 words, ~2,685 tokens.

Download SKILL.mdSave it as .claude/skills/think/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
think
description
Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request is too vague to build yet. Once a spec exports, hand off to the sibling /spec-to-plan skill to turn it into a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster re-broadcasts it to the AgentCulture mesh — it originates in devague, not guildmaster (the supplier post steward→guildmaster cutover).
type
command

think — work an idea backwards into a buildable spec

The skill is named think; the product/CLI it drives is devague. (The forward leg — turning a converged spec into a plan — is the sibling /spec-to-plan skill, which drives devague plan.)

think turns a vague feature idea into a buildable spec by working backwards: you start from the announcement you'd make if it had already shipped, then build an Announcement Frame by capturing claims, pressure -testing them, parking what's still genuinely unknown, and only exporting once the frame converges.

The CLI is deterministic and move-driven — it is not a wizard. There is no fixed sequence of prompts. You (the agent) choose the next move; the CLI just tracks state and tells you what's still missing. Run devague learn for the canonical ten-stage arc and devague explain <move> for any single move.

This skill is the operator: a portable wrapper that resolves the CLI and forwards every move verbatim — including status, the read-only verb that reads the convergence gate and tells you the recommended next move.

How to run

The entry point is scripts/think.sh. Invoke it from the repository you are speccing (frames persist under .devague/ in the current directory):

bash
bash .claude/skills/think/scripts/think.sh <move> [args...]
bash .claude/skills/think/scripts/think.sh status

It resolves the CLI portably — an installed devague on PATH (the normal case), falling back to uv run devague when you are inside the devague checkout. If neither resolves it prints an install hint (uv tool install devague). Every move — including status — is forwarded verbatim, so you can equally call the CLI directly (devague <move> …) when it is installed; the wrapper exists only for portable resolution.

Moves
MoveWhat it does
new "<announcement>"Start a frame from the announcement (the first move). Seeds an auto-confirmed announcement claim.
capture --kind <kind> "<text>"Record + classify a claim. --origin llm lands it as proposed.
interrogate <id> --honesty "…"Attach an honesty condition (what must be true). Also --hard-question, --risk, --contradicts, --blocking.
confirm <id> [<id>…] / reject <id> [<id>…]Resolve one or more claims (c*) / honesty conditions (h*) in one transactional call. User-only decision. Also confirm --from-review <file> to apply an edited review artifact.
reviewList every proposed (unconfirmed) claim + honesty condition with ids (--json too); writes a non-authoritative artifact to .devague/reviews/<slug>.md. Un-gated; never mutates.
question "<text>"Record / list / --resolve a pending user decision as durable working state in .devague/questions/<slug>.md.
park "<text>" --kind <kind>Move uncertainty into first-class open vagueness instead of forcing an answer.
convergeEvaluate the gate; list remaining gaps.
exportWrite the buildable spec to docs/specs/ — only after converge passes.
statusRead-only: where the frame stands + the recommended next move (--json too).
show / listRender a frame / list frames (--json for raw state).
learn / explain <move>Teach the method / explain one move.

Claim kinds: announcement, audience, after_state, before_state, why_it_matters, boundary, success_signal, open_question, non_goal, requirement, assumption, decision. Vagueness kinds: unknown_nonblocking, unknown_blocking, out_of_scope, follow_up.

These are exactly the kinds the shipped CLI enforces (CLAIM_KINDS / VAGUENESS_KINDS in devague/frame.py) — the skill documents the surface as built, so every command here passes the CLI's choices= validation. requirement is spec-affecting (needs a confirmed honesty condition); non_goal / decision are descriptive; an unconfirmed assumption is a convergence warning, not a blocker. The formal entity model, the (state × origin) vocabulary, and the per-move input/output/transition/error contract are documented in docs/spec-contract.md (issue #5); for the authoritative live shape of any move, run it with --json (or devague learn --json / devague explain <move>).

status — the next-move verb

status is a first-class, read-only CLI verb (devague status, internalised from this wrapper in 0.11.0 — issue #30). It composes list + converge and prints where the current frame stands, the remaining gaps, and the recommended next move; it never mutates state (the drafting↔converged transition stays in converge). It reports ready_for_spec, lists the blockers and warnings, and shows required_next_moves[0] as the recommended move. Pass --json for the same fields as a structured payload ({frame, total, ready_for_spec, blockers, warnings, parked_items, required_next_moves}).

text
frame: my-feature    (1 frame total)
convergence: NOT passed — 2 gap(s):
  - missing a 'boundary' / non-goal claim
  - claim c2 has no confirmed honesty condition

recommended next move (first gap):
  devague capture --kind boundary "<text>"

Run it whenever you're unsure what to do next.

Show full SKILL.md (495 more words)Show less

Hard rules (do not violate)

These are the point of the method — convergence must mean something.

  • LLM proposals stay proposed. A claim captured with --origin llm, and any honesty condition you (the agent) propose, lands as proposed. Never confirm your own proposal. Confirmation is a user-only decision — surface the proposal and let the user confirm or reject it. Proposed content must not silently become an authoritative requirement.
  • Honesty conditions route through the user. Propose them freely with interrogate --honesty; the user owns whether they hold.
  • Converge, don't vibe. export is gated on converge passing. Never claim the frame is ready on a hunch — run converge (or status) and resolve every listed gap. The gate requires confirmed announcement / audience / after_state, a before_state or why_it_matters, a boundary, a success_signal, a confirmed honesty condition on every spec-affecting claim, and no unresolved blocking vagueness or hard question.
  • Park real unknowns; don't paper over them. If something is genuinely unknown, park it (blocking or non-blocking) rather than fabricating an answer. Blocking vagueness holds back convergence — by design.

Output contract

Results go to stdout, diagnostics and errors to stderr — a strict split you can rely on when parsing. Pass --json to any move for a structured payload on the same stream. Exit code 0 on success, non-zero on user error (with a hint: line). Frames live under .devague/ in the current directory.

Worked example

A short end-to-end session (the kind you'd run to spec a feature like devague#5):

bash
d() { bash .claude/skills/think/scripts/think.sh "$@"; }

d new "Devague ships a documented spec contract"
d capture --kind audience "devague + the assisting LLM"
d capture --kind after_state "a vague idea becomes a buildable, pressure-tested spec"
d capture --kind why_it_matters "specs converge on evidence, not vibes"
d capture --kind boundary "not a full PRD generator; no fixed wizard"
d capture --kind success_signal "a frame exports only after the gate passes"

# Pressure-test a claim, then let the USER confirm the condition:
d interrogate c1 --honesty "the contract round-trips: save -> load -> identical frame"
# ...user reviews and runs: d confirm h1

# Park a genuine unknown instead of guessing:
d park "exact JSON schema versioning policy" --kind unknown_nonblocking

d status        # what's left + the next move
d converge      # gate; resolve any listed gaps
d export        # writes docs/specs/<slug>.md once converged

The exported spec-md is a buildable artifact.

After export — commit, then hand off

Once export writes the spec and the user has reviewed it, close the idea→spec leg cleanly before moving on:

  1. Commit the spec. Commit the exported docs/specs/<slug>.md (along with the .devague/<slug>.json frame state and any review artifact under docs/reviews/) so the converged frame is durable in history, not just on disk. Use a focused message, e.g. git commit -m "spec: <slug> (devague /think)". The frame and the spec are the evidence trail for every confirmed claim — keep them together. (Per the repo's standing convention this normally becomes a branch + PR via the cicd skill; commit-only is fine when the user asks for it.)
  2. Hand off to /spec-to-plan. The forward leg is the sibling skill: devague plan new --frame <slug> seeds a plan from the converged frame and works it forward into a buildable plan (it can equally feed superpowers:writing-plans or a normal implementation PR).

Don't pause for a "what next?" menu after a reviewed export — the standing flow is commit, then /spec-to-plan.

Provenance

This is a first-party skill — its origin is agentculture/devague, where the devague agent maintains it alongside the tool it operates (dogfooding). It is the inverse of the other skills under .claude/skills/, which devague vendors from guildmaster. When this skill is ready, guildmaster pulls it from devague and re-broadcasts it to the rest of the AgentCulture mesh. The cite, don't import policy still holds: downstream repos copy it, they don't symlink or depend on it. See docs/skill-sources.md.

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

Files

SKILL.md and 1 other file (scripts) in .claude/skills/think of agentculture/culture.

  • SKILL.md
  • scripts/think.sh

Open the folder on GitHubat commit d5b5715

Compare with similar skills

Think 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.

Think compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Think this skillagentculture/culture113—~2.7kAutomated safety check: PassApache-2.0
Idea Refinementaddyosmani/agent-skills103k6 repos~2kAutomated safety check: PassMIT
Idea Darwinsickn33/agentic-awesome-skills47k2 repos~1.1kAutomated safety check: PassMIT
Same Idea Both Platformssickn33/agentic-awesome-skills47k1 repos~1.4kAutomated safety check: PassMIT
Idea Evaluatorsickn33/agentic-awesome-skills47k1 repos~930Automated safety check: PassMIT
Idea Autopsysickn33/agentic-awesome-skills47k1 repos~1.6kAutomated 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

  • Same Idea Both Platforms

    sickn33/agentic-awesome-skills

    Write one idea as a Twitter/X post and a LinkedIn post that read as written separately, not pasted twice.

    47k GitHub starsUsed in 1 repo~1.4k tokens
    Writing & ContentAuto-check passed

  • Idea Evaluator

    sickn33/agentic-awesome-skills

    Evaluates an idea by hosting a multi-turn debate between a Pro and Con agent, delivering a final verdict on whether it's worth pursuing.

    47k GitHub starsUsed in 1 repo~930 tokens
    Auto-check passed

  • Idea Autopsy

    sickn33/agentic-awesome-skills

    Autopsy a business idea before you build it: kill-list check, five hard filters, a free-AI one-prompt test, live ad-market verification, and a verdict with a named kill-pattern.

    47k GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed

  • Idea Os

    sickn33/agentic-awesome-skills

    Five-phase pipeline (triage → clarify → research → PRD → plan) that turns a raw idea into four linked files: clarifying questions, deep research, a PRD with non-goals and metrics, and a phased…

    47k GitHub starsUsed in 1 repo~1.5k tokens
    Product & Project ManagementAuto-check passed

More from agentculture/culture

All 18 skills in this repo

  • Agent Config

    agentculture/culture

    Show a Culture agent's full configuration in one read-only view: its system-prompt file (CLAUDE.md / AGENTS.md / GEMINI.md), the parallel culture.yaml, and the agent's local .claude/skills index.

    113 GitHub stars~1k tokensUpdated 1 mo ago
    Auto-check passed

  • Cicd

    agentculture/culture

    CI/CD lane for culture: branch, commit, push, create PR, wait for automated reviewers, fetch comments, fix or pushback, reply, resolve threads.

    113 GitHub stars~3.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Communicate

    agentculture/culture

    All agent communication from culture: in-mesh chat (channels, DMs, mentions, knowledge sharing) via culture channel CLI, AND cross-repo hand-off briefs to sibling-repo agents (agentirc, steward…

    113 GitHub stars~2.8k tokensUpdated 1 mo ago
    Auto-check passed

  • Communicate

    agentculture/culture

    Cross-repo + mesh communication: file tracked GitHub issues on sibling repos, comment on existing issues, fetch issues with body + comments to inline current state into briefs, and send live…

    113 GitHub stars~2.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Assign To Workforce

    agentculture/culture

    Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent.

    113 GitHub stars~2.7k tokensUpdated 1 mo ago
    Auto-check: warnings

  • Pypi Maintainer

    agentculture/culture

    Switch a PyPI package install between the production index, TestPyPI pre-release builds, and a local editable checkout.

    113 GitHub stars~711 tokensUpdated 1 mo ago
    Auto-check passed

Questions about Think

What does Think do?

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the devague CLI). Think is an agent skill from agentculture/culture. Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the devague CLI).

When should I use Think?

Think fits situations like: the user says think this through; turn this idea into a spec; announcement frame; A feature request is too vague to build yet.

How do I install Think in Claude Code?

Run `npx skills add agentculture/culture --skill think -a claude-code`. Or copy the skill folder (.claude/skills/think in agentculture/culture) into .claude/skills/think in your project. Claude Code loads it when a task matches its description.

How do I install Think in Codex?

Run `npx skills add agentculture/culture --skill think -a codex`. Or copy the skill folder (.claude/skills/think in agentculture/culture) into .agents/skills/think in your project. Codex loads it when a task matches its description.

Can I use Think 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 agentculture/culture --skill think -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/think, .gemini/skills/think, .github/skills/think and .opencode/skills/think in your project.

What does Think need to run?

Going by SKILL.md and its folder, Think needs a shell for the scripts in its folder and the command-line tools its instructions call (bash and uv). Our summary lists: A Bash shell.

Does Think access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Think 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. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Think use?

Think is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Think use?

About 2.7k tokens (SKILL.md is roughly 11k 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 Think?

Skills that share tags, products or a category with Think: Idea Refinement (addyosmani/agent-skills, 103k stars), Idea Darwin (sickn33/agentic-awesome-skills, 47k stars), Same Idea Both Platforms (sickn33/agentic-awesome-skills, 47k stars) and Idea Evaluator (sickn33/agentic-awesome-skills, 47k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Think?

agentculture (a GitHub organization) maintains it in agentculture/culture, which has 113 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on August 23, 2026.

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