Skills

Skills (recipes) are slash commands that define what to do. Each skill is described in a SKILL.md file with frontmatter metadata and instructions for agents. Brewcode includes 15 skills covering the full task lifecycle — from project analysis to secrets scanning.

Summary table

#	Skill	Command	Model	Purpose
1	setup	`/brewcode:setup`	opus	Project analysis, template generation
2	spec	`/brewcode:spec`	opus	Specification creation through research
3	plan	`/brewcode:plan`	opus	Plan creation from SPEC or Plan Mode
4	start	`/brewcode:start`	opus	Task execution with infinite context
5	convention	`/brewcode:convention`	opus	Convention analysis and reference classes
6	rules	`/brewcode:rules`	sonnet	Knowledge-to-rules synchronization
7	grepai	`/brewcode:grepai`	sonnet	Semantic search management
8	install	`/brewcode:install`	sonnet	Dependency installation
9	teardown	`/brewcode:teardown`	haiku	Plugin file removal
10	text-optimize	`/brewcode:text-optimize`	sonnet	Text optimization for LLMs
11	text-human	`/brewcode:text-human`	sonnet	AI artifact removal from code
12	standards-review	`/brewcode:standards-review`	opus	Standards compliance review
13	skills	`/brewcode:skills`	opus	Skill management
14	agents	`/brewcode:agents`	opus	Agent creation and improvement
15	secrets-scan	`/brewcode:secrets-scan`	sonnet	Secrets and key scanning

Core cycle

setup — Project setup

opusfork

Analyzes the project structure, technology stack, test frameworks, and project agents. Generates adapted templates in .claude/tasks/templates/.

Parameter	Value
Arguments	`[universal-template-path]` (optional)
Tools	Read, Write, Glob, Grep, Bash, AskUserQuestion
Context	fork

Phases:

Project scanning (setup.sh scan)
Stack and pattern analysis
Template generation (PLAN, SPEC, KNOWLEDGE, config)
Adapted code review skill creation
All artifact validation
CLAUDE.md update (agent table)

/brewcode:setup

spec — Specification creation

opussession

Creates a structured specification through parallel codebase research and user dialog.

Parameter	Value
Arguments	`[-n] <description> \| <path-to-requirements>`
Tools	Read, Write, Glob, Grep, Bash, Task, AskUserQuestion
Flag `-n`	No user questions (autonomous mode)

Process:

Read and analyze input data
3-5 clarifying questions (skipped with -n)
Check whether the task needs splitting
Parallel research (5-10 agents simultaneously)
Consolidation into SPEC.md
Specification review (reviewer + fix loop)

/brewcode:spec "Implement JWT authorization with role-based model"
/brewcode:spec -n ./docs/requirements/auth.md

plan — Plan creation

opussession

Creates an execution plan (PLAN.md) with phases, dependencies, and completion criteria from a specification or Plan Mode file.

Parameter	Value
Arguments	`[-n] [task-dir\|SPEC.md\|plan-file]`
Tools	Read, Write, Glob, Grep, Bash, Task, AskUserQuestion
Flag `-n`	Autonomous mode

Artifacts:

