Skip to main content
skill CX Codex

jackin-brainstorm — Claude Code skill: design from a roadmap item

Turns the intent behind a roadmap item into concrete design decisions through open discussion, writing each one into the item's ## Design section.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jackin-project/jackin-dev --skill jackin-brainstorm -a claude-code
Open on GitHub

What jackin-brainstorm does

The skill takes an existing roadmap item and works through it with you: alternatives, trade-offs, open questions. Every settled point lands in ## Design inside docs/content/docs/roadmap/<slug>.mdx as the decision plus a one-line reason. Questions come one at a time, so nothing gets buried.

This is a judgment task. It describes and decides; it does not write code and does not split work into tasks — that belongs to plan. When something unfamiliar comes up, it can look around the codebase or spin a separate jackin-research dossier and link it from ## Design. Settled chunks are committed with a docs: prefix and pushed right away.

Invoke it with a slug: jackin-brainstorm <slug>. The --research flag runs research first when the item looks thin, and --resume picks up from the current ## Design state. The skill only fires on an explicit request.

What it helps with

  • turn a roadmap item's intent into concrete design decisions
  • surface alternatives and trade-offs before implementation starts
  • keep the discussion in ## Design so it can be resumed later
  • pull in research when an item has too little material
  • commit decisions as they settle instead of leaving them in chat

Example prompts for the agent

  • Run the jackin-brainstorm skill on the auth-flow item
  • Resume designing auth-flow from the current ## Design state
  • Run jackin-brainstorm on auth-flow with the --research flag

How to install jackin-brainstorm

1Skills CLI (Vercel)

npx skills add jackin-project/jackin-dev --skill jackin-brainstorm -a claude-code

2Manually: put the files in place

~/.claude/skills/jackin-brainstorm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/jackin-brainstorm/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about jackin-brainstorm

How do I install jackin-brainstorm in Claude Code?

Run npx skills add jackin-project/jackin-dev --skill jackin-brainstorm -a claude-code. The skill file lands at ~/.claude/skills/jackin-brainstorm/SKILL.md.

What does jackin-brainstorm do?

It runs an open discussion about a roadmap item and records the decisions in that item's ## Design section. It writes no code and breaks nothing into tasks.

How is jackin-brainstorm different from jackin-research?

Research handles large investigations across external sources or the codebase. Brainstorm designs the item; when material is thin, it can start research itself via the --research flag.

Source text

SKILL.md · Apache-2.0
---
name: jackin-brainstorm
description: Use only when the user explicitly requests this skill. Turns a jackin❯ roadmap item's intent into concrete design decisions through freeform discussion, written into its ## Design.
argument-hint: "<slug> [--research] [--resume]"
disable-model-invocation: true
license: Apache-2.0
user-invocable: true
---

# jackin-brainstorm

Turn an existing roadmap item's intent (and any gathered research) into concrete **design decisions**, through open back-and-forth with the operator, written incrementally into the item's `## Design` section.

Judgment task — describe and decide; do not script it, do not write code, do not break work into tasks (that is `plan`, deferred).

## When to use

- Operator runs `jackin-brainstorm <slug>` to design an open roadmap item.

## When NOT to use

- Creating the item → `jackin-propose`.
- Large external/codebase investigation → `jackin-research`.
- Implementing → `/goal Implement <slug>.md`.

## Arguments

- `--research` — run `jackin-research` first if the item looks thin.
- `--resume` — continue from the current `## Design` state.

## Process

1. **Load context.** Read `docs/content/docs/roadmap/<slug>.mdx` — Problem, Why It Matters, Design-so-far, Related Files — plus any research already linked.
2. **Discuss freeform.** Open back-and-forth: surface alternatives, trade-offs, open questions. Pull in jackin❯ design principles and the relevant rule files (`ENGINEERING.md`, `HOST_AND_CONTAINER.md`, TUI/docs rules) as constraints. Prefer one question at a time; check in as each part settles.
3. **Write incrementally.** As each point settles, append or update the matching part of `## Design` in the `.mdx` — the decision plus a one-line *why*. `--resume` picks up from there.
4. **Hit an unknown?** Gather quickly (Explore/grep, or `deep-research`). Large investigation → spin a separate `jackin-research` dossier and link it from `## Design`. Then resume deciding.
5. **Converge.** When `## Design` covers the approach end to end, summarize and point at the implementation step (`/goal Implement <slug>.md`).
6. **Commit + push.** `docs:` per settled chunk (push after every commit).

## Common mistakes

- Writing code, or filling `## Tasks` — out of scope.
- Dumping a finished design without the back-and-forth, or asking many questions at once.
- Recording decisions only in chat instead of into `## Design` (it must be resumable).
- Restating rule-file content instead of referencing it by name.

© jackin-project · Apache-2.0 · jackin-project/jackin-dev

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set8

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor