# brainstorming

Adopt this skill: https://proskills.md/skills/other/benkapner-claude-code-basecamp-skills-brainstorming

Page: https://proskills.md/skills/other/benkapner-claude-code-basecamp-skills-brainstorming
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/brainstorming/SKILL.md
size: 2126
upstream: https://github.com/benkapner/claude-code-basecamp/blob/main/skills/brainstorming/SKILL.md

```text
---
name: brainstorming
description: "User asks for design, planning, or approach exploration before implementation. Covers new features, components, refactors, or architecture decisions. Creates design docs and proposes approaches with trade-offs."
---

# Brainstorming — Design Exploration

Turn ideas into fully formed designs through collaborative dialogue.

When triggered, present a design before implementation. The design scales to complexity: short (few sentences) for simple tasks, detailed (pages) for architectural changes. Always get approval before proceeding to code.

## When to Activate

- User explicitly asks: "design this", "how should i build", "what's the approach", "plan this out"
- User describes a feature/component/refactor and asks for guidance before coding
- User wants to explore trade-offs or multiple approaches to a problem

## Process

1. **Explore context** — check relevant code files, docs, recent commits
2. **Ask clarifying questions** — one at a time, prefer multiple choice, understand: purpose, constraints, success criteria, scope
3. **Propose 2-3 approaches** — name each, describe trade-offs, state your recommendation
4. **Present design** — scale to complexity (1-2 sentences for trivial, multiple sections for architecture), ask approval after each section
5. **Get approval** — wait for user buy-in before writing code

## Design Principles

- **One question at a time** — don't overwhelm
- **YAGNI ruthlessly** — remove unnecessary features
- **Design for isolation** — break into units with one purpose, well-defined interfaces, independently testable
- **Explore alternatives** — always 2-3 approaches, with trade-offs
- **Scope check** — if request spans multiple subsystems, decompose first

## In Existing Codebases

- Explore current structure and patterns before proposing changes
- Include targeted fixes only if they block the current goal
- Don't propose unrelated refactoring

## Output

Present design as prose (short or detailed based on complexity), then ask: "Does this look right?" Wait for approval before proceeding to implementation.
```

## File: README.md
upstream: https://github.com/benkapner/claude-code-basecamp/blob/main/README.md

````text
# Claude Code Basecamp

A workspace for Claude Code users who work across multiple repositories. Clone your repos, get shared skills and commands out of the box, add your own.

## How It Works

This is a **meta-workspace**. You clone your project repositories into the `repositories/` folder and run Claude Code from the workspace root. Claude automatically gets access to all skills and commands. Your repos stay independent — they push to their own remotes, the workspace never touches them.

```
claude-code-basecamp/
  repositories/           # Clone your repos here (gitignored — yours, not shared)
    my-api/
    frontend/
    data-pipeline/
  skills/                 # AI skills — activate automatically when relevant
  commands/               # Slash commands — you trigger with /command
  .claude/                # Claude Code hooks and config
```

## Quick Start

```bash
git clone https://github.com/redhat-community-ai-tools/claude-code-basecamp.git
cd claude-code-basecamp
uv sync
uv run .ai-workspace/scripts/setup.py

# Clone your repos
cd repositories/
git clone <your-repo-url>
cd ..

# Start working
claude
```

Tell Claude which repo to focus on — "I'm working on my-api" or type `/focus` to pick from a list. Skills activate automatically. Commands are there when you need them.

## What You Get

### Skills (activate automatically)

Skills are knowledge that Claude carries in the background. You don't trigger them — they activate when relevant to what you're doing.

| Skill | What it does |
|-------|-------------|
| `security-check` | Detects credential leaks, insecure patterns, LLM-specific risks |
| `python-patterns` | Dotenv conventions, API clients, LLM parsing, testing, and pipelines |
| `refactoring-patterns` | Measurement-driven refactoring with before/after metrics |
| `verification-loop` | Powers `/verify`, `/quality-gate` (invoked on demand) |
| `brainstorming` | Design exploration before implementation |
| `update-docs` | Detects docs made stale by a code diff, applies targeted updates |
| `ci-guard` | Flags repos under `repositories/` that have no CI workflow |
| `semantic-versioning` | Reads conventional commits to pick the next major/minor/patch |
| `cost-speed-meter` | Opt-in timing of commands, suggests faster feedback loops |

### Commands (you trigger these)

| Command | When to use | What it does |
|---------|-------------|-------------|
| `/verify` | After coding | Check types, lint, tests |
| `/quality-gate` | Before `git push` | Tests + secret scan |
| `/refactor-safe` | After review | Refactor without changing public API |
| `/test-coverage` | Adding tests | Find untested code, generate tests |
| `/diff-explain` | Reviewing changes | Explain by intent, not file count |
| `/explain-code` | Unfamiliar code | Layered explanation scaled to complexity |
| `/explain-simple` | Non-technical audience | Plain language, no jargon |
| `/prompt-test` | Editing LLM prompts | Test against samples, catch regressions |
| `/ai-engineer-review` | Architecture check | Brutally honest review |
| `/architecture-docs` | Documentation | Architecture docs with Mermaid diagrams |
| `/env-check` | Something broke | Validate environment setup |
| `/recap` | End of session | Summarize for standup |
| `/focus` | Switch repos | Pick repos from a list |
| `/changelog` | Before a release | Generate changelog grouped by intent |
| `/dep-check` | Periodic audit | Check unused deps, outdated versions, vulnerabilities |
| `/check-code` | Quick pass | Lightweight Python lint and format check |
| `/update-docs` | After code changes | Find stale docs, propose targeted updates |
| `/repo-sync` | Start of session | Fetch and report repos that are behind or dirty |
| `/harness-lint` | Agent setup CI | 97 deterministic rules, no LLM, reproducible |
| `/harness-review` | Agent setup audit | Per-component KEEP/REVIEW/REMOVE verdicts |
| `/harness-security` | Agent setup audit | Deterministic scan plus semantic security review |
| `/skill-review` | Authoring a skill | Deep static and qualitative evaluation of one skill |
| `/skill-verify` | Before installing | Lint plus security in one pass: SAFE / CAUTION / UNSAFE |
| `/toolkit` | Discovery | See everything available |

### Hooks (automatic safety nets)

| Hook | What it does |
|------|-------------|
| Session start | Reports git status of all your repos |
| Secret scan | Blocks `git commit`/`push` if API keys detected in tracked files |
| Commit size guard | Warns if staged diff exceeds 500 lines, suggests splitting |
| Skill suggestion | Reminds Claude which skills are relevant to files you're editing |

## Adding Your Own Skills and Commands

You can extend the workspace with your own skills and commands:

- **Add a skill** — Create a folder in `skills/` with a `SKILL.md` file. Claude picks it up automatically.
- **Add a command** — Create a folder in `commands/` with a `command.md` file. It becomes a `/command` you can type.

After adding, Claude picks them up automatically.

## Learn More

- [`GUIDE.md`](GUIDE.md) — Full reference for all skills, commands, and hooks

## Credits

Built on top of [ai-workspace-template](https://github.com/MichaelYochpaz/ai-workspace-template) by Michael Yochpaz.
````
