Skip to content
Back to search

parabolic-plugins

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/parabolic-technologies--banzai-claude-plugin/badge.svg)](/listings/parabolic-technologies--banzai-claude-plugin)

HTML

<a href="/listings/parabolic-technologies--banzai-claude-plugin"><img src="/api/listings/parabolic-technologies--banzai-claude-plugin/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Add the marketplace:

claude plugin marketplace add Parabolic-Technologies/banzai-claude-plugin

Then install the plugin either for one project, from that project's directory:

claude plugin install banzai@parabolic-plugins --scope project

or for all your projects:

claude plugin install banzai@parabolic-plugins --scope user

With a user install the commands are available in every project, but the hook acts only in a project that has `documentation/work/`, which `setup` creates; everywhere else it stays silent.

Then start Claude Code in the project and type:

/banzai:setup

`setup` prepares the project once and is safe to run again. It:

- adds `.banzai/` to `.gitignore`; - enables the plugin and names its marketplace in `.claude/settings.json`; - creates `documentation/decisions/` and `documentation/work/`; - offers to record the project's build, test, lint and format commands in your `CLAUDE.md`, or in your `AGENTS.md` when there is no `CLAUDE.md`, and asks before it writes them.

Now give it a first piece of work in your own words, for example:

/banzai:feature let the greet CLI print the greeting in upper case

The model writes a plan and shows the approval dialog. After your "Yes" it writes the code and the tests.

Or let it run to the end and report:

/banzai:auto let the greet CLI print the greeting in upper case

For a team

Commit the files `setup` wrote so that your team shares them. The settings make the marketplace known to a teammate's Claude Code but install nothing. Each teammate opens the project in Claude Code once and trusts the folder, which fetches the marketplace, and then runs one of the install commands above.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 18 lines
  1. {
  2. "name": "parabolic-plugins",
  3. "owner": {
  4. "name": "Parabolic Technologies, Inc."
  5. },
  6. "metadata": {
  7. "description": "Plugins by Parabolic Technologies, Inc."
  8. },
  9. "plugins": [
  10. {
  11. "name": "banzai",
  12. "source": "./plugins/banzai",
  13. "description": "Spec-driven development with human-in-the-loop plan approval or a human-on-the-loop run, guardrails for source edits, and an independent code review.",
  14. "category": "development",
  15. "tags": ["spec-driven-development", "human-in-the-loop", "human-on-the-loop", "workflow", "code-review", "guardrails"]
  16. }
  17. ]
  18. }
