Skip to content
Back to search

vibe-wise

MarketplaceWorks with Claude CodeGitHub

A Claude Code / Codex plugin that helps you learn how to build while AI writes the code.

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/nykooi1--vibe-wise/badge.svg)](/listings/nykooi1--vibe-wise)

HTML

<a href="/listings/nykooi1--vibe-wise"><img src="/api/listings/nykooi1--vibe-wise/badge.svg" alt="findsafeskills safety rating" /></a>

Install

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 · 14 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "vibe-wise",
  3. "owner": { "name": "Noah Kim" },
  4. "metadata": {
  5. "description": "VibeWise: learn how to build while AI writes the code."
  6. },
  7. "plugins": [
  8. {
  9. "name": "vibe-wise",
  10. "source": "./",
  11. "description": "Learn how to build software while Claude writes the code."
  12. }
  13. ]
  14. }
README.md · README · 297 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <img src=".claude-plugin/icon.svg" alt="VibeWise brain with code brackets" width="96" height="96">
  2. # VibeWise
  3. **You build. AI writes.**
  4. A plugin for **Claude Code** and **Codex** that puts learning first and keeps you in control while AI writes the code you designed. The AI **asks for your approach first**, helps you examine tradeoffs, and explains unfamiliar concepts. You shape the design and decide when it's ready to implement. The AI writes the code, then explains what it changed and why.
  5. For anyone who wants to learn as they build—whether you're an aspiring engineer, a junior developer, or an experienced engineer exploring an unfamiliar stack. Practice planning how the pieces fit together, anticipating failures, and checking the result while keeping ownership of the decisions.
  6. ## Table of Contents
  7. - [Get started](#get-started)
  8. - [Claude Code](#claude-code)
  9. - [Codex](#codex)
  10. - [What it feels like](#what-it-feels-like)
  11. - [Make it yours](#make-it-yours)
  12. - [Updating](#updating)
  13. - [License](#license)
  14. ## Get started
  15. You need an up-to-date [Claude Code](https://code.claude.com/docs/en/setup) or
  16. [Codex](https://developers.openai.com/codex), and
  17. [Python 3](https://www.python.org/downloads/). In Claude Code, VibeWise uses Python
  18. to restore learning context and reset learning notes. In Codex, only reset needs it.
  19. No extra Python packages are needed.
  20. ### Claude Code
  21. Install from the built-in **Anthropic Directory**. In Claude Code, run:
  22. ```text
  23. /plugin install vibe-wise@anthropic-plugin-directory
  24. ```
  25. Choose an installation scope and confirm. No marketplace setup is needed.
  26. Restart Claude Code in the project you want to work on, then run:
  27. ```text
  28. /vibe-wise:learn
  29. ```
  30. Setup asks one question at a time. Use the arrow keys and Enter for choices; pick **Use defaults** to skip preference setup. Then ask Claude to build something. Starting fresh or joining an unfamiliar repository both work. For an existing repository, Claude first inspects the code and sketches a small system map.
  31. <details>
  32. <summary>Alternative: install through GitHub</summary>
  33. If Anthropic Directory isn't available in your Claude Code version, use the GitHub
  34. marketplace. Choose one installation method; you don't need both.
  35. Run these commands **one at a time** in Claude Code. First, add the marketplace:
  36. ```text
  37. /plugin marketplace add nykooi1/vibe-wise
  38. ```
  39. After it finishes, install the plugin:
  40. ```text
  41. /plugin install vibe-wise@vibe-wise
  42. ```
  43. Enable automatic updates through `/plugin` → **Marketplaces** → **vibe-wise** →
  44. **Enable auto-update**. This is off by default for third-party marketplaces.
  45. Restart Claude Code, then run `/vibe-wise:learn` in your project.
  46. </details>
  47. ### Codex
  48. In a terminal, run these commands **one at a time**. First, add the marketplace:
  49. ```sh
  50. codex plugin marketplace add nykooi1/vibe-wise
  51. ```
  52. After it finishes, install the plugin:
  53. ```sh
  54. codex plugin add vibe-wise@vibe-wise
  55. ```
  56. Start Codex in your project and run `$vibe-wise:learn`. Run it again at the start
  57. of each Codex session, and whenever Codex seems to have lost track of learning
  58. mode. It resumes from your saved notes without repeating setup. To reset, run
  59. `$vibe-wise:reset`. Claude Code and Codex share the same `.vibe-wise/` notes.
  60. In Codex, the commands in this guide use `$` instead of `/`: `/vibe-wise:learn`
  61. becomes `$vibe-wise:learn`.
  62. ## What it feels like
  63. You're building a Notion-style notes app: users sign in, create and edit private
  64. notes, and organize them into folders. Here, you're working through how notes and
  65. folders relate—and what should happen when someone deletes a folder.
  66. This condensed example is adapted from a real learning session. Later implementation
  67. steps are illustrative; intervening design discussions are omitted.
  68. **You:**
  69. ```text
  70. A note can be in several folders. Deleting a folder should delete its notes.
  71. ```
  72. **Claude / Codex:**
  73. ```text
  74. ✦ Build checkpoint: Deleting a shared note
  75. "Trip ideas" is in both Travel and Summer. Deleting it removes it from both.
  76. When someone deletes Travel, what should happen to that note in Summer?
  77. ```
  78. **You:**
  79. ```text
  80. Keep it in Summer. If it has no folders left, keep the note outside any folder.
  81. ```
  82. **Claude / Codex:**
  83. ```text
  84. That separates deleting a folder from deleting a note.
  85. ✦ Build checkpoint: Connecting notes and folders
  86. How would you represent which folders a note belongs to, without copying the note?
  87. ```
  88. **You:**
  89. ```text
  90. A links table with note_id and folder_id. Deleting a folder removes its links,
  91. not the notes.
  92. ```
  93. **Claude / Codex:**
  94. ```text
  95. Each link records one membership. Several links can point to the same note;
  96. a note with no links is unfiled.
  97. notes ← folder links → folders
  98. ✦ Design checkpoint: Folder membership
  99. Proposed: store notes once and track folder membership in a links table.
  100. Deleting a folder removes its links and keeps the notes. This supports multiple
  101. folders per note; loading a folder's notes needs a lookup through those links.
  102. Confirming records this design. We still need to work through access rules
  103. and technology choices before writing code.
  104. ❯ 1. Confirm and continue
  105. This approach makes sense to me; move to the next piece.
  106. 2. Discuss
  107. Ask questions or clarify anything that doesn't make sense before deciding.
  108. ```
  109. **You:**
  110. ```text
  111. Confirm and continue.
  112. ```
  113. *Later, after the remaining choices for this step are worked through...*
  114. **Claude / Codex:**
  115. ```text
  116. ✦ Implementation checkpoint: Folder membership
  117. I'll add the agreed tables and folder-deletion operation, then test that deleting
  118. a folder preserves its notes and their membership in other folders.
  119. This step builds storage behavior; the UI comes later.
  120. ❯ 1. Implement this step
  121. This approach makes sense to me; write the code for this step.
  122. 2. Discuss
  123. Ask questions or clarify anything that doesn't make sense before deciding.
  124. ```
  125. **You:**
  126. ```text
  127. Implement this step.
  128. ```
  129. *Claude or Codex writes the code and runs the tests.*
  130. **Claude / Codex:**
  131. ```text
  132. ✦ Implementation report: Folder membership
  133. - Added the schema migration: each membership references one note and one folder.
  134. - Added folder deletion: removes the folder and its links, preserving note content.
  135. - Added and ran tests for shared notes and notes left without a folder; both passed.
  136. ```
  137. You don't need to know the answer already. The AI can explain unfamiliar concepts, sketch the relevant pieces, and help you tackle a smaller question. You stay involved in forming the plan. Answer in plain English; ask for more help or say “skip” whenever you want.
  138. Describing what you want sets the requirements. Build Checkpoints ask you to work
  139. out how it should function; a feature preference doesn't approve an architecture.
  140. | Checkpoint | What happens |
  141. | --- | --- |
  142. | **Build** | You reason through how to approach the problem with the AI. |
  143. | **Design** | Review the design. **Confirm and continue** records it and continues planning; no code yet. |
  144. | **Implementation** | Review the specific code changes. **Implement this step** authorizes the AI to make them. |
  145. These aren't three mandatory stops. When ready to code, the Implementation
  146. checkpoint also confirms the design, skipping a separate Design checkpoint.
  147. Both confirmations offer **Discuss** to ask questions, clarify anything confusing,
  148. or explore alternatives before deciding.
  149. When the AI proposes additional implementation details, it separates them from your
  150. decisions in a short list or table explaining each addition and why it matters.
  151. You can question or change any item before proceeding.
  152. After implementation, the AI briefly explains what changed, how the key code works,
  153. why it fits your decision, any tests it added or updated and what they cover, and
  154. which checks ran with their results. Ask to dig deeper anywhere it's unclear.
  155. Small diagrams help you trace data, understand relationships, and see how the system fits together.
  156. ## Make it yours
  157. Experience changes the support you get, not your ownership of decisions:
  158. | Level | Teaching approach |
  159. | --- | --- |
  160. | Beginner | Explain unfamiliar pieces, use diagrams, ask smaller reasoning questions. |
  161. | Intermediate | Less introductory context; explore interactions and tradeoffs. |
  162. | Advanced | Probe difficult constraints, failure modes, and design assumptions. |
  163. Everyone reasons first. The AI adapts to what you demonstrate and how familiar you
  164. are with the stack. Checkpoint frequency—Light, Normal, or Frequent—is separate.
  165. - “Use fewer checkpoints.”
  166. - “Focus on backend architecture.”
  167. - “Use multiple-choice questions.”
  168. - “Just implement this one.”
  169. - “Pause learning.” Resume with `/vibe-wise:learn`.
  170. Preferences, learning notes, and a project map live in `.vibe-wise/` in your project. In a Git repository, that's the repository root, and VibeWise finds it from any subfolder. Without Git, it's the folder you start in, so always start from your project's top folder. Learning mode resumes in future sessions and after compaction. Add `.vibe-wise/` to your `.gitignore` to keep your notes out of Git; the plugin won't change it silently.
  171. No extra account, backend, or telemetry. Saved notes are included in the AI's context, so your normal Claude Code or Codex data settings still apply.
  172. To start learning this project from scratch, run `/vibe-wise:reset`. It shows the
  173. project and asks **Cancel / Reset learning**. After confirmation, it backs up your
  174. profile, progress, and project map inside the notes directory's `backups/` folder,
  175. then restarts onboarding. Source code and other projects stay untouched. To change
  176. your experience level or preferences, just tell the AI; no reset is needed.
  177. ## Updating
  178. In Claude Code, open `/plugin` → **Installed**, select VibeWise, and choose **Update now**.
  179. For automatic updates, open **Marketplaces**, select the source you installed from,
  180. and enable auto-update if it's off.
  181. To update a directory installation from your terminal:
  182. ```sh
  183. claude plugin update vibe-wise@anthropic-plugin-directory
  184. ```
  185. If you installed through the GitHub marketplace instead:
  186. ```sh
  187. claude plugin marketplace update vibe-wise
  188. claude plugin update vibe-wise@vibe-wise
  189. ```
  190. Then restart Claude Code. Your project learning notes stay intact; no reset is needed.
  191. Run `claude plugin list` to check the installed version.
  192. [More about plugin updates](https://code.claude.com/docs/en/discover-plugins#keep-plugins-updated).
  193. For Codex, refresh the marketplace, then install the latest version:
  194. ```sh
  195. codex plugin marketplace upgrade vibe-wise
  196. ```
  197. ```sh
  198. codex plugin add vibe-wise@vibe-wise
  199. ```
  200. Then start a new Codex session.
  201. ## License
  202. [MIT](LICENSE). You can use, modify, and share this software, including commercially. Keep the license notice with copies. The software comes without a warranty.

Ratings and comments

Sign in to rate this skill.

Sign in

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