PLAN.md — Phase Registry (phase table)
phases/*.md — individual phase files
KNOWLEDGE.jsonl — empty file for knowledge accumulation
artifacts/ and backup/ — directories

Process:

Determine source (SPEC or Plan Mode)
Generate 5-12 phases with verification phases
Quorum review (3 agents, 2/3 rule)
Requirements tracing (SPEC -> phases)
Quick ref update (.claude/TASK.md)

/brewcode:plan .claude/tasks/20260301_143052_auth_task/
/brewcode:plan -n

start — Task execution

opussession

Launches task execution with infinite context, automatic handoff between sessions, and failure escalation.

Parameter	Value
Arguments	`[task-path]`, defaults to `.claude/TASK.md`
Tools	Read, Write, Edit, Bash, Task, Glob, Grep, Skill, AskUserQuestion

Mechanism:

Initialization via bc-coordinator (lock, status)
Task creation from Phase Registry (TaskCreate)
Dependency setup (TaskUpdate)
Execution loop: pending -> in_progress -> completed
2-step protocol: WRITE report -> CALL coordinator
Finalization via coordinator
Rule extraction (/brewcode:rules)

Failure escalation

After the 1st failure — R&D task. After the 2nd — split the phase into sub-phases. After the 3rd — model switch, reassignment, user question.

/brewcode:start
/brewcode:start .claude/tasks/20260301_143052_auth_task/PLAN.md

Quality

standards-review — Standards review

opussession

Checks code for compliance with project standards and finds duplicates. Supports Java/Kotlin, TypeScript/React, Python.

Parameter	Value
Arguments	`[commit\|branch\|folder] [-p <prompt>]`
Tools	Read, Glob, Grep, Task, Bash, Write, grepai_search, AskUserQuestion, Skill

Check priority: Existing code (reuse) -> CLAUDE.md -> rules/*.md -> stack reference.

Phases:

Technology stack detection
File list retrieval (commit/branch/folder)
Context loading (rules, standards)
Expert analysis (parallel haiku agents by file groups)
Validation (sonnet reviewer)
Report generation in .claude/reports/
Optional simplify pass

/brewcode:standards-review
/brewcode:standards-review abc123
/brewcode:standards-review src/main/java/services/

convention — Convention analysis

opussession

Analyzes the project to extract reference classes, patterns, and architecture by layer. Generates convention documents in .claude/convention/.

Parameter	Value
Arguments	`[full\|conventions\|rules\|paths <p1,p2>]`
Tools	Read, Write, Edit, Glob, Grep, Bash, Task, AskUserQuestion, Skill

Modes:

Mode	Phases	Purpose
`full` (default)	P0-P8	Full analysis + rules
`conventions`	P0-P7	Convention documents only
`rules`	P0, P7-P8	Rule extraction only
`paths <p1,p2>`	P0-P7 (scoped)	Analysis of specified paths

Output: 3 documents — reference-patterns.md, testing-conventions.md, project-architecture.md.

/brewcode:convention
/brewcode:convention rules
/brewcode:convention paths src/main/java/services,src/main/java/api

rules — Rule extraction

sonnetsession

Syncs KNOWLEDGE.jsonl or session knowledge into .claude/rules/ rule files.

Parameter	Value
Arguments	`[list] \| [<path>] \| [<path> <prompt>]`
Tools	Read, Bash, Task

Modes:

Input	Mode
`list`	Show current rules
`<path>`	Extract from KNOWLEDGE.jsonl file
`<path> <text>`	Custom prompt
(empty)	Extract from current session

Deduplication: 3 checks — intra-file similarity (>70% skip), cross-file antonyms, duplicates with CLAUDE.md.

/brewcode:rules list
/brewcode:rules .claude/tasks/20260301_auth_task/KNOWLEDGE.jsonl

secrets-scan — Secrets scanning

sonnetsession

Scans all git-tracked files for leaked secrets, keys, and credentials.

Parameter	Value
Arguments	`[--fix]`
Tools	Read, Task, Write, Bash, AskUserQuestion

Process:

File list retrieval (git ls-files)
Parallel scanning by 10 agents
Result merging and deduplication
Report generation with severity levels (CRITICAL/HIGH/MEDIUM/LOW)
Optional interactive fixing (--fix)

Search patterns: passwords, API keys, tokens, AWS credentials, DB URLs, private keys.

/brewcode:secrets-scan
/brewcode:secrets-scan --fix

Utilities

grepai — Semantic search

sonnetsession

Manages grepai — AI-powered code search via Ollama + bge-m3.

Parameter	Value
Arguments	`[setup\|status\|start\|stop\|reindex\|optimize\|upgrade]`
Tools	Read, Write, Edit, Bash, Task, AskUserQuestion

Modes:

Mode	Purpose
setup	Full grepai installation and configuration
status	Health check: CLI, ollama, bge-m3, MCP, index
start	Start watch mode (auto-indexing)
stop	Stop the watch process
reindex	Full reindexing
optimize	Re-analyze project + new config.yaml
upgrade	Update grepai via brew

/brewcode:grepai setup
/brewcode:grepai status
/brewcode:grepai reindex

install — Dependency installation

sonnetfork

Interactive dependency installer for Brewcode.

Component	Type	Purpose
brew	required	Package manager
coreutils + timeout	required	Timeouts for scripts
jq	required	JSON processor for hooks
ollama	optional	Local embeddings server
bge-m3	optional	Embeddings model (~1.2GB)
grepai	optional	Semantic search CLI

/brewcode:install

teardown — File removal

haikufork

Removes plugin files from the project: templates, configuration, logs, plans, grepai. Task directories and user rules are preserved.

Parameter	Value
Arguments	`[--dry-run]`
`--dry-run`	Only show files without deleting

/brewcode:teardown
/brewcode:teardown --dry-run

text-optimize — Text optimization

sonnetsession

Optimizes text and documentation for efficient LLM token consumption.

Parameter	Value
Arguments	`[-l\|-d] [file\|folder\|path1,path2]`
`-l`	Light — text cleanup only
(default)	Medium — balanced restructuring
`-d`	Deep — maximum compression

Rule categories: Claude behavior (C.1-C.6), Token efficiency (T.1-T.8), Structure (S.1-S.8), Reference integrity (R.1-R.3), Perception (P.1-P.6).

/brewcode:text-optimize CLAUDE.md
/brewcode:text-optimize -d agents/
/brewcode:text-optimize -l file1.md,file2.md

text-human — Code humanization

sonnetsession

Detects and removes AI artifacts from code and documentation: comments like “Added by AI”, unicode symbols, excessive documentation.

Parameter	Value
Arguments	`<commit-hash\|path> [custom instructions]`
Tools	Read, Write, Edit, Grep, Glob, Bash, Task, AskUserQuestion

Language support: Java/Kotlin, TypeScript/JS/React, Python (separate reference files).

/brewcode:text-human 3be67487
/brewcode:text-human src/main/java/services/
/brewcode:text-human 3be67487 don't touch docs on public records

skills — Skill management

opussession

Create, improve, and list skills with activation optimization.

Mode	Purpose
`list` (default)	Show all skills (global, project, plugin)
`up <target>`	Improve a skill via skill-creator
`create <prompt>`	Create a new skill with research

/brewcode:skills
/brewcode:skills up commit
/brewcode:skills create "semantic code search"

agents — Agent management

opussession

Interactive creation and improvement of Claude Code agents.

Mode	Purpose
`help` (default)	Show help
`create <description>`	Create a new agent
`up <name\|path>`	Improve an existing agent

/brewcode:agents create backend validator
/brewcode:agents up reviewer
/brewcode:agents .claude/agents/reviewer.md

Skill dependencies

install --> setup --> spec --> plan --> start --> rules
                       |                          |
                       +-- convention             +-- teardown
                       |
                       +-- grepai

Tip

Skills text-optimize, text-human, standards-review, secrets-scan, skills, and agents can be used independently of the core cycle — they require no prior setup.