README.md · README · 328 lines
  1. # Banzai
  2. **Spec-driven development for Claude Code with a human in the loop or on the
  3. loop: the AI agent works from a written plan, and you choose for each task
  4. whether to approve the plan before the code or to read the report after
  5. it.**
  6. [![CI](https://github.com/Parabolic-Technologies/banzai-claude-plugin/actions/workflows/ci.yml/badge.svg)](https://github.com/Parabolic-Technologies/banzai-claude-plugin/actions/workflows/ci.yml)
  7. [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue)](LICENSE)
  8. An AI coding agent tends to start writing code before you have agreed on
  9. what it should build. Banzai is a Claude Code plugin for developers who want
  10. the agent to work from a spec and a plan instead, and who want to choose,
  11. task by task, how closely they supervise it.
  12. ![The approval dialog in a terminal: it quotes four lines of the plan, names the file the answer approves, and offers Yes and No.](assets/approval-dialog.svg)
  13. ## Two ways to supervise
  14. You pick one for each task by the command you type.
  15. | | Human in the loop | Human on the loop |
  16. | --------------------- | --------------------------------------------- | ---------------------------------------------------------------- |
  17. | Command | `/banzai:feature` | `/banzai:auto` |
  18. | You are asked | Before the code: one click approves the plan. | At the start only: up to four questions in one dialog. |
  19. | Who checks the plan | You. | An independent reviewer, before any code. |
  20. | Who checks the change | You, and `/banzai:review` when you type it. | An independent reviewer; blocker and major findings are fixed. |
  21. | Source files | The file tools write none until you approve. | Not held back by the hook. |
  22. | You read | The plan, then the diff. | The last message, then the diff. |
  23. | Use it for | Work you want to steer before it is built. | Work you are willing to check after it is built. |
  24. Either way the work is written down. Requirements, plans, decisions, reports
  25. and reviews are ordinary Markdown files in your project, so you can read,
  26. diff and commit them.
  27. Around both, Banzai adds:
  28. - **Guardrails.** One hook asks you before a source file changes when no
  29. command was typed. A change through the shell or an MCP tool cannot be
  30. stopped beforehand; it is found after the call and shown to you.
  31. - **Independent code review** with `/banzai:review`. A finished change can
  32. be reviewed by a fresh subagent that has not seen how it was made.
  33. - **Quick fix** with `/banzai:fix`. A small change needs no plan: you type
  34. the command and it runs directly.
  35. - **Large work** with `/banzai:epic`. Work too large for one plan is split
  36. into stages and packages and tracked across sessions.
  37. That is six slash commands and one guardrail hook.
  38. Compared with Claude Code's plan mode: the plan is a file in your project,
  39. your approval is bound to that file's content, and it still holds in a new
  40. session.
  41. Compared with letting the agent run on its own: `/banzai:auto` asks before
  42. it guesses what users get, has a reviewer with fresh context check the plan
  43. and the finished change, and tells you which choices it made for you.
  44. ## Requirements
  45. - Claude Code 2.1.327 or later.
  46. - Node.js 26 LTS or later on your `PATH`. Older versions are not tested. The
  47. hook is plain JavaScript with no dependencies. Without Node.js the hook
  48. does not run and nothing is held back.
  49. - A project in Git. The hook finds changes made through the shell by asking
  50. Git, so outside Git it sees only changes made with the file tools.
  51. Banzai was built and checked in the terminal client on macOS, and its tests
  52. also run on Linux. In the desktop app the approval dialog and one full
  53. `/banzai:auto` run were seen to work. The IDE extensions and Windows have
  54. not been checked.
  55. ## Install
  56. Add the marketplace:
  57. ```bash
  58. claude plugin marketplace add Parabolic-Technologies/banzai-claude-plugin
  59. ```
  60. Then install the plugin either for one project, from that project's
  61. directory:
  62. ```bash
  63. claude plugin install banzai@parabolic-plugins --scope project
  64. ```
  65. or for all your projects:
  66. ```bash
  67. claude plugin install banzai@parabolic-plugins --scope user
  68. ```
  69. With a user install the commands are available in every project, but the
  70. hook acts only in a project that has `documentation/work/`, which `setup`
  71. creates; everywhere else it stays silent.
  72. Then start Claude Code in the project and type:
  73. ```text
  74. /banzai:setup
  75. ```
  76. `setup` prepares the project once and is safe to run again. It:
  77. - adds `.banzai/` to `.gitignore`;
  78. - enables the plugin and names its marketplace in `.claude/settings.json`;
  79. - creates `documentation/decisions/` and `documentation/work/`;
  80. - offers to record the project's build, test, lint and format commands in
  81. your `CLAUDE.md`, or in your `AGENTS.md` when there is no `CLAUDE.md`, and
  82. asks before it writes them.
  83. Now give it a first piece of work in your own words, for example:
  84. ```text
  85. /banzai:feature let the greet CLI print the greeting in upper case
  86. ```
  87. The model writes a plan and shows the approval dialog. After your "Yes" it
  88. writes the code and the tests.
  89. Or let it run to the end and report:
  90. ```text
  91. /banzai:auto let the greet CLI print the greeting in upper case
  92. ```
  93. ### For a team
  94. Commit the files `setup` wrote so that your team shares them. The settings
  95. make the marketplace known to a teammate's Claude Code but install nothing.
  96. Each teammate opens the project in Claude Code once and trusts the folder,
  97. which fetches the marketplace, and then runs one of the install commands
  98. above.
  99. ## Commands
  100. You type every command yourself; the model cannot start one.
  101. | Command | Use it for |
  102. | --------------------------------- | ----------------------------------------------------------------- |
  103. | `/banzai:setup` | Prepare a project, once. |
  104. | `/banzai:fix <what to change>` | A small, direct change with no plan. |
  105. | `/banzai:feature <what to build>` | Planned work: plan, your approval, code, tests, report. |
  106. | `/banzai:auto <what to build>` | Planned work with no approval: plan, code, review, fixes, report. |
  107. | `/banzai:review [work]` | An independent review of a finished change. |
  108. | `/banzai:epic <mode>` | Work too large for one plan; see [Large work](#large-work). |
  109. Always type the full name. A bare `/review` is a different command.
  110. A *work* is one change with its own directory,
  111. `documentation/work/<work>/`. Its name is the date and the subject, such as
  112. `261118-greet-upper-case`, and that name is what `[work]` stands for.
  113. ## Human in the loop: `/banzai:feature`
  114. 1. You type `/banzai:feature` and say what to build.
  115. 2. When the request leaves open what users get, the model asks you up to
  116. three questions, each with the answer it recommends. It decides matters
  117. of form itself, such as names and messages, and marks each such choice.
  118. 3. The model writes `plan.md` in the work's directory. A larger request
  119. first gets `requirements.md`, and a choice that is costly to reverse gets
  120. a decision record under `documentation/decisions/`, which you accept in
  121. chat before the plan is written.
  122. 4. An approval dialog appears. It quotes the plan's "For approval" section,
  123. which says what will be built and names each choice the model made for
  124. you, and it names the files your answer approves.
  125. 5. "Yes" approves exactly those files as they are. If one of them changes
  126. later, the approval ends and the dialog comes again.
  127. 6. The model writes the code and the tests, runs the project's checks and
  128. completes `report.md`.
  129. 7. `/banzai:review <work>` starts a reviewer with fresh context and writes
  130. `review.md`. A review changes no source file; you choose what to fix.
  131. When the work is done, your project holds:
  132. ```text
  133. documentation/
  134. ├── decisions/ decision records
  135. └── work/
  136. └── 261118-greet-upper-case/
  137. ├── requirements.md what must be true when it is done
  138. ├── plan.md how it will be built
  139. ├── report.md what was built and how it was checked
  140. └── review.md what the reviewer found
  141. ```
  142. To continue a work in a new session, type `/banzai:feature <work>`. An
  143. approval of unchanged files still holds.
  144. ## Human on the loop: `/banzai:auto`
  145. `/banzai:auto <what to build>` is for work you are willing to check after it
  146. is built instead of before. You answer its questions once and come back to a
  147. finished change with a plan, an independent review and a report.
  148. 1. The model reads the code. When the work decides something that is costly
  149. to reverse (a data model, a public API, a new dependency, a security
  150. boundary), it asks you in the dialog of step 2 if one question settles
  151. the decision. Otherwise it stops and names `/banzai:feature` instead.
  152. 2. When the request leaves open what users get, a question dialog appears,
  153. once, with up to four questions and a recommended answer for each. After
  154. it the model asks nothing more and decides the rest itself.
  155. 3. The model writes `requirements.md` and `plan.md`. A reviewer that has not
  156. seen the conversation audits the plan, and the model corrects what it
  157. confirms.
  158. 4. The model writes the code and the tests and completes `report.md`.
  159. 5. The reviewer audits the change. The model fixes the blocker and major
  160. findings it confirms, the reviewer checks once more, and `review.md`
  161. records what was closed and what is still open.
  162. 6. The last message lists what was built, what you decided, what was decided
  163. for you, the review's result and the command that shows the change.
  164. No dialog asks you to approve the plan, and the hook holds back no source
  165. change in such a session. Claude Code's own permission prompts still apply:
  166. in its default mode it asks before edits and shell commands. Typing
  167. `/banzai:feature <work>` afterwards asks you to approve that work's plan.
  168. The work leaves `requirements.md`, `plan.md`, `report.md` and `review.md`,
  169. and `review.md` also records the audit of the plan. To continue the work in
  170. a new session, type `/banzai:auto <work>`.
  171. ## Large work
  172. `/banzai:epic` keeps track of work that is too large for one plan. The work
  173. is split into stages and packages, and each package is then built with its
  174. own `/banzai:feature` or `/banzai:fix`. Bring your own plan, or give only
  175. the goal: the command asks a few questions, writes the plan and shows it,
  176. and you change it by saying what to change. It keeps the epic's plan,
  177. tracker and log in `documentation/epics/<epic>/` and changes no source file.
  178. | Mode | What it does |
  179. | ----------------- | -------------------------------------------------------------------- |
  180. | `start <subject>` | Stores your plan, or drafts one from your goal and answers. |
  181. | `next` | Reports where the epic stands and names the next package to build. |
  182. | `record <entry>` | Records a started or finished package, a question or a decision. |
  183. | `gate <N>` | Lists the evidence for a stage's gate; you decide whether it passed. |
  184. ## What the hook holds back
  185. The hook acts in a directory that has `documentation/work/` and in every
  186. directory below it. Everywhere else it stays silent.
  187. To the hook, a source file is every file of the project except the files
  188. under `documentation/` and the `CLAUDE.md` and `AGENTS.md` at its root. So
  189. `package.json`, `.gitignore` and `.claude/settings.json` are source files
  190. too.
  191. - With no command typed, each source change asks you, and "Yes" covers that
  192. one change.
  193. - After `/banzai:fix`, the session may change source files.
  194. - After `/banzai:auto`, the session may change source files, and a plan
  195. written in it needs no approval.
  196. - After `/banzai:feature`, the file tools write no source file until the plan
  197. is approved.
  198. - A source change made through the shell or an MCP tool cannot be stopped
  199. beforehand. The hook finds it by comparing the project before and after
  200. the call, and the next shell command shows you the changed files and asks.
  201. "No" does not undo the change: revert it yourself. Until you accept it,
  202. each shell command asks again and MCP calls are refused, except the
  203. desktop app's own task list and summary.
  204. The approval dialog shows up to five lines of at most 72 characters from the
  205. plan's "For approval" section, and they come first in its text. When the
  206. list of approved files is long, the terminal folds its end out of view. The
  207. desktop app shows about three rows of the text and scrolls the rest.
  208. The hook behaves the same in every permission mode, `bypassPermissions`
  209. included.
  210. In a run with nobody to answer (`claude -p`), every question of the hook is
  211. refused. `/banzai:fix` still works. A plan cannot be approved, a run with no
  212. command typed cannot change a source file with the file tools, and after a
  213. change through the shell is found, the run's later shell and MCP calls are
  214. refused.
  215. ## Disable or uninstall
  216. To work without the hook, disable the plugin:
  217. ```bash
  218. claude plugin disable banzai@parabolic-plugins
  219. ```
  220. Approval records are kept in `.banzai/approvals/` in the project, outside
  221. Git. Losing them costs one new click per work. Uninstalling the plugin
  222. deletes the hook's data, and approvals made before then no longer count. To
  223. uninstall and keep them, give the scope you installed with, `project` or
  224. `user`:
  225. ```bash
  226. claude plugin uninstall banzai@parabolic-plugins --scope project --keep-data
  227. ```
  228. ## Limits
  229. - The gate stops mistakes, not attacks. It is not a sandbox, and it is not
  230. protected against a model that works to get around it.
  231. - It does not see changes to files that Git ignores, changes in a project
  232. outside Git, or changes a background process makes after its command ended.
  233. - Each shell or MCP call takes about 80 ms longer on a small repository, and
  234. an estimated 150 ms on one with 7,000 files.
  235. - Plan approvals, checks and reviews are no guarantee that a change is
  236. correct. Read the diff before you commit.
  237. [DECISIONS.md](DECISIONS.md) gives the reason for each design choice and
  238. what was rejected.
  239. ## Community
  240. Report reproducible problems through
  241. [GitHub Issues](https://github.com/Parabolic-Technologies/banzai-claude-plugin/issues).
  242. To contribute, read [Contributing](.github/CONTRIBUTING.md). Report
  243. vulnerabilities through the [security policy](.github/SECURITY.md). Changes
  244. are listed in the
  245. [changelog](CHANGELOG.md).
  246. ## Author and license
  247. Owned by **Parabolic Technologies, Inc. ("Parabolic")**.
  248. Created by [Alexander Torosh](https://github.com/alexander-torosh).
  249. Contact: [alexander@parabolic.io](mailto:alexander@parabolic.io).
  250. Source: [Parabolic-Technologies/banzai-claude-plugin](https://github.com/Parabolic-Technologies/banzai-claude-plugin).
  251. Banzai is licensed under the [Apache License, Version 2.0](LICENSE).
  252. See [NOTICE](NOTICE), [third-party information](THIRD_PARTY_NOTICES.md),
  253. [Terms of Use](TERMS_OF_USE.md), and [Names and Logos](TRADEMARKS.md).
  254. Using Banzai does not require open-sourcing your own project. Community
  255. participation follows the [Code of Conduct](.github/CODE_OF_CONDUCT.